公平vs非公平

Question

我已经通过RentrantLock接受了公平和非公平纪律的测试。我写了一个模拟哲学家吃饭的小程序。

每个哲学家都有左右叉子，分别是ReentrantLocks。我模拟了1000次思考和进食行为：

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

act在哪里

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

    }

想想没什么意思，只是睡了一段时间而已。下面是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 ReentantLock（true））和不公平（new ReentantLock（））纪律没有太大差异。

（第一个数字是一个哲学家的数字）

公平锁定：

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

我曾预料到一些哲学家会挨饿，我的意思是有些哲学家必须比其他人吃得多，但饥饿并没有发生。为什么？




Answer 1

@Maks，你试过为EAT_TIME设置随机值吗？

这可能会给逻辑带来一些不公平。

Answer 2

删除所有睡眠（），你可能会看到一些不公平。

Answer 3

释放锁的线程有更好的机会重新获得锁，因为它很忙，而其他线程可能被阻塞。繁忙等待不会显示这一点，因为每个线程都有均等的机会获取锁。释放锁的那个可能有点不利。

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

但是如果我让锁变得公平

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