在Java并发编程的领域中，单例模式是一种常见且实用的设计模式，它确保一个类只有一个实例，并提供一个全局访问点。在多线程环境下实现线程安全的单例模式并非易事，需要深入理解Java的并发机制和相关特性。
单例模式的实现方式有多种，不同的实现方式在线程安全、性能等方面存在差异。最基本的单例模式实现是饿汉式。饿汉式单例在类加载时就创建了实例，这种方式天然具备线程安全性。因为类的加载过程是由JVM保证线程安全的，所以在多线程环境下不会出现多个实例的问题。以下是饿汉式单例的示例代码：
```java
public class EagerSingleton {
private static final EagerSingleton INSTANCE = new EagerSingleton();
private EagerSingleton() {}
public static EagerSingleton getInstance() {
return INSTANCE;
}
}
```
饿汉式的优点是简单直接，不需要额外的同步操作，性能较高。但它的缺点也很明显，无论是否使用该实例，都会在类加载时创建，可能会造成资源的浪费。
为了避免饿汉式的资源浪费问题，我们可以采用懒汉式单例。懒汉式单例在第一次使用时才创建实例。但是，在多线程环境下，简单的懒汉式实现是线程不安全的。以下是简单懒汉式的示例代码：
```java
public class LazySingleton {
private static LazySingleton INSTANCE;
private LazySingleton() {}
public static LazySingleton getInstance() {
if (INSTANCE == null) {
INSTANCE = new LazySingleton();
}
return INSTANCE;
}
}
```
在多线程环境下，多个线程可能同时进入`if (INSTANCE == null)`语句块，从而创建多个实例，破坏了单例模式的唯一性。为了解决这个问题，我们可以使用同步方法来保证线程安全。
```java
public class SynchronizedLazySingleton {
private static SynchronizedLazySingleton INSTANCE;
private SynchronizedLazySingleton() {}
public static synchronized SynchronizedLazySingleton getInstance() {
if (INSTANCE == null) {
INSTANCE = new SynchronizedLazySingleton();
}
return INSTANCE;
}
}
```
使用`synchronized`关键字修饰`getInstance`方法，确保同一时间只有一个线程可以进入该方法，从而保证了线程安全。但是，这种方式会带来性能开销，因为每次调用`getInstance`方法都需要进行同步操作。
为了进一步优化性能，我们可以采用双重检查锁定（Double-Checked Locking）的方式。双重检查锁定在保证线程安全的尽量减少了同步操作的范围。
```java
public class DoubleCheckedLockingSingleton {
private static volatile DoubleCheckedLockingSingleton INSTANCE;
private DoubleCheckedLockingSingleton() {}
public static DoubleCheckedLockingSingleton getInstance() {
if (INSTANCE == null) {
synchronized (DoubleCheckedLockingSingleton.class) {
if (INSTANCE == null) {
INSTANCE = new DoubleCheckedLockingSingleton();
}
}
}
return INSTANCE;
}
}
```
在双重检查锁定中，首先检查实例是否已经创建，如果没有创建，则进入同步块。在同步块中再次检查实例是否已经创建，避免多个线程同时创建实例。使用`volatile`关键字修饰`INSTANCE`变量，确保变量的可见性，避免指令重排序带来的问题。
除了上述方法，还有一种更为优雅的实现方式——静态内部类单例。静态内部类在外部类加载时不会被加载，只有在调用`getInstance`方法时才会加载内部类并创建实例。
```java
public class StaticInnerClassSingleton {
private StaticInnerClassSingleton() {}
private static class SingletonHolder {
private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
}
public static StaticInnerClassSingleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
```
静态内部类单例利用了类加载的特性，保证了线程安全，同时避免了饿汉式的资源浪费问题，是一种比较推荐的实现方式。
在Java并发编程实战中，选择合适的线程安全单例模式对于系统的性能和稳定性至关重要。我们需要根据具体的业务场景和需求，综合考虑各种实现方式的优缺点，选择最适合的单例模式。对于多线程编程，我们还需要深入理解Java的并发机制，避免出现线程安全问题。
标签： java并发编程实战pdf java并发编程深度解析
