用java如何实现两个线程一个写数据另一个读数据

可以使用Java中的Lock和Condition来实现两个线程一个写数据另一个读数据的功能。具体实现步骤如下：

1. 创建一个共享数据的类，其中包含一个数据变量和两个方法，一个用于写入数据，一个用于读取数据。

2. 创建一个写线程类，该类实现Runnable接口并重写run方法，在run方法中调用共享数据类的写入方法。

3. 创建一个读线程类，该类实现Runnable接口并重写run方法，在run方法中调用共享数据类的读取方法。

4. 在主方法中创建共享数据对象和两个线程对象，然后启动这两个线程。

下面是具体的代码实现：

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

public class SharedData {
    private int data;
    private boolean available = false;
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    public void write(int data) {
        lock.lock();
        try {
            while (available) {
                condition.await();
            }
            this.data = data;
            available = true;
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public int read() {
        lock.lock();
        try {
            while (!available) {
                condition.await();
            }
            available = false;
            condition.signalAll();
            return data;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return -1;
        } finally {
            lock.unlock();
        }
    }
}

class Writer implements Runnable {
    private SharedData sharedData;

    public Writer(SharedData sharedData) {
        this.sharedData = sharedData;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            sharedData.write(i);
            System.out.println("写入了数据：" + i);
            try {
                Thread.sleep((long) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Reader implements Runnable {
    private SharedData sharedData;

    public Reader(SharedData sharedData) {
        this.sharedData = sharedData;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            int data = sharedData.read();
            System.out.println("读取了数据：" + data);
            try {
                Thread.sleep((long) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        SharedData sharedData = new SharedData();
        Thread writerThread = new Thread(new Writer(sharedData));
        Thread readerThread = new Thread(new Reader(sharedData));
        writerThread.start();
        readerThread.start();
    }
}

在上面的代码中，使用Lock和Condition来实现了一个共享数据类，该类包含一个数据变量和两个方法，一个用于写入数据，一个用于读取数据。在写入方法中，如果数据已经被写入，则等待读取方法读取数据，否则将数据写入并通知读取方法可以读取数据了；在读取方法中，如果没有数据可读，则等待写入方法写入数据，否则读取数据并通知写入方法可以写入数据了。在主方法中创建共享数据对象和两个线程对象，然后启动这两个线程，写线程将数据写入共享数据对象，读线程从共享数据对象中读取数据。