了解 Java 线程干扰

Question

我正在学习 Java，来自 python 背景，并试图理解线程干扰，从本页中的代码和解释开始：http://docs.oracle.com/javase/tutorial/essential/concurrency/interfere.html

为了重现干扰，我有另一个 class 启动三个线程，每个线程随机调用递增或递减 10 次。

我预计，有 3 个线程和 30 个递增或递减，有些会重叠，因此最终的 Counter 值将不等于 (# increments) - (# decrements).

但每次我运行代码和分析结果输出时，我发现最终值等于 (# increments) - (# decrements)。虽然有可能5运行秒后，我不知何故没有受到任何干扰，但更有可能是我误解了干扰效果或无意中实现了避免干扰的代码。

这是我的代码：

// file: CounterThreads.java
public class CounterThreads {
    private static class CounterThread implements Runnable {
        private Counter c;

        CounterThread(Counter c)
        {
            this.c = c;
        }

        public void run()
        {
            String threadName = Thread.currentThread().getName();
            for (int i=0; i<10; i++) {
                try {

                    if (((int)(Math.random() * 10) % 2) == 0) {
                        System.out.format("%s - Decrementing...\n", threadName);
                        c.decrement();
                    } else {
                        System.out.format("%s - Incrementing...\n", threadName);
                        c.increment();
                    }
                    System.out.format("%s - The internal counter is at %s\n", threadName, c.value());
                    Thread.sleep(1000);

                } catch (InterruptedException e) {
                    System.out.format("Thread %s interrupted\n", threadName);
                }
            }
        }
    }

    public static void main(String[] args)
    {
        Counter c = new Counter();
        for (int  i=0; i<3; i++) {
            Thread t = new Thread(new CounterThread(c));
            System.out.format("Starting Thread: %s\n", t.getName());
            t.start();
        }
    }
}

文件 Counter.java 包含从上面的 oracle 文档复制的代码，为方便起见在此处复制

// file: Counter.java
public class Counter {
    private int c = 0;

    void increment ()
    {
        c++;
    }

    void decrement()
    {
        c--;
    }

    int value()
    {
        return c;
    }
}

Answer 1

要重现，你需要最大化概率增加and/or减少你的计数器同时（注意：它是这不是一件容易的事，因为 incrementing/decrementing 计数器是一个非常快的操作），这不是您当前代码的情况，因为：

您没有使用任何机制来同步 incrementing/decrementing 您的计数器之前的线程。
你在标准输出流中打印消息的频率太高而且打印位置错误，当你知道 PrintStream 是线程安全的并且 使用内部锁来防止并发访问 这会降低递增的可能性 and/or 同时递减你的计数器。
你添加了一个无用的长时间睡眠，这再次降低了你的计数器被并发修改的可能性。
您没有使用尽可能多的线程。

因此，您的代码应该稍微重写以解决以前的问题。

要修复 #1，您可以使用 CyclicBarrier 来确保所有线程在继续之前到达相同的障碍点（位于 incrementing/decrementing 您的计数器之前）。

要修复 #2，我建议只保留一条消息在有 incremented/decremented 你的柜台后。

要修复 #3，我会简单地删除它，因为它无论如何都没有用。

为了修复#4，我会使用 Runtime.getRuntime().availableProcessors() 作为要使用的线程数量，因为它将使用与本地计算机上一样多的处理器，这应该足以完成此类任务。

所以最终代码可以是：

计数器

public class Counter {
    private final CyclicBarrier barrier;
    private int c;

    public Counter(int threads) {
        this.barrier = new CyclicBarrier(threads);
    }

    void await() throws BrokenBarrierException, InterruptedException {
        barrier.await();
    }
    ...
}

main方法

public static void main(String[] args) {
    int threads = Runtime.getRuntime().availableProcessors();
    Counter c = new Counter(threads);
    for (int  i=0; i<threads; i++) {
        ...
    }
}

run方法的for循环

try {
    // Boolean used to know if the counter has been decremented or not
    // It has been moved before the await to avoid doing anything before
    // incrementing/decrementing the counter
    boolean decrementing = (int)(Math.random() * 10) % 2 == 0;
    // Wait until all threads reach this point
    c.await();
    if (decrementing) {
        c.decrement();
    } else {
        c.increment();
    }
    // Print the message
    System.out.format(
        "%s - The internal counter is at %d %s\n", 
        threadName, c.value(), decrementing ? "Decrementing" : "Incrementing"
    );

} catch (Exception e) {
    System.out.format("Thread %s in error\n", threadName);
}

了解 Java 线程干扰

Understanding Java Thread Interference

java

multithreading

java-threads