面试官：你写的单例模式有空指针异常，请你用Volatile改一下。我愣了五分钟

电玩女神 2021-09-24 19:16 197阅读 0赞

> 欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章，主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等，同时欢迎大家加我微信「java\_front」一起交流学习

# 1 单例模式 #

大家对单例模式并不会陌生，当创建一个对象需要消耗比较多资源时，例如创建数据库连接和消息服务端等等，这时我们选择只创建一份这种类型的对象并在进程内共享。

但是单例模式想要写好并不容易，我们写多个版本的单例模式看看每个版本都有什么问题。

## 1.1 版本一 ##

这个版本问题非常明显：getConnection方法中多个线程可能同时执行到语句1，而此时myConnection都为空，造成连接对象被多次创建。

public class MySimpleConnection { 
        private static MySimpleConnection myConnection = null;
    
        private MySimpleConnection() { 
            System.out.println(Thread.currentThread().getName() + " -> init connection");
        }
    
        public static MySimpleConnection getConnection() { 
            if (null == myConnection) {  // 语句1
                myConnection = new MySimpleConnection();
            }
            return myConnection;
        }
    
        public static void main(String[] args) { 
            for (int i = 0; i < 10; i++) { 
                new Thread(() -> { 
                    MySimpleConnection.getConnection();
                }, "threadName" + i).start();
            }
        }
    }

执行结果可以看出连接被创建多次：

threadName1 -> init connection
    threadName4 -> init connection
    threadName3 -> init connection
    threadName2 -> init connection
    threadName0 -> init connection

## 1.2 版本二 ##

这个版本在getConnection方法增加了同步关键字，可以正确处理同步问题，程序执行正确符合预期，但是将同步关键词加在方法上锁粒度较大，可能会影响性能。

public class MySynchronizeConnection { 
        private static MySynchronizeConnection myConnection = null;
    
        private MySynchronizeConnection() { 
            System.out.println(Thread.currentThread().getName() + " -> init connection");
        }
    
        public static synchronized MySynchronizeConnection getConnection() { 
            if (null == myConnection) { 
                myConnection = new MySynchronizeConnection();
            }
            return myConnection;
        }
    
        public static void main(String[] args) { 
            for (int i = 0; i < 10; i++) { 
                new Thread(() -> { 
                    MySynchronizeConnection.getConnection();
                }, "threadName" + i).start();
            }
        }
    }

执行结果正确符合预期：

threadName0 -> init connection

## 1.3 版本三 ##

这个版本采用DCL（Double Check lock）双重检查锁，缩小了同步锁粒度，性能会有所提升。

public class MyDCLConnection { 
        private static MyDCLConnection myConnection = null;
    
        private MyDCLConnection() { 
            System.out.println(Thread.currentThread().getName() + " -> init connection");
        }
    
        public static MyDCLConnection getConnection() { 
            if (null == myConnection) { 
                synchronized (MyDCLConnection.class) { 
                    if (null == myConnection) { 
                        myConnection = new MyDCLConnection();
                    }
                }
            }
            return myConnection;
        }
    
        public static void main(String[] args) { 
            for (int i = 0; i < 10; i++) { 
                new Thread(() -> { 
                    MyDCLConnection.getConnection();
                }, "threadName" + i).start();
            }
        }
    }

这段代码看似没有问题了，但是其实有一个严重问题：这段代码有可能引发空指针异常，也就是调用getConnection方法会拿到一个空对象。

你可能会说不对，我们不是判断了当连接不为空时才获取连接吗？怎么会拿到一个空对象呢？这就引出我们下一个话题：指令重排。

# 2 指令重排 #

在JVM编译代码时或者CPU执行JVM字节码时，为了提升性能可能对代码进行指令重排，也就是说代码执行顺序不一定是代码编写顺序。

指令重排目的是为了在不改变程序运行结果的前提下，优化程序运行效率，其中不改变运行结果是指在单线程场景下。

我们分析一个指令重排实例。

public void test() { 
        int a = 1; // 语句1
        int b = 2; // 语句2
        a = a + 1; // 语句3
        b = b * 2; // 语句4
    }

这段代码执行顺序可能如下：

1234
    1243
    1324
    2134
    2143
    2413

我们思考一下语句3和语句4会不会第一个执行？答案是不会。在进行指令重排时必须要考虑数据依赖性。

语句3依赖语句1，语句4依赖语句2，所以语句3和语句4不会第一个执行。这也告诉我们如果语句之间没有依赖关系就可能发生指令重排。

指令重排在多线程场景下会产生什么问题呢？我们分析一个多线程指令重排实例。

public class MyTest { 
        int a = 0;
        boolean b = false;
    
        public void method1() { 
            a = 1000; // 语句1
            b = true; // 语句2
        }
    
        public void method2() { 
            if (b) { 
                a = a + 1; // 语句3
                System.out.println(a);
            }
        }
        
        public static void main(String[] args) { 
            for (int i = 0; i < 10000; i++) { 
                MyTest test = new MyTest();
                new Thread(() -> test.method1()).start();
                new Thread(() -> test.method2()).start();
            }
        }
    }

