java中如何同步三个生产者和一个消费者线程

Question

我必须创建三个生产者和一个消费者线程。 生产者线程正在从文件中读取字符并使用一个字符的缓冲区。 我像上面一样制作了商店，现在我必须将线程同步到消费者写入整个单词并将控制权交还给其他生产者 - 像这样的模式

Producer1->Word1 
Producer2->word1 
Producer3->word1 
Producer1->Word2 
Producer2->word2 
Producer3->word2 
Producer1->Word3 
Producer2->word3 
Producer3->word3 

商店（已编辑）：

public class Store {
    public static final char CONSUMER_FREE = '\0';

    private volatile char consumer = CONSUMER_FREE;
    private final ThreadPoolExecutor executor;


    public Store(ThreadPoolExecutor executor) {
        this.executor = executor;
    }

    public synchronized void produce(char c) {
        while (isConsumerBussy()) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        consumer = c;
        notify(); // single Consumer
    }

    public synchronized char consume() throws StoreProducersRip {
        while (isConsumerFree()) {
            try {
                wait(250);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            return consumer;
        } finally {
            freeConsumer();
            notifyAll();
        }
    }

    private void freeConsumer() {
        consumer = CONSUMER_FREE;
    }

    private boolean isConsumerBussy() {
        return consumer != CONSUMER_FREE;
    }

    private boolean isConsumerFree() throws StoreProducersRip {
        if (executor.getActiveCount() == 0) throw new StoreProducersRip();
        return consumer == CONSUMER_FREE;
    }
}

Answer 1

您可以为此目的使用锁。 下面的代码演示了 3 个生产者同步和 1 个消费者异步到生产者，但它也将同步到多个消费者。 此外，您应该添加一些逻辑来消耗产生的相同数量。 如果你想获得多线程的好处，你应该缓冲你的生产者输入并在消费之前创建一些管道。

public class Executor {

    public static void main(String[] args) {
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
        Store store = new Store(executor);

        Runnable word1 = new Runnable() {
            @Override
            public void run() {
                store.producerLock.lock();
                store.produce('1');
                store.produce('2');
                store.produce('3');
                store.producerLock.unlock();
            }
        };

        Runnable consume = new Runnable() {
            @Override
            public void run() {
               store.consumerLock.lock();
               System.out.print(store.consume());
               System.out.print(store.consume());
               System.out.print(store.consume());
               System.out.println();
               store.consumerLock.unlock();
            }
        };

        Future p1 = executor.submit(word1);
        Future p2 = executor.submit(word1);
        Future p3 = executor.submit(word1);

        executor.submit(consume);
        executor.submit(consume);
        executor.submit(consume);

        executor.shutdown();
    }
}