0

为了练习生锈的 Java，我想尝试一个简单的多线程共享数据示例，但遇到了令我惊讶的事情。

基本上，我们AtomicInteger在三个线程之间有一个共享计数器，每个线程轮流递增和打印计数器。

主要的

AtomicInteger counter = new AtomicInteger(0);

CounterThread ct1 = new CounterThread(counter, "A");
CounterThread ct2 = new CounterThread(counter, "B");
CounterThread ct3 = new CounterThread(counter, "C");

ct1.start();
ct2.start();
ct3.start();

反线程

public class CounterThread extends Thread
{   
    private AtomicInteger _count;
    private String _id;

    public CounterThread(AtomicInteger count, String id)
    {
        _count = count;
        _id = id;
    }

    public void run()
    {
        while(_count.get() < 1000)
        {
            System.out.println(_id + ": " + _count.incrementAndGet());
            Thread.yield();
        }
    }
}

我希望当每个线程执行Thread.yield()时，它会将执行权交给另一个线程以_count像这样递增：

A: 1
B: 2
C: 3
A: 4
...

相反，我得到了A将增加_count100 倍的输出，然后将其传递给B. 有时所有三个线程会一致地轮流，但有时一个线程会主导几个增量。

为什么不Thread.yield()总是将处理交给另一个线程？

4

2 回答 2

2

我希望当每个线程执行 Thread.yield() 时，它会将执行权交给另一个线程以增加 _count，如下所示：

在旋转的线程应用程序中，预测输出非常困难。您必须在锁和其他东西上做很多工作才能获得完美的A:1 B:2 C:3 ...类型输出。

问题在于，由于硬件、竞争条件、时间切片随机性和其他因素，一切都是竞争条件并且不可预测。例如，当第一个线程启动时，它可能会在下一个线程启动之前运行几毫秒。没有人可以yield()。此外，即使它产生了，也许你在一个 4 处理器的盒子上，所以根本没有理由暂停任何其他线程。

相反，我得到的输出是 A 将 _count 增加 100 次，然后将其传递给 B。有时所有三个线程都会一致地轮流，但有时一个线程会主导几个增量。

是的，通常使用这种旋转循环，您会看到单个线程在获得时间片时会爆发输出。这也对影响时间的事实感到困惑System.out.println(...)。synchronized如果它没有进行同步操作，你会看到更多的突发输出。

为什么 Thread.yield() 不总是让处理给另一个线程？

我很少使用Thread.yield(). 它充其量只是对调度程序的一个提示，在某些架构上可能会被忽略。它“暂停”线程的想法非常具有误导性。它可能会导致线程被放回运行队列的末尾，但不能保证有任何线程在等待，因此它可能会继续运行，就好像已经删除了产量一样。

有关更多信息，请参见我的答案：多线程中不需要的输出

于 2013-09-11T17:51:17.437 回答
1

让我们阅读一些javadoc，好吗？

向调度程序提示当前线程愿意放弃其当前对处理器的使用。调度程序可以随意忽略此提示。

[...]

很少使用这种方法。它对于调试或测试目的可能很有用，它可能有助于重现由于竞争条件导致的错误。在设计并发控制结构（例如 java.util.concurrent.locks 包中的结构）时，它也可能很有用。

您不能保证另一个线程会在yield(). 这取决于调度员，他/她似乎不想在你的情况下。您可能会考虑sleep()ing 来进行测试。

于 2013-09-11T17:42:28.497 回答