具有 AtomicInteger 和 Synchronized 的 ExecutorService 给出不同的结果

Question

以下是代码 - AtomicInteger

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class ExecutorExample1 {
    public static void main(String[] args) {
        ExecutorService executorService= Executors.newFixedThreadPool(2);
        executorService.execute(new MyTask());
        executorService.execute(new MyTask());
        executorService.execute(new MyTask());
        executorService.shutdown();
    }
}

class MyTask implements Runnable{
    private static AtomicInteger count = new AtomicInteger(0);
    @Override
    public void run() {
        try {
            count.addAndGet(1);
            task();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void task()throws InterruptedException{
        System.out.println(count + " Enterd Run of: " + Thread.currentThread().getName());
        Thread.sleep(5000);
        System.out.println(count + " Executing: " + Thread.currentThread().getName());
        Thread.sleep(5000);
        System.out.println(count + " Completed Executing: " + Thread.currentThread().getName());
    }
}

以上代码输出：

2 进入运行：pool-1-thread-1 2 进入运行：pool-1-thread-2 2 执行：pool-1-thread-2 2 执行：pool-1-thread-1 2 完成执行：pool-1-thread-1 2 完成执行：pool-1-thread-2 3 进入运行：pool-1-thread-1 3 执行：pool-1-thread-1 3 完成执行：pool-1-thread-1

用 int 和同步块替换 AtomicInteger 的相同代码

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class ExecutorExample1 {
    public static void main(String[] args) {
        ExecutorService executorService= Executors.newFixedThreadPool(2);
        executorService.execute(new MyTask());
        executorService.execute(new MyTask());
        executorService.execute(new MyTask());
        executorService.shutdown();
    }
}

class MyTask implements Runnable{
    //private static AtomicInteger count = new AtomicInteger(0);
    private static int count = 0;
    @Override
    public void run() {
        try {
            //count.addAndGet(1);
            synchronized (MyTask.class){
                count+=1;
            }
            task();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void task()throws InterruptedException{
        System.out.println(count + " Enterd Run of: " + Thread.currentThread().getName());
        Thread.sleep(5000);
        System.out.println(count + " Executing: " + Thread.currentThread().getName());
        Thread.sleep(5000);
        System.out.println(count + " Completed Executing: " + Thread.currentThread().getName());
    }
}

同步块代码的输出

2 进入运行：pool-1-thread-2 1 进入运行：pool-1-thread-1 2 执行：pool-1-thread-2 2 执行：pool-1-thread-1 2 完成执行：pool-1-thread-2 2 完成执行：pool-1-thread-1 3 进入运行：pool-1-thread-2 3 执行：pool-1-thread-2 3 完成执行：pool-1-thread-2

问题？

1. 为什么输出会有差异？
2. 为什么原子整数会增加到 2 而不是 1。
3. 如何使用 atomicinteger 实现同步输出。
4. 同时使用 volatile 和 atomic 有什么好处或用途？

Answer 1

AtomicInteger 在后台使用 volatile 字段。这样做是为了确保所有读者（其他线程）使用最新的值。在第二种情况下使用简单的int 时，您的字段不是volatile，因此您看到的1 来自一个陈旧的值。

通过使用volatile 关键字，您应该能够获得类似的结果。

另一种方法是使用门来确保满足条件，然后再继续前进。例如，这可以通过CountDownLatch 来实现（也有其他方法）：https://www.baeldung.com/java-countdown-latch