Java中的AtomicInteger

今天我们将深入了解Java中的AtomicInteger。在一个单一的任务单元中执行原子操作，而不受其他操作的干扰。原子操作在多线程环境中是必不可少的，以避免数据不一致性。

AtomicInteger

让我们创建一个简单的多线程程序，其中每个线程递增共享的count变量4次。因此，如果有两个线程，在它们完成后，count的值应该是8。JavaAtomic.java

package com.journaldev.concurrency;

public class JavaAtomic {

    public static void main(String[] args) throws InterruptedException {

        ProcessingThread pt = new ProcessingThread();
        Thread t1 = new Thread(pt, "t1");
        t1.start();
        Thread t2 = new Thread(pt, "t2");
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Processing count=" + pt.getCount());
    }

}

class ProcessingThread implements Runnable {
    private int count;

    @Override
    public void run() {
        for (int i = 1; i < 5; i++) {
            processSomething(i);
            count++;
        }
    }

    public int getCount() {
        return this.count;
    }

    private void processSomething(int i) {
        // 处理一些工作
        try {
            Thread.sleep(i * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

如果你运行上面的程序，你会注意到count的值在5、6、7、8之间变化。原因是因为count++不是一个原子操作。因此，当一个线程读取它的值并将其递增一次时，另一个线程已经读取了旧值，导致错误的结果。为了解决这个问题，我们必须确保对计数的递增操作是原子的，我们可以使用同步来实现，但是Java 5 java.util.concurrent.atomic提供了用于int和long的包装类，可以在不使用同步的情况下实现这个原子操作。

Java AtomicInteger 示例

这是更新后的程序，它将始终将计数值输出为 8，因为 AtomicInteger 方法 incrementAndGet() 会原子性地将当前值递增一。

package com.journaldev.concurrency;

import java.util.concurrent.atomic.AtomicInteger;

public class JavaAtomic {

    public static void main(String[] args) throws InterruptedException {

        ProcessingThread pt = new ProcessingThread();
        Thread t1 = new Thread(pt, "t1");
        t1.start();
        Thread t2 = new Thread(pt, "t2");
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Processing count=" + pt.getCount());
    }
}

class ProcessingThread implements Runnable {
    private AtomicInteger count = new AtomicInteger();

    @Override
    public void run() {
        for (int i = 1; i < 5; i++) {
            processSomething(i);
            count.incrementAndGet();
        }
    }

    public int getCount() {
        return this.count.get();
    }

    private void processSomething(int i) {
        // 处理某些工作
        try {
            Thread.sleep(i * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

使用并发类进行原子操作的好处是我们不需要担心同步问题。这提高了代码的可读性，并且减少了出错的机会。此外，原子操作并发类被认为比涉及锁定资源的同步更有效率。