单例模式

单例对象(Singleton)是一种常用的设计模式。在Java应用中,单例对象能保证在一个JVM中,该对象只有一个实例存在。

这样的模式有几个好处:

1、某些类创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销。

2、省去了new操作符,降低了系统内存的使用频率,减轻GC压力。

3、有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了。(比如一个军队出现了多个司令员同时指挥,肯定会乱成一团),所以只有使用单例模式,才能保证核心交易服务器独立控制整个流程。

UML图:

首先我们写一个简单的单例类:

主要的几种实现方式:

    public class Singleton {  
      
        /* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */  
        private static Singleton instance = null;  
      
        /* 私有构造方法,防止被实例化 */  
        private Singleton() {  
        }  
      
        /* 静态工程方法,创建实例 */  
        public static Singleton getInstance() {  
            if (instance == null) {  
                instance = new Singleton();  
            }  
            return instance;  
        }  
      
        /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */  
        public Object readResolve() {  
            return instance;  
        }  
    }  

 1、懒汉式

    /** 
     * 示例:单例--单例对象能保证在一个JVM中,该对象只有一个实例存在。 
     *  
     * 缺点:这种做法在多线程环境下,不安全 
     *  
     * 懒汉式 
     */  
      
    class Singleton {  
        /** 
         * 持有私有静态变量(也称类变量),防止被引用 
         *  
         * 此处赋值为null,目的是实现延迟加载 (因为有些类比较庞大,所以延迟加载有助于提升性能) 
         */  
        private static Singleton instance = null;  
      
        /** 私有构造方法,防止被实例化 */  
        private Singleton() {  
      
        }  
      
        /** 静态工厂方法,创建实例 --只不过这里是创建自己,而且只能创建一个 */  
        public static Singleton getInstance() {  
            if (instance == null) {  
                instance = new Singleton();  
            }  
            return instance;  
        }  
      
        public void info() {  
            System.out.println("this is a test method...");  
        }  
    }  
      
    /** 
     * 客户端测试类 
     *  
     * @author Leo 
     */  
    public class Test {  
        public static void main(String[] args) {  
            Singleton s1 = Singleton.getInstance();  
            /** 
             * 调用普通方法 
             */  
            s1.info();  
            Singleton s2 = Singleton.getInstance();  
            /** 
             * 运行结果为true,说明s1、s2这两个类变量都指向内存中的同一个对象 
             */  
            System.out.println(s1 == s2);  
        }  
    }  

2、饿汉式

    /** 
     * 饿汉式 
     */  
      
    class Singleton {  
        private static Singleton instance = new Singleton();  
      
        private Singleton() {  
      
        }  
      
        public static Singleton getInstance() {  
            return instance;  
        }  
      
        public void info() {  
            System.out.println("this is a test method...");  
        }  
    }  
      
    /** 
     * 客户端测试类 
     *  
     * @author Leo 
     */  
    public class Test {  
        public static void main(String[] args) {  
            Singleton s1 = Singleton.getInstance();  
            /** 
             * 调用普通方法 
             */  
            s1.info();  
            Singleton s2 = Singleton.getInstance();  
            /** 
             * 运行结果为true,说明s1、s2这两个类变量都指向内存中的同一个对象 
             */  
            System.out.println(s1 == s2);  
        }  
      
    }  

如果考虑多线程,那么getInstance()方法要加同步synchronized,这时饿汉式比懒汉式要好,尽管资源利用率要差,但是不用同步。

  /** 
     * 饿汉式 
     */  
      
    class Singleton {  
        private static Singleton instance = new Singleton();  
      
        private Singleton() {  
      
        }  
      
        public static Singleton getInstance() {  
            return instance;  
        }  
      
        public void info() {  
            System.out.println("this is a test method...");  
        }  
    }  
      
    /** 
     * 客户端测试类 
     *  
     * @author Leo 
     */  
    public class Test {  
        public static void main(String[] args) {  
            Singleton s1 = Singleton.getInstance();  
            /** 
             * 调用普通方法 
             */  
            s1.info();  
            Singleton s2 = Singleton.getInstance();  
            /** 
             * 运行结果为true,说明s1、s2这两个类变量都指向内存中的同一个对象 
             */  
            System.out.println(s1 == s2);  
        }  
      
    } 

