单例模式之懒汉与饿汉与双重加锁机制

单例模式

单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。
单例模式的实现
1.饿汉式
饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

package com.it.sign;
public class A2 {
    //定义一个该类的静态变量 实例化
    public static final A2 a = new A2();
    //构造方法私有化
    private A2(){
    }
    public static A2 getInstance(){
            return  a;
        }
    }

饿汉式是线程安全的，因为虚拟机保证只会装载一次，在装载类的时候是不会发生并发的。

2.懒汉式
懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间。

package com.it.sign;
/*
 * 单例（单态）一个类只能生成一个对象
 *   1 构造方法私有化
 *   2 定义一个该类的静态变量
 *   3 对外提供一个public返回实例的静态方法
 * 如果该变量为null，生成该对象，如果不为不null，直接返回该对象
 */
 
public class A {
    //定义一个该类的静态变量
  public static A a;
  
    //构造方法私有化
    private A(){

    }

    /**
     * 对外提供一个public返回实例的静态方法
     *  如果该变量为null，
     *  生成该对象，如果不为不null，
     *  直接返回该对象
     */
    public static A getInstance(){
        if(a==null){
            a = new A();
            return  a;
        }else
        {
            return  a;
        }
    }
}

从线程安全性上讲，不加同步的懒汉式是线程不安全的，比如，有两个线程，一个是线程A，一个是线程B，它们同时调用getInstance方法，那就可能导致并发问题
当然懒汉式也是可以实现线程安全的，只要加上synchronized即可，如下：

package com.it.sign;
public class A {
    //定义一个该类的静态变量
    public static A a;
    //构造方法私有化
    private A(){
    }
	public  synchronized  static A getInstance(){
        if(a==null){
            a = new A();
            return  a;
        }else
        {
            return  a;
        }
    }
}

但是这样一来，会降低整个访问的速度，而且每次都要判断。那么有没有更好的方式来实现呢？
3.双重检查加锁
可以使用"双重检查加锁"的方式来实现，就可以既实现线程安全，又能够使性能不受到很大的影响。那么什么是"双重检查加锁"机制呢？

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

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

package com.it.sign;
public class A {
    //定义一个该类的静态变量
  public volatile static A a;
  
    //构造方法私有化
    private A(){

    }
    public static A getInstance(){
      //先检查实例是否存在，如果不存在才进入下面的同步块  
        if(a == null){  
            //同步块，线程安全地创建实例  
            synchronized(A.class){  
                //再次检查实例是否存在，如果不存在才真正地创建实例  
                if(a == null){  
                    a = new A();  
                }  
          }  
    }
    return a;
}

这种实现方式可以实现既线程安全地创建实例，而又不会对性能造成太大的影响。它只是在第一次创建实例的时候同步，以后就不需要同步了，从而加快了运行速度。