我们思考一下a最终输出值是多少？答案是有可能是1或者1001。

*  由于变量a和b不存在数据依赖关系，所以经过指令重排，语句2可能先于语句1执行
 *  执行完语句2后可能还没有执行语句1，method2抢到执行机会执行语句3，这时执行结果等于1
 *  如果指令不重排，执行结果等于1001

所以在多线程环境，运行结果具有不确定性是指令重排可能带来的问题。

# 3 回到问题 #

再回到第一章节的问题：为什么会出现空指针异常？我们分析这一段代码。

public static MyDCLConnection getConnection() { 
        if (null == myConnection) {  // 语句1
            synchronized (MyDCLConnection.class) { 
                if (null == myConnection) { 
                    myConnection = new MyDCLConnection(); // 语句2
                }
            }
        }
        return myConnection; // 语句3
    }

我们重点分析语句2，new操作在更细的层面分为以下三个步骤:

(A) 分配新对象内存
    (B) 调用类构造器初始化成员变量
    (C) instance被赋为指向新对象的引用

经过指令重排可能形成以下新顺序：

(A) 分配新对象内存
    (B) instance被赋为指向新对象的引用
    (C) 调用类构造器初始化成员变量

根据新顺序我们分析一种异常场景：

*  线程1执行到语句2，执行到instance被赋为指向新对象的引用这个步骤，还没有初始化对象
 *  此时线程2执行到语句1，由于instance已经被赋为指向新对的象引，myConnection已经不等于null，所以可以执行到语句3
 *  但是语句3返回的是没有进行初始化的对象，所以使用这个对象就会抛出空指针异常

# 4 Volatile #

上述问题应该如何解决呢？本章节我们来谈一谈Volatile关键字。Volatile是JVM提供的轻量级同步机制，具有以下特性：

*  保证可见性
 *  不保证原子性
 *  保证有序性（禁止指令重排）

其中保证可见性和不保证原子性不在本文进行讨论，本文我们分析Volatile如何保证有序性。

Volatile禁止指令重排原理是使用了内存屏障。内存屏障是一种CPU指令，它使CPU或者编译器对屏障指令之前和之后发出的内存操作执行一个排序约束。通过插入内存屏障指令，禁止在内存屏障指令前后的指令进行重排序。内存屏障有如下四种类型：

*  LoadLoad
 *  StoreStore
 *  LoadStore
 *  StoreLoad

这样说有一些抽象，我们结合代码进行分析，还是使用上文代码实例，只是不同的是这一次我们新增了Volatile关键字。

public class MyTest { 
        int a = 0;
        volatile boolean b = false;
    
        public void method1() { 
            a = 1000; // 语句1
            b = true; // 语句2
        }
    
        public void method2() { 
            if (b) { 
                a = a + 1; // 语句3
                System.out.println(a);
            }
        }
        
        public static void main(String[] args) { 
            for (int i = 0; i < 10000; i++) { 
                MyTest test = new MyTest();
                new Thread(() -> test.method1()).start();
                new Thread(() -> test.method2()).start();
            }
        }
    }

我们将b变量声明为Volatile，那么在为b赋值即Volatile写前后会加上如下屏障，从而保证了语句1和语句2执行顺序不会重排。

volatile boolean b = false;
    public void method1() { 
      a = 1000; // 语句1
      StoreStore屏障
      b = true; // 语句2
      StoreLoad屏障
    }

在JDK5之后Volatile还可以保证对象构造是有序的，也就是说new操作如下步骤可以保证有序，这就为我们解决单例DCL空指针异常提供了思路。

(A) 分配新对象内存
    (B) 调用类构造器初始化成员变量
    (C) instance被赋为指向新对象引用

# 5 解决方案 #

经过上述分析我们可以使用Volatile解决单例DCL空指针异常。

public class MyVolatileConnection { 
        private static volatile MyVolatileConnection myConnection = null;
    
        private MyVolatileConnection() { 
            System.out.println(Thread.currentThread().getName() + " -> init connection");
        }
    
        public static MyVolatileConnection getConnection() { 
            if (null == myConnection) { 
                synchronized (MyVolatileConnection.class) { 
                    if (null == myConnection) { 
                        myConnection = new MyVolatileConnection();
                    }
                }
            }
            return myConnection;
        }
    
        public static void main(String[] args) { 
            for (int i = 0; i < 10; i++) { 
                new Thread(() -> { 
                    MyVolatileConnection.getConnection();
                }, "threadName" + i).start();
            }
        }
    }

代码改动并不大只需在声明MyConnection变量处加上Volatile关键字。本文我们从单例模式的一个问题出发，一步步分析到Volatile关键字原理并最终解决单例模式DCL空指针问题，希望本文对大家有所帮助。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dvc2hpeHV5ZQ_size_16_color_FFFFFF_t_70_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dvc2hpeHV5ZQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20210923/04a5bf40b2b34c9db68632a9d5bbb65e.png