第十五节 同步之原子类(Atomic类)

亮子 2023-04-14 00:59:36 10224 0 0 0

1、什么是原子类?什么情况下使用原子类?

java 1.5引进原子类,具体在java.util.concurrent.atomic包下,atomic包里面一共提供了13个类,分为4种类型,分别是:原子更新基本类型,原子更新数组,原子更新引用,原子更新属性。原子类也是java实现同步的一套解决方案。

既然已经有了synchronized关键字和lock,为什么还要引入原子类呢?或者什么场景下使用原子类更好呢?

在很多时候,我们需要的仅仅是一个简单的、高效的、线程安全的递增或者递减方案,这个方案一般需要满足以下要求:

1、 简单:操作简单,底层实现简单

2、 高效:占用资源少,操作速度快

3、 安全:在高并发和多线程环境下要保证数据的正确性

对于是需要简单的递增或者递减的需求场景,使用synchronized关键字和lock固然可以实现,但代码写的会略显冗余,且性能会有影响,此时用原子类更加方便。

面试的时候可以举meterService添加监控项的例子,walGet、walAcl,起一个周期线程池调用sdk往CMC提交数据,参考举周写的。

2、原子类如何使用

上面介绍了原子类有4大类,这里以原子更新基本类型中的AtomicInteger类为例,介绍通用的API接口和使用方法。

首先是几个常用的API:

// 以原子方式将给定值与当前值相加,可用于线程中的计数使用,(返回更新的值)。
int addAndGet(int delta)

// 以原子方式将给定值与当前值相加,可用于线程中的计数使用,(返回以前的值)
int getAndAdd(int delta)

// 以原子方式将当前值加 1(返回更新的值)
int incrementAndGet()

// 以原子方式将当前值加 1(返回以前的值)
int getAndIncrement() 

// 以原子方式设置为给定值(返回旧值)
int getAndSet(int newValue)

// 以原子方式将当前值减 1(返回更新的值)
int decrementAndGet() :

// 以原子方式将当前值减 1(返回以前的值)
int getAndDecrement()

// 获取当前值
get()

还是举那个同步问题的经典例子,定义一个临界变量val,起10个异步线程,每个线程都是对这个临界变量进行1000次自增操作,如下:

package Atomic;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @ClassName AtomicWrongDemo
 * @Description TODO
 * @Auther Jerry
 * @Date 2020/3/22 - 22:40
 * @Version 1.0
 */

public class AtomicWrongDemo {
    private int val = 0;

    public static void main(String[] args) {
        // 初始化实例
        AtomicWrongDemo atomicWrongDemo = new AtomicWrongDemo();

        for (int i = 0; i < 10; ++i)
        {
            new Thread(atomicWrongDemo::increase).start();
        }

        // 让主线程休眠5秒,保证前面起的10个异步线程都执行完毕
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println(atomicWrongDemo.getVal());
    }

    private void increase()
    {
        for (int i = 0; i < 1000; ++i)
        {
            ++this.val;
        }
    }

    private int getVal()
    {
        return this.val;
    }
}

运行结果有时为我们期望的10000,有时候比10000少,比如9408,出现比10000少的结果是因为自增操作++i不是原子操作,出现了竞争,需要对临界变量做同步处理。

使用synchronized关键字和lock固然可以实现,但这里只是对临界变量val++时做同步处理,有种高射炮打蚊子的感觉,且加锁后势必会对性能有所印象,这种场景正是我们使用Atomic类的场景,如下:

package Atomic;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @ClassName AtomicDemo
 * @Description TODO
 * @Auther Jerry
 * @Date 2020/3/22 - 22:31
 * @Version 1.0
 */

public class AtomicDemo {
    private AtomicInteger val = new AtomicInteger();

    public static void main(String[] args) {
        // 初始化实例
        AtomicDemo atomicDemo = new AtomicDemo();

        for (int i = 0; i < 10; ++i)
        {
            new Thread(atomicDemo::increase).start();
        }

        // 让主线程休眠5秒,保证前面起的10个异步线程都执行完毕
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println(atomicDemo.getVal().toString());
    }

    private void increase()
    {
        for (int i = 0; i < 1000; ++i)
        {
            this.val.incrementAndGet();
        }
    }

    private AtomicInteger getVal()
    {
        return this.val;
    }
}

这里我们使用了AtomicInterger类的increamentAndGet方法,以原子方式将当前值加 1(返回更新的值),结果自然是每次运行都打印10000,可以看到代码写起来很简洁,很轻量级。

这里的API估计我用的时候还得再看看,因为用的也不多,所以知道怎么用API,到时候再查一下用就行。

参考文章