六种java的多线程设计模式详解和代码举例
java的多线程处理，有哪些模式可以使用呢，如何使用呢。本文列举了六种多线程设计模式供大家参考。
1.生产者-消费者模式
设计理念：
生产者-消费者模式通过协调两个线程（生产者和消费者）来处理数据，生产者生成数据并将其放入队列，消费者从队列中取出数据进行处理。这种模式可以有效地解耦数据的生成和消费过程。
举个代码栗子如下：
import java.util.LinkedList;
import java.util.Queue;
class Producer implements Runnable {
??? private Queue queue; // 共享队列
??? private final int bound; // 队列容量上限
??? Producer(Queue q, int bound) {
??????? this.queue = q;
??????? this.bound = bound;
??? }
??? public void run() {
??????? while (true) {
??????????? int item = produce(); // 生产数据
??????????? // 如果队列已满，等待消费者消费
??????????? if (queue.size() == bound) {
??????????????? System.out.println("Queue is full. Waiting for consumer");
??????????????? try {
??????????????????? Thread.sleep(1000);
??????????????? } catch (InterruptedException e) {
??????????????????? e.printStackTrace();
??????????????? }
??????????? }
??????????? queue.add(item); // 将数据放入队列
??????????? System.out.println("Produced " + item);
??????? }
??? }
??? int produce() {
??????? return (int) (Math.random() * 100); // 模拟生产数据
??? }
}
class Consumer implements Runnable {
??? private Queue queue;
??? Consumer(Queue q) {
??????? this.queue = q;
??? }
??? public void run() {
??????? while (true) {
??????????? // 如果队列为空，等待生产者生产
??????????? if (queue.isEmpty()) {
??????????????? System.out.println("Queue is empty. Waiting for producer");
??????????????? try {
??????????????????? Thread.sleep(1000);
??????????????? } catch (InterruptedException e) {
??????????????????? e.printStackTrace();
??????????????? }
??????????? }
??????????? int item = queue.remove(); // 从队列中取出数据
??????????? consume(item); // 消费数据
??????????? System.out.println("Consumed " + item);
??????? }
??? }
??? void consume(int item) {
??????? // 消费数据的具体实现
??? }
}
public class ProducerConsumerExample {
??? public static void main(String[] args) {
??????? Queue q = new LinkedList<>();
??????? Thread t1 = new Thread(new Producer(q, 5)); // 创建生产者线程
??????? Thread t2 = new Thread(new Consumer(q)); // 创建消费者线程
??????? t1.start();
??????? t2.start();
??? }
} 可能出现的问题：
? 死锁： 如果生产者和消费者之间的同步机制不当，可能会导致死锁。
? 资源浪费： 如果队列大小设置不当，可能会导致频繁的线程阻塞和唤醒，造成资源浪费。
? 饥饿或堆积： 如果消费者线程比生产者线程多，生产者可能会饿死；反之则可能出现堆积。
回避手段：
? 使用合适的同步机制： 使用 BlockingQueue 等线程安全的数据结构，它们提供了必要的同步机制。
? 合理设置队列大小： 根据实际需求合理设置队列大小，避免资源浪费。
? 平衡生产者和消费者数量： 根据任务特性和系统资源合理分配生产者和消费者的数量。
2.线程池模式
设计理念：
线程池模式通过复用一组线程来执行任务，减少了频繁创建和销毁线程的开销，提高了效率。
举个代码栗子：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class Task implements Runnable {
??? private final String name;
??? Task(String name) {
??????? this.name = name;
??? }
??? public void run() {
??????? System.out.println("Task " + name + " is running");
??? }
}
public class ThreadPoolExample {
??? public static void main(String[] args) {
??????? ExecutorService executor = Executors.newFixedThreadPool(5); // 创建固定大小的线程池
??????? for (int i = 0; i < 10; i++) {
??????????? executor.execute(new Task("" + i)); // 提交任务到线程池
??????? }
??????? executor.shutdown(); // 关闭线程池
??? }
}可能出现的问题：
? 线程池参数设置不当： 线程池大小设置不合适可能导致资源浪费或任务执行延迟。
? 任务执行顺序不确定： 线程池中的任务执行顺序可能不是提交的顺序。
回避手段：
? 合理配置线程池参数： 根据任务特性和系统资源合理配置线程池的大小、最大任务队列长度等参数。
? 使用优先队列： 如果需要任务执行顺序，可以使用优先队列来管理任务。
3.Futures和Promises模式
设计理念：
Futures和Promises模式允许异步执行任务并在未来某个时间点获取结果，适用于需要非阻塞操作的场景。
举个代码栗子：
import java.util.concurrent.*;
class CallableTask implements Callable {
??? private final String name;
??? CallableTask(String name) {
??????? this.name = name;
??? }
??? @Override
??? public String call() throws Exception {
??????? Thread.sleep(1000); // 模拟任务执行时间
??????? return "Result of " + name;
??? }
}
public class FuturesAndPromisesExample {
??? public static void main(String[] args) throws ExecutionException, InterruptedException {
??????? ExecutorService executor = Executors.newFixedThreadPool(2); // 创建线程池
??????? Future future = executor.submit(new CallableTask("Task 1")); // 提交Callable任务
??????? System.out.println("Future result: " + future.get()); // 获取结果
??????? executor.shutdown(); // 关闭线程池
??? }
} 可能出现的问题：
? 异常处理困难： 异步任务的异常可能不容易被捕获和处理。
? 结果获取阻塞： Future.get() 方法可能会阻塞主线程，直到异步任务完成。
回避手段：
? 适当的异常处理： 使用 try-catch 块来捕获和处理异步任务的异常。
? 非阻塞结果获取： 使用 Future 的 isDone() 方法检查任务是否完成，或者使用回调函数来处理结果。
4.监视器模式
设计理念：
监视器模式是一种同步机制，它允许多个线程访问共享资源，同时确保同一时间只有一个线程可以访问共享资源。监视器模式通常通过`synchronized`关键字实现，它可以保护方法或代码块，确保线程安全。
举个代码栗子：
class SharedObject {
??? private int data;
??? public synchronized void setData(int data) { // 同步方法保护共享资源
??????? this.data = data;
??? }
??? public synchronized int getData() { // 同步方法保护共享资源
??????? return data;
??? }
}
class Writer implements Runnable {
??? private final SharedObject sharedObject;
??? Writer(SharedObject sharedObject) {
??????? this.sharedObject = sharedObject;
??? }
??? public void run() {
??????? sharedObject.setData(20); // 写入数据
??? }
}
class Reader implements Runnable {
??? private final SharedObject sharedObject;
??? Reader(SharedObject sharedObject) {
??????? this.sharedObject = sharedObject;
??? }
??? public void run() {
??????? System.out.println("Data: " + sharedObject.getData()); // 读取数据
??? }
}
public class MonitorObjectExample {
??? public static void main(String[] args) {
??????? SharedObject sharedObject = new SharedObject();
??????? Thread writer = new Thread(new Writer(sharedObject)); // 创建写线程
??????? Thread reader = new Thread(new Reader(sharedObject)); // 创建读线程
??????? writer.start();
??????? reader.start();
??? }
}在这个示例中，`SharedObject`类中的`setData`和`getData`方法都被声明为`synchronized`，这意味着同一时间只有一个线程可以执行这些方法中的任何一个。这确保了当一个线程正在修改数据时，其他线程不能读取或修改数据，从而避免了数据不一致的问题。
可能出现的问题：
? 死锁： 如果不正确地使用 synchronized 关键字，可能会导致死锁。
? 性能问题： 过度同步可能会导致性能下降。
回避手段：
? 最小化同步范围： 只在必要的时候同步代码块，而不是整个方法。
? 避免在同步块中执行长时间操作： 例如，不要在同步块中进行I/O操作。
5.屏障模式
设计理念：
屏障模式（CyclicBarrier）允许一组线程相互等待，直到所有线程都到达一个公共屏障点，然后可以选择执行一个共同的任务（如计数器重置）后继续执行。
举个代码栗子：
import java.util.concurrent.CyclicBarrier;
class BarrierTask implements Runnable {
??? private final CyclicBarrier barrier;
??? BarrierTask(CyclicBarrier barrier) {
??????? this.barrier = barrier;
??? }
??? public void run() {
??????? try {
??????????? System.out.println("Before barrier");
??????????? barrier.await(); // 等待其他线程到达屏障
??????????? System.out.println("After barrier");
??????? } catch (Exception e) {
??????????? e.printStackTrace();
??????? }
??? }
}
public class BarrierExample {
??? public static void main(String[] args) {
??????? CyclicBarrier barrier = new CyclicBarrier(2, () -> System.out.println("All threads have reached the barrier")); // 创建屏障
??????? Thread t1 = new Thread(new BarrierTask(barrier)); // 创建线程
??????? Thread t2 = new Thread(new BarrierTask(barrier)); // 创建线程
??????? t1.start();
??????? t2.start();
??? }
}可能出现的问题：
? 屏障释放问题： 如果屏障没有被正确释放，可能会导致线程永远等待。
? 线程中断处理： 在等待屏障释放时，线程中断可能没有被正确处理。
回避手段：
? 确保屏障被释放： 在所有线程到达屏障后，确保执行屏障的 await() 方法。
? 正确处理中断： 在 await() 方法中捕获 InterruptedException ，并根据需要恢复线程状态或重新中断。
6.读写锁模式
设计理念：
读写锁模式（ReentrantReadWriteLock）允许多个读操作同时进行，而写操作是互斥的，这样可以提高读操作的并发性，特别是在读多写少的场景下。
举个代码栗子：
import java.util.concurrent.locks.ReentrantReadWriteLock;
class SharedData {
??? private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(); // 读写锁
??? private int data;
??? void writeData(int data) {
??????? rwLock.writeLock().lock(); // 获取写锁
??????? try {
??????????? this.data = data;
??????? } finally {
??????????? rwLock.writeLock().unlock(); // 释放写锁
??????? }
??? }
??? int readData() {
??????? rwLock.readLock().lock(); // 获取读锁
??????? try {
??????????? return data;
??????? } finally {
??????????? rwLock.readLock().unlock(); // 释放读锁
??????? }
??? }
}
class Writer implements Runnable {
??? private final SharedData sharedData;
??? Writer(SharedData sharedData) {
??????? this.sharedData = sharedData;
??? }
??? public void run() {
??????? sharedData.writeData(10); // 写入数据
??? }
}
class Reader implements Runnable {
??? private final SharedData sharedData;
??? Reader(SharedData sharedData) {
??????? this.sharedData = sharedData;
??? }
??? public void run() {
??????? System.out.println("Data: " + sharedData.readData()); // 读取数据
??? }
}
public class ReadWriteLockExample {
??? public static void main(String[] args) {
??????? SharedData sharedData = new SharedData();
??????? Thread writer = new Thread(new Writer(sharedData)); // 创建写线程
??????? Thread reader = new Thread(new Reader(sharedData)); // 创建读线程
??????? writer.start();
??????? reader.start();
??? }
}可能出现的问题：
? 写饥饿： 如果读操作非常频繁，写操作可能会被饿死。
? 死锁： 如果一个线程同时持有读锁和写锁，可能会导致死锁。
回避手段：
? 限制读锁的持有时间： 尽量减少读锁的持有时间，避免长时间占用读锁。
? 避免锁升级： 不要从读锁升级到写锁，因为这可能导致死锁。
以上我们提供了对多线程各种模式的解释和代码举例，也包括它们的设计理念和使用时需要注意的问题。
希望这些信息能帮助你更好地应用这些多线程设计模式。
今日份的程序员鼓励师，加油哦