理解设计模式——创建型模式（5）单例模式

单例模式

为什么要使用单例模式？

1. 保证一个类只有一个实例。为啥要保证一个类只有一个实例呢？因为这样可以控制某些共享资源的访问权限。
2. 提供一个全局访问节点。全局变量也可以提供这种功能，但是全局变量很不安全，任何人在任何位置都能对这些全局变量进行覆盖。

单例模式的特点

1. 构造函数私有化。防止其他人随便就“new”出一个实例来。
2. 通过一个静态方法获取实例。这个静态方法会在首次被调用的时候，调用该类的私有构造函数生成实例对象并缓存。以后被调用的时候直接返回缓存中的实例对象。

单线程/多线程问题（代码展示）：

单例模式比较好理解，唯一的难点可能就是和多线程相关的问题，直接上码吧。代码的运行结果写在注释里了。

1. 单线程下的单例模式。

/**
 * 懒汉式单例，线程不安全
 */
public class Singleton {
    private static Singleton singleton;
    public String name;
    
    private Singleton(String name){
        this.name = name;
    }
    
    public static Singleton getInstance(String name){
        if(null == singleton){
            singleton = new Singleton(name);
        }
        return singleton;
    }
}

/**
 * 线程不安全单例模式，客户端测试代码
 */
public class client {
    public static void main(String[] args) {
        // 单线程测试
//        Singleton singleton1 = Singleton.getInstance("singleton1");
//        Singleton singleton2 = Singleton.getInstance("singleton2");
//        System.out.println(singleton1.name); // "singleton1"
//        System.out.println(singleton2.name); // "singleton1"
        // 多线程测试
        Thread thread1 = new Thread(new thread1());
        Thread thread2 = new Thread(new thread2());
        thread1.start();  // "singleton1"
        thread2.start();  // "singleton2"
    }

    static class thread1 implements Runnable { // 内部的有static方法，这里类前不加static会报错

        @Override
        public void run() {
            Singleton singleton3 = Singleton.getInstance("singleton1");
        }
    }

    static class thread2 implements Runnable {

        @Override
        public void run() {
            Singleton singleton4 = Singleton.getInstance("singleton2");
        }
    }
}

2. 多线程下的单例模式。

/**
 1. DCL+懒汉式单例，线程安全
 */
public class Singleton {
    private static volatile Singleton singleton;
    public String name;

    private Singleton(String name){
        this.name = name;
    }

    /**
     * 使用DCL(double-checked locking,双重检验锁)的懒汉式获取单例对象
     */
    public static Singleton getInstance(String name){
        // first-check: 提高性能，避免每个线程都执行synchronized
        if(null == singleton){
            synchronized (Singleton.class){
                // second-check: 可能多个线程通过第一层检验，没有第二层检验会生成多个实例
                if(null == singleton){
                    singleton = new Singleton(name);
                }
            }
        }
        return singleton;
    }
}

/**
 * 线程安全单例模式，客户端测试代码
 */
public class client {
    public static void main(String[] args){
        // 多线程测试
        Thread thread1 = new Thread(new CreationalPatterns.SingletonPattern.ThreadSafe.client.thread1());
        Thread thread2 = new Thread(new CreationalPatterns.SingletonPattern.ThreadSafe.client.thread2());
        thread1.start();  // "singleton1"
        thread2.start();  // "singleton1"
    }

    static class thread1 implements Runnable { // 内部的有static方法，这里类前不加static会报错

	@Override
	public void run() {
            CreationalPatterns.SingletonPattern.NotThreadSafe.Singleton singleton3 = CreationalPatterns.SingletonPattern.NotThreadSafe.Singleton.getInstance("singleton1");
            System.out.println(singleton3.name);
        }
    }

    static class thread2 implements Runnable {

	@Override
	public void run() {
            CreationalPatterns.SingletonPattern.NotThreadSafe.Singleton singleton4 = Singleton.getInstance("singleton2");
            System.out.println(singleton4.name);
        }
    }
}

单例模式总结

1. 单例模式分为“饿汉式”和“懒汉式”两种，“懒汉式”更为普遍。二者的区别并不难理解，因此本文也就不过多讨论了。
2. 多线程下单例模式存在线程不安全的问题，代码展示1的client测试类清楚地展示了这一点：不同的线程获取了不同的单例（“singleton1”和“singleton2”）。通过双重检验锁（DCL）可以较为完美地解决线程安全问题，从代码展示2的client测试类看到，不同的线程获取到了同一个单例（“singleton1”）。
3. 线程安全的实现：DCL+ synchronized + volatile。
     synchronized关键字 ：用来控制线程同步。当synchronized关键字修饰一个代码块的时候（例如代码展示2的singleton类），这个代码块不能被多个线程同时访问，不同线程想要访问只能排队一个访问结束后下一个再访问。
      volatile关键字：这个关键字修饰的是singleton类的实例。volatile关键字在生成实例的时候禁止了重排序（简单来说，重排序是cpu为了提高效率采取的一种手段，可自行百度）。如果不使用这个关键字，在使用DCL的时候可能会出现程序报错的隐患（参考这里）。
      DCL：双重检验锁的原理是什么？顾名思义是检查了两次，检查了两次啥呢？检查了两次singleton实例是否存在：if(null == singleton){}。第一重检查（first check）目的是节省资源，因为synchronized是个很耗资源的操作。first check可以在已经有线程生成了一个实例的情况下，其它线程可以绕过synchronized；第二重检查（second check）目的是保证只生成一个实例。结合代码展示2中的DCL部分，可能存在多个线程同时通过first check的情况，假如没有second check，那么有多少个线程就会生成多少个实例（synchronized失去意义，大家轮流排队生成新实例）。

共同学习，欢迎交流！
这里是源码