单例模式与线程保险

单例模式与线程安全

请看如下的单例类：

class Singleton{
  private static Singleton singleton = null;

  public static Singleton getSingleton() {
    if (null == singleton) {
      singleton = new Singleton();
    }
    return singleton;
  }

首先判断singleton是否为null，如果是就创建singleton对象，否则直接返回singleton。但是判断和创建并非原子操作，假设线程1正在执行null == singleton，判断为true，准备执行下一句new Singleton();此时线程2可能已经new了一个 Singleton了，线程1再次new了一个Singleton，出现2个Singleton与单例的设计思想不符，即单例的控制在并发情况下失效了，测试代码可直观的反应该问题：

public class MyThread extends Thread {

  public void run() {
    System.out.println(Singleton.getSingleton().toString());
  }
  public static void main(String[] args) {
    for(int i=0;i<10;i++){
      MyThread myThread = new MyThread();
      myThread.start();
    }
  }
}
class Singleton{
  private static Singleton singleton = null;

  public static Singleton getSingleton() {
    if (null == singleton) {
      singleton = new Singleton();
    }
    return singleton;
  }
}

输出：

Singleton@69b332
Singleton@69b332
Singleton@69b332
Singleton@69b332
Singleton@173a10f
Singleton@69b332
Singleton@69b332
Singleton@69b332
Singleton@69b332
Singleton@69b332

可以在getSingleton方法前加synchronized，确保任意时刻都只有一个线程可以进入该方法。但是这样一来，会降低整个访问的速度，而且每次都要判断。

可以使用"双重检查加锁"的方式来实现，就可以既实现线程安全，又能够使性能不受到很大的影响。

    public class Singleton {  
        /**  
         * 对保存实例的变量添加volatile的修饰  
         */  
        private volatile static Singleton instance = null;  
        private Singleton(){  
        }  
        public static  Singleton getInstance(){  
            //先检查实例是否存在，如果不存在才进入下面的同步块  
            if(instance == null){  
                //同步块，线程安全地创建实例  
                synchronized(Singleton.class){  
                    //再次检查实例是否存在，如果不存在才真正地创建实例  
                    if(instance == null){  
                        instance = new Singleton();  
                    }  
                }  
            }  
            return instance;  
        }  
    }

所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

双重检查加锁机制的实现会使用一个关键字volatile，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存,从而确保多个线程能正确的处理该变量。

双重检查机制，尽可能缩小了同步块的范围。

这里解释一下为什么要判断2次，当两个线程调用getInstance方法时，它们都将通过第一重instance==null的判断，由于同步机制，这2个线程只能有一个进入，另一个排队。而此时如果没有第二重判断，则第一个线程创建了实例，而第二个实例离开队列重新获得锁，则将继续创建实例，这样就没有达到单例的目的。

在多线程开发中，为了解决并发问题，主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中，JVM已经隐含地为您执行了同步，这些情况下就不用自己再来进行同步控制了。这些情况包括：

由静态初始化器（在静态字段上或 static{} 块中的初始化器）初始化数据时

访问 final 字段时

在创建线程之前创建对象时

线程可以看见它将要处理的对象时。

一种可行的方式就是采用类级内部类，在这个类级内部类里面去创建对象实例。这样一来，只要不使用到这个类级内部类，那就不会创建对象实例，从而同时实现延迟加载和线程安全。

看看代码示例可能会更清晰一些，示例代码如下：

    public class Singleton {  
        /**  
         * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例  
         * 没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载  
         */  
        private static class SingletonHolder{  
            /**  
             * 静态初始化器，由JVM来保证线程安全  
             */  
            private static Singleton instance = new Singleton();  
        }  
        /**  
         * 私有化构造方法  
         */  
        private Singleton(){  
        }  
        public static  Singleton getInstance(){  
            return SingletonHolder.instance;  
        }  
    }

当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.instance，导致 SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。

这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本

相关推荐