Java设计模式 - 单例模式详解（下）

单例模式引发相关整理

关联线程安全

在多线程下，懒汉式会有一定修改。当两个线程在if(null == instance)语句阻塞的时候，可能由两个线程进入创建实例，从而返回了两个对象。对此，我们可以加锁，保证仅有一个线程处于getInstance（）方法中，从而保证了线程一致性。多线程下的单例

/**
 * @author sunyang
 * @date 2018/11/8 12:18
 */
public class Singleton4 {

    private static Singleton4 instance;

    private Singleton4(){

    }
    //需要加上synchronized 同步
    public static synchronized Singleton4 getInstance(){
        if (instance == null){
            instance = new Singleton4();
        }
        return instance;
    }
}

如果一个项目中有100次获取实例，那么jvm就会有100次进行加锁，释放锁的操作，每次操作都浪费资源。

可以在最外层再加一层判断，如下

/**
 * @author sunyang
 * @date 2018/11/12 19:07
 */
public class Singleton41 {
    private static Singleton41 instance;

    private Singleton41(){}

    private static synchronized void doGetInstance(){
        if (null == instance){
            instance = new Singleton41();
        }
    }

    public static synchronized Singleton41 getInstance(){
        if (null == instance){
            doGetInstance();
        }
        return instance;
    }
}

简化形式后：

/**
 * @author sunyang
 * @date 2018/11/12 19:13
 */
public class Singleton5 {

    private static Singleton5 instance;

    private Singleton5(){}

    //如果多个线程同时通过第一次检查，并且其中一个线程
    // 首先通过了第二次检查并实例化了对象，那么剩余通过了
    //第一次检查的线程就不会再去实例化对象。提升了效率
    public static Singleton5 getInstance(){
        if (null == instance){
            synchronized (Singleton5.class){
                if (null == instance){
                    instance = new Singleton5();
                }
            }
        }
        return instance;
    }
}

题外话：一个类在new的时候，一般经历以下三个顺序：

1.开辟空间

2.符号引用改空间，并在空间内对类进行初始化操作

3.将符合引用转为直接引用这个时候if(null==instance) return false;

---

在实际的情况中，为了降低CPU的闲置时间，jvm会对指令进行重排序以形成指令流水线。顺序可能乱序：

1.开辟空间

2.转为直接引用

3.初始化类

结论：双重检查机制就会出现问题：可能返回一个未被完全初始化的类；

代码不安全截图

 

volatile单例中的作用

• 可见性：jvm中每一个线程都有自己的内存区域。对变量使用volatile修饰，可以强制将每一次的读写都写入堆内存中，实现了各个线程都能共享的最新数据。
• 禁止指令重排序优化：被volatile修饰的变量，在赋值的结尾会插入一个内存屏障，从而防止指令重排序。volatile增强了数据的一致性。

/**
 * 解决上图双重检查机制出现的问题，可能返回一个未被完全初始化的类
 *
 * @author sunyang
 * @date 2018/11/12 20:24
 */
public class Singleton51 {

    private static volatile Singleton51 instance;

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

如果实现懒加载

先了解下静态嵌套类的使用

静态嵌套类：是一种在类之外声明的嵌套类，由于是静态的，所以不经过初始化，就可以通过类名直接调用。

内部类：该类作为另一个类的成员，因此只有引用另一个类，才能创建这个类。通过静态嵌套类，便可以实现

对饿汉式进行懒化的效果。

/**
 * @author sunyang
 * @date 2018/11/12 20:42
 */
public class Singleton6 {
    private Singleton6(){}
    //静态内部类
    private static class SingletonHolder{
        private static Singleton6 INSTANCE = new Singleton6();
    }

    //通过静态嵌套类，便可以实现对饿汉式进行懒化的效果
    public static final Singleton6 getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

分析

要分析这种方式有没有实现懒加载，就要分析一下语句new Singleton6()是什么时候被调用的.

使用javac进行编译，会得到如下图的三个class文件：

 

从图上可以看到，静态嵌套类是单独作为一个class存在，而其中创建对象的逻辑位于嵌套类中，jvm读取嵌套类的字节码以后才能创建对象，从硬盘中读取class文件，在内存中分配空间，是一件费事费力的工作，所以jvm选择按需加载，没有必要加载的就不加载，没必要分配就不分配。