java中的并发
今天,我决定尝试解决哲学家进餐的问题。所以我写下面的代码。但我认为这是不对的,所以如果有人告诉我它有什么问题,我会很高兴。我使用fork作为锁(我只读取它们,因为我不把对它们的访问放在同步块中),我有一个扩展线程的类,它保留了它的两个锁
import java.util.Random;
public class EatingPhilosophersProblem {
private final static Random RANDOM = new Random();
/**
*
* @author Damyan Class represents eating of every philosopher. It
* represents infinity cycle of eating.
*/
private static class PhilosopherEating extends Thread {
int forkOne;
int forkTwo;
public PhilosopherEating(String name, int forkOne, int forkTwo) {
super(name);
this.forkOne = forkOne;
this.forkTwo = forkTwo;
}
@Override
public void run() {
super.run();
while (true) {
requireLock(this, forkOne, forkTwo);
}
}
}
private static Boolean[] forks = new Boolean[] { new Boolean(true), new Boolean(true), new Boolean(true),
new Boolean(true), new Boolean(true) };
// locks should be created by new, otherwise almost 100% sure that they will
// point to the same object (because of java pools)
// this pools are used from java for immutable objects
private static void requireLock(PhilosopherEating philosopherEating, int firstIndex, int secondIndex) {
// we lock always from the the lower index to the higher, otherwise
// every philosopher can take his left fork and deadlock will apear
if (firstIndex > secondIndex) {
int temp = firstIndex;
firstIndex = secondIndex;
secondIndex = temp;
}
if (firstIndex == 4 || secondIndex == 4) {
System.err.println(firstIndex + " and " + secondIndex);
}
synchronized (forks[firstIndex]) {
synchronized (forks[secondIndex]) {
printPhilosopherhAction(philosopherEating, "start eating");
try {
Thread.sleep(RANDOM.nextInt(100));
} catch (InterruptedException e) {
e.printStackTrace();
}
printPhilosopherhAction(philosopherEating, "stop eating");
}
}
};
private static void printPhilosopherhAction(PhilosopherEating philosopherEating, String action) {
System.out.println("Philosopher " + philosopherEating.getName() + " " + action);
}
public static void main(String[] args) {
PhilosopherEating first = new PhilosopherEating("1 - first", 0, 1);
PhilosopherEating second = new PhilosopherEating("2 - second", 1, 2);
PhilosopherEating third = new PhilosopherEating("3 - third", 2, 3);
PhilosopherEating fourth = new PhilosopherEating("4 - fourth", 3, 4);
PhilosopherEating fifth = new PhilosopherEating("5 - fifth", 4, 0);
first.start();
second.start();
third.start();
fourth.start();
fifth.start();
}
我觉得有些不对劲,因为第五位哲学家从不吃东西,主要是第四和第三位哲学家吃东西。 提前谢谢
# 1 楼答案
你的问题有一个名字:它被称为线程“饥饿”。这是当多个线程竞争同一资源时,其中一个(或多个)持续被拒绝访问时发生的情况
弄清楚如何避免僵局是哲学家进餐之谜的一个方面,但弄清楚如何让每个哲学家都有合理的进餐时间可能是另一个方面
JP Moresmau的回答建议你强迫每个哲学家休息一下(在经典谜题中通常被称为“思考”),这样其他哲学家就可以轮到吃饭了。这是可行的,但如果你认为你的哲学家在某些应用程序中是工作线程,那么“吃”对应于工作线程做一些有用的工作,“休息”或“思考”对应于线程闲置,这可能是你希望避免的事情
如果所有的哲学家都总是饿着肚子,那么要确保所有的哲学家都能得到公平的进食时间,就不只是锁
这里有一个提示:使任何类型的“公平性”得到保证的更高级别的同步对象通常在实现中使用队列
# 2 楼答案
当哲学家吃饭时,你会锁定一段随机的时间,但你会不断循环,所以当其他线程收到解除锁定的通知时,你的第一位哲学家又开始吃饭了。如果我修改了你的代码,在锁外用餐后随机等待:
我看到所有哲学家都更擅长轮流吃饭