单例模式的5种实现

1.懒汉模式

所谓懒汉模式，就是在类装载的时候就对象就已经被实例化实例化

要素：

A: getInstance ->获取实例方法；

B：instance 实例对象

C: private 构造函数 （在其他class无法new出来）

实现代码：

public class singleton {


    /**
     * 饿汉式：指全局的类实例在类装载时构建,类无法做到延迟加载
     *
     */

    private  static  singleton instance = new singleton();

    private singleton(){};

    public  static singleton getInstace()
    {
        return  instance;
    }

}

2.懒汉式

即需要的时候再创建实例

public class singleton {

    private  singleton singleton2 = null;

    private  singleton(){};

    public singleton getInstance()
    {
        if(singleton2 == null) singleton2 = new singleton();
        return  singleton2;
    }

}

3.懒汉式

线程安全的写法,缺点是效率较低

public class  singleton {
  private  static singleton singleton2 = null;

    private  singleton(){};

    public synchronized static singleton getInstance()     //线程安全的写法
    {
        if(singleton2 == null) singleton2 = new singleton();
        return  singleton2;
    }
}

4.双重检查锁

注意这里用到了volatile 关键字，其主要作用如下：

正确的双重检查锁定模式需要需要使用 volatile。volatile主要包含两个功能。

1. 保证可见性。使用 volatile 定义的变量，将会保证对所有线程的可见性。
2. 禁止指令重排序优化。

public class  singleton {
private  static volatile singleton singleton2 = null;

    private  singleton(){};

    public  static singleton getInstance()     //线程安全的写法
    {
       if(singleton2 == null)
       {
          synchronized ( singleton.class)
          {
              singleton2 = new singleton();
          }
       }
       return  singleton2;
    }
}

5.静态内部类

静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。即当SingleTon第一次被加载时，并不需要去加载SingleTonHoler，只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载SingleTonHoler类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。
 

public class singleton {
    private  singleton(){};
    private static  class SingleTonHoler
    {
        private  static singleton singleton2 =  new singleton();
    }
    public static singleton getInstance()
    {
        return  SingleTonHoler.singleton2;
    }
}