Producer & Consumer ---- a practice in concurrent simulation

最新推荐文章于 2022-07-31 12:43:30 发布

原创最新推荐文章于 2022-07-31 12:43:30 发布 · 235 阅读

0 ·

CC 4.0 BY-SA版权

LEARNING NOTES 专栏收录该内容

10 篇文章

订阅专栏

本文通过Java代码实现了一个简单的写-读并发模型。该模型利用两个线程分别进行写入和读取操作，并通过同步机制确保数据的一致性和完整性。案例展示了如何使用synchronized关键字和wait/notifyAll方法来协调线程间的交互。

import java.util.Arrays;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class Write implements Runnable {
    private WriteAndRead writeAndRead;
    private int p = 0;
    private int count = 0;

    Write(WriteAndRead wr) {
        writeAndRead = wr;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                synchronized (this) {
                    while (writeAndRead.numbers[p] != null)
                        wait();
                }
                synchronized (writeAndRead.read) {
                    System.out.println("write");
                    writeAndRead.numbers[p] = p;
                    p = (p + 1) % 8;
                    ++count;
                    writeAndRead.read.notifyAll();
                    TimeUnit.MILLISECONDS.sleep(100);
                }
                if (count > WriteAndRead.END)
                    throw new InterruptedException();
            }
        } catch (InterruptedException e) {
            System.out.println("write interrupted.");
        }
    }
}

class Read implements Runnable {
    private WriteAndRead writeAndRead;
    private int p = 0;
    private int count = 0;

    Read(WriteAndRead wr) {
        writeAndRead = wr;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                synchronized (this) {
                    while (writeAndRead.numbers[p] == null) {
                        wait();
                    }
                }

                System.out.println("read ");
                TimeUnit.MILLISECONDS.sleep(100);
                synchronized (writeAndRead.write) {
                    System.out.println(writeAndRead.numbers[p]);
                    writeAndRead.numbers[p] = null;
                    p = (p + 1) % 8;
                    ++count;
                    writeAndRead.write.notifyAll();
                }
                if (count == WriteAndRead.END) {
                    System.out.println("end");
                    writeAndRead.exce.shutdownNow();
                    throw new InterruptedException();
                }
            }

        } catch (InterruptedException e) {
            System.out.println("read interrupted.");
        }
    }
}


class WriteAndRead {
    final Write write = new Write(this);
    final Read read = new Read(this);
    Integer[] numbers = new Integer[8];
    static final int END = 3;
    ExecutorService exce = Executors.newCachedThreadPool();

    WriteAndRead() {
        Arrays.fill(numbers, null);
        exce.execute(write);
        exce.execute(read);
    }

    public static void main(String[] args) {
        new WriteAndRead();
    }
}