虽说单例模式属于设计模式中最简单的一个模式，但是如果深入探索一下，其实还是有些学问的。比如：

• 如何设计一个线程安全的单例？
• 如何设计一个多线程环境中耗时较低的单例？
  接下来，我将按照以下流程，用实验来验证单例模式的线程安全问题，以及多线程环境下，如何让对象实例创建时耗时更少。

非线程安全的单例-懒汉式

public class SingletonLazy {

    private static SingletonLazy singleton = null;

    private static int counter = 0;

    private SingletonLazy() {
        counter++;
        System.out.println(String.format("线程[%s]调用构造器，对象被创建[%d]次", Thread.currentThread().getName(), counter));
    }

    public static SingletonLazy getInstance() {
        if (singleton == null) {
            singleton = new SingletonLazy();
        }
        return singleton;
    }

}

那么，我们怎么知道它是否线程安全呢？
接下来，我们使用Runnable，来创建10个线程，来观察构造器被调用了多少次。如果被调用了多次，自然创建了多个对象，就是线程不安全的：

public class SingleTonApplication {

    /**
     * 简单的懒汉式在多线程环境下不是线程安全的。
     * @param args
     */
    public static void main(String[] args) {
        // 检测线程安全性
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                SingletonLazy singletonLazy = SingletonLazy.getInstance();
                System.out.println(String.format("[%s]线程打印当前对象：%s", Thread.currentThread().getName(), singletonLazy.toString()));
            }
        };
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }// end for

    }// end main
}

输出结果如下：

线程[Thread-7]调用构造器，对象被创建[8]次
线程[Thread-3]调用构造器，对象被创建[3]次
线程[Thread-1]调用构造器，对象被创建[4]次
线程[Thread-6]调用构造器，对象被创建[7]次
线程[Thread-2]调用构造器，对象被创建[2]次
线程[Thread-4]调用构造器，对象被创建[5]次
线程[Thread-0]调用构造器，对象被创建[2]次
线程[Thread-5]调用构造器，对象被创建[6]次
线程[Thread-9]调用构造器，对象被创建[10]次
[Thread-0]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@2116aeb
线程[Thread-8]调用构造器，对象被创建[9]次
[Thread-4]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@2eac0b4
[Thread-2]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@1c2bd9d7
[Thread-6]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@4bcf6203
[Thread-1]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@475f7458
[Thread-3]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@46d8dc2e
[Thread-7]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@44fd2254
[Thread-8]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@4268d15
[Thread-5]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@45826b5c
[Thread-9]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@755688aa

可以看出，多个线程在竞争CPU资源时，创建了不止一个实例。
通过这个实验，可以看出，这个单例不是线程安全的。
于是，我们给getInstance方法加上synchronized关键字：

public static synchronized SingletonLazy getInstance() {...}

输出如下：

线程[Thread-8]调用构造器，对象被创建[1]次
[Thread-2]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@48c85a33
[Thread-4]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@48c85a33
[Thread-5]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@48c85a33
[Thread-8]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@48c85a33
[Thread-3]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@48c85a33
[Thread-9]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@48c85a33
[Thread-0]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@48c85a33
[Thread-1]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@48c85a33
[Thread-6]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@48c85a33
[Thread-7]线程打印当前对象：com.hua.singleton.lazy.SingletonLazy@48c85a33
Process finished with exit code 0

可以看到线程[Thread-8]抢到了CPU资源，创建了唯一的实例。
这时，线程安全的问题解决了。但是引发了一个新问题：
当有多个线程几乎同时访问getInstance方法时，多个线程必须有次序地进入方法内，这样导致了若干个线程需要耗费等待进入临界区（被锁住的代码块）的时间。我们在getInstance方法添加sleep()来让进入临界区的线程等会儿，模拟对象在获取对象时的耗时，改造后的代码如下：

线程安全的单例-懒汉式

public class Singleton {

    private static Singleton singleton = null;

    private static int counter = 0;

    private Singleton() {
        counter++;
        System.out.println(String.format("构造对象被调用[%d]次", counter));
    }

    /**
     * 当有多个线程几乎同时访问getInstance方法时，多个线程必须有次序地进入方法内，
     * 这样导致了若干个线程需要耗费等待进入临界区（被锁住的代码块）的时间。
     * @return
     */
    public static synchronized Singleton getInstance() {
        // 模拟同步方法的耗时  start
        try {
            System.out.println(String.format("[%s]获取对象实例等待1秒", Thread.currentThread().getName()));
            Thread.sleep(1000);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 模拟同步方法的耗时  end
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }

}

现在，我们需要借助CountDownLatch类，来让main主线程等待所有的子线程执行结束再结束，然后我们统计获取10次对象实例的耗时：

public class SingleTonApplication {

    public static void main(String[] args) throws InterruptedException {

        int createTimes = 10;

        final CountDownLatch latch = new CountDownLatch(createTimes);

        // 检测线程安全性
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                Singleton singleton = Singleton.getInstance();
                System.out.println(String.format("[%s]线程打印当前对象：%s", Thread.currentThread().getName(), singleton.toString()));
                latch.countDown();
            }
        };

        long start = System.currentTimeMillis();

        for (int i = 0; i < createTimes; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }// end for

        latch.await(); // 等待所有线程执行完
        System.out.println(String.format("获取对象[%d]次耗时：[%dms]", createTimes, (System.currentTimeMillis() - start)));

    }// end main
}

输出如下：

