单例模式

单例模式是指确保一个类仅有一个唯一的实例，并且提供一个全局的访问点

设计思路：将构造方法声明为private， 然后提供一个可以获取该实例的静态方法，即getInstance方法。

单例模式可以控制实例数目，节省系统资源。

单例模式有多种写法，不同的写法有不同的性能与特性。

1 懒汉模式

/*
* 懒汉模式，延迟实例化，线程不安全，当线程A进入if（instance == null）后中断，
* 此时instance == null，线程B亦可进入if（instance == null）并实例化A后中断，
* 执行线程A，此时线程A执行instance  =new A（）;实例化。违反了单例模式的唯一实例
*/
class A{
    private static A instance = null;
    public int b = 0;
    private A(){b++;}
    void f(){
        System.out.println("实例化次数："+b);
        System.out.println("我是A");

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

2 同步的懒汉模式

//懒汉模式，延迟实例化，线程安全，但是加锁，效率低，若非程序对获取实例
//即getInstance的性能不做要求，不然不建议使用

class B{
    private static B instance=null;
    public int b = 0;
    private B(){b++;}
    public void f(){
        System.out.println("实例化次数："+b);
        System.out.println("我是B");
    }
    public static synchronized B getInstance(){
        if(instance == null)
            instance = new B();
        return instance;
    }
}

3.饿汉模式

//饿汉模式， 使用static关键字，在类加载时就实例化，这种模式没有使用加锁，
//性能较好，也能实现线程安全，但如果没有用到这个实例，便会导致这个实例成为垃圾，
//浪费资源。对于对资源敏感的系统不建议使用此种方式。
//注：反射和反序列化能破解这种写法的单例模式
class C{
    private static C instance = new C();
    public int b = 0;
    private C(){
        b++;
    }
    public void f(){
        System.out.println("初始化次数："+b);
        System.out.println("我是C");
    }
    public static C getInstance(){
        return  instance;
    }
}

4.枚举实现单例模式

//使用枚举， 推荐这种写法，简单
// 线程安全
// 防止反射和反序列化操作破解
// 无延时加载
enum D{
    INSTANCE;
    public void f(){
        System.out.println("我是D");
    }
    public static D getInstance(){
        return INSTANCE;
    }
}

还有一种写法是双重锁，但并不能保证线程安全，详见https://blog.youkuaiyun.com/chenchaofuck1/article/details/51702129