为什么此线程安全？

Question

因为它总是打印出“ 3”。 不需要同步吗？ 我正在测试这个简单的东西，因为我在一个真正的多线程问题上遇到了麻烦，这不好说明这个问题，因为它很大。 这是显示情况的简化版本。

class Test {

public static int count = 0;

class CountThread extends Thread {

    public void run()
    {
        count++;
    }
}  

public void add(){
    CountThread a = new CountThread();
    CountThread b = new CountThread();
    CountThread c = new CountThread();

    a.start();
    b.start();
    c.start();

    try {
        a.join();
        b.join();
        c.join();
    } catch (InterruptedException ex) {
        ex.printStackTrace();
    }

}
public static void main(String[] args) {

    Test test = new Test();
    System.out.println("START = " + Test.count);

    test.add();

    System.out.println("END: Account balance = " + Test.count);
}

Answer 1

因为它总是打印出“ 3”。 不需要同步吗？

它不是线程安全的，您只是很幸运。 如果您运行1000次或在不同的体系结构上运行，将看到不同的输出-即不是3。

我建议使用AtomicInteger而不是不synchronized的静态字段++。

public static AtomicInteger count = new AtomicInteger();
...
public void run() {
    count.incrementAndGet();
}
...

Answer 2

在我看来， count++足够快才能完成，直到您为另一个类调用“运行”为止。 因此，基本上它按顺序运行。
但是，如果这是一个实际示例，并且两个不同的线程并行使用CountThread ，那么是的，您将遇到同步问题。

为了验证这一点，您可以尝试在count ++之前和之后打印一些测试输出，然后您将看到b.start()在a.start()完成之前a.start()正在调用count++ 。 与c.start()相同。

考虑改用AtomicInteger，这比在可能的情况下进行同步要好得多-

IncrementAndGet
public final int incrementAndGet()
以原子方式将当前值增加一。

Answer 3

此代码不是线程安全的：

public static int count = 0;

class CountThread extends Thread {

    public void run()
    {
        count++;
    }
}

您可以在一个系统上运行此代码一百万次，并且每次都可能通过。 这并不意味着它是线程安全的。

考虑一个将count复制到多个处理器缓存的系统。 在强制将其中一个缓存复制回主RAM之前，它们可能都独立更新。 考虑到++不是原子操作。 count的读取和写入顺序可能会导致数据丢失。

实现此代码的正确方法（使用Java 5及更高版本）：

public static java.util.concurrent.atomic.AtomicInteger count =
                                 new java.util.concurrent.atomic.AtomicInteger();

class CountThread extends Thread {

    public void run()
    {
        count.incrementAndGet();
    }
}

Answer 4

仅仅因为输出正确就不是线程安全的。 创建线程会导致OS方面的大量开销，在此之后，可以预料的是，单行代码将在单个时间片内完成。 无论如何，它都不是线程安全的，只是没有足够的潜在冲突来实际触发。

Answer 5

它不是线程安全的。

恰好是有机会显示问题的短暂途径。 考虑在run计数到更高的数字（1000000？），以增加多个线程上的2个操作重叠的机会。

还要确保您的机器不是单核CPU ...

Answer 6

为了使该类线程安全，要么使count volatile以在线程之间强制执行内存隔离，要么使用AtomicInteger ，或者这样重写（我的偏好）：

class CountThread extends Thread {

    private static final Object lock = new Object();

    public void run()
    {
        synchronized(lock) {
            count++;
        }
    }
}