多线程模式

单例模式

饿汉模式

public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

懒汉模式-单线程版

public class Singleton {
    private static Singleton instance ;
    private Singleton() {}
    public static Singleton getInstance() {
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

懒汉模式-多线程版-低性能

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

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

分析： 线程A执行完1，线程B执行1，县城A.B都执行2进行竞争对象锁，县城A抢占到锁，然后执行3创建一个新对象，然后释放锁，线程2竞争到对象锁，执行3,4又创建一个对象，两个线程执行完毕创建了两个锁不满足单利模式(单利模式是只是用一个对象)

懒汉模式-多线程-双重效验锁满足单例模式

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

双重效验：当线程A执行完已经创建对象，县城B不会再创建

volatile

1. 保证可见性
2. 禁止指令重排序
3. 不保证原子性

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

            }
        }
        return instance;
    }
}

• 假设volatile支持指令重排序
  
  

volatile禁止指令重排序作用

分解为原子性指令后，有被volatile修饰的变量的指令不能重排序，其余指令可以重排序,但是只能在它之前或之后排序不能跨越它，也就是要保持它的相对位置