java面试常见模式问题---单例模式

public class SingletonLazy {
    // 当需要用到该实例的时候再创建实例对象
    private static SingletonLazy instance;
    
    private SingletonLazy() {
    }
    
    public void process() {
        System.out.println("方法实例化成功！");
    }
    
    public static SingletonLazy getInstance() {
        if (instance == null) {// 实例为null时候才创建
            
            instance = new SingletonLazy();// 当需要的时候再进行实例化对象
        }
        return instance;
    }
    
    public static synchronized SingletonLazy getInstance2() {
        if (instance == null) {// 实例为null时候才创建
            // 方法上加synchronized锁后可以保证线程安全
            instance = new SingletonLazy();// 当需要的时候再进行实例化对象
        }
        return instance;
    }
    
    public static SingletonLazy getInstance3() {
        if (instance == null) {// 实例为null时候才创建
            // 局部加锁后可以保证线程安全,效率较高
            // 缺陷：假设线程A和线程B
            synchronized (SingletonLazy.class){
                // 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化
                // 当A线程执行完毕后，B再获得执行权，这时候还是可以实例化该对象
                instance = new SingletonLazy();// 当需要的时候再进行实例化对象
            }
        }
        return instance;
    }
}

public static SingletonLazy getInstance3plus() {
    if (instance == null) {// 实例为null时候才创建
        // 局部加锁后可以保证线程安全,效率较高
        // 假设线程A和线程B 
        synchronized (SingletonLazy.class){// 第一重检查
            // 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化
            // 当A线程执行完毕后，B再获得执行权，这时候再判断instance == null是否成立
            // 如果不成立，B线程无法 实例化SingletonLazy
            if (instance == null){// 第二重检查
                instance = new SingletonLazy();// 当需要的时候再进行实例化对象
            }
        }
    }
    return instance;
}

// 添加volatile 关键字，禁止实例化对象时，内存模型中出现指令重排现象
private static volatile SingletonLazy instance;

public static SingletonLazy getInstance3plusplus() {
    if (instance == null) {// 实例为null时候才创建
        // 局部加锁后可以保证线程安全,效率较高
        // 假设线程A和线程B
        synchronized (SingletonLazy.class){// 第一重检查
            // 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化
            // 当A线程执行完毕后，B再获得执行权，这时候再判断instance == null是否成立
            // 如果不成立，B线程无法 实例化SingletonLazy
            if (instance == null){// 第二重检查
                instance = new SingletonLazy();// 当需要的时候再进行实例化对象
            }
        }
    }
    return instance;
}

@Test
public void testSingletonLazy(){
    SingletonLazy.getInstance().process();
}

public class SingletonHungry {
    // 当类加载的时候就直接实例化对象
    private static SingletonHungry instance = new SingletonHungry();
    private SingletonHungry(){}
    
    public void process() {
        System.out.println("方法实例化成功！");
    }
    public static SingletonHungry getInstance(){
        return instance;// 当类加载的时候就直接实例化对象
    }
}

@Test
public void testSingletonHungry(){
    SingletonHungry.getInstance().process();
}