如何创建多线程环境下的可序列化单例模式

本文从以下几个点讲解：

1. 实现单例的两种方式（预加载&懒加载）
2. 多线程环境下的单例
3. 可序列化的单例
4. 对以上代码的重构
5. 单例与枚举

1. 实现单例的两种方式

预加载：

public class Foo {    private static final Foo INSTANCE = new Foo();    private Foo() {        if(INSTANCE != null) {            throw new IllegalStateException("Already instantiated");        }    }    public static Foo getInstance() {        return INSTANCE;    }}

懒加载：

class Foo {    private static Foo INSTANCE = null;    private Foo() {        if(INSTANCE != null) {            throw new IllegalStateException("Already instantiated");        }    }    public static Foo getInstance() {        if(INSTANCE == null) {            INSTANCE = new Foo();        }        return INSTANCE;    }}

2. 多线程环境下的单例

上面的代码在单线程的情况下可以满足需要，如果在多线程环境下，则需要进行修改：

class Foo {    // 请注意volatile关键字    private static volatile Foo INSTANCE = null;    private Foo() {        if(INSTANCE != null) {            throw new IllegalStateException("Already instantiated");        }    }    public static Foo getInstance() {        if(INSTANCE == null) {          // check 1            synchronized(Foo.class) {                if(INSTANCE == null) {  // check 2                    INSTANCE = new Foo();                }            }        }        return INSTANCE;    }}

3. 可序列化的单例

解决了多线程环境下的单例，可以进一步的思考如何实现可序列化的单例。反序列化可以不通过构造函数直接生成一个对象，所以反序列化时，我们需要保证其不再创建新的对象。
关于序列化的详细文章：click me

class Foo implements Serializable {    private static final long serialVersionUID = 1L;    private static volatile Foo INSTANCE = null;    private Foo() {        if(INSTANCE != null) {            throw new IllegalStateException("Already instantiated");        }    }    public static Foo getInstance() {        if(INSTANCE == null) {            synchronized(Foo.class) {                if(INSTANCE == null) {                    INSTANCE = new Foo();                }            }        }        return INSTANCE;    }    @SuppressWarnings("unused")    private Foo readResolve() {        return INSTANCE;    }}

readResolve方法可以保证，即使程序在上一次运行时序列化过此单例，也只会返回全局唯一的单例。

4. 对以上代码重构

public class Foo implements Serializable {    private static final long serialVersionUID = 1L;    // 使用内部静态class实现懒加载    private static class FooLoader {        // 保证在多线程下无差错运行        private static Foo INSTANCE = new Foo();    }    private Foo() {        throw new UnsupportedOperationException("can not construct this Foo");    }    public static Foo getInstance() {        return FooLoader.INSTANCE;    }    @SuppressWarnings("unused")    private Foo readResolve() {        return FooLoader.INSTANCE;    }}

5. 单例与枚举

最后提供一种更加简洁的方法：

public enum Foo {    INSTANCE;}

08年 google 开发者年会中，Joshua Bloch Joshua Bloch 在 高效 Java 话题中解释了这种方法，视频请戳 这里，在他 演讲的ppt 30-32 页提到：

// 实现单例正确的方式如下：public enum Elvis {    INSTANCE;    private final String[] favoriteSongs = { "Hound Dog", "Heartbreak Hotel" };    public void printFavorites() {        System.out.println(Arrays.toString(favoriteSongs));    }}

在 Effective Java 线上部分 说到：

上述实现单例的方式，其实等同于将 INSTANCE 设置为 public static final 的方式。
不同之处在于，使用枚举的方式显得更为简洁，而且枚举默认提供了序列化机制，也保证了多线程访问的安全。
虽然这种单例的实现方式还没有被广泛使用，但是实现单例的最好方式就是使用一个单元素的枚举。

为什么可以这么简洁？

因为 Java 中每一个枚举类型都默认继承了 java.lang.Enum，而 Enum 实现了 Serializable 接口，所以枚举类型对象都是默认可被序列化的。
通过反编译，也可以知道枚举常量本质上是一个pubilc static final xxx

关于序列化的详细文章：click me