单例设计模式的八种实现

一、饿汉式之静态常量

1.1 实现步骤

1. 私有化构造方法
2. 本类内部创建对象实例并私有化
3. 提供一个公开的静态方法返回实例对象，供外部访问

代码实现

public class Singleton implements Serializable {
    //1.构造器私有化
    private Singleton(){}

    //2.本类内部创建对象实例
    private static final Singleton instance = new Singleton();

    //3.提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }

    private Object readResolve(){
        return instance;
    }
}

1.2 优缺点说明

1）优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
2）缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。
3) 这种方式基于classloader机制避免了多线程的同步问题。不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到了lazy loading的效果。
4）并且这种方式对于反射和序列化都是不安全的。
反射
测试

我们可以看到通过反射获取构造方法之后我们可以new一个实例，这个实例和通过饿汉式得到的实例对象并不是同一个实例。

序列化
工具类

public class SerializeUtil {
    //将当前对象序列化到一个obj的文件中
    public static void serialize(Object obj) {
        ObjectOutputStream output = null;
        try {
            File file = new File("obj");
            output = new ObjectOutputStream(new FileOutputStream(file));
            output.writeObject(obj);
            output.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //把obj文件反序列化成一个对象
    public static Object unzerialize() {
        ObjectInputStream input = null;
        try {
            File file = new File("obj");
            input = new ObjectInputStream(new FileInputStream(file));
            //读取
            Object object = input.readObject();
            return object;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

测试

可以看到，我们先把对象序列化到obj文件中，然后又从obj文件中反序列化获取两个对象，这两个对象并不是同一个对象。出现这种情况的原因是静态的变量在序列化的时候是不会被保存的，那么在反序列化的时候就会重新生成实例，这样就破坏了单例。

解决序列化问题的方法是，我们在类中加一个方法，让这个方法最终返回这个实例对象。就像开始代码中的那个readResolve()方法就是解决了这种序列化的问题。

二、饿汉式之静态代码块

这种方式和第一种方式有点类似。

public class Singleton2 implements Serializable {
    private Singleton2() {
    }

    private static Singleton2 instance;

    static {
        instance = new Singleton2();
    }

    public static Singleton2 getInstance() {
        return instance;

    }
}

这种方式和第一种方式有些类似，只不过把实例化的过程放在了静态代码块中，也是在类装载的时候就执行静态代码块中的代码，初始化类的实例。优缺点和第一种是一样的。

三、静态内部类

public class Singleton3 {
    //私有化构造方法
    private Singleton3(){}

    //在静态内部类里面创建实例
    private static class SingletonHolder{
        private static final Singleton3 instance = new Singleton3();
    }

    //对外提供静态公开方法用于获取对象
    public static Singleton3 getInstance(){
        return SingletonHolder.instance;
    }
}

在Singleton3装载的时候并不会装载静态内部类，只有当我们去调用getInstance()方法的时候才会去装载静态内部类，而在装载类的时候，因为JVM的一种保护机制（具体叫啥忘了），线程是安全的。所以这种方式是属于一种线程安全，并且不会造成多余浪费的方式。但是这种方式对反射和序列化也是不安全的。

四、枚举式

public enum Singleton4 {
    INSTANCE{
        @Override
        protected void doSomething() {
            System.out.println("doSomething");
        }
    };
    protected abstract void doSomething();
}

枚举式是Java 1.5之后才出来的一种形式，用这种形式实现单例是很简单的，并且线程安全且对反射和反序列化都是安全的。是推荐使用的一种形式。

五、懒汉式（线程不安全）

public class Singleton5 implements Serializable {
    private static Singleton5 instance;
    private Singleton5(){}

    //提供一个静态公开的方法，当使用到该方法的时候才会去创建instance
    public static Singleton5 getInstance(){
        if(instance==null){
            instance = new Singleton5();
        }
        return instance;
    }
}

这种方式起到了懒加载的效果，但是只能在单线程下使用。在多线程情况下，一个线程进入了if(singleton == null)判断语句块，还未来的及往下执行，另一个线程也通过这个判断语句，这时便会产生多个实例。同时这种方式对于反射和反序列化也是不安全的

六、懒汉式（线程安全）

public class Singleton6 {
    private static Singleton6 instance;
    private Singleton6(){}

    //提供一个静态公开的方法，当使用到该方法的时候才会去创建instance
    public static synchronized Singleton6 getInstance(){
        if(instance==null){
            instance = new Singleton6();
        }
        return instance;
    }
}

与懒汉式的线程不安全相比用一个synchronized关键字实现了线程安全的问题，但同时也带了了效率低的问题。其他的问题也没有解决。

七、懒汉式（同步代码块）

public class Singleton7 {
    //提供私有静态类的成员属性(不初始化)
    private static Singleton7 instance = null;

    //私有构造方法
    private Singleton7() {

    }

    //对外提供公有静态方法获取对象
    public static  Singleton7 getInstance() {
        //判断instance是否已经被初始化
        if (instance == null) {
            synchronized(Singleton7.class){
                if(instance==null){
                    instance = new Singleton7();
                }
            }
        }
        return instance;
    }
}

解决了线程安全但是效率不高

八、双重检查锁

public class Student5 {
    //提供私有静态类的成员属性(不初始化)
    private volatile static Student5 instance = null;

    //私有构造方法
    private Student5() {

    }

    //对外提供公有静态方法获取对象
    public static Student5 getInstance() {
        //判断instance是否已经被初始化
        if (instance == null) {
            synchronized(Student5.class){
                if(instance==null){
                    instance = new Student5();
                }
            }
        }
        return instance;
    }
}

这种方式是一种比较好的方式，刚开始的时候instance为null，加入两个线程a和b同时通过了第一个if判断，然后线程a先得到锁进入第二个if判断，创建了一个实例。线程b得到锁之后通过判断得到instance不为null，直接return。后续的线程再进来在第一个if那里就已经进不到if判断里面的同步代码块了。解决了线程频繁等待锁所带来的消耗。同时使用volatile关键字使得变量的值能够及时在主内存中刷新，保证了每个线程得到的instance的值都是最新的。