顺序写入和读取（两个线程）

以下是一个基于Java的示例代码，实现了顺序写入和读取的功能，使用了两个线程进行操作。

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

public class SequentialReadWrite {
    private Lock lock = new ReentrantLock();
    private Condition writeCondition = lock.newCondition();
    private Condition readCondition = lock.newCondition();
    private volatile boolean isWriting = true;
    private volatile int value;

    public void write(int newValue) {
        lock.lock();
        try {
            while (!isWriting) {
                try {
                    writeCondition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            value = newValue;
            System.out.println("Writing value: " + value);

            isWriting = false;
            readCondition.signal();
        } finally {
            lock.unlock();
        }
    }

    public void read() {
        lock.lock();
        try {
            while (isWriting) {
                try {
                    readCondition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("Reading value: " + value);

            isWriting = true;
            writeCondition.signal();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        SequentialReadWrite sequentialReadWrite = new SequentialReadWrite();

        Thread writeThread = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                sequentialReadWrite.write(i);
            }
        });

        Thread readThread = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                sequentialReadWrite.read();
            }
        });

        writeThread.start();
        readThread.start();

        try {
            writeThread.join();
            readThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这个示例中，SequentialReadWrite类表示一个带有写入和读取方法的类，write()方法用于写入数据，read()方法用于读取数据。使用Lock和Condition来实现线程间的同步。

在write()方法中，首先获取锁并检查是否允许写入。如果不允许写入，则调用writeCondition.await()方法使当前写入线程等待。当允许写入时，设置新值，并打印写入的值。然后设置isWriting为false，表示不允许写入，然后调用readCondition.signal()方法唤醒等待的读取线程。

在read()方法中，首先获取锁并检查是否允许读取。如果不允许读取，则调用readCondition.await()方法使当前读取线程等待。当允许读取时，打印读取的值。然后设置isWriting为true，表示允许写入，然后调用writeCondition.signal()方法唤醒等待的写入线程。

在main()方法中，创建一个SequentialReadWrite对象，并创建一个写入线程和一个读取线程。然后启动这两个线程，并等待它们完成。

运行这个示例代码，将会按照顺序进行写入和读取操作，并正确地输出写入和读取的值。