java - 哲学家就餐问题发生死锁时如何抛出异常？

Question

下面是我的哲学家就餐问题。当我执行它时，有时会发生死锁并且程序停止工作，如下例所示:

Filozof#0 正在拿 fork
Filozof#4 正在拿 fork
Filozof#4 在左边拿 fork
Filozof#3 正在拿 fork
Filozof#1 正在拿 fork
Filozof#2 正在拿 fork
Filozof#3 在左边拿 fork
Filozof#1 在左边拿 fork
Filozof#0 在左边拿 fork
Filozof#2 在左边拿了 fork

我想要做的是在最后一个线程中抛出一个异常，该异常将完成死锁。我不想解决僵局问题。我需要的是抛出异常。我怎样才能做到这一点？

public class Philosopher extends Thread implements Runnable {
            private int forkLeft;
            private int forkRight;
            private int index;

            public Philosopher(int index) {
                forkLeft = index;
                forkRight = (index + 1) % 5;
                this.index = index;
            }

            @Override
            public void run() {
                // Endless life of a philosopher
                while (true) {
                    takeForks();
                    eat();
                    putDownForks();
                    think();
                }
            }

            /**
             * Take left and right forks
             */
            private void takeForks() {
                System.out.printf("Filozof#%d is taking forks\n", index);
                Table.takeFork(forkLeft);
                System.out.printf("Filozof#%d took fork at left\n", index);
                Table.takeFork(forkRight);
                System.out.printf("Filozof#%d took fork at right\n", index);
            }

            /**
             * Put left and right forks down
             */
            private void putDownForks() {
                System.out.printf("Filozof#%d is putting forks down\n", index);
                Table.putDownFork(forkLeft);
                System.out.printf("Filozof#%d put left fork down\n", index);
                Table.putDownFork(forkRight);
                System.out.printf("Filozof#%d put right fork down\n", index);
            }

            /**
             * Eat for a while
             */
            private void eat() {
                System.out.printf("Filozof#%d is now eating\n", index);
                sleep();
            }

            /**
             * think for a while
             */
            private void think() {
                System.out.printf("Filozof#%d is now thinking\n", index);
                sleep();
            }

            private void sleep() {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }


    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    public class Table {
        public static Lock[] forks;
        public static Philosopher[] philosophers;

        public static void main(String[] args) {
            philosophers = new Philosopher[5];
            forks = new Lock[5];

            for (int i = 0; i < philosophers.length; i++) {
                philosophers[i] = new Philosopher(i);
                forks[i] = new ReentrantLock();
            }

            for (int i = 0; i < philosophers.length; i++) {
                philosophers[i].start();
            }
        }

        /**
         * Locks a fork with given index
         * @param fork index of the fork
         */
        public static void takeFork(int fork) {
            forks[fork].lock();
        }

        /**
         * unlocks a fork with given index
         * @param fork index of the fork
         */
        public static void putDownFork(int fork) {
            forks[fork].unlock();
        }
    }

Answer 1

当死锁发生时，你不想抛出异常，你应该只是阻止它发生。发生死锁是因为您没有按照锁定的顺序释放锁定。为了避免这种情况，只需按照获取锁的顺序释放锁即可。