单例设计模式浅谈

单例模式的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问,从而控制实例化个数和节约系统资源。如果希望在系统中某个类的对象只能存在一个,单例模式是最好的解决方案,如某些工具类。

单例模式: 保证一个类仅有一个实例,并提供一个全局的访问机制
特点:
     构造函数私有化
     声明一个本类对象
     给外部提供一个静态方法以获取对象
实现方法:
     饿汉式
     懒汉式

单线程下单利模式的实现:
class Singleton {
     //饿汉式声明一个本类对象,对其实例化
     private static Singleton singleton_01 = new Singleton();
     //懒汉式声明一个本类对象,不进行初始化
     private static Singleton singleton_02 = null;
     
     //构造方法私有化
     private Singleton(){
          
     }
     
     //给外部提供一个静态方法以获取实例,饿汉式
     public static Singleton getInstance_01(){
          return singleton_01;
     }
     
     //给外部提供一个静态方法以获取实例,懒汉式
     public static Singleton getInstance_02(){
          if(singleton_02 == null){
               singleton_02 = new Singleton();
          }
          return singleton_02;
     }
}
饿汉式和懒汉式的比较:
       饿汉式在第一次加载类的时候会连带着创建Singleton实例,这样的结果显然与我们所期望的不同,因为创建实例的时候可能并不是我们需要这个实例的时候。而且考虑到如果这个Singleton实例的创建非常消耗系统资源,而应用始终都没有使用Singleton实例,那么创建Singleton消耗的系统资源就被白白浪费了。 为了避免出现这种情况,我们通常使用惰性进制来实例化对象,即懒汉式。这时当我们第一次调用Singleton.getInstance()的时候,这个单例才被创建,而以后再次调用的时候仅仅返回这个单例就可以了。但是懒汉式在单线程中不存在问题,在多线程环境下就会面临挑战,而且很容易出现线程安全问题。

分析懒汉式在多线程环境下出现问题的原因:
这是如果两个线程A和B同时执行了该方法,然后以如下方式执行:
1. A进入if判断,此时singleton_02为null,因此进入if内
2. B进入if判断,此时A恰好还没有创建singleton_02,因此singleton_02也为null,因此B也进入if内
3. A创建了一个singleton_02并返回
4. B也创建了一个singleton_02并返回
此时问题出现了,我们的单例被创建了两次,而这显然并不是我们所期望的。

解决方案一

使用synchronize关键字,为可能出现线程完全问题的地方加锁,这样确实解决了错误的出现,但是,这样是非常损耗性能的,因为,每次调用getInstance方法的时候都必须获得对象锁,而实际上,当单例实例被创建以后,其后的请求没有必要再使用互斥机制了

        //给外部提供一个静态方法以获取实例,饿汉式
        public static synchronized Singleton_01 getInstance_01(){
                return singleton_01;
        }
        
        //给外部提供一个静态方法以获取实例,懒汉式
        public static synchronized =Singleton getInstance_02(){
                if(singleton_02 == null){
                        singleton_02 = new Singleton();
                }
                return singleton_02;
        }

解决方法二:(网上查阅的时候看到的)

使用双重检测( double-checked locking)
public static Singleton getInstance_03(){
     if (singleton_03 == null){
          synchronized(singleton_03){
               if(singleton_03 == null){
                     singleton_03 = new Singleton();
               }
          }       
     }
     return singleton_03;
}
让我们来分析一下这个代码是如何进行的
首先当一个线程发出请求后,会先检查singleton_03是否为null,如果不是则直接返回其内容,这样避免了进入synchronized块所需要花费的资源。其次,即使上面提到的情况发生了,两个线程同时进入了第一个if判断,那么他们也必须按照顺序执行synchronized块中的代码,第一个进入代码块的线程会创建一个新的Singleton实例,而后续的线程则因为无法通过if判断,而不会创建多余的实例。
上述描述似乎已经解决了我们面临的所有问题,但实际上,从JVM的角度讲,这些代码仍然可能发生错误。
对于JVM而言,它执行的是一个个Java指令。 在Java指令中创建对象和赋值操作是分开进行的,
也就是说singleton_03= new Singleton();语句是分 两步执行 的。但是JVM并不保证这两个操作的先后顺序,也就是说有可能JVM会为新的Singleton实例分配空间,然后直接赋值给singleton_03成员,然后再去初始化这个Singleton实例。这样就使出错成为了可能,我们仍然以A、B两个线程为例:
1.A、B线程同时进入了第一个if判断
2.A首先进入synchronized块,由于singleton_03为null,所以它执行singleton_03= new Singleton(); 
3.由于JVM内部的优化机制,JVM先分配给Singleton实例的空白内存,并赋值给singleton_03成员 (注意此时JVM没有开始初始化这个实 例,只是分配 了内存),然后A离     开了同步快         
4.B进入synchronized块,由于singleton_03此时不是null,因此它马上离开了synchronized块并将结果返回给调用该方法的程序。
5.此时B线程打算使用Singleton实例,却发现它没有被初始化,于是错误发生了。

为了实现慢加载,并且不希望每次调用getInstance时都必须互斥执行,最好并且最方便的解决办法是:通过内部类实现多线程环境中的单例模式

class Singleton {
        //饿汉式声明一个本类对象,对其实例化
        private static Singleton singleton_01 = new Singleton();
        //懒汉式声明一个本类对象,不进行初始化
        private static Singleton singleton_02 = null;
        private static Singleton singleton_03 = null;

        //构造方法私有化
        private Singleton(){
                
        }
        
        //给外部提供一个静态方法以获取实例,饿汉式
        public static synchronized Singleton_01 getInstance_01(){
                return singleton_01;
        }
        
        //给外部提供一个静态方法以获取实例,懒汉式
        public static synchronized Singleton getInstance_02(){
                if(singleton_02 == null){
                        singleton_02 = new Singleton();
                }
                return singleton_02;
        }
        
        //double-checked locking
        public static Singleton getInstance_03(){
                if (singleton_03 == null){
                        synchronized(singleton_03){
                                if(singleton_03 == null){
                                        singleton_03 = new Singleton();
                                }
                        }       
                }
                return singleton_03;
        }
        
        //内部类方式
        private static class SingletonContainer{
                private static Singleton singleton_04 = new Singleton();
        }
        
        public static Singleton getInstance_04(){
                return SingletonContainer.singleton_04;
        }
}

JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候,JVM能够帮我们保证singleton_04只被创建一次,并且会保证把赋值给singleton_04的内存初始化完毕,这样我们就不用担心上面第二种的问题。此外该方法也只会在第一次调用的时候使用互斥机制,这样就解决了第一种低效问题。最后singleton_04是在第一次加载SingletonContainer类时被创建的,而SingletonContainer类则在调用getInstance方法的时候才会被加载,因此也实现了惰性加载。




  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值