要改进单例模式的实现以确保线程安全并优化性能，有几种常见的方法。以下是几种改进 `ThreadUtil` 单例实现的方法：
### 1. 懒汉式（线程安全版）
使用同步机制来确保线程安全，但只在第一次创建实例时同步，这样既保证了线程安全，又保持了懒加载的特点。
```java
public class ThreadUtil {
private static ThreadUtil instance;
private final ScheduledThreadPoolExecutor mThreadPoolExecutor;
private final ExecutorService singleThreadExecutor;
private ThreadUtil() {
mThreadPoolExecutor = new ScheduledThreadPoolExecutor(CORE_POOL_SIZE);
singleThreadExecutor = Executors.newSingleThreadExecutor();
}
public static synchronized ThreadUtil getInstance() {
if (instance == null) {
instance = new ThreadUtil();
}
return instance;
}
}
```
### 2. 饿汉式
在类加载时就创建实例，避免了同步问题，但牺牲了懒加载。
```java
public class ThreadUtil {
private static final ThreadUtil instance = new ThreadUtil();
// ... 其他代码
private ThreadUtil() {
// ... 初始化代码
}
public static ThreadUtil getInstance() {
return instance;
}
}
```
### 3. 双重检查锁定（Double-Checked Locking）
使用双重检查锁定来实现延迟加载和线程安全。
```java
public class ThreadUtil {
private static volatile ThreadUtil instance;
private final ScheduledThreadPoolExecutor mThreadPoolExecutor;
private final ExecutorService singleThreadExecutor;
private ThreadUtil() {
// ... 初始化代码
}
public static ThreadUtil getInstance() {
if (instance == null) {
synchronized (ThreadUtil.class) {
if (instance == null) {
instance = new ThreadUtil();
}
}
}
return instance;
}
}
```
### 4. 静态内部类
使用静态内部类的方式来实现单例，这种方式利用了类加载机制来保证初始化实例时的线程安全。
```java
public class ThreadUtil {
private final ScheduledThreadPoolExecutor mThreadPoolExecutor;
private final ExecutorService singleThreadExecutor;
private ThreadUtil() {
// ... 初始化代码
}
private static class Holder {
private static final ThreadUtil INSTANCE = new ThreadUtil();
}
public static ThreadUtil getInstance() {
return Holder.INSTANCE;
}
}
```
### 5. 枚举
使用枚举来实现单例，这是最简单、最安全的实现方式。
```java
public enum ThreadUtil {
INSTANCE;
private final ScheduledThreadPoolExecutor mThreadPoolExecutor;
private final ExecutorService singleThreadExecutor;
ThreadUtil() {
// ... 初始化代码
}
public ScheduledThreadPoolExecutor getThreadPoolExecutor() {
return mThreadPoolExecutor;
}
public ExecutorService getSingleThreadExecutor() {
return singleThreadExecutor;
}
}
```
每种方法都有其优缺点，选择哪一种取决于具体的应用场景和需求。例如，如果单例的实例化成本很高，可能会倾向于使用懒汉式；如果对性能要求极高，可能会选择静态内部类或枚举方式。