1. 懒汉式(线程不安全)

代码:

/**
 * 单例 - 懒汉 - 线程不安全
 */
public class SingletonThreadUnsafe {

    private static SingletonThreadUnsafe instance;
    // 1. 构造方法私有化  -单例模式都需要这么做
    private SingletonThreadUnsafe(){}
    // 2. 提供一个静态的公有方法,当使用到该方法时,才会去创建实例-即懒汉模式
    public static SingletonThreadUnsafe getInstance(){
        if(instance== null){
            instance = new SingletonThreadUnsafe();
        }
        return instance;
    }
}

测试:

class SingletonThreadUnsafeTest {
    @Test
    void getInstance() {
        System.out.println("懒汉式 1 ， 线程不安全~");
        SingletonThreadUnsafe s1 = SingletonThreadUnsafe.getInstance();
        SingletonThreadUnsafe s2 = SingletonThreadUnsafe.getInstance();
        System.out.println(s1 == s2); // true
        System.out.println("s1.hashCode=" + s1.hashCode());
        System.out.println("s2.hashCode=" + s2.hashCode());
    }
}

在这里插入图片描述
说明:

起到了 Lazy Loading 的效果，但是只能在单线程下使用。
如果在多线程下，一个线程进入了 if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
结论：在实际开发中，不要使用这种方式.

2. 懒汉式(线程安全，同步方法)

代码:

/**
 * 单例-懒汉-同步方法 线程安全
 */
public class SingletonThreadSafeSync1 {
    //静态成员变量
    private static SingletonThreadSafeSync1 instance;

    //私有化构造方法
    private SingletonThreadSafeSync1() {
    }

    //提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
    public static synchronized SingletonThreadSafeSync1 getInstance() {
        if (instance == null) {
            instance = new SingletonThreadSafeSync1();
        }
        return instance;
    }
}

测试:

class SingletonThreadSafeSync1Test {
    @Test
    void getInstance() {
        System.out.println("懒汉式 2 ， 线程安全~");
        SingletonThreadSafeSync1 s1 = SingletonThreadSafeSync1.getInstance();
        SingletonThreadSafeSync1 s2 = SingletonThreadSafeSync1.getInstance();
        System.out.println(s1 == s2); // true
        System.out.println("instance.hashCode=" + s1.hashCode());
        System.out.println("instance2.hashCode=" + s2.hashCode());
    }
}

在这里插入图片描述
说明:

解决了线程安全问题.
效率太低了，每个线程在想获得类的实例时候，执行 getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低.
结论：在实际开发中， 不推荐使用这种方式.

3. 懒汉式(线程安全，同步代码块)

代码:

/**
 * 单例-懒汉-同步代码块 线程安全
 * 效率低不推荐使用
 */
public class SingletonThreadSafeSync2 {
    //静态成员变量
    private static SingletonThreadSafeSync2 instance;

    //私有化构造方法
    private SingletonThreadSafeSync2() {
    }
   //提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
    public static SingletonThreadSafeSync2 getInstance(){
        //不推荐,每次都会进入同步代码块,很影响效率
            synchronized (SingletonThreadSafeSync2.class){
                if (instance == null) {
                instance = new SingletonThreadSafeSync2();
            }
        }
        return instance;
    }
}

测试同上,效果同上,解决了线程安全问题, 但效率低,不推荐.

4. 双重检查(推荐)

代码:

/**
 * 双重检查
 */
public class DoubleCheck {
    // 注意加上volatile 关键字,防止指令重排
    private static volatile DoubleCheck instance;

    //私有化构造方法
    private DoubleCheck() {
    }

    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
    //同时保证了效率, 推荐使用
    public static DoubleCheck getInstance() {
        if (instance == null) {
            synchronized (DoubleCheck.class) {
                if (instance == null) {
                    //下面这句代码其实分为三步：
                    //1.开辟内存分配给这个对象
                    //2.初始化对象
                    //3.将内存地址赋给虚拟机栈内存中的doubleLock变量
                    //注意上面这三步，第2步和第3步的顺序是随机的，这是计算机指令重排序的问题
                    //假设有两个线程，其中一个线程执行下面这行代码，如果第三步先执行了，就会把没有初始化的内存赋值给doubleLock
                    //然后恰好这时候有另一个线程执行了第一个判断if(doubleLock == null)，然后就会发现doubleLock指向了一个内存地址
                    //这另一个线程就直接返回了这个没有初始化的内存，所以要防止第2步和第3步重排序
                    // 所以要加上加上volatile关键字,防止指令重排
                    instance = new DoubleCheck();
                }
            }
        }
        return instance;
    }
}

测试:

class DoubleCheckTest {
    @Test
    void getInstance() {
        System.out.println("双重检查");
        DoubleCheck s1 = DoubleCheck.getInstance();
        DoubleCheck s2 = DoubleCheck.getInstance();
        System.out.println(s1 == s2); // true
        System.out.println("instance.hashCode=" + s1.hashCode());
        System.out.println("instance2.hashCode=" + s2.hashCode());
    }
}

在这里插入图片描述
说明:

Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这样就可以保证线程安全了。
实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步
线程安全；延迟加载；效率较高
结论：在实际开发中，推荐使用这种单例设计模式

5. 静态内部类(推荐)

代码:

/**
 * 静态内部类实现单例, 推荐使用
 */
public class StaticInnerClass {
	// 防止指令重排
    private static volatile StaticInnerClass instance;
    //构造器私有化
    private StaticInnerClass() {}
    //写一个静态内部类,该类中有一个静态属性 Singleton
    //加载一个类时，其内部类不会同时被加载,利用内部类的这个特性来实现单例
    private static class SingletonInstance {
        private static final StaticInnerClass INSTANCE = new StaticInnerClass();
    }
    //提供一个静态的公有方法，直接返回 SingletonInstance.INSTANCE
    public static synchronized StaticInnerClass getInstance() {
        return SingletonInstance.INSTANCE;
    }
    Runtime a = Runtime.getRuntime();
}

测试:

class StaticInnerClassTest {
    @Test
    void getInstance() {
        System.out.println("使用静态内部类完成单例模式");
        StaticInnerClass instance = StaticInnerClass.getInstance();
        StaticInnerClass instance2 = StaticInnerClass.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}

在这里插入图片描述
说明:

这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。可参见这里
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
结论：推荐使用

6. 枚举

这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建
新的对象。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式
结论：推荐使用

不忘初心,方得始终

发布了132 篇原创文章 · 获赞 108 · 访问量 26万+

私信关注

创建型模式-单例设计-懒汉式(延迟加载)

创建型模式-单例设计-懒汉式

1. 懒汉式(线程不安全)

2. 懒汉式(线程安全，同步方法)

3. 懒汉式(线程安全，同步代码块)

4. 双重检查(推荐)

5. 静态内部类(推荐)

6. 枚举

猜你喜欢