原子类的使用

最新推荐文章于 2023-06-13 22:01:29 发布

.idea

最新推荐文章于 2023-06-13 22:01:29 发布

阅读量758

点赞数 1

文章标签：多线程 java

本文链接：https://blog.csdn.net/m0_46550452/article/details/107457918

版权

一.概述

java.util.concurrent.atomic包为我们提供了一系列线程安全，用法简单的用于更新变量的原子操作类。原子类基于CAS算法实现线程安全，无需加锁，性能高效。

以AtomicInteger原子类与int类进行效果比较：

package package05_atomic;

import java.util.concurrent.atomic.AtomicInteger;

class Compare {
    //默认初始值为1
    private AtomicInteger AI = new AtomicInteger();
    private void addValue() {
        for (int i = 0; i < 5; i++) {
            int value = AI.addAndGet(1);
            System.out.println(Thread.currentThread().getName()+":"+value);
        }
    }

     public static void main(String[] args) {
         Compare demo = new Compare();
         new Thread(demo::addValue,"线程一").start();
         new Thread(demo::addValue,"线程二").start();
     }
}

在这里插入图片描述

package package05_atomic;

class Compare {

    private Integer value = 1;
    private void addValue() {
        for (int i = 0; i < 5; i++) {
            ++value;
            System.out.println(Thread.currentThread().getName()+":"+value);
        }
    }

     public static void main(String[] args) {
         Compare demo = new Compare();
         new Thread(demo::addValue,"线程一").start();
         new Thread(demo::addValue,"线程二").start();
     }
}

在这里插入图片描述
在未使用原子类的时候结果出现了混乱。这是由于普通的数据类型无法保证++i等操作的原子性，从而出现混乱。

二.常见原子类

原子操作类可分为五种类型：基本数据类型原子类、数组类型原子类、引用类型原子类、对象的属性修改类型、高性能原子类。

（1）基本数据类型原子类

以AtomicInteger为例：

package package05_atomic;

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerTest {
    public static void main(String[] args) {
        AtomicInteger i = new AtomicInteger(0);
// 获取并自增
        System.out.println(i.getAndIncrement());
// 自增并获取
        System.out.println(i.incrementAndGet());
// 获取并加值
        System.out.println(i.getAndAdd(5));
// 加值并获取
        System.out.println(i.addAndGet(-5));
// 获取并更新
        System.out.println(i.getAndUpdate(p -> p - 2));
// 更新并获取
        System.out.println(i.updateAndGet(p -> p + 2));
// 获取并计算
        System.out.println(i.getAndAccumulate(10, (p, x) -> p + x));
// 计算并获取
        System.out.println(i.accumulateAndGet(-10, (p, x) -> p + x));
    }
}

（2）数组类型原子类

以AtomicIntegerArray为例：

public final int get(int i) //获取 index=i 位置元素的值
public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue
public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增
public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减
public final int getAndAdd(int delta) //获取 index=i 位置元素的值，并加上预期的值
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值）（比较的是引用地址），则以原子方式元素值设置为输入值
public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

（3）引用类型原子类

引用类型原子类用于原子更新多个变量（对象）。以AtomicReference为例：

package package05_atomic;

import java.util.concurrent.atomic.AtomicReference;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

class AtomicReferenceTest {
    public static void main(String[] args) {
        AtomicReference<Person> atomicReference = new AtomicReference<Person>();
        Person person = new Person("曹孟德",62);
        atomicReference.set(person);
        System.out.println(atomicReference.get().toString());

        Person newperson = new Person("郭奉孝",37);
        atomicReference.compareAndSet(person,newperson);
        System.out.println(atomicReference.get().toString());
    }
}

注：在对多个变量进行原子赋值的时候可能会出现ABA问题：在这里插入图片描述
解决办法是在每一个线程对变量进行赋值操作时加上版本号信息。

（4）对象的属性修改类型

该类型用于原子更新某个类里的某个字段。
以AtomicReferenceFieldUpdate为例：

package package05_atomic;

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

class Student {
    public volatile String name;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

class FieldUpdate {
    public static void main(String[] args) {
        Student student = new Student();
        AtomicReferenceFieldUpdater arfu = AtomicReferenceFieldUpdater.newUpdater(Student.class, String.class, "name");
        arfu.compareAndSet(student, null, "诸葛孔明");
        System.out.println(student);
    }
}