Java进阶篇之并发实践：优化与挑战

使用synchronized关键字和wait()/notify()方法：这种方式利用Java对象的内置锁机制。当缓冲区为空时，消费者会调用wait()方法释放锁并进入等待状态，直到生产者调用notify()或notifyAll()唤醒一个或所有等待的消费者。同样，当缓冲区满时，生产者也会调用wait()并等待消费者消费数据。
使用java.util.concurrent包中的BlockingQueue接口： BlockingQueue提供了一个线程安全的队列，当队列为空时，take()方法会阻塞消费者线程，直到有可用元素；当队列满时，put()方法会阻塞生产者线程，直到有空间可用。这简化了生产者-消费者模型的实现，无需手动处理锁和条件变量。
使用java.util.concurrent.locks包中的Lock和Condition类： Lock提供了比synchronized更灵活的锁定机制，而Condition则提供了一种更高级的条件变量机制，可以替代wait()和notify()方法，使代码更清晰且易于维护。

示例：

以下是一个使用BlockingQueue实现的简单生产者-消费者模型的示例：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class ProducerConsumerExample {

    private static final BlockingQueue<Integer> buffer = new LinkedBlockingQueue<>(10);

    public static void main(String[] args) {
        Thread producerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        int value = (int)(Math.random() * 100);
                        buffer.put(value);
                        System.out.println("Produced: " + value);
                        TimeUnit.MILLISECONDS.sleep(500);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread consumerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        int value = buffer.take();
                        System.out.println("Consumed: " + value);
                        TimeUnit.MILLISECONDS.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

在这个例子中，LinkedBlockingQueue作为一个线程安全的队列，用于存储由生产者产生的整数，消费者则从队列中取出这些整数进行处理。put()和take()方法确保了线程间的同步，使得生产者在队列满时阻塞，消费者在队列空时阻塞。

生产者-消费者模型是解决多线程数据共享和同步的有效手段，尤其是在处理大量数据流或消息传递的场景中。Java提供了多种工具和API来帮助开发者轻松实现这一模式，从而构建高效、可靠的并发应用。

（3）读写锁

Java中的读写锁（ReadWriteLock）是一种用于控制对共享资源访问的锁机制。与传统的互斥锁（mutex）不同，读写锁允许多个读操作同时进行，但写操作是独占的，即任何时刻只能有一个写操作进行。这样设计的目的是为了提高并发性能，在读操作远多于写操作的场景下尤其有效。

读写锁的特性

读读不互斥：多个线程可以同时持有读锁，进行读操作。
读写互斥：如果有线程持有写锁，其他线程不能持有读锁或写锁。
写写互斥：同一时刻只能有一个线程持有写锁。

Java中的实现

在Java中，读写锁的接口定义在java.util.concurrent.locks包下的ReadWriteLock接口中。但是，这个接口本身并不提供具体实现，而是由ReentrantReadWriteLock类提供。ReentrantReadWriteLock是可重入的读写锁实现，它允许一个已经获取了读锁的线程再次获取读锁，或者一个已经获取了写锁的线程再次获取写锁或读锁。

示例：

下面是一个简单的读写锁使用示例：

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock rlock = rwl.readLock();
    private final ReentrantReadWriteLock.WriteLock wlock = rwl.writeLock();
    private String data = "initial value";

    public String readData() {
        rlock.lock();
        try {
            System.out.println("Reading data...");
            return data;
        } finally {
            rlock.unlock();
        }
    }

    public void writeData(String newData) {
        wlock.lock();
        try {
            System.out.println("Writing data...");
            data = newData;
        } finally {
            wlock.unlock();
        }
    }
}

注意事项

锁的释放顺序：如果一个线程先获得了读锁，再获取写锁，那么在释放锁时，必须先释放写锁，再释放读锁，否则会导致死锁。
公平性：ReentrantReadWriteLock提供两种模式：公平模式和非公平模式。公平模式下，线程按照请求锁的顺序获取锁，而非公平模式下，可能优先让写操作获取锁，这可能导致某些读操作长时间等待。