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

好的，我来解答这个问题。首先，我们需要定义一个4位循环缓冲区（也叫循环队列），用来存储生成的随机数。我们可以使用数组来实现这个缓冲区。

接下来，我们需要实现两个线程：一个线程向循环缓冲区中写入数据，另一个线程从循环缓冲区中读取数据并打印出来。这里我们可以使用Java中的线程和锁来实现。

下面是两种方法的具体实现：

方法一：使用synchronized关键字实现线程同步

import java.util.Random;

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

    public static void main(String[] args) {
        Thread writerThread = new Thread(() -> {
            Random random = new Random();
            while (true) {
                synchronized (Test.class) {
                    if (count == BUFFER_SIZE) {
                        try {
                            Test.class.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int num = random.nextInt(10) + 1;
                    buffer[writeIndex] = num;
                    writeIndex = (writeIndex + 1) % BUFFER_SIZE;
                    count++;
                    Test.class.notify();
                }
            }
        });

        Thread readerThread = new Thread(() -> {
            while (true) {
                synchronized (Test.class) {
                    if (count == 0) {
                        try {
                            Test.class.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int num = buffer[readIndex];
                    readIndex = (readIndex + 1) % BUFFER_SIZE;
                    count--;
                    System.out.println(num);
                    Test.class.notify();
                }
            }
        });

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

在这个实现中，我们使用了synchronized关键字来保证多个线程对共享变量进行操作的线程安全性。当缓冲区已满时，写线程会进入等待状态，直到读线程取走了一个数据，释放了一个空位。同样，当缓冲区为空时，读线程会进入等待状态，直到写线程写入了一个数据，释放了一个位置。

方法二：使用ReentrantLock类实现线程同步

import java.util.Random;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    private static final int BUFFER_SIZE = 4;
    private static int[] buffer = new int[BUFFER_SIZE];
    private static int count = 0;
    private static int writeIndex = 0;
    private static int readIndex = 0;
    private static ReentrantLock lock = new ReentrantLock();
    private static Condition notFull = lock.newCondition();
    private static Condition notEmpty = lock.newCondition();

    public static void main(String[] args) {
        Thread writerThread = new Thread(() -> {
            Random random = new Random();
            while (true) {
                lock.lock();
                try {
                    while (count == BUFFER_SIZE) {
                        notFull.await();
                    }
                    int num = random.nextInt(10) + 1;
                    buffer[writeIndex] = num;
                    writeIndex = (writeIndex + 1) % BUFFER_SIZE;
                    count++;
                    notEmpty.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });

        Thread readerThread = new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    while (count == 0) {
                        notEmpty.await();
                    }
                    int num = buffer[readIndex];
                    readIndex = (readIndex + 1) % BUFFER_SIZE;
                    count--;
                    System.out.println(num);
                    notFull.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });

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

在这个实现中，我们使用了ReentrantLock和Condition类来实现线程同步。ReentrantLock类提供了锁机制，Condition类提供了等待和通知机制。当缓冲区已满时，写线程会进入等待状态，直到读线程取走了一个数据，释放了一个空位。同样，当缓冲区为空时，读线程会进入等待状态，直到写线程写入了一个数据，释放了一个位置。

以上就是用两种方法编写一个Java程序的详细介绍。