共享物品生产者和消费者问题

Question

我有一味生产者消费者问题（我找不到类似的问题，搜索关键词也跑出来了），其中的

1. 消费者本身就是生产者。
2. 生产的物品可以共享。
3. 如果某个线程在生产，其他线程就会等它生产完成后使用同一个生产的物品。

我想到了一个解决方案，但我卡在了如何测试它。有没有一个理论框架来验证这类问题的解决方案的正确性。另外，是否可以在不修改源码的情况下测试这些解决方案

如果你对这个代码感兴趣，它列在下面。

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;

public class SharedItemProducer {

    /* testing parameters */
    static final int randMax = 1;
    static final Random R = new Random();
    static final int numThreads = 8;
    static final long produceDelay = 0;
    static final long maxRunTime = 5000;

    Integer item = 0;
    final Object waitingRoom = new Object();
    AtomicInteger wantToBeProducer = new AtomicInteger(0);

    public void produce() {
        log("entering produce");

        if (wantToBeProducer.compareAndSet(0, 1)) {
            log("i'm the producer. cur=%d", item);
            try {
                Thread.sleep(produceDelay);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            item = item + 1;
            synchronized (waitingRoom) {
                waitingRoom.notifyAll();
            }
            wantToBeProducer.set(0);
            log("done producing");
        } else {
            log("someone else is producing, waiting..");
            synchronized (waitingRoom) {
                try {
                    waitingRoom.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            log("wait complete");
        }
    }

    public static void main(String[] args) {

        long start = System.currentTimeMillis();

        /* run the tests */
        SharedItemProducer1 P = new SharedItemProducer1();
        for (int i = 0; i < numThreads; i++) {
            new Thread(() -> {
                while (true) {
                    P.produce();
                    try {
                        Thread.sleep(R.nextInt(randMax));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

        /* limit time for tests */
        new Thread(() -> {
            try {
                Thread.sleep(maxRunTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.exit(0);
        }).start();
    }

    static boolean enableLog = false;
    static final String FMT = "[%s] [%s] ";

    public static void log(String info, Object... params) {
        if (!enableLog)
            return;
        Object[] pfParams = new Object[params.length + 2];
        System.arraycopy(params, 0, pfParams, 2, params.length);
        pfParams[0] = new Date();
        pfParams[1] = Thread.currentThread().getName();
        System.out.printf(FMT + info + "\n", pfParams);
    }
}

Answer 1

如果我没有理解错的话，你要求的是一种控制线程交错的方法，这样你就可以验证可能的边缘情况和奇怪的情况。

我建议你看看以下内容 Baeldung - 测试Java中的多线程代码 并看看是否有帮助。

它不仅谈到了测试并发代码的概念和策略，还提到了一些可能有用的工具，包括。

• Tempus Fugit
• 线织机
• 多线程TC

请大家看一看，试一试。

为了更好的测试你的代码，我还建议你把代码再模块化一点，这样你就可以把生产者和消费者分开来测试。

EDIT: 为了想出测试用例，列出一个典型的并发问题清单可能会有帮助，你可能想在你的代码中验证这些问题。请看一下CMU SEI的这篇博文，叫做 测试并发系统。并发缺陷，测试技术和建议 以获得一份广泛的清单。