单例模式 各种情况下的演进 多线程

说到单例模式，首先想到的就是懒汉式和饿汉式，当然各有各的特点和优势：

饿汉式在jvm加载时就会进行初始化，显然会比较占用系统资源，而懒汉式则是在需要使用的时候，才进行加载，又称之为延迟加载。

懒汉式代码：

public class Singleton{
    private static Singleton uniqueInstance;
    //私有构造方法
    private Singleton(){
        
    }
    //用getInstance()方法实例化对象，并返回这个实例
    public static Singleton getInstance(){
        if(uniqueInstance == null){
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

1.私有化构造方法；
2.创建一个私有的静态属性；
3.提供一个静态的getInstance方法，返回一个对象；
4.当对象为空时，创建对象，并返回。
到这里我们的懒汉式已经完成了，大工告成，万事大吉。但是事情远远还没有结束，万一有多个线程访问怎么办，会不会出问题，会不会出现多个不同的对象。

看下面这张图，当出现多线程时，会出现以下情况：

这个时候，我们引以为傲的性能非常好的懒汉式出现问题了，多线程情况下，会出现多个不同的对象，已经不再是单例了。

于是我们自然的想到了 synchronized关键字，对没错，加锁。

public class Singleton{
    private static Singleton uniqueInstance;
    //私有构造方法
    private Singleton(){
        
    }
    //同步方法，用getInstance()方法实例化对象，并返回这个实例
    public static synchronized Singleton getInstance(){
        if(uniqueInstance == null){
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

仅仅在前面懒汉式的基础上加了同步锁，就解决了多线程的问题，但是我们知道同步锁对性能是有影响的，如果我们对性能没有要求，那这样做当然没有问题，

如果没有追求，那咸鱼有什么区别（我想当一条咸鱼）。因为加了同步锁之后，有可能性能会下降100倍，至于具体是多少我也不知道。

既然不加锁会有线程问题，加了锁会有性能问题，那干脆直接使用饿汉式。

public class Singleton2{
    private static Singleton2 uniqueInstance = new Singleton2();
    private Singleton2(){
        
    }
    public static Singleton2 getInstance(){
        return uniqueInstance;
    }
}

这样多线程情况下也是同一个对象，但是这样会造成JVM加载此类时负担较重，所以我们还得想办法。

懒汉式的双重检查加锁就能完美的达到效果：

public class Singleton3{
    /**
     * volatile关键字是用来保证每个线程获取时是取的最后修改的值
     * 可以理解它为瞬态，也就是会从某个某个线程修改后立即更新主内存中的值
     * /
    private volatile static Singleton uniqueInstance;
    private Singleton3(){
        
    }
    
    /**
     * 使用双重判断，同时加上锁，这样解决了性能问题，只会在第一次加载
     * 为空的情况下，才走锁的代码块
     * /
    public static Singleton3 getInstance(){
        if(uniqueInstance == null){
            synchronized (Singleton3.class){
                if(uniqueInstance == null){
                    uniqueInstance = new Singleton3();
                }
            }
        }
        return uniqueInstance;
    }
}

其他步骤跟普通的懒汉式一样，属性使用了volatile关键字，主要是在多线程时，保证某个线程更改了属性，会立即更新到主内存中，并且线程每次拿到的都是最新的值。

使用双重非空判断，当uniqueInstance为空时走同步代码块，进入后防止另外的多线程也进入getInstance方法，如果此时已经创建，则再次进行非空判断，

为空时则创建对象。volatile的作用就是在多线程时体现出来了。

使用上面这个，完美解决，手工。