[Thread-5]获取对象实例等待1秒
构造对象被调用[1]次
[Thread-9]获取对象实例等待1秒
[Thread-5]线程打印当前对象：com.hua.singleton.lazythreadsafe.Singleton@b07848
[Thread-8]获取对象实例等待1秒
[Thread-9]线程打印当前对象：com.hua.singleton.lazythreadsafe.Singleton@b07848
[Thread-7]获取对象实例等待1秒
[Thread-8]线程打印当前对象：com.hua.singleton.lazythreadsafe.Singleton@b07848
[Thread-6]获取对象实例等待1秒
[Thread-7]线程打印当前对象：com.hua.singleton.lazythreadsafe.Singleton@b07848
[Thread-1]获取对象实例等待1秒
[Thread-6]线程打印当前对象：com.hua.singleton.lazythreadsafe.Singleton@b07848
[Thread-2]获取对象实例等待1秒
[Thread-1]线程打印当前对象：com.hua.singleton.lazythreadsafe.Singleton@b07848
[Thread-4]获取对象实例等待1秒
[Thread-2]线程打印当前对象：com.hua.singleton.lazythreadsafe.Singleton@b07848
[Thread-3]获取对象实例等待1秒
[Thread-4]线程打印当前对象：com.hua.singleton.lazythreadsafe.Singleton@b07848
[Thread-0]获取对象实例等待1秒
[Thread-3]线程打印当前对象：com.hua.singleton.lazythreadsafe.Singleton@b07848
[Thread-0]线程打印当前对象：com.hua.singleton.lazythreadsafe.Singleton@b07848
获取对象[10]次耗时：[10052ms]

根据输出日志，我们看到，每个线程在获取实例时，都需要等待一定的时间。多线程的优势并没有发挥出来，其实，我们只需要在创建对象时，进行同步。所以，引入双重校验锁的单例创建模式。

线程安全、耗时更少的单例-双重校验锁

public class SingletonDCL {

    private volatile static SingletonDCL singleton;

    private static int counter = 0;

    private SingletonDCL() {
        counter++;
        System.out.println(String.format("构造对象被调用[%d]次", counter));
    }

    /**
     * 双重校验锁式（也有人把双重校验锁式和懒汉式归为一类）分别在代码锁前后进行判空校验，
     * 避免了多个有机会进入临界区的线程都创建对象，
     * 同时也避免了后来线程在"lazythreadsafe"中，先来线程创建对象后，但仍未退出临界区的情况下等待
     * @return
     */
    public static SingletonDCL getInstance() {
        // 模拟同步方法的耗时  start
        try {
            System.out.println(String.format("[%s]获取对象实例等待1秒", Thread.currentThread().getName()));
            Thread.sleep(1000);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 模拟同步方法的耗时  end
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new SingletonDCL();
                }// end if
            }// end syn
        }// end if
        return singleton;
    }

}

实验代码：

public class SingleTonApplication {

    public static void main(String[] args) throws InterruptedException {
        int createTimes = 10;
        final CountDownLatch latch = new CountDownLatch(createTimes);

        // 检测线程安全性
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                SingletonDCL singleton = SingletonDCL.getInstance();
                System.out.println(String.format("[%s]线程打印当前对象：%s", Thread.currentThread().getName(), singleton.toString()));
                latch.countDown(); // 将count值减1
            }
        };

        long start = System.currentTimeMillis();

        for (int i = 0; i < createTimes; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }// end for

        // 等待所有线程完成工作
        latch.await();
        System.out.println(String.format("获取对象[%d]次耗时：[%dms]", createTimes, (System.currentTimeMillis() - start)));

    }// end main
}

控制台输出为：

[Thread-9]获取对象实例等待1秒
[Thread-6]获取对象实例等待1秒
[Thread-1]获取对象实例等待1秒
[Thread-7]获取对象实例等待1秒
[Thread-2]获取对象实例等待1秒
[Thread-3]获取对象实例等待1秒
[Thread-5]获取对象实例等待1秒
[Thread-8]获取对象实例等待1秒
[Thread-0]获取对象实例等待1秒
[Thread-4]获取对象实例等待1秒
构造对象被调用[1]次
[Thread-1]线程打印当前对象：com.hua.singleton.dcl.SingletonDCL@7115e166
[Thread-2]线程打印当前对象：com.hua.singleton.dcl.SingletonDCL@7115e166
[Thread-3]线程打印当前对象：com.hua.singleton.dcl.SingletonDCL@7115e166
[Thread-6]线程打印当前对象：com.hua.singleton.dcl.SingletonDCL@7115e166
[Thread-9]线程打印当前对象：com.hua.singleton.dcl.SingletonDCL@7115e166
[Thread-8]线程打印当前对象：com.hua.singleton.dcl.SingletonDCL@7115e166
[Thread-5]线程打印当前对象：com.hua.singleton.dcl.SingletonDCL@7115e166
[Thread-7]线程打印当前对象：com.hua.singleton.dcl.SingletonDCL@7115e166
[Thread-0]线程打印当前对象：com.hua.singleton.dcl.SingletonDCL@7115e166
[Thread-4]线程打印当前对象：com.hua.singleton.dcl.SingletonDCL@7115e166
获取对象[10]次耗时：[1031ms]

我们可以看到，在等待时，多个线程同时进入了getInstance方法。
随后，先检查一次singleton有没有被创建，如果被创建了，就直接返回。如果没有被创建，进入同步代码块。
在同步代码块中，再判断一次有没有singleton对象，如果有就不做处理。没有时，才创建。
这时，可能有朋友问，为何同步代码块里面也要判断if (singleton == null)呢？我们可以想象一下，多个线程同时走到getInstance方法中，这时同步代码块里，singleton还没有被创建，如果不判断，程序会认为此处应该创建实例，这样就会有多个实例被创建。我们的单例模式自然就不起作用了。

总结

双重校验锁式的单例模式线程安全，同时避免了后来线程在先来线程创建对象后，但仍未退出临界区的情况下的等待。