ava实现生产者与消费者

生产者与消费者问题是一个非常经典的多线程同步问题，可以用Java的多线程机制来实现。以下是一个简单的Java代码示例，使用wait()、notify()和synchronized关键字来解决生产者消费者问题。

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

class Buffer {
   private int data;
   private boolean empty;

   public Buffer() {
      empty = true;
   }

   public synchronized void produce(int newData) {
      while (!empty) {
         try {
            wait();
         } catch (InterruptedException e) {}
      }
      data = newData;
      empty = false;
      notifyAll();
   }

   public synchronized int consume() {
      while (empty) {
         try {
            wait();
         } catch (InterruptedException e) {}
      }
      empty = true;
      notifyAll();
      return data;
   }
}

class Producer implements Runnable {
   private Buffer buffer;

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

   public void run() {
      for (int i = 0; i < 10; i++) {
         buffer.produce(i);
         System.out.println("Produced: " + i);
         try {
            Thread.sleep((int)(Math.random() * 100));
         } catch (InterruptedException e) {}
      }
   }
}

class Consumer implements Runnable {
   private Buffer buffer;

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

   public void run() {
      int data;
      for (int i = 0; i < 10; i++) {
         data = buffer.consume();
         System.out.println("Consumed: " + data);
         try {
            Thread.sleep((int)(Math.random() * 100));
         } catch (InterruptedException e) {}
      }
   }
}

在这个示例中，Buffer类表示共享的缓冲区，produce()方法用于生产数据，consume()方法用于消费数据。在Buffer类中，使用了synchronized关键字来保证线程安全，使用wait()和notify()方法来实现线程间的通信。

Producer类和Consumer类分别表示生产者线程和消费者线程，它们都实现了Runnable接口。在Producer类和Consumer类中，使用了Thread.sleep()方法来模拟生产和消费过程中的延迟。

执行程序后，可以看到生产者线程和消费者线程交替执行，生产者线程生产数据并将其写入缓冲区，消费者线程从缓冲区中读取数据并消费。通过wait()和notify()方法以及synchronized关键字的使用，保证了线程安全和正确的执行顺序。