单例模式学习

并发编程解决思路：

1.实例化过程只有一次

2.提供返回实例对象的方法

1.饿汉模式

public class HungerySingleton {
    //加载的时候就产生的实例对象,ClassLoader
    //private byte[] data=new byte[1024];
    private static HungerySingleton instance=new HungerySingleton();
    private HungerySingleton(){
    }

    //返回实例对象
   public static HungerySingleton getInstance(){
        return instance;
   }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                System.out.println(HungerySingleton.getInstance());
            }).start();
        }
    }
}

线程安全性：在加载的时候已经被实例化，只有一次，线程安全的，不同的线程使用同一个实例对象

懒加载：不是延迟加载，如果有数据，长时间不用，占内存，性能有影响

性能：性能比较好

2.懒汉模式

public class HoonSingleton {
    private static HoonSingleton instance=null;
    private HoonSingleton(){
    }

    public static HoonSingleton getInstance(){
        if(null==instance)
            instance=new HoonSingleton();
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                System.out.println(HoonSingleton.getInstance());
            }).start();
        }
    }
}

线程安全性：不安全，不能保证实例对象的唯一性

懒加载：实现

性能：性能比较好

3.懒汉式+同步方法

public class HoonSynSingleton {
    private static HoonSynSingleton instance=null;
    private HoonSynSingleton(){
    }

    public synchronized static HoonSynSingleton getInstance(){
        if(null==instance)
            instance=new HoonSynSingleton();
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                System.out.println(HoonSynSingleton.getInstance());
            }).start();
        }
    }
}

线程安全性：安全

懒加载：实现

性能：synchronized 退化到了串行执行 

4.DCL

import java.net.Socket;
import java.sql.Connection;

//Double-check-locking
public class DCL {
    Connection conn;
    Socket socket;
    private static DCL instance=null;
    private DCL(){
    }

    public  static DCL getInstance(){
        if(null==instance)
            synchronized (DCL.class){
                if(null==instance)
                        instance=new DCL();
            }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                System.out.println(DCL.getInstance());
            }).start();
        }
    }
}

线程安全性：安全

懒加载：实现

性能：比较好 

Happy-before原则  指令重排 导致空指针异常

5.Volatile+DCL

private volatile static DCL instance=null;

解决指令重排问题

6.Holder模式

类声明的时候，成员变量中不声明实例变量，而放到内部静态类中

public class HolderDemo {
    private HolderDemo(){

    }
    private static class Holder{
        private static HolderDemo instance=new HolderDemo();
    }
    //懒加载
    //synchronized
    //<init>
    public static HolderDemo getInstance(){
        return Holder.instance;
    }

    //广泛的一种单例模式
}

线程安全性：安全

懒加载：实现

性能：比较好

7.枚举类型实现

public enum EnumSingleton {
    INSTANCE;
    public static EnumSingleton getInstance(){
        return INSTANCE;
    }
}

//holder
//枚举
//DCL

线程安全性：安全

懒加载：否

性能：比较好

改进之后支持懒加载：

public class EnumSingletonDemo {
    private EnumSingletonDemo(){
    }
    //延迟加载
    private enum EnumHolder{
        INSTANCE;
        private  EnumSingletonDemo instance=null;
        EnumHolder(){
            instance=new EnumSingletonDemo();
        }
        private EnumSingletonDemo getInstance(){
            return instance;
        }
    }//懒加载
    public static EnumSingletonDemo  getInstance(){
        return EnumHolder.INSTANCE.getInstance();
    }

}