Question

我无法理解为什么t3没有变得饥饿，因为只有一个锁并且总是有一些高优先级线程等待它（正如我所看到的，如果t1获得了锁定，t2等待，反之亦然。那么为什么t3获得锁定？

public class Starvation {

    public static int count = 0;

    public static void main(String[] args){

        final CountDownLatch latch = new CountDownLatch(3);
        final Object lock = new Object();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    latch.countDown();
                    latch.await();
                    while(count<100){
                        synchronized (lock) {
                            count++;
                            System.out.println("Count 1");
                        }
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    latch.countDown();
                    latch.await();
                    while(count<100){
                        synchronized (lock) {
                            count++;
                            System.out.println("Count 2");
                        }
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    latch.countDown();
                    latch.await();
                    while(count <100){
                        synchronized (lock) {
                            count++;
                            System.out.println("Count 3");
                        }
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });

        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t3.setPriority(Thread.MIN_PRIORITY);

        t1.start();
        t2.start();
        t3.start();

        try {
            t1.join();
            t2.join();
            t3.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

Answer 1

我无法理解为什么t3不会变得饥饿，因为只有一个锁并且总是有一些高优先级线程等待它（正如我所看到的，如果t1获得锁定，t2等待，反之亦然。那么为什么t3会锁定？

典型线程实现的优先级将特别努力不要使线程饿死。如果存在具有更高优先级的线程，则它们可以运行更多而不是t3，但t3将被赋予周期。此外，如果您的硬件具有2个以上的CPU，则无论其他线程的优先级如何，都可以在休眠CPU上调度t3。

例如，我见过保持优先级的线程优先级系统和优先级计数器。每次线程获得时间片时，其优先级计数器都会递减。然后当它达到0时再次回到最大值。这意味着在某些时候，较低优先级的线程将具有相同或更高的优先级计数器并将获得周期。但这是特定于操作系统的，可能还有其他方法可以实现它。

线程的优先级应该被认为是底层操作系统的提示。尽管我编写了很多线程代码，但我很少使用优先级。

为什么线程在我的例子中不会饿死

1 个答案: