Java中的AtomicInteger

今天我们将研究AtomicIntegerJava。原子操作在单个任务单元中执行，不受其他操作的干扰。在多线程环境中，原子操作是必要的，以避免数据不一致。

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) {        // processing some job
        try {
            Thread.sleep(i * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }}

如果您将运行上述程序，您会注意到该count值在5,6,7,8之间变化。原因是count ++不是原子操作。因此，当一个线程读取它的值并将其递增1时，其他线程已读取较旧的值，从而导致错误的结果。

要解决这个问题，我们必须确保count上的递增操作是原子的，我们可以使用Synchronization来实现，但是Java 5 java.util.concurrent.atomic提供了int和long的包装类，可以用来实现这种原子操作而不使用Synchronization。

Java AtomicInteger示例

这是更新的程序，它总是将计数值输出为8，因为AtomicInteger方法incrementAndGet()原子地将当前值增加1。

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) {        // processing some job
        try {
            Thread.sleep(i * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }}

使用并发类进行原子操作的好处是我们不需要担心同步。这提高了代码的可读性，减少了错误的可能性。假设原子操作并发类比涉及锁定资源的同步更有效。