通过单例模式的学习告诉我们:

1、单例模式理解起来简单,但是具体实现起来还是有一定的难度。

2、synchronized关键字锁定的是对象,在用的时候,一定要在恰当的地方使用(注意需要使用锁的对象和过程,可能有的时候并不是整个对象及整个过程都需要锁)。

到这儿,单例模式基本已经讲完了,结尾处,笔者突然想到另一个问题,就是采用类的静态方法,实现单例模式的效果,也是可行的,此处二者有什么不同?

首先,静态类不能实现接口。(从类的角度说是可以的,但是那样就破坏了静态了。因为接口中不允许有static修饰的方法,所以即使实现了也是非静态的)

其次,单例可以被延迟初始化,静态类一般在第一次加载是初始化。之所以延迟加载,是因为有些类比较庞大,所以延迟加载有助于提升性能。

再次,单例类可以被继承,他的方法可以被覆写。但是静态类内部方法都是static,无法被覆写。

最后一点,单例类比较灵活,毕竟从实现上只是一个普通的Java类,只要满足单例的基本需求,你可以在里面随心所欲的实现一些其它功能,但是静态类不行。从上面这些概括中,基本可以看出二者的区别,但是,从另一方面讲,我们上面最后实现的那个单例模式,内部就是用一个静态类来实现的,所以,二者有很大的关联,只是我们考虑问题的层面不同罢了。两种思想的结合,才能造就出完美的解决方案,就像HashMap采用数组+链表来实现一样,其实生活中很多事情都是这样,单用不同的方法来处理问题,总是有优点也有缺点,最完美的方法是,结合各个方法的优点,才能最好的解决问题!

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏恰童鞋骚年

Hadoop学习笔记—5.自定义类型处理手机上网日志

  假设我们如下一个日志文件,这个文件的内容是来自某个电信运营商的手机上网日志,文件的内容已经经过了优化,格式比较规整,便于学习研究。

8010
来自专栏GIS讲堂

数据库 连接(JOIN)

连接运算中有两种最为重要的连接,一种是等值连接(Equijoin),另一种是自然连接(Nature Join):等值连接是从关系R和S中的笛卡尔积中选取A,B属...

22330
来自专栏GreenLeaves

SQL学习之使用常用函数处理数据

一、在介绍使用函数处理数据前,先说下使用DBMS(数据库管理系统)处理数据所带来的问题! 1、与几乎所有的DBMS都同等的支持SQL语句(如SELECT)不同,...

19650
来自专栏菩提树下的杨过

AS3中的单件(Singleton)模式

单件(singleton)模式在c#中是最容易实现的模式,其主要用意就在于限制使用者用new来创建多个实例。但在as3中,构造函数必须是public的(语法本身...

22550
来自专栏互联网技术栈

MySQL 高性能表设计规范

良好的逻辑设计和物理设计是高性能的基石, 应该根据系统将要执行的查询语句来设计schema, 这往往需要权衡各种因素。

10120
来自专栏JadePeng的技术博客

c# IO操作(带进度的文件复制器,读取文本文件的指定行)

带进度的文件复制器      基本原理就是通过Stream的BeginRead来异步复制文件,同时刷新进度条的状态 ? ? ? 代码 读取文件的指定行 1、...

41070
来自专栏码洞

核心技术靠化缘是要不来的——自己动手写ORM框架

开源市场上的Java的ORM框架一个都不好用,所以花了几天时间自己撸了一个 OrmKids,欢迎大家下载学习。遇到问题请关注公众号进群大家一起讨论。

17720
来自专栏爱撒谎的男孩

Mybatis之ResultMap

42840
来自专栏Fish

android文件存储

为了输出数据,要把list中存储的写到一个txt文件里,就顺手学了一下 文件存储的方法,说是学,其实又是百度之后复制粘贴。不过学到了一个关于java中的一个知识...

23490
来自专栏杨建荣的学习笔记

MySQL中需要注意的字段长度问题

在MySQL的表结构设计中,突然想起来几个地方碰到的问题比较多,大体来说一个就是字符集,一个就是数据类型。 而字符集和数据类型结合起来,就有一个蛮有意思的细节,...

41860

扫码关注云+社区

领取腾讯云代金券