Java实现生产者消费者问题与读者写者问题详解

Java实现生产者消费者问题与读者写者问题是多线程编程中的经典问题，本文将从理论基础、问题场景以及代码实现三方面来详细讲解解决这两个问题的完整攻略。

理论基础

在介绍具体问题场景之前，首先需要了解几个概念：

• 生产者：向缓冲区中存入数据的线程。
• 消费者：从缓冲区中取出数据的线程。
• 缓冲区：存放生产者生产的数据，并提供给消费者消费。
• 临界区：多个线程共同访问的区域，可能存在数据不一致或者死锁的问题。

生产者消费者问题和读者写者问题都属于多线程访问临界资源的场景。生产者消费者问题将缓冲区作为临界资源，生产者往缓冲区添加数据，消费者从缓冲区取出数据。读者写者问题主要区别在于读者和写者都可以按照数据的顺序进行访问，但是不能同时进行数据修改。

生产者消费者问题

问题描述

一个生产者线程负责向缓冲区中添加数据，一个消费者线程负责从缓冲区中取出数据。当缓冲区为空时，消费者线程应该等待直到缓冲区中有数据；当缓冲区已满时，生产者应该等待直到有空余的空间。

代码实现

下面是Java实现生产者消费者问题的代码示例：

class Buffer {
  private int[] buffer;
  private int size;
  private int front;
  private int rear;
  private int count;

  public Buffer(int size) {
    this.size = size;
    buffer = new int[size];
    front = 0;
    rear = -1;
    count = 0;
  }

  public synchronized void put(int value) throws InterruptedException {
    while (count == size) {
      wait();
    }
    rear = (rear + 1) % size;
    buffer[rear] = value;
    count++;
    notifyAll();
  }

  public synchronized int get() throws InterruptedException {
    while (count == 0) {
      wait();
    }
    int value = buffer[front];
    front = (front + 1) % size;
    count--;
    notifyAll();
    return value;
  }
}

class Producer implements Runnable {
  private Buffer buffer;

  public Producer(Buffer buffer) {
    this.buffer = buffer;
  }

  public void run() {
    for (int i = 1; i <= 10; i++) {
      try {
        buffer.put(i);
        System.out.println("Produced: " + i);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}

class Consumer implements Runnable {
  private Buffer buffer;

  public Consumer(Buffer buffer) {
    this.buffer = buffer;
  }

  public void run() {
    for (int i = 1; i <= 10; i++) {
      try {
        int value = buffer.get();
        System.out.println("Consumed: " + value);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}

public class ProducerConsumerExample {
  public static void main(String[] args) {
    Buffer buffer = new Buffer(5);
    Thread producerThread = new Thread(new Producer(buffer));
    Thread consumerThread = new Thread(new Consumer(buffer));
    producerThread.start();
    consumerThread.start();
  }
}

在这段代码中，Buffer类表示缓冲区，Producer和Consumer类分别表示生产者和消费者。在put()和get()方法中，用synchronized关键字对方法进行了同步，保证同时只有一个线程能够进行访问。同时，为了避免生产者或消费者线程在临界区中产生死锁，需要在方法中使用wait()和notifyAll()方法进行线程间的协调。

示例说明

假设缓冲区大小为5，生产者需要向其中添加1到10的数字，消费者需要从中取出这些数字并进行输出。由于缓冲区大小限制，生产者和消费者可能需要进行等待或阻塞，以确保数据的正确性和线程的安全。在上述代码中，wait()和notifyAll()方法的运用有效地避免了资源的竞争和死锁问题的产生。当生产者线程在缓冲区已满的状态下进行生产时，会使用wait()方法进行等待；当缓冲区中数据不足时，消费者线程会使用wait()方法等待新的数据被添加进缓冲区。而在put()和get()方法执行完后，使用notifyAll()方法通知其他线程进行资源的获取或者生产。

读者写者问题

问题描述

多个读者线程可以同时读取一个共享资源，但是同时只能有一个写者线程进行修改。当有一个写者线程对共享资源进行修改时，任何其他读者或写者线程都不能访问该资源，直到该线程完成修改为止。

代码实现

下面是Java实现读者写者问题的代码示例：

class ReadWriteLock {
  private int readCount;
  private int writeCount;

  public synchronized void lockRead() throws InterruptedException {
    while (writeCount > 0) {
      wait();
    }
    readCount++;
  }

  public synchronized void unlockRead() {
    readCount--;
    notifyAll();
  }

  public synchronized void lockWrite() throws InterruptedException {
    while (writeCount > 0 || readCount > 0) {
      wait();
    }
    writeCount++;
  }

  public synchronized void unlockWrite() {
    writeCount--;
    notifyAll();
  }
}

class Reader implements Runnable {
  private int id;
  private ReadWriteLock lock;

  public Reader(int id, ReadWriteLock lock) {
    this.id = id;
    this.lock = lock;
  }

  public void run() {
    try {
      lock.lockRead();
      System.out.println("Reader " + id + " is reading.");
      Thread.sleep(1000);
      lock.unlockRead();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

class Writer implements Runnable {
  private int id;
  private ReadWriteLock lock;

  public Writer(int id, ReadWriteLock lock) {
    this.id = id;
    this.lock = lock;
  }

  public void run() {
    try {
      lock.lockWrite();
      System.out.println("Writer " + id + " is writing.");
      Thread.sleep(1000);
      lock.unlockWrite();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

public class ReaderWriterExample {
  public static void main(String[] args) {
    ReadWriteLock lock = new ReadWriteLock();
    for (int i = 1; i <= 5; i++) {
      Thread readerThread = new Thread(new Reader(i, lock));
      readerThread.start();
    }
    for (int i = 1; i <= 2; i++) {
      Thread writerThread = new Thread(new Writer(i, lock));
      writerThread.start();
    }
  }
}

在这段代码中，ReadWriteLock类表示读写锁，Reader和Writer类分别表示读者和写者。在lockRead()和lockWrite()方法中，使用了synchronized关键字对方法进行了同步，保证同一时间只有一个读者或者写者能够进行访问。在方法中使用了wait()和notifyAll()方法进行线程间的协调，以确保不会出现更新丢失和死锁等问题。

示例说明

假设有5个读者线程和2个写者线程，读者线程可以同时访问一个共享资源，但是当有一个写者线程在更新时，任何读者或写者线程都不能访问该资源。在上述代码中，lockRead()方法用于获取读锁，lockWrite()方法用于获取写锁。在这两个方法中，使用了wait()和notifyAll()方法进行线程间的协调，以确保数据的正确性和线程的安全。另外，在访问共享资源的过程中，需要注意使用try和catch语句对异常进行处理并防止意外发生。