Java用两种方法编程一个程序：一个线程向一个4位循环缓冲区中循环写入1-10的随机数，另一个线程将循环缓冲区中数据取出打印出来。

下面是两种可能的 Java 程序实现，一种使用 `wait()` 和 `notify()` 方法实现线程间同步，另一种使用 `BlockingQueue` 实现线程间通信。

### 方法一：使用 wait() 和 notify()

import java.util.Random;

public class CircularBuffer {
    private static final int BUFFER_SIZE = 4;
    private int[] buffer = new int[BUFFER_SIZE];
    private int readIndex = 0;
    private int writeIndex = 0;
    private int count = 0;

    public synchronized void write(int value) throws InterruptedException {
        while (count == BUFFER_SIZE) {
            wait();
        }
        buffer[writeIndex] = value;
        writeIndex = (writeIndex + 1) % BUFFER_SIZE;
        count++;
        notifyAll();
    }

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

    public static void main(String[] args) {
        CircularBuffer buffer = new CircularBuffer();

        Thread writerThread = new Thread(() -> {
            Random random = new Random();
            while (true) {
                int value = random.nextInt(10) + 1;
                try {
                    buffer.write(value);
                    System.out.println("Writer wrote: " + value);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread readerThread = new Thread(() -> {
            while (true) {
                try {
                    int value = buffer.read();
                    System.out.println("Reader read: " + value);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        writerThread.start();
        readerThread.start();
    }
}

该程序使用一个循环缓冲区来实现线程间通信。`CircularBuffer` 类包含两个方法，`write()` 和 `read()`，分别用于写入和读取缓冲区中的数据。这两个方法都使用 `synchronized` 关键字进行同步，并在缓冲区已满或已空时调用 `wait()` 方法等待。当写入或读取完成时，它们会调用 `notifyAll()` 方法唤醒等待的线程。

程序创建了两个线程，一个线程负责向缓冲区中写入随机数，另一个线程负责从缓冲区中读取数据并打印。在这两个线程中，都使用了一个死循环来不断地执行写入或读取操作。每次写入或读取完成后，线程会睡眠 1 秒钟，以便更好地观察程序输出结果。

### 方法二：使用 BlockingQueue

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

public class CircularBuffer {
    private static final int BUFFER_SIZE = 4;
    private BlockingQueue<Integer> buffer = new ArrayBlockingQueue<>(BUFFER_SIZE);

    public void write(int value) throws InterruptedException {
        buffer.put(value);
        System.out.println("Writer wrote: " + value);
    }

    public int read() throws InterruptedException {
        int value = buffer.take();
        System.out.println("Reader read: " + value);
        return value;
    }

    public static void main(String[] args) {
        CircularBuffer buffer = new CircularBuffer();

        Thread writerThread = new Thread(() -> {
            Random random = new Random();
            while (true) {
                int value = random.nextInt(10) + 1;
                try {
                    buffer.write(value);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread readerThread = new Thread(() -> {
            while (true) {
                try {
                    int value = buffer.read();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        writerThread.start();
        readerThread.start();
    }
}

该程序使用一个 `BlockingQueue` 来实现线程间通信。`CircularBuffer` 类包含了一个 `BlockingQueue` 类型的成员变量 `buffer`，该变量被用于存储写入缓冲区的数据。`write()` 和 `read()` 方法分别用于写入和读取缓冲区中的数据。

程序创建了两个线程，一个线程负责向缓冲区中写入随机数，另一个线程负责从缓冲区中读取数据并打印。在这两个线程中，都使用了一个死循环来不断地执行写入或读取操作。每次写入或读取完成后，线程会睡眠 1 秒钟，以便更好地观察程序输出结果。