你是否真的能把单例模式给写好？

发表于 | 更新于: | 分类于

当你看到这个标题的时候，以为我是一个标题党？（其实也是…）

但是你真的不能小瞧这个单例模式，不信的话，你可以继续往下看。

小白些单例模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * Created with vernon-test
 *
 * @description: 设计模式-单例模式
 * @author: chenyuan
 * @date: 2020/6/7
 * @time: 9:25 PM
 */
public class Singleton {

    private static Singleton instance = null;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
            System.out.println("我开始new对象了~");
        }
        return instance;
    }
}

这种单例估计是我们第一眼就能想到的，咋一眼看没问题，因为我们的大脑一眼反应我们的程序都是单线程的。实际上我们系统在初始化的时候就有可能存在多线程的情况。我们模拟并发写一个小程序来验证下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * Created with vernon-test
 *
 * @description: 测试类
 * @author: chenyuan
 * @date: 2020/6/7
 * @time: 9:27 PM
 */
public class TestCase {

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    Singleton instance = Singleton.getInstance();
                    System.out.println(instance);
                }
            });
            thread.start();
        }
    }
}

看一眼运行的结果：

1
2
3
4
5
6
7
8
9
10
11
12
我开始new对象了~
com.vernon.test.designpattern.singleton.Singleton@773d663a
com.vernon.test.designpattern.singleton.Singleton@a963d08
我开始new对象了~
com.vernon.test.designpattern.singleton.Singleton@773d663a
com.vernon.test.designpattern.singleton.Singleton@773d663a
com.vernon.test.designpattern.singleton.Singleton@773d663a
com.vernon.test.designpattern.singleton.Singleton@773d663a
com.vernon.test.designpattern.singleton.Singleton@773d663a
com.vernon.test.designpattern.singleton.Singleton@773d663a
com.vernon.test.designpattern.singleton.Singleton@773d663a
com.vernon.test.designpattern.singleton.Singleton@773d663a

很明显，new了2次对象，看打印的对象地址也是不对的。

那我们如何去改进呢？– 加锁

加synchronized锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * Created with vernon-test
 *
 * @description: 设计模式-单例模式
 * @author: chenyuan
 * @date: 2020/6/7
 * @time: 9:25 PM
 */
public class Singleton2 {

    private static Singleton2 instance = null;

    private Singleton2() {
    }
		 
    // 加锁不就搞定了吗？
    public static synchronized Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
            System.out.println("我开始new对象了~");
        }
        return instance;
    }
}

这个确实能解决掉问题，但是后续每次获取它的时候每次都要加锁排队，性能存在一定的问题。

Double Check

那是不是在方法里面做2次校验就能解决掉问题呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
 * Created with vernon-test
 *
 * @description: 设计模式-单例模式
 * @author: chenyuan
 * @date: 2020/6/7
 * @time: 9:25 PM
 */
public class Singleton3 {

    private static Singleton3 instance = null;

    private Singleton3() {
    }
    // double check
    public static Singleton3 getInstance() {
        if (instance == null) {
            synchronized (Singleton3.class) {
                if (instance == null) {
                    instance = new Singleton3();
                    System.out.println("我开始new对象了~");
                }
            }
        }
        return instance;
    }
}

从代码看上去，不管是单线程还是多线程，起码在instance==null的时候都能被hold住。但是表现懵逼了我们的双眼。如果这里发生了重排序，就会存在问题。

创建一个对象可以划分为3步：

  • 1、分配内存空间；
  • 2、初始化对象；
  • 3、将内存空间的地址赋值给对象的引用；

如果发生重排序的话，步骤2~3有可能颠倒过来。

防止重排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
 * Created with vernon-test
 *
 * @description: 设计模式-单例模式
 * @author: chenyuan
 * @date: 2020/6/7
 * @time: 9:25 PM
 */
public class Singleton4 {
	
  	// 加上volatile关键字，防止重排序
    private static volatile Singleton4 instance = null;

    private Singleton4() {
    }

    // double check
    public static Singleton4 getInstance() {
        if (instance == null) {
            synchronized (Singleton4.class) {
                if (instance == null) {
                    instance = new Singleton4();
                    System.out.println("我开始new对象了~");
                }
            }
        }
        return instance;
    }
}

在这里加上volatile关键字就可以很好的解决了。传送门：https://mp.weixin.qq.com/s/HtMphMK8lyrieg-663q9og

静态内部类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
 * Created with vernon-test
 *
 * @description: 设计模式-单例模式
 * @author: chenyuan
 * @date: 2020/6/7
 * @time: 9:25 PM
 */
public class Singleton5 {

    private static class SingletonHolder {
        public static Singleton5 instance = new Singleton5();
    }

    public static Singleton5 getInstance() {
        return SingletonHolder.instance;
    }
}

该方法采用内部类来解决，加载一个类时，其内部类不会同时被加载。一个类被加载，当且仅当其某个静态成员（静态域、构造器、静态方法等）被调用时发生。

参考地址

如果大家喜欢我的文章，可以关注个人订阅号。欢迎随时留言、交流。如果想加入微信群的话一起讨论的话，请加管理员简栈文化-小助手（lastpass4u），他会拉你们进群。

简栈文化服务订阅号