公平政策如何在 Java 线程中起作用？

Question

我正在尝试使用锁为传统的消费者和生产者线程问题编写程序。 以下是相同的语法。

以下示例仅在我使用公平策略 true 时才能正常工作，否则它不会提供预期的结果。 如果我为生产者和消费者打开 await 方法，它也可以正常工作。 这实际上意味着，如果没有等待和公平策略，就不可能产生 1 并使用它。

public class ProductLockDemo2 {

    private Integer number = 0;
    private Lock lock = new ReentrantLock(true);
    private Condition pCondition = lock.newCondition();
    private Condition cCondition = lock.newCondition();

    public Integer getNumber() {
        return number;
    }

    public void setNumber(Integer number) {
        this.number = number;
    }

    public void produce() throws InterruptedException {

        if (getNumber() == 10) {
            pCondition.await();
        }
        lock.lock();
        number = number + 1;
        System.out.println("producing number :" + number);
        Thread.sleep(1000);
        cCondition.signal();
//      pCondition.await();
        lock.unlock();

    }

    public void consume() throws InterruptedException {

        if (getNumber() == 0) {
            cCondition.await();
        }

        lock.lock();
        System.out.println("consumeing:" + number);
        Thread.sleep(1000);
        pCondition.signal();
//      cCondition.await();
        lock.unlock();

    }
}

Answer 1

您的两个线程实际上一直都持有锁。 这意味着一个线程将在另一个线程有机会运行之前运行很长时间。

目前尚不清楚您的程序为何以这种方式运行。 为什么你睡觉的时候拿着锁？ 您如何期望其他线程有机会运行？ 当没有可能的并发性时为什么要使用两个线程，因为两个线程都无法完成任何工作而无需持有相同的锁，另一个线程需要完成任何工作？

如果您想要严格的交替，您可以随时编写代码来强制执行该结果。 但 99.9% 的情况下，你不希望这样。 如果你这样做了，你为什么要使用线程？ 为什么你会想要尽可能低效的调度策略，尽可能频繁地爆出缓存并强制上下文切换？

为什么你的制片人在制作时会持有锁？ 为什么不给消费者一个工作的机会？

Tl;DR: 你得到了可怕的结果，因为你设计了一个生产者和一个消费者，它们根本不能同时操作。 生产者应该只在它需要将结果传递给消费者的瞬间持有锁，而消费者应该只在它需要获得工作消耗的瞬间持有锁。 两个线程在做任何实际工作或等待新工作时都不应该持有锁。