单例模式和多线程

前言：

    学过设计模式的同学都知道单例模式是23中设计模式中最简单也是实际应用中用到的最多的设计模式了，今天这篇文章就是讲解如何使单例模式在遇到多线程是安全正确的。

一、立即加载/“饿汉模式”

    什么是立即加载？立即加载就是使用类的时候已经将对象创建完毕，常见的实现办法就是直接new实例化。
    立即加载/''饿汉模式”是在调用方法前，实例已经被创建了。

代码示例：

public class Singleton {
    //立即加载方式 == 饿汉模式
    private static Singleton singleton = new Singleton();
    //构造函数私有化以防止他人创建实例
    private Singleton(){}
    public static Singleton getInstance() {
        return singleton;
    }
}

注意：此版本代码的缺点是不能有其他实例变量，因为getInstance()方法没有同步，所以有可能出现非线程安全问题。

二、延迟加载/“懒汉模式”

    什么是延迟加载？延迟加载就是在调用get()方法时实例才能被创建，常见的实现办法就是在get()方法中进行new实例化。
    延迟加载/“懒汉模式”是在调用方法时实例才被创建。

代码示例：

public class Singleton {
    private static Singleton singleton ;
    //构造函数私有化以防止他人创建实例
    private Singleton(){}
    public static Singleton getInstance() {
        //延迟加载
        if (singleton ! = null) {
            }else {
                singleton = new Singleton();
        }
        return singleton;
    }
}

注意：延迟加载实现了单例设计模式，但是在多线程环境中就会出现多个实例的情况，与单例模式的设计初衷是相违背的。本文逐步对延迟加载/“懒汉模式”的解决方案进行探讨。

一：声明synchronized关键字

    竟然多线程可以同时进入getInstance()方法，那么只需要对getInstance()方法声明synchronized关键字即可。

代码示例：

public class Singleton {
    private static Singleton singleton;
    //构造函数私有化
    private Singleton() {
    }
    synchronized public static Singleton getInstance() {
        try {
            if (singleton != null) {
            } else {
                //模拟创建对象前做的其他工作
                Thread.sleep(3000);
                singleton = new Singleton();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return singleton;
    }
}

注意：此方法加入同步synchronized关键字在多线程环境下可以得到相同实例的对象，但运行效率非常低下，且是同步运行的，下一个线程想要取得对象，则必须等上一个线程释放锁之后，才可以继续执行。

二：同步代码块

    同步方法是对方法的整体进行持锁，这对运行效率是非常不利的，因此可以对代码块进行同步。

代码示例：

public class Singleton {
    private static Singleton singleton;
    //构造函数私有化以防止他人创建实例
    private Singleton() {
    }
     public static Singleton getInstance() {
        try {
            synchronized (Singleton.class) {
                if (singleton != null) {
                } else {
                    //模拟创建对象前做的其他工作
                    Thread.sleep(3000);
                    singleton = new Singleton();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return singleton;
    }
}

注意：此种方法等同于synchronized public static Singleton getInstance()的写法，效率一样低下，全部代码被上锁。

三：针对重要代码进行单独的同步

    针对某些重要的代码进行单独的同步，而其他的代码则不需要同步，这在运行时效率会显著提高。

代码示例：

public class Singleton {
    private static Singleton singleton;

    //构造函数私有化
    private Singleton() {
    }

    public static Singleton getInstance() {
        try {
            if (singleton != null) {
            } else {
                //模拟创建对象前做的其他工作
                Thread.sleep(3000);
                synchronized (Singleton.class) {
                    singleton = new Singleton();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return singleton;
    }
}

注意：此方法只对实例化对象的关键代码进行同步，从语句结构上来讲，运行得效率的确得到了提升。但如果是遇到多线程的情况下还是无法解决得到同一实例对象的结果。因此提出方案四使用DCL双检查锁机制。

四：使用DCL双检查锁机制

    使用DCL双检查锁机制来实现多线程环境中的延迟加载单例设计模式。

代码示例：

public class Singleton {

    private volatile static Singleton singleton;
    //构造函数私有化
    private Singleton() {
    }

    /**
     * 使用双检查锁机制来解决问题，既保证了不需要同步代码块的异步执行性,又保证了单例模式的效果
     */
    public static Singleton getInstance() {
        try {
            if (singleton != null) {
            } else {
                //模拟创建对象前做的其他工作
                Thread.sleep(3000);
                synchronized (Singleton.class) {
                    if (singleton == null) {
                        singleton = new Singleton();
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return singleton;
    }
}

小结：使用双重检查锁功能，成功解决了“懒汉模式”遇到的多线程问题。DCL也是大多数多线程结合单例模式使用的解决方案。

三、静态内部类实现单例模式

    使用静态内置类同样可以解决多线程单例模式的非线程安全问题。

代码示例：

public class Singleton {
    //内部类方式
    private static class SingletonHandler {
      private static Singleton singleton = new Singleton();
    }
    //构造函数私有化
    private Singleton() {}
    public static Singleton getInstance() {
        return SingletonHandler.singleton;
    }
}

注意：静态内部类可以在多线程环境下实现单例的线程安全，但在序列化实例对象时，使用默认的方式运行得到的结果还是多例的。