java

JUC并发编程(四)——atomic原子类包

Nick · 6月8日 · 2025年 · 本文8426字 · 阅读22分钟210

atomic原子类概述

什么是原子类？

不可分割，一个操作是不可中断的数据类型，即便是多线程的情况下也可以保证，java中是java.util.concurrent.atomic包。

原子类有什么作用？

  1. 原子类的作用和锁类似，是为了保证并发情况下线程安全。不过原子类相比于锁，有一定的优势：
  2. 粒度更细：原子变量可以把竞争范围缩小到变量级别，这是我们可以获得的最细粒度的情况了，通常锁的粒度都要大于原子变量的粒度
  3. 效率更高：通常，使用原子类的效率会比使用锁的效率更高，除了高度竞争的情况

六类原子类

JUC并发编程(四)——atomic原子类包-Nickの博客

Atomic*基本类型原子类

Atomic*基本类型原子类：
Atomicinteger：整形原子类
AtomicLong：长整型原子类
AtomicBoolean：布尔型原子类

Atomic*基本类型原子类常用方法(Atomicinteger为例)

  1. public final int get() //获取当前的值
  2. public final int getAndSet(int newValue) //获取当前的值，并设置新的值
  3. public final int getAndIncrement() //中取当前的值，并自增
  4. public final int getAndDecrementO //获取当前的值，并自减
  5. public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
  6. boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）

AtomicInteger案例演示代码演示：

package atomic;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 描述：     演示AtomicInteger的基本用法，对比非原子类的线程安全问题，使用了原子类之后，不需要加锁，也可以保证线程安全。
 */
public class AtomicIntegerDemo1 implements Runnable {

    private static final AtomicInteger atomicInteger = new AtomicInteger();

    public void incrementAtomic() {
        atomicInteger.getAndAdd(-1);
    }

    private static volatile int basicCount = 0;

    public void incrementBasic() {
        basicCount++;
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicIntegerDemo1 r = new AtomicIntegerDemo1();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("原子类的结果：" + atomicInteger.get());
        System.out.println("普通变量的结果：" + basicCount);
    }

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            incrementAtomic();
            incrementBasic();
        }
    }
}

结果如下：
JUC并发编程(四)——atomic原子类包-Nickの博客

普通变量的是线程不安全的

Atomic*原子数组

AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(1000);

代码演示：

package atomic;

import java.util.concurrent.atomic.AtomicIntegerArray;

/**
 * 描述：     演示原子数组的使用方法
 */
public class AtomicArrayDemo {

    public static void main(String[] args) {
        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(1000);
        Incrementer incrementer = new Incrementer(atomicIntegerArray);
        Decrementer decrementer = new Decrementer(atomicIntegerArray);
        Thread[] threadsIncrementer = new Thread[100];
        Thread[] threadsDecrementer = new Thread[100];
        for (int i = 0; i < 100; i++) {
            threadsDecrementer[i] = new Thread(decrementer);
            threadsIncrementer[i] = new Thread(incrementer);
            threadsDecrementer[i].start();
            threadsIncrementer[i].start();
        }

//        Thread.sleep(10000);
        for (int i = 0; i < 100; i++) {
            try {
                threadsDecrementer[i].join();
                threadsIncrementer[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        for (int i = 0; i < atomicIntegerArray.length(); i++) {
//            if (atomicIntegerArray.get(i)!=0) {
//                System.out.println("发现了错误"+i);
//            }
            System.out.println(atomicIntegerArray.get(i));
        }
        System.out.println("运行结束");
    }
}

class Decrementer implements Runnable {

    private AtomicIntegerArray array;

    public Decrementer(AtomicIntegerArray array) {
        this.array = array;
    }

    @Override
    public void run() {
        for (int i = 0; i < array.length(); i++) {
            array.getAndDecrement(i);
        }
    }
}

class Incrementer implements Runnable {

    private AtomicIntegerArray array;

    public Incrementer(AtomicIntegerArray array) {
        this.array = array;
    }

    @Override
    public void run() {
        for (int i = 0; i < array.length(); i++) {
            array.getAndIncrement(i);
        }
    }
}

运行结果：
JUC并发编程(四)——atomic原子类包-Nickの博客

数组内容先减后加扣没有出现多线程安全问题。

Atomic*Reference引用类型原子类

AtomicReference : AtomicReference类的作用，和
Atomicinteger并没有本质区别，Atomicinteger可以让一个整数保证原子性，而AtomicReference可以让一个对象保证原子性，当然，AtomicReference的功能明显比Atomicinteger强，因为一个对象里可以包含很多属性。用法和Atomicinteger类似。

主要使用方法是：
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）

手写自旋锁案例

package lock.spinlock;

import java.util.concurrent.atomic.AtomicReference;

/**
 * 描述：     自旋锁
 */
public class SpinLock {

    private AtomicReference<Thread> sign = new AtomicReference<>();

    public void lock() {
        Thread current = Thread.currentThread();
        while (!sign.compareAndSet(null, current)) {
            System.out.println("自旋获取失败，再次尝试");
        }
    }

    public void unlock() {
        Thread current = Thread.currentThread();
        sign.compareAndSet(current, null);
    }

    public static void main(String[] args) {
        SpinLock spinLock = new SpinLock();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始尝试获取自旋锁");
                spinLock.lock();
                System.out.println(Thread.currentThread().getName() + "获取到了自旋锁");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    spinLock.unlock();
                    System.out.println(Thread.currentThread().getName() + "释放了自旋锁");
                }
            }
        };
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        thread1.start();
        thread2.start();
    }
}

