Java单例模式深度解析：手写实现与优化技巧
一、单例模式概述
单例模式（Singleton Pattern）是设计模式中最常见的一种，它确保一个类只有一个实例，并提供一个全局访问点。在Java中，单例模式广泛应用于各种场景，如数据库连接、配置文件读取、日志管理等。本文将深入分析单例模式，并探讨其手写实现与优化技巧。
二、单例模式实现方式
1. 懒汉式单例
懒汉式单例在类加载时不初始化，第一次使用时才创建实例。以下是懒汉式单例的实现代码：
```java
public class LazySingleton {
private static LazySingleton instance;
private LazySingleton() {}
public static synchronized LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
```
懒汉式单例存在线程安全问题，当多个线程同时访问getInstance()方法时，可能会导致创建多个实例。
2. 饿汉式单例
饿汉式单例在类加载时就初始化，保证了线程安全。以下是饿汉式单例的实现代码：
```java
public class EagerSingleton {
private static final EagerSingleton instance = new EagerSingleton();
private EagerSingleton() {}
public static EagerSingleton getInstance() {
return instance;
}
}
```
饿汉式单例在类加载时就完成了初始化，没有线程安全问题，但会占用更多的内存。
3. 双重校验锁单例
双重校验锁单例在懒汉式单例的基础上，通过双重校验锁来保证线程安全。以下是双重校验锁单例的实现代码：
```java
public class DoubleCheckSingleton {
private static volatile DoubleCheckSingleton instance;
private DoubleCheckSingleton() {}
public static DoubleCheckSingleton getInstance() {
if (instance == null) {
synchronized (DoubleCheckSingleton.class) {
if (instance == null) {
instance = new DoubleCheckSingleton();
}
}
}
return instance;
}
}
```
双重校验锁单例在保证线程安全的同时，减少了同步代码块的使用，提高了效率。
4. 静态内部类单例
静态内部类单例利用静态内部类来创建单例，保证了线程安全。以下是静态内部类单例的实现代码：
```java
public class StaticInnerClassSingleton {
private static class SingletonHolder {
private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
}
private StaticInnerClassSingleton() {}
public static final StaticInnerClassSingleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
```
静态内部类单例在类加载时不会创建实例，只有当调用getInstance()方法时才会创建实例，具有懒加载的特性，且保证了线程安全。
5. 枚举单例
枚举单例是Java 5及以上版本提供的单例实现方式，具有天然线程安全的特点。以下是枚举单例的实现代码：
```java
public enum EnumSingleton {
INSTANCE;
public void doSomething() {
// 业务逻辑
}
}
```
枚举单例在类加载时就完成了初始化，保证了线程安全，且枚举类本身就是单例，无需额外实现。
三、单例模式优化技巧
1. 避免使用反射破坏单例
反射可以破坏单例模式，因此，在实现单例时，需要防止反射攻击。以下是一个防止反射破坏单例的示例：
```java
public class ReflectionSingleton {
private static ReflectionSingleton instance;
private ReflectionSingleton() {}
public static ReflectionSingleton getInstance() {
if (instance == null) {
synchronized (ReflectionSingleton.class) {
if (instance == null) {
instance = new ReflectionSingleton();
}
}
}
return instance;
}
// 防止反射破坏单例
private Object readResolve() {
return instance;
}
}
```
在ReflectionSingleton类中，添加了readResolve()方法，当使用反射创建实例时，会调用该方法，返回单例实例。
2. 避免使用反序列化破坏单例
反序列化可以破坏单例模式，因此，在实现单例时，需要防止反序列化攻击。以下是一个防止反序列化破坏单例的示例：
```java
public class SerializationSingleton implements Serializable {
private static final long serialVersionUID = 1L;
private static SerializationSingleton instance;
private SerializationSingleton() {}
public static SerializationSingleton getInstance() {
if (instance == null) {
synchronized (SerializationSingleton.class) {
if (instance == null) {
instance = new SerializationSingleton();
}
}
}
return instance;
}
// 防止反序列化破坏单例
protected Object readResolve() {
return instance;
}
}
```
在SerializationSingleton类中，添加了readResolve()方法，当使用反序列化创建实例时，会调用该方法，返回单例实例。
四、总结
单例模式在Java中应用广泛，本文深入分析了单例模式的实现方式、优化技巧以及防止破坏单例的方法。在实际开发中，应根据具体需求选择合适的单例实现方式，并注意优化和防范攻击。
