多线程使用 ReentrantLock

Question

我是多线程新手，非常感谢一些帮助。

编辑的代码和问题

我想使用 ReentrantLock 类来控制对两个 ArrayList 的访问。第一个是orderList，而第二个是preparedOrders ArrayList。类 Chef（扩展 Thread）的两个对象每次都希望从数组列表中删除一个订单，随机休眠一段时间，然后将订单放入preparedOrders 数组列表中，直到 OrdersList 为空。这是我当前的代码：

厨师班

import java.util.concurrent.locks.ReentrantLock;

public class Chef extends Thread{

    private String name;
    private ReentrantLock orderLock; 
    private ReentrantLock preparedLock;
    private String orderName;
    private Object useForLocking = new Object();

    public Chef(String name, ReentrantLock orderLock, ReentrantLock preparedLock){
        this.name = name;
        this.orderLock = orderLock; 
        this.preparedLock = preparedLock;
    }

    public void run(){
        while(Restaurant.orderList.size()>0){
            try{
                getOrder();
                System.out.println(name +" is preparing "+orderName+"\n");
                Thread.sleep(Math.round(Math.random()*100));
                outputOrder();
            }catch(Exception e){
                System.out.println("run exception: "+e+"\n");
            }
        }
    }

    public void getOrder(){
        if(orderLock.tryLock()){
            orderLock.lock();
            try{
                orderName = Restaurant.orderList.remove(0);
            }catch(Exception e){
                System.out.println("getOrder exception: "+e+"\n");
            }finally{
                orderLock.unlock();
                synchronized (useForLocking){
                    useForLocking.notify();
                }
            }
        }else{
            try{
                synchronized (useForLocking){
                    useForLocking.wait();
                }
            }catch(Exception e){
                System.out.println("getOrder wait exception: "+e+"\n");
            }
        }
    }

    public void outputOrder(){
        if(preparedLock.tryLock()){
            preparedLock.lock();
            try{
                Restaurant.preparedOrders.add(orderName);
            }catch(Exception e){
                System.out.println("outputOrder exception: "+e+"\n");
            }finally{
                preparedLock.unlock();
                synchronized (useForLocking){
                    useForLocking.notify();
                }
            }
        }else{
            try{
                synchronized (useForLocking){
                    useForLocking.wait();
                }
            }catch(Exception e){
                System.out.println("outputOrder wait exception: "+e+"\n");
            }
        }
    }
}

餐厅类（主）

import java.util.concurrent.locks.ReentrantLock;
import java.util.ArrayList;

 public class Restaurant{
    public static ArrayList<String> orderList = new ArrayList<String>();
    public static ArrayList<String> preparedOrders = new ArrayList<String>();

    public static void main(String[] args) {

        orderList.add("Cheese Pizza");
        orderList.add("Hotdog");
        orderList.add("Hamburger");
        orderList.add("Cheese burger");
        orderList.add("Chicken Nuggets");
        orderList.add("Chicken Burger");

        ReentrantLock orderLock = new ReentrantLock();
        ReentrantLock preparedLock = new ReentrantLock();

        Chef c1 = new Chef("Chef John", orderLock, preparedLock);
        Chef c2 = new Chef("Chef Mark", orderLock, preparedLock);

        c1.start();
        c2.start();
    }
 }

输出

Chef John is preparing Cheese Pizza
Chef John is preparing Hotdog
Chef John is preparing Hamburger
Chef John is preparing Cheese burger
Chef John is preparing Chicken Nuggets
Chef John is preparing Chicken Burger

为什么第一个线程没有解锁？

Answer 1

看起来好像您的方法每个都将互斥锁锁定了两次，但只解锁了一次。他们会这样做：

if(preparedLock.tryLock()) {   // locks the mutex if the result is true.
    preparedLock.lock();       // This locks it A SECOND TIME.
    try{
        ...
    }finally{
        preparedLock.unlock(); // This unlocks it ONCE.
    }
}
// At this point, the thread still has one lock on preparedLock

ReentrantLock 对象允许单个线程持有对互斥体的多个声明。这对于这样的情况很有用：

private final Lock myMutex = new ReentrantLock();

public void foobar(...) {
    myMutex.lock();
    try {
        ...
    }
    finally {
        myMutex.unlock();
    }
}

public void bizzwizz(...) {
    myMutex.lock();
    try {
        ...
        foobar(...);
        ...
    }
    finally {
        myMutex.unlock();
    }
}

foobar() 和 bizzwizz() 都是公共函数。我们希望其他类能够调用其中任何一个，但我们也希望它们都锁定myMutex，并且我们希望bizzwizz() 能够调用foobar()。

如果 myMutex 不是可重入的，当bizzwizz() 调用foobar() 时我们会遇到问题，因为foobar() 会尝试锁定已经被锁定的互斥锁。通常情况下，lock() 调用在拥有它的线程释放锁之前不会返回。但这永远不会发生，因为拥有它的线程就是调用lock() 的线程。这种情况有时被称为自死锁。

可重入互斥体允许单个线程对互斥体拥有多个声明。每个lock() 调用将声明数量增加一，每个unlock() 调用将其递减。只要线程 A至少有一个声明，线程 B、C 和 D 将无法 lock() 互斥锁。

Answer 2

这不是您问题的答案。我不确定你的问题是什么，但这是你应该知道的。

如果您要使用 Lock 对象，请像这样使用它们：

myLock.lock();
try {
    doSomethingThatNeedsProtection();
}
finally {
    myLock.unlock();
}

此模式可确保代码始终保持myLock 未锁定，无论发生什么其他情况。重点是：

• lock() 调用在 try { ... } finally { ... } 语句之外。我们通常不期望lock() 调用会抛出，但如果确实 抛出，随后尝试解锁它是错误的。

• 在lock() 调用和try 之间没有其他内容。一旦lock() 成功返回，我们要确保不会抛出任何会绕过finally {...} 子句的Exception 或Error。

• unlock() 调用位于 finally {...} 内部。这样可以确保无论发生什么其他情况，这段代码 sn-p 都会使锁保持解锁状态。