我已经通过 RentrantLock 测试了公平和不公平的纪律。我写了一个模拟哲学家用餐的小程序。

每个哲学家都有左叉和右叉，它们是ReentrantLock。我已经模拟了 1000 次思考和进食的行为:

 for (int i = 0; i < ACT_TIMES; i++) {
            act();
        }

act 在哪里

private void act() {
        think();
        eat();

    }

Think 并不有趣，它只是睡了一段时间。这是eat方法

private void eat() {
        try {
            if (left.tryLock(0, TimeUnit.MILLISECONDS)) {
                if (right.tryLock(0, TimeUnit.MILLISECONDS)) {
                    log("eating");
                    eatCount++;
                    try {
                        Thread.sleep(EAT_TIME);
                    } catch (InterruptedException e) {
                    } finally {
                        left.unlock();
                        right.unlock();
                    }
                } else {
                    left.unlock();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

主要方法:

 Lock[] forks = new Lock[5];
        for (int i = 0; i < forks.length; i++) {
            forks[i] = new ReentrantLock();
        }
        Philosopher p1 = new Philosopher(0, forks[1], forks[0]);
        Philosopher p2 = new Philosopher(1, forks[2], forks[1]);
        Philosopher p3 = new Philosopher(2, forks[3], forks[2]);
        Philosopher p4 = new Philosopher(3, forks[4], forks[3]);
        Philosopher p5 = new Philosopher(4, forks[0], forks[4]);
        ExecutorService exec = Executors.newFixedThreadPool(5);
        exec.submit(p1);
        exec.submit(p2);
        exec.submit(p3);
        exec.submit(p4);
        exec.submit(p5);

在所有 5 个线程完成后，我为每个哲学家打印 eatCount。对于公平 (new ReentrantLock(true)) 和不公平 (new ReentrantLock()) 纪律，这些值差别不大。

(第一个数字是哲学家的数字)

公平锁:

0 344
1 348
2 366
3 359
4 363
Total number of eating 1780

不公平锁:

0 338
1 338
2 339
3 341
4 352
Total number of eating 1708

我曾预料到会因不公平锁定而出现饥饿，我的意思是某些哲学家/哲学家的 eatCount 必须比其他人大得多，但饥饿并没有发生。为什么？

最佳答案

释放锁的线程有更好的机会重新获得锁，因为它很忙，而其他线程可能被阻塞。忙等待不会显示这一点，因为每个线程都有平等的机会获取锁。可能释放锁的人会略微处于劣势。

final ReentrantLock lock = new ReentrantLock();
for (int i = 0; i < 5; i++) {
    final int finalI = i;
    new Thread(new Runnable() {
        @Override
        public void run() {
            for (int j = 0; j < 5; j++) {
                lock.lock();
                System.out.println("locked by " + finalI);
                lock.unlock();
            }
        }
    }).start();
}

打印

locked by 0
locked by 0
locked by 0
locked by 0
locked by 0
locked by 1
locked by 1
locked by 1
locked by 1
locked by 1
locked by 2
locked by 2
locked by 2
locked by 2
locked by 2
locked by 3
locked by 3
locked by 3
locked by 3
locked by 3
locked by 4
locked by 4
locked by 4
locked by 4
locked by 4

但是如果我用 true 使锁公平，我明白了

locked by 0
locked by 1
locked by 2
locked by 3
locked by 4
locked by 0
locked by 1
locked by 2
locked by 3
locked by 4
locked by 0
locked by 1
locked by 2
locked by 3
locked by 4
locked by 0
locked by 1
locked by 2
locked by 3
locked by 4
locked by 0
locked by 1
locked by 2
locked by 3
locked by 4

关于java - 公平与不公平，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13918689/