保证了Thread类型原子性，多线程时，Thread变量不会被多个线程同时修改。

JUC并发编程(四)——atomic原子类包-Nickの博客

Atomic**FieldUpdater把普通变量升级为具有原子功能

AtomicIntegerFieldUpdater对普通变量进行升级
使用场景：偶尔需要一个原子get-set操作，或者无法修改的变量。

AtomicIntegerFieldUpdater的用法案例：

package atomic;

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

/**
 * 描述：     演示AtomicIntegerFieldUpdater的用法
 */
public class AtomicIntegerFieldUpdaterDemo implements Runnable{

    static Candidate tom;
    static Candidate peter;

    public static AtomicIntegerFieldUpdater<Candidate> scoreUpdater = AtomicIntegerFieldUpdater
            .newUpdater(Candidate.class, "score");

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            peter.score++;
            scoreUpdater.getAndIncrement(tom);
        }
    }

    public static class Candidate {

        volatile int score;
    }

    public static void main(String[] args) throws InterruptedException {
        tom=new Candidate();
        peter=new Candidate();
        AtomicIntegerFieldUpdaterDemo r = new AtomicIntegerFieldUpdaterDemo();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("普通变量："+peter.score);
        System.out.println("升级后的结果"+ tom.score);
    }
}

运行结果：
JUC并发编程(四)——atomic原子类包-Nickの博客

AtomicintegerFieldUpdater注意点：
可见范围，需要public（类似于反射）
不支持static

Adder累加器

  1. 是Java 8引入的，相对是比较新的一个类
  2. 高并发下LongAdder比AtomicLong效率高，不过本质是空间换时间
  3. 竞争激烈的时候，LongAdder把不同线程对应到不同的Cell上进行修改，降低了冲突的概率，是多段锁的理念，提高了并发性
  4. 由于竞争很激烈，每一次加法，都要行lefresh，导致很耗费资源。

LongAdder比AtomicLong自加效率对比：
多线程下，提交一万次任务，每次任务累加10000次。

  1. 使用AtomicLong
package atomic;

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

/**
 * 描述：     演示高并发场景下，LongAdder比AtomicLong性能好
 */
public class AtomicLongDemo {

