Java使用两个线程的金典案例

一个典型的Java使用两个线程的案例是生产者-消费者问题。这个问题涉及到两个线程，一个是生产者线程，一个是消费者线程，它们共享一个缓冲区。生产者线程不断向缓冲区中生产数据，而消费者线程不断从缓冲区中消费数据。如果缓冲区空了，消费者线程就要等待，直到生产者线程将数据放入缓冲区中；如果缓冲区满了，生产者线程就要等待，直到消费者线程从缓冲区中取出数据。

以下是一个简单的Java生产者-消费者问题的代码示例：

public class ProducerConsumerExample {
    public static void main(String[] args) {
        Buffer buffer = new Buffer();
        Producer producer = new Producer(buffer);
        Consumer consumer = new Consumer(buffer);

        Thread producerThread = new Thread(producer);
        Thread consumerThread = new Thread(consumer);

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

class Buffer {
    private int data;
    private boolean empty;

    public Buffer() {
        empty = true;
    }

    public synchronized int get() {
        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {
                System.out.println("InterruptedException caught");
            }
        }
        empty = true;
        notifyAll();
        return data;
    }

    public synchronized void put(int data) {
        while (!empty) {
            try {
                wait();
            } catch (InterruptedException e) {
                System.out.println("InterruptedException caught");
            }
        }
        empty = false;
        this.data = data;
        notifyAll();
    }
}

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.put(i);
            System.out.println("Producer produced " + i);
            try {
                Thread.sleep((int) (Math.random() * 100));
            } catch (InterruptedException e) {
                System.out.println("InterruptedException caught");
            }
        }
    }
}

class Consumer implements Runnable {
    private Buffer buffer;

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

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

在这个示例中，Buffer类表示缓冲区，它有两个方法：put()方法将数据放入缓冲区中，get()方法从缓冲区中取出数据。当缓冲区为空时，get()方法会等待，直到缓冲区中有数据；当缓冲区已满时，put()方法会等待，直到缓冲区有空间。

Producer类表示生产者线程，它将数据放入缓冲区中。Consumer类表示消费者线程，它从缓冲区中取出数据。在主函数中，创建一个缓冲区、一个生产者线程和一个消费者线程，并将它们启动。