Java常见的并发编程模式（Future模式、生产者-消费者模式、读写锁模式）

在Java开发中，我们经常会使用多线程提高程序的性能，那有哪些常用的并发编程模式呢？接下来这篇文章主要介绍3个在开发中经常使用的并发模式，分别是Future模式、生产者-消费者模式和读写锁模式。

1. Future模式

Future模式是一种异步编程模式，允许在一个线程中提交任务，并在另一个线程中获取任务的执行结果。在Java中，可以使用Future接口和FutureTask类来实现Future模式。
代码如下：

import java.util.concurrent.*;

public class FutureExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newCachedThreadPool();
        Future<Integer> future = executor.submit(() -> {
            Thread.sleep(2000);
            return 42;
        });

        System.out.println("提交任务成功，等待结果...");

        Integer result = future.get();  //42
        System.out.println("任务执行结果：" + result);

        executor.shutdown();
    }
}

2. 生产者-消费者模式

生产者-消费者模式是一种经典的并发模式，用于解决生产者和消费者之间的协作问题。在Java中，可以使用BlockingQueue来实现生产者-消费者模式。

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ProducerConsumerExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("生产者生产：" + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    int value = queue.take();
                    System.out.println("消费者消费：" + value);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();
    }
}

读写锁模式（ReadWrite Lock Pattern）：

读写锁模式是一种并发模式，它允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。这种模式可以提高读操作的并发性能，适用于读操作频繁、写操作较少的场景。在Java中，可以使用ReentrantReadWriteLock类实现读写锁。

代码如下：

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private static int sharedData = 0;
    private static ReadWriteLock lock = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        new Thread(() -> {
            writeData(10);
        }).start();

        new Thread(() -> {
            readData();
        }).start();
    }

    private static void writeData(int data) {
        lock.writeLock().lock();
        try {
            sharedData = data;
            System.out.println("写入数据：" + data);
        } finally {
            lock.writeLock().unlock();
        }
    }

    private static void readData() {
        lock.readLock().lock();
        try {
            System.out.println("读取数据：" + sharedData);
        } finally {
            lock.readLock().unlock();
        }
    }
}