Java Singleton单例模式六种实用写法

背景

以下列举Singleton模式的6种常见写法，并简要说明。分别是：
饿汉式、懒汉式、基本线程安全式、volatile线程安全式、枚举式、静态内部类式。

• 饿汉式【线程安全】

1. 二话不说上来就实例化。
2. 在线程没出现前就已经实例化了，因此饿汉式是线程安全的。
3. 只不过上来就实例化会多消耗一丢丢时间。

public class Singleton_1 {

    public int id = 0;
    public String name = "Singleton_1";
    public static Singleton_1 instance = new Singleton_1();

    private Singleton_1()
    {}

    public static Singleton_1 GetInstance()
    {
        return instance;
    }
}

• 懒汉式【线程不安全】

1. 用的时候再实例化。
2. 单线程可以玩一玩，多线程不安全。

public class Singleton_2 {

    public int id = 0;
    public String name = "Singleton_2";
    public static Singleton_2 instance;

    private Singleton_2()
    {}

    public static Singleton_2 GetInstance()
    {
        if(instance == null)
        {
            instance = new Singleton_2();
        }
        return instance;
    }
}
 

• 基本线程安全式【大部分时间线程安全】

1. 在懒汉的基础上改进，增加线程安全特性。
2. 使用synchronized锁及双重检查。
3. 在极少的极端情况下由于指令重排序，导致生出来instance是个残疾儿，基本线程安全。

public class Singleton_3 {

    private static Integer lock = 1; //作为一个锁，随便什么值
    public int id = 0;
    public String name = "Singleton_3";
    public static Singleton_3 instance;

    private Singleton_3()
    {}

    public static Singleton_3 GetInstance()
    {
        if(instance == null)
        {
            synchronized (lock) {
                if(instance == null)  instance = new Singleton_3();
            }
        }
        return instance;
    }
}

• volatile线程安全式【线程安全】

1. 使用volatile禁止指令重排序，真正的线程安全。

public class Singleton_4 {

    private static Integer lock = 1; //作为一个锁，随便什么值
    public int id = 0;
    public String name = "Singleton_4";
    public volatile static Singleton_4 instance;

    private Singleton_4()
    {}

    public static Singleton_4 GetInstance()
    {
        if(instance == null)
        {
            synchronized (lock) {
                if(instance == null)  instance = new Singleton_4();
            }
        }
        return instance;
    }
}

说明：要保证线程绝对安全volatile必须加，因为第一个线程会因为未加volatile对new Singleton_4()中的指令进行重排序而生成半初始化状态的instance对象，具体体现就是instance指向的内存中已经有变量了，但是是初始值(比如0)。这时候第二个线程进入临界区（且此时锁已经释放）判断instance不为空，而开始使用半初始化的instance对象。

• 枚举式【推荐】

1. Enum枚举单例，写法忒简单了也。
2. 利用JVM保证线程安全，无序列化、反射攻击等问题。

public enum Singleton_5 {
    INSTANCE; //定义一个枚举量，随便命名，这里是INSTANCE
    public int id = 0;  //枚举对象属性
    public String name = "Singleton_5";//枚举对象属性
    public void method()//枚举对象行为
    {
        System.out.println("any method ......");
    }
}

• 静态内部类式【推荐】

1. 饿汉式的改进；不会像饿汉式上来就实例化，内部类调用时才实例化。
2. 静态内部类通过JVM保证单例。
3. 线程安全。

public class Singleton_6 {

    //类Singleton_6其他方法
    public void method()
    {
        System.out.println("Singleton_6's method !");
    }

    public static Singleton_6 GetInstance()
    {
        return InnerConstructor.instance;
    }

    //内部类，用于构造Singleton_6
    static public class InnerConstructor
    {
        public static Singleton_6 instance = new Singleton_6();
    }
}