单例模式各种写法

单例模式

单例设计模式，采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例。

单例模式使用场景

1. 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

2. 当想实现一个单例类的时候，必须要记住使用相应获取对象的方法，而不是使用new

3. 需要频繁的进行创建和销毁的对象，创建对象是消耗时间过多或耗费资源过多，但又经常用到的对象，工具类对象，频繁访问数据库或文件的对象等（比如数据源，session等）。

饿汉式（静态常量）

步骤：

1. 构造器私有化

2. 类的内部创建对象

3. 向外部暴露一个静态的公共方法

 /**
  * @author 
  * （饿汉式 静态常量写法）
  */
 public class SingleTest01 {
     private SingleTest01(){
 ​
     }
     private final static SingleTest01 INSTANCE = new SingleTest01();
     public static  SingleTest01 getInstance (){
        return INSTANCE;
     }
 }
 ​
 ​

测试：

 //测试：  
     @Test
     public void test(){
         SingleTest01 singleTest01= SingleTest01.getInstance();
         SingleTest01 singleTest02= SingleTest01.getInstance();
         System.out.println(singleTest01);
         System.out.println(singleTest02);
 ​
     }  

优点：写法简单，在类装载时就完成了实例化，避免了线程同步问题

缺点： 在类装载就完成实例化，没有达到懒加载（lazy loading）的效果，如果没有用到这个实例，可能造成内存浪费。

饿汉式（静态代码块）

 **
  * @author 
  * （饿汉式: 静态代码块）
  */
 public class SingleTest02 {
     private SingleTest02(){
 ​
     }
     private  static SingleTest02 INSTANCE ;
     static {
         INSTANCE = new SingleTest02();
     }
     public static SingleTest02 getInstance (){
        return INSTANCE;
     }
 ​
 }
 ​

测试：

 //测试：
   
     @Test
     public void test(){
         SingleTest02 singleTest01= SingleTest02.getInstance();
         SingleTest02 singleTest02= SingleTest02.getInstance();
         System.out.println(singleTest01);
         System.out.println(singleTest02);
 ​
     }  

优缺点同饿汉式静态常量

懒汉式(线程不安全):

 /**
  * @author 
  * （懒汉式: 静态代码块）
  */
 public class SingleTest03 {
     private SingleTest03(){
 ​
     }
     private  static SingleTest03 INSTANCE ;
     public static SingleTest03 getInstance (){
        if(INSTANCE ==null){
            INSTANCE =new SingleTest03();
        }
        return INSTANCE;
     }
 ​
 }

优缺点：起到懒加载的效果，但是只能在单线程下使用

原因：在多线程情况下，一个线程进入了if(INSTANCE ==null)判断但还没来得及往下执行，另一个也通过了这个判断语句，产生多个实例。

懒汉式(线程安全):

 /**
  * @author
  * （懒汉式: 静态代码块）
  */
 public class SingleTest04 {
     private SingleTest04(){
 ​
     }
     private  static SingleTest04 INSTANCE ;
     //加入synchronized
     public static synchronized SingleTest04 getInstance (){
        if(INSTANCE ==null){
            INSTANCE = new SingleTest04();
        }
        return INSTANCE;
     }
 }

优点： 实现了懒加载解决了线程不安全问题。

缺点：效率太低，每个线程想获取类的实例时候，getInstance()方法都要进行同步。

双重检查

 /**
  * @author
  *  双重检查
  */
 public class SingleTest05 {
     private SingleTest05(){
 ​
     }
     // volatile 实时写入主存
     private  static volatile SingleTest05 INSTANCE ;
     //加入双重解决代码 解决线程安全 同时实现懒加载
     public static synchronized SingleTest05 getInstance (){
        if(INSTANCE ==null){
            synchronized (SingleTest05.class){
                if (INSTANCE == null) {
                    INSTANCE=new SingleTest05();
                }
            }
        }
        return INSTANCE;
     }
 }

优点：实现了懒加载，线程安全，同时提高了效率，推荐使用

静态内部类方式

 /**
  * @author
  * （静态内部类实例）
  */
 public class SingleTest06 {
     private SingleTest06(){
 ​
     }
     private static class SingletonInstance {
         private static final SingleTest06 INSTANCE = new SingleTest06();
     }
 ​
     public static SingleTest06 getInstance(){
         return SingletonInstance.INSTANCE;
     }
 ​
 }

优点：

1. 这种方式采用类装载的机制来保证初始化实例只有一个线程

2. 静态内部类方式在SingleTest06类被装载时并不会立即实例化，而是在需要实例化时，调用了getInstance方法，才会装载SingletonInstance类，从而完成SingleTest06 的实例化。

3. 类的静态属性只会在第一次加载类的时候进行初始化，jvm保证了线程的安全性，在类进行初始化时，别的线程无法进入

4. 避免了线程不安全，利用静态内部类特点实现了延迟加载，效率高

枚举方式

 public enum Singleton07 {
     INSTANCE;
     public void sayHello(){
         System.out.println("hello");
     }
 }

测试：

  @Test
     public void test5(){
         Singleton07 singleTest01= Singleton07.INSTANCE;
         Singleton07 singleTest02= Singleton07.INSTANCE;
         System.out.println(singleTest01 == singleTest02);
         singleTest01.sayHello();
     }

优缺点：不仅避免多线程同步问题，而且该方法还能防止反序列化从新创建新的对象。