Java单例模式实现方式

懒汉式-非线程安全

1public class LazyNoSafe {
2    private static LazyNoSafe instance;
3    public static LazyNoSafe getInstance() {
4        if (instance == null) {
5            instance = new LazyNoSafe();
6        }
7        return instance;
8    }
9    private LazyNoSafe() {}
10}

说明：

• 延迟加载
• 非线程安全
• 无法保证序列化和反序列化单例

懒汉式-线程安全

1public class LazySafe {
2    private static LazySafe instance;
3    public synchronized static LazySafe getInstance() {
4        if (instance == null) {
5            instance = new LazySafe();
6        }
7        return instance;
8    }
9    private LazySafe() {}
10}

说明：

• 延迟加载
• 线程安全
• 无法保证序列化和反序列化单例
• 效率低下，synchronized很影响性能

懒汉式-静态内部类

1public class LazyUseInner {
2    private static class InnerClass {
3        private static LazyUseInner instance = new LazyUseInner();
4    }
5    public static LazyUseInner getInstance() {
6        return InnerClass.instance;
7    }
8    private LazyUseInner() {}
9}

说明

• 延迟加载
• 线程安全
• 无法保证序列化和反序列化单例

懒汉式-双重锁机制

1public class DoubleLock {
2    private volatile static DoubleLock instance;
3    public static DoubleLock getInstance() {
4        if (instance == null) { //第一次检查
5            synchronized(DoubleLock.class) {
6                if (instance == null) {
7                    instance = new DoubleLock();
8                }
9            }
10        }
11        return instance;
12    }
13    private DoubleLock() {}
14}

说明：

• jdk1.5及以上线程安全，volatile语义在jdk1.5得到修正
• 延迟加载
• 效率不错，由于有第一步检查，规避了绝大多数执行锁同步情况
• 无法保证序列化和反序列化单例

饿汉式

1public class HungrySafe {
2    private static HungrySafe instance = new HungrySafe();
3    public static HungrySafe getInstance() {
4        return instance;
5    }
6    private HungrySafe() {}
7}

说明：

• 简单粗暴
• 无法延迟加载
• 线程安全
• 无法保证序列化和反序列化单例

枚举单例

1public enum UseEnum {
2    INSTANCE;
3    public void otherMethod() {
4        // do something...
5    }
6}

说明

• 无法延迟加载
• 线程安全
• 保证序列化和反序列化单例
• Effective Java中推荐使用

结尾

对于序列化的反序列化可以实现readResolve()来保证单例。
项目中使用单例前最好先思考以下三点：线程安全、延迟加载、序列化与反序列化安全。