目录
一、引言
在 Java 并发编程的领域中，确保线程安全是开发可靠应用的核心任务之一。线程安全设计模式作为有效的解决方案，为多线程环境下处理复杂的同步和资源共享问题提供了结构化的思路。通过合理运用这些模式，开发者能够提高代码的稳定性、性能和可维护性。
二、常见的线程安全设计模式
（一）单例模式
- 饿汉式单例：
饿汉式单例模式在类加载时就创建单例实例。由于实例在类加载阶段就被初始化，所以它是线程安全的。示例代码如下：
public class EagerSingleton {
private static final EagerSingleton instance = new EagerSingleton();
private EagerSingleton() {}
public static EagerSingleton getInstance() {
return instance;
}
}
这种模式的优点是实现简单且安全，缺点是如果单例实例的创建开销较大，且在应用启动时并不需要立即使用该实例，会造成资源的浪费。
- 懒汉式单例（非线程安全）：
懒汉式单例模式在第一次调用获取实例的方法时才创建实例。以下是一个简单的非线程安全的懒汉式单例示例：
public class LazySingleton {
private static LazySingleton instance;
private LazySingleton() {}
public static LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
在多线程环境下，当多个线程同时检查到 instance 为 null 时，可能会创建多个实例，因此这种方式不是线程安全的。
- 懒汉式单例（线程安全）：
为了使懒汉式单例在多线程环境下安全，我们可以使用synchronized关键字来同步获取实例的方法：
public class ThreadSafeLazySingleton {
private static ThreadSafeLazySingleton instance;
private ThreadSafeLazySingleton() {}
public static synchronized ThreadSafeLazySingleton getInstance() {
if (instance == null) {
instance = new ThreadSafeLazySingleton();
}
return instance;
}
}
虽然这种方式保证了线程安全，但每次调用 getInstance 方法都需要获取锁，会带来一定的性能开销。
- 双重检查锁定（DCL）单例：
双重检查锁定模式通过两次检查instance是否为null，并结合volatile关键字来提高性能和保证线程安全：
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 的可见性，防止指令重排序导致的问题，使得在多线程环境下既能保证线程安全，又能提高性能。
- 枚举单例：
使用枚举实现单例是一种简洁且安全的方式，它不仅能保证线程安全，还能防止反序列化创建新的实例：
public enum EnumSingleton {
INSTANCE;
// 可以在这里添加其他业务方法
public void doSomething() {
// 业务逻辑
}
}
（二）生产者 - 消费者模式
- 基于阻塞队列的实现：
在 Java 中，可以使用BlockingQueue来实现生产者 - 消费者模式。BlockingQueue提供了put和take方法，当队列满时put方法会阻塞生产者线程，当队列空时take方法会阻塞消费者线程。示例代码如下：
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
class Producer implements Runnable {
private final BlockingQueue<Integer> queue;
public Producer(BlockingQueue<Integer> queue) {
this.queue = queue;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
queue.put(i);
System.out.println("Producer produced: " + i);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
}
class Consumer implements Runnable {
private final BlockingQueue<Integer> queue;
public Consumer(BlockingQueue<Integer> queue) {
this.queue = queue;
}
@Override
public void run() {
while (true) {
try {
Integer item = queue.take();
if (item == null) {
break;
}
System.out.println("Consumer consumed: " + item);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
}
public class ProducerConsumerExample {
public static void main(String[] args) {
BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5);
Thread producerThread = new Thread(new Producer(queue));
Thread consumerThread = new Thread(new Consumer(queue));
producerThread.start();
consumerThread.start();
try {
producerThread.join();
queue.put(null); // 通知消费者结束
consumerThread.join();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
- 基于管程（Monitor）的实现：
通过使用Object的wait和notify方法，也可以实现生产者 - 消费者模式。这种方式需要手动管理线程的等待和唤醒，示例代码如下：
class ProducerConsumer {
private int count = 0;
private final int capacity;
private final Object lock = new Object();
public ProducerConsumer(int capacity) {
this.capacity = capacity;
}
public void produce() throws InterruptedException {
synchronized (lock) {
while (count == capacity) {
lock.wait();
}
count++;
System.out.println("Producer produced: " + count);
lock.notifyAll();
}
}
public void consume() throws InterruptedException {
synchronized (lock) {
while (count == 0) {
lock.wait();
}
count--;
System.out.println("Consumer consumed: " + count);
lock.notifyAll();
}
}
}
public class ProducerConsumerMonitorExample {
public static void main(String[] args) {
ProducerConsumer pc = new ProducerConsumer(5);
Thread producerThread = new Thread(() -> {
for (int i = 0; i < 10; i++) {
try {
pc.produce();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
Thread consumerThread = new Thread(() -> {
for (int i = 0; i < 10; i++) {
try {
pc.consume();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
producerThread.start();
consumerThread.start();
try {
producerThread.join();
consumerThread.join();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
（三）线程池模式
线程池是一种管理和复用线程的有效方式，可以减少线程创建和销毁的开销。在 Java 中，可以使用 ExecutorService 接口和相关的工具类来创建和管理线程池。
- 固定大小线程池：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FixedThreadPoolExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
executor.submit(() -> {
System.out.println(Thread.currentThread().getName() + " is running");
});
}
executor.shutdown();
}
}
固定大小线程池创建一个指定大小的线程池，线程池中的线程数量固定，适用于任务量相对稳定的场景。
- 缓存线程池：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CachedThreadPoolExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
executor.submit(() -> {
System.out.println(Thread.currentThread().getName() + " is running");
});
}
executor.shutdown();
}
}
缓存线程池根据任务的需求动态创建和回收线程，适用于任务量波动较大的场景。
- 单线程线程池：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SingleThreadExecutorExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
executor.submit(() -> {
System.out.println(Thread.currentThread().getName() + " is running");
});
}
executor.shutdown();
}
}
单线程线程池只有一个线程来执行任务，适用于需要按顺序执行任务的场景。
三、总结
Java 并发编程中的线程安全设计模式是开发者应对多线程挑战的有力工具。单例模式确保实例的唯一性和线程安全，生产者 - 消费者模式实现了任务的异步处理和解耦，线程池模式则优化了线程的管理和使用。在实际开发中，需要根据具体的业务场景和需求，选择合适的设计模式，并合理配置相关参数，以实现高效、可靠的并发程序。同时，对这些模式的深入理解和灵活运用，也有助于提升开发者在并发编程领域的技能和水平。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
