Java并发编程 - 深入单例模式（您的单例模式写对了吗？）

在Java并发编程中，单例模式是一种常用的软件设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。在多线程环境中正确实现单例模式尤为重要，因为如果不正确地实现，可能会导致多个实例被创建，从而破坏单例模式的目的。

单例模式的实现方式

单例模式有多种实现方式，每种方式都有其优缺点。下面介绍几种常见的单例模式实现方式，并探讨它们在并发环境下的表现。

1. 饿汉式（静态常量）

这是最简单的单例模式实现，它在类加载时就创建了单例对象。

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}
1
2
3
4
5
6
7
8
9

优点：

• 实现简单。
• 线程安全，因为实例在类加载时就已经创建。

缺点：

• 不论是否使用，单例对象都会被创建，可能造成资源浪费。

2. 懒汉式（双重检查锁定）

这是一种常用的懒加载单例模式实现，它只有在第一次被请求时才创建单例对象。为了避免在多线程环境下创建多个实例，使用了synchronized关键字。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

优点：

• 按需创建实例，节省资源。
• 利用了双重检查锁定来提高性能。

缺点：

• 如果多个线程同时进入第一个if语句，可能存在多个线程同时执行new Singleton()的情况，导致创建多个实例。

3. 静态内部类

这是另一种懒加载单例模式实现，它结合了饿汉式和懒汉式的特点，既实现了延迟加载，又保证了线程安全性。

public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}
1
2
3
4
5
6
7
8
9
10
11

优点：

• 实现简单，易于理解。
• 线程安全，因为实例是在静态内部类加载时创建的。
• 实例是延迟加载的，提高了性能。

缺点：

• 相比饿汉式，稍微复杂一点。

4. 枚举

使用枚举可以轻松实现线程安全的单例模式，而且避免了同步带来的性能开销。

public enum Singleton {
    INSTANCE;

    public void someMethod() {
        // ...
    }
}
1
2
3
4
5
6
7

优点：

• 自然地实现了线程安全。
• 实现简单，易于理解。
• 枚举的实例化由JVM保证线程安全。

缺点：

• 语法上与传统单例模式略有不同。

5. 反序列化安全

在某些情况下，即使实现了上述任一单例模式，反序列化也可能导致创建额外的实例。为了解决这个问题，可以重写readResolve方法来确保单例模式的完整性。

public class Singleton implements Serializable {
    private static final long serialVersionUID = 1L;
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }

    protected Object readResolve() {
        return INSTANCE;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

优点：

• 防止反序列化时创建额外的实例。

总结

在Java并发编程中，正确实现单例模式对于保证程序的正确性和性能至关重要。在选择单例模式实现时，需要考虑到线程安全、延迟加载、性能等因素。使用静态内部类或枚举是实现线程安全单例模式的好方法，它们不仅易于理解和实现，而且天然地保证了线程安全。在实际应用中，可以根据具体需求选择合适的实现方式。