Java鎖的條件實現

Question

需要有關以下鏈接中的代碼的幫助，因為它應該同樣無限期地運行任何典型的生產者/消費者問題，但不知何故它在調用 condition.signal() 時卡住了。 我在這里做錯了什么？

在 main 方法中，我創建了兩個線程，一個是消費者，另一個是生產者。 它具有共享任務隊列，兩者都更新條目。

package com.anurgup.handson;

import java.util.PriorityQueue;
import java.util.Queue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionService implements Runnable {

    Lock lock = new ReentrantLock();
    Condition added = lock.newCondition();
    Condition removed = lock.newCondition();

    // type of service
    String type;

    // shared task for insertion and deletion of task
    static Queue<Integer> task = new PriorityQueue<Integer>();

    // max number of task allowed
    private static final int MAX_SIZE = 5;

    public ConditionService(String type) {
        this.type = type;
    }

    public static void main(String[] args) {

        ExecutorService service = Executors.newFixedThreadPool(2);
        service.submit(new ConditionService("producer"));
        service.submit(new ConditionService("consumer"));

    }

    public void produce() {
        try {
            while (true) {
                System.out.println("in producer...");
                synchronized (task) {
                    while (task.size() == MAX_SIZE)
                        removed.await();
                    System.out.println("added item: " + task.size());
                    task.add(task.size());
                    added.signal();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void consume() {
        try {
            while (true) {
                System.out.println("in consumer...");
                synchronized (task) {
                    while (task.isEmpty())
                        added.await();
                    System.out.println("removed item: " + task.peek());
                    task.remove();
                    removed.signal();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        if (this.type.equals("producer"))
            this.produce();
        else
            this.consume();
    }
}

Answer 1

你犯了兩個錯誤。 首先，你的鎖和條件需要是靜態的，否則每個任務只會同步並等待自己。 其次，您需要使用lock.lock() ，而不是synchronized 。 它應該是這樣的：

lock.lock();
try {
    // wait
    // produce/consume
} finally {
    lock.unlock();
}