    public static void main(String[] args) throws InterruptedException {
        AtomicLong counter = new AtomicLong(0);
        System.out.println("初始值：" + counter.get());
        ExecutorService service = Executors.newFixedThreadPool(20);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            service.submit(new Task(counter));
        }
        service.shutdown();
        while (!service.isTerminated()) {

        }
        long end = System.currentTimeMillis();
        System.out.println("累加后值：" + counter.get());
        System.out.println("AtomicLong耗时：" + (end - start));
    }

    private static class Task implements Runnable {

        private AtomicLong counter;

        public Task(AtomicLong counter) {
            this.counter = counter;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                counter.incrementAndGet();
            }
        }
    }
}
  1. 使用AtomicLong
package atomic;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;

/**
 * 描述：     演示高并发场景下，LongAdder比AtomicLong性能好
 */
public class LongAdderDemo {

    public static void main(String[] args) throws InterruptedException {
        LongAdder counter = new LongAdder();
        System.out.println("初始值：" + counter.sum());
        ExecutorService service = Executors.newFixedThreadPool(20);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            service.submit(new Task(counter));
        }
        service.shutdown();
        while (!service.isTerminated()) {

        }
        long end = System.currentTimeMillis();
        System.out.println("累加后值：" + counter.sum());
        System.out.println("LongAdder耗时：" + (end - start));
    }

    private static class Task implements Runnable {

        private LongAdder counter;

        public Task(LongAdder counter) {
            this.counter = counter;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        }
    }
}

运行结果：
不使用累加器：
JUC并发编程(四)——atomic原子类包-Nickの博客

使用累加器：
JUC并发编程(四)——atomic原子类包-Nickの博客

效率越提升10倍不止

LongAdder带来的改进和原理
在内部，这个LongAdder的实现原理和刚才的AtomicLong是有不同的，刚才的AtomicLong的实现原理是，每一次加法都需要做同步，所以在高并发的时候会导致冲突比较多，也就降低了效率

而此时的LongAdder，每个线程会有自己的一个计数器，仅用来在自己线程内计数，这样一来就不会和其他线程的计数器干扰

如图中所示，第一个线程的计数器数值，也就是ctr’
为1的时候，可能线程2的计数器ctr’’的数值已经是3了，他们之间并不存在竞争关系,所以在加和的过程中，根本不需要同步机制，也不需要刚才的flush和refresh。这里也没有一个公共的counter来给所有线程统一计数

AtomicLong累加过程示例：
JUC并发编程(四)——atomic原子类包-Nickの博客

LongAdder累加过程示例：
JUC并发编程(四)——atomic原子类包-Nickの博客

LongAdder原理
LongAdder引入了分段累加的概念，内部有一个base变量和一个Cell[]数组共同参与计数：
base变量：竞争不激烈，直接累加到该变量上
Cell[]数组：竞争激烈，各个线程分散累加到自己的槽Cell[i]中

JUC并发编程(四)——atomic原子类包-Nickの博客

Accumulator累加器

Accumulator和Adder非常相似，Accumulator就是一个更通用版本的Adder

演示LongAccumulator的用法

package atomic;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.LongAccumulator;
import java.util.stream.IntStream;

/**
 * 描述：     演示LongAccumulator的用法
 */
public class LongAccumulatorDemo {

    public static void main(String[] args) {
        LongAccumulator accumulator = new LongAccumulator((x, y) -> x * y, 1);
        ExecutorService executor = Executors.newFixedThreadPool(8);
        IntStream.range(1, 10).forEach(i -> executor.submit(() -> accumulator.accumulate(i)));

        executor.shutdown();
        while (!executor.isTerminated()) {

        }
        System.out.println(accumulator.getThenReset());
    }
}

其中x是初始值，y是传入值accumulator.accumulate(i))，在运行中，“累加”是并行操作的，多线程并行操作，可以提高效率，但是执行顺序不能保证，需要计算的逻辑是可以并行的，否则最终结果有问题。

相关文章

JUC并发编程(九)——Future和Callable(获取子线程结果)

9月13日 · 2025年

JUC并发编程(八)——AQS(并发灵魂)

8月6日 · 2025年

JUC并发编程(七)——控制并发流程

7月27日 · 2025年

JUC并发编程(六)——并发容器

7月6日 · 2025年
0 条回应
©2021版权所有
在线人数：1人 来访统计
新时代
Ado
隐藏