java - 在 Java 中跨多个线程递增值是如何工作的？

Question

我有两段多线程代码。一个将 Integer 传递给线程，线程将其递增，另一个传递一个具有递增的内部 Integer 的对象。当我运行这些时，输出是不同的，而不是我所期望的。有人可以解释一下发生了什么以及我如何使第一个行为与第二个行为类似。

实现1:

public class Main {
    public static void main(String[] args) {
        Integer counter = 0;
        for (int i = 0; i < 3; i++) {
            Threaded t = new Threaded("Thread " + i, counter);
            Thread thread = new Thread(t);
            thread.start();
        }
    }
}

class Threaded implements Runnable {
    private final String name;
    private Integer counter;
    
    public Threaded(String name, Integer counter) {
        this.name = name;
        this.counter = counter;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            counter++;
            System.out.println(name + ": " + counter);
        }
    }
}

输出 1:

Thread 1: 1
Thread 1: 2
Thread 0: 1
Thread 0: 2
Thread 0: 3
Thread 0: 4
Thread 0: 5
Thread 2: 1
Thread 2: 2
Thread 2: 3
Thread 2: 4
Thread 1: 3
Thread 1: 4
Thread 1: 5
Thread 2: 5

实现2:

public class Main {
    public static void main(String[] args) {
        MyObj obj = new MyObj();
        for (int i = 0; i < 3; i++) {
            Threaded t = new Threaded("Thread " + i, obj);
            Thread thread = new Thread(t);
            thread.start();
        }
    }
}

class MyObj {
    private int count = 0;
    
    public void inc() { count++; }
    
    public int getCount() { return count; }
}

class Threaded implements Runnable {
    
    private final String name;
    private final MyObj obj;
    
    public Threaded(String name, MyObj obj) {
        this.name = name;
        this.obj = obj;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            obj.inc();
            System.out.println(name + ": " + obj.getCount());
        }
    }
}

输出 2:

Thread 1: 2
Thread 1: 3
Thread 1: 4
Thread 1: 5
Thread 1: 6
Thread 0: 1
Thread 0: 7
Thread 2: 8
Thread 0: 9
Thread 2: 10
Thread 2: 11
Thread 0: 12
Thread 2: 13
Thread 2: 15
Thread 0: 14

是否可以让多个线程都直接递增一个 Integer，但得到类似于实现 2 的输出？

Answer 1

对于第一个示例，每个线程都有自己的计数器，并且单独递增。 Integer 是不可变的，当它递增时，结果是一个新的 Integer 对象。线程获得相同的起始值，但没有共享状态。

对于第二个示例，线程共享同一个 MyObject 实例，没有什么可以阻止它们覆盖彼此的工作。在第二个示例中使用 AtomicInteger，线程不会相互干扰。

class MyObj {
    private AtomicInteger counter = new AtomicInteger(0);

    public void inc() { 
        counter.incrementAndGet(); 
    }

    public int getCount() { 
        return counter.get();
    }
}