另一个问题

Question

这是哲学家进餐问题的另一个实现，这是家庭作业问题，我将在这里展示我迄今为止所做的尝试：

/**
 * DPServer.java
 * <p>
 * This class implements the methods called by the philosophers
 */
package cc;

import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DPServer {

    private static Lock chopstick[] = new Lock[5]; // Create chopstick locks
    private static Lock mutex = new ReentrantLock(true);

    private static int MAX_EAT_TIME = 5000; // maximum eating time in milliseconds
    private static int MAX_THINK_TIME = 5000; // maximum thinking time in milliseconds
    private static Random r = new Random(0);


    // default constructor for DPServer class
    public DPServer() {
        for (int i = 0; i < 5; i++) {
            chopstick[i] = new ReentrantLock(true);
        } // end for

    } // end DPServer default constructor


    // called by a philosopher when they wish to eat
    public void takeChopsticks(int philosopherNumber) {
        // acquire chopstick[philosopherNumber] and chopstick[(philosopherNumber + 1) mod 5]
        System.out.println("Acquiring chopstick[" + philosopherNumber + "] and chopstick[" + ((philosopherNumber + 1) % 5) + "]");
        chopstick[philosopherNumber].lock();
        chopstick[(philosopherNumber + 1) % 5].lock();
        // eat for a random number of milliseconds
        int eatTime = r.nextInt(MAX_EAT_TIME);
        System.out.println("Philosopher " + philosopherNumber + " is eating for " + eatTime + " milliseconds");
        try {
            Thread.sleep(eatTime);
        } catch (InterruptedException ex) {
            System.out.println("Philosopher " + philosopherNumber + " eatTime sleep was interrupted");
        }

    } // end takeChopsticks


    // called by a philosopher when they are finished eating
    public void returnChopsticks(int philosopherNumber) {
        // release chopstick[philosopherNumber] and chopstick[(philosopherNumber + 1) mod 5]
        System.out.println("Releasing chopstick[" + philosopherNumber + "] and chopstick[" + ((philosopherNumber + 1) % 5) + "]");
        chopstick[(philosopherNumber + 1) % 5].unlock();
        chopstick[philosopherNumber].unlock();

        // think for a random number of milliseconds
        int thinkTime = r.nextInt(MAX_THINK_TIME);
        System.out.println("Philosopher " + philosopherNumber + " is thinking for " + thinkTime + " milliseconds");
        try {
            Thread.sleep(thinkTime);
        } catch (InterruptedException ex) {
            System.out.println("Philosopher " + philosopherNumber + " thinkTime sleep was interrupted");
        }
    }
}


// implementation of the Dining Philosopher class
package cc;

public class DPhilosopher {
    private int dpNum;
    private DPServer dpServ;

    // value constructor for the DPhilosopher class
    public DPhilosopher(int num, DPServer d) {
        dpNum = num;
        dpServ = d;
    } // end DPhilosopher value constructor


    public void DPEatThink() {
        while (true) {
            // get ready to eat
            System.out.println("Philosopher " + dpNum + " is getting ready to eat");
            dpServ.takeChopsticks(dpNum);

            // finish eating
            System.out.println("Philosopher " + dpNum + " is finished eating");
            dpServ.returnChopsticks(dpNum);

        }

    }

    public static void main(String[] args) {
        DPServer dps = new DPServer();
        DPhilosopher dp[] = new DPhilosopher[5];
        Thread dpThread[] = new Thread[5];

        // Create and launch the DPhilosopher threads
        for (int i = 0; i < 5; i++) {
            dp[i] = new DPhilosopher(i, dps);
            final int finalI = i;
            dpThread[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    dp[finalI].DPEatThink();
                }
            });
            dpThread[i].start();
        }

    } // end main
}

大部分的代码是准备好的，除了拿筷子（）和返回筷子（）方法需要改变，我所做的就是添加这个：

chopstick[(philosopherNumber + 1) % 5].lock();
chopstick[philosopherNumber].lock();

和

chopstick[(philosopherNumber + 1) % 5].unlock();
chopstick[philosopherNumber].unlock();

我知道这不是线程安全的，这个链接也保证了这一点。真正的神话是老师希望我们使用DPServer#mutexlock来解决这个问题，我可以在takechoppesticks（）和returnchoppesticks（）中锁定/解锁互斥锁，锁定和解锁两个锁（choppestick[philosopherNumber].lock（）；和筷子[（哲学家编号1）%5]。lock（）；），但这会造成僵局。

我只是不知道如何只用一个互斥重入锁来解决这个问题。

有人能帮我吗？

提前谢谢。

Answer 1

如果在获取锁的周围放置锁，如下所示：

// called by a philosopher when they wish to eat
public void takeChopsticks(int philosopherNumber) {
    // acquire chopstick[philosopherNumber] and chopstick[(philosopherNumber + 1) mod 5]
    System.out.println("Acquiring chopstick[" + philosopherNumber + "] and chopstick[" + ((philosopherNumber + 1) % 5) + "]");

    lockLock.lock();
    chopstick[philosopherNumber].lock();
    chopstick[(philosopherNumber + 1) % 5].lock();
    lockLock.unlock();

    // eat for a random number of milliseconds
    int eatTime = r.nextInt(MAX_EAT_TIME);
    System.out.println("Philosopher " + philosopherNumber + " is eating for " + eatTime + " milliseconds");
    try {
        Thread.sleep(eatTime);
    } catch (InterruptedException ex) {
        System.out.println("Philosopher " + philosopherNumber + " eatTime sleep was interrupted");
    }

} // end takeChopsticks

那么，一次只能有一位哲学家在拿起筷子，但其他一切都如预期的那样继续工作。

另一个选择是改变筷子的索引，这样奇数哲学家总是从拿起左边的筷子开始，偶数哲学家总是从拿起右边的筷子开始。由于这是一个家庭作业，我将把如何做的细节留作练习（其实没那么难，一个if-else语句让它非常简单）。