Java 原子操作类

最新推荐文章于 2024-07-26 08:00:00 发布
最新推荐文章于 2024-07-26 08:00:00 发布
阅读量483 收藏 9
点赞数 9
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46561911/article/details/134739694
版权

一、原子类

1.1 基本原子类

  • AtomicBoolean
  • AtomicInteger
  • AtomicLong

1.1.1 常用API

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

1.1.2 基本使用

public class AtomicIntegerDemo {
    public static final int SIEZ_ = 50;

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

        AtomicInteger atomicInteger = new AtomicInteger();
        CountDownLatch countDownLatch = new CountDownLatch(SIEZ_);

        for (int i = 1; i <=SIEZ_; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1 ;j <=1000; j++) {
                        atomicInteger.incrementAndGet();
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    countDownLatch.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"\t"+"---result : "+atomicInteger.get());
    }
}

1.2 数组类型原子类

  • AtomicIntegerArray
  • AtomicLongArray
  • AtomicReferenceArray

1.2.1 基本使用

public class AtomicIntegerArrayDemo {
    public static void main(String[] args) {
        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(new int[5]);
        //AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(5);
        //AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(new int[]{1,2,3,4,5});

        for (int i = 0; i <atomicIntegerArray.length(); i++) {
            System.out.println(atomicIntegerArray.get(i));
        }
        System.out.println();
        System.out.println();
        System.out.println();
        int tmpInt = 0;

        tmpInt = atomicIntegerArray.getAndSet(0,1122);
        System.out.println(tmpInt+"\t"+atomicIntegerArray.get(0));
        atomicIntegerArray.getAndIncrement(1);
        atomicIntegerArray.getAndIncrement(1);
        tmpInt = atomicIntegerArray.getAndIncrement(1);
        System.out.println(tmpInt+"\t"+atomicIntegerArray.get(1));

    }
}

1.3 引用类型原子类

  • AtomicReference

1.3.1 AtomicReference基本使用

public class AtomicReferenceDemo
{
    public static void main(String[] args)
    {
        User z3 = new User("z3",24);
        User li4 = new User("li4",26);

        AtomicReference<User> atomicReferenceUser = new AtomicReference<>();

        atomicReferenceUser.set(z3);
        System.out.println(atomicReferenceUser.compareAndSet(z3,li4)+"\t"+atomicReferenceUser.get().toString());
        System.out.println(atomicReferenceUser.compareAndSet(z3,li4)+"\t"+atomicReferenceUser.get().toString());
    }
}

 AtomicReference实现自旋锁

public class SpinLockDemo{
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"\t come in");
        while(!atomicReference.compareAndSet(null,thread)){}
    }

    public void myUnLock(){
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName()+"\t myUnLock over");
    }

    public static void main(String[] args){
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {
            spinLockDemo.myLock();
            //暂停一会儿线程
            try { TimeUnit.SECONDS.sleep( 5 ); } catch (InterruptedException e) { e.printStackTrace(); }
            spinLockDemo.myUnLock();
        },"A").start();
        //暂停一会儿线程，保证A线程先于B线程启动并完成
        try { TimeUnit.SECONDS.sleep( 1 ); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            spinLockDemo.myLock();
            spinLockDemo.myUnLock();
        },"B").start();
    }
}
  • AtomicStampedReference

AtomicStampedReference是携带版本号的引用类型原子类，可以解决ABA问题。解决修改过几次

1.3.2 AtomicStampedReference基本使用

    static AtomicInteger atomicInteger = new AtomicInteger(100);
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100,1);

    public static void main(String[] args) {
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t"+"---默认版本号: "+stamp);
            //让后面的t4获得和t3一样的版本号，都是1，好比较
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

            atomicStampedReference.compareAndSet(100,101,stamp,stamp+1);
            System.out.println(Thread.currentThread().getName()+"\t"+"---1次版本号: "+atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t"+"---2次版本号: "+atomicStampedReference.getStamp());
        },"t3").start();

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t"+"---默认版本号: "+stamp);
            //上前面的t3完成ABA问题
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            boolean result = atomicStampedReference.compareAndSet(100, 20210308, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName()+"\t"+"---操作成功否："+result+"\t"+atomicStampedReference.getStamp()+"\t"+atomicStampedReference.getReference());
        },"t4").start();
    }
  • AtomicMarkableReference

原子更新带有标记位的引用类型对象 。只关心是否被修改过

1.3.3 AtomicMarkableReference基本使用

public class ABADemo{
    static AtomicInteger atomicInteger = new AtomicInteger(100);

    static AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<>(100,1);

    static AtomicMarkableReference<Integer> markableReference = new AtomicMarkableReference<>(100,false);

    public static void main(String[] args){
        new Thread(() -> {
            atomicInteger.compareAndSet(100,101);
            atomicInteger.compareAndSet(101,100);
            System.out.println(Thread.currentThread().getName()+"\t"+"update ok");
        },"t1").start();

        new Thread(() -> {
            //暂停几秒钟线程
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            atomicInteger.compareAndSet(100,2020);
        },"t2").start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }

        System.out.println(atomicInteger.get());

        System.out.println();
        System.out.println();
        System.out.println();

        System.out.println("============以下是ABA问题的解决,让我们知道引用变量中途被更改了几次=========================");
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t 1次版本号"+stampedReference.getStamp());
            //故意暂停200毫秒，让后面的t4线程拿到和t3一样的版本号
            try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }

            stampedReference.compareAndSet(100,101,stampedReference.getStamp(),stampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t 2次版本号"+stampedReference.getStamp());
            stampedReference.compareAndSet(101,100,stampedReference.getStamp(),stampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t 3次版本号"+stampedReference.getStamp());
        },"t3").start();

        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t =======1次版本号"+stamp);
            //暂停2秒钟,让t3先完成ABA操作了，看看自己还能否修改
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            boolean b = stampedReference.compareAndSet(100, 2020, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName()+"\t=======2次版本号"+stampedReference.getStamp()+"\t"+stampedReference.getReference());
        },"t4").start();

        System.out.println();
        System.out.println();
        System.out.println();

        System.out.println("============AtomicMarkableReference不关心引用变量更改过几次，只关心是否更改过======================");

        new Thread(() -> {
            boolean marked = markableReference.isMarked();
            System.out.println(Thread.currentThread().getName()+"\t 1次版本号"+marked);
            try { TimeUnit.MILLISECONDS.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }
            markableReference.compareAndSet(100,101,marked,!marked);
            System.out.println(Thread.currentThread().getName()+"\t 2次版本号"+markableReference.isMarked());
            markableReference.compareAndSet(101,100,markableReference.isMarked(),!markableReference.isMarked());
            System.out.println(Thread.currentThread().getName()+"\t 3次版本号"+markableReference.isMarked());
        },"t5").start();

        new Thread(() -> {
            boolean marked = markableReference.isMarked();
            System.out.println(Thread.currentThread().getName()+"\t 1次版本号"+marked);
            //暂停几秒钟线程
            try { TimeUnit.MILLISECONDS.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }
            markableReference.compareAndSet(100,2020,marked,!marked);
            System.out.println(Thread.currentThread().getName()+"\t"+markableReference.getReference()+"\t"+markableReference.isMarked());
        },"t6").start();
    }
}

1.4 对象的属性修改原子类

  • AtomicIntegerFieldUpdater  

        原子更新对象中int类型字段的值

  • AtomicLongFieldUpdater

        原子更新对象中Long类型字段的值

  • AtomicReferenceFieldUpdater

        原子更新引用类型字段的值

1.4.1 作用

        以一种线程安全的方式操作非线程安全对象内的某些字段

1.4.2 使用要求

  • 更新的对象属性必须使用 public volatile 修饰符。
  • 因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。

1.4.3 基本使用

  • AtomicIntegerFieldUpdaterDemo
class BankAccount
{
    String bankName = "boc";

    //以一种线程安全的方式操作非线程安全对象内的某些字段
    //1 更新的对象属性必须使用 public volatile 修饰符。
    public volatile int money = 0;

    //2 因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须
    // 使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。
    AtomicIntegerFieldUpdater FieldUpdater = AtomicIntegerFieldUpdater.newUpdater(BankAccount.class,"money");

    public void transfer(BankAccount bankAccount)
    {
        FieldUpdater.incrementAndGet(bankAccount);
    }
}


/**
 * 以一种线程安全的方式操作非线程安全对象的某些字段。
 * 需求：
 * 1000个人同时向一个账号转账一元钱，那么累计应该增加1000元，
 * 除了synchronized和CAS,还可以使用AtomicIntegerFieldUpdater来实现。
 */
public class AtomicIntegerFieldUpdaterDemo
{
    public static void main(String[] args) throws InterruptedException
    {
        BankAccount bankAccount = new BankAccount();
        CountDownLatch countDownLatch = new CountDownLatch(1000);
        for (int i = 1; i <=1000; i++) {
            new Thread(() -> {
                bankAccount.transfer(bankAccount);
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"\t"+"---bankAccount: "+bankAccount.money);
    }
}
  • AtomicReferenceFieldUpdater
class MyVar {
    public volatile Boolean isInit = Boolean.FALSE;
    AtomicReferenceFieldUpdater<MyVar,Boolean> FieldUpdater = AtomicReferenceFieldUpdater.newUpdater(MyVar.class,Boolean.class,"isInit");

    public void init(MyVar myVar) {
        if(FieldUpdater.compareAndSet(myVar,Boolean.FALSE,Boolean.TRUE))
        {
            System.out.println(Thread.currentThread().getName()+"\t"+"---start init");
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t"+"---end init");
        }else{
            System.out.println(Thread.currentThread().getName()+"\t"+"---抢夺失败，已经有线程在修改中");
        }
    }

}


/**
 *  多线程并发调用一个类的初始化方法，如果未被初始化过，将执行初始化工作，要求只能初始化一次
 */
public class AtomicReferenceFieldUpdaterDemo {
    public static void main(String[] args) {
        MyVar myVar = new MyVar();

        for (int i = 1; i <=5; i++) {
            new Thread(() -> {
                myVar.init(myVar);
            },String.valueOf(i)).start();
        }
    }
}
喵喵队摆大烂
关注
  • 9
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java并发编程系列之十九：原子操作类
rhwayfun专栏
04-05 1万+
原子操作类简介当更新一个变量的时候，多出现数据争用的时候可能出现所意想不到的情况。这时的一般策略是使用synchronized解决，因为synchronized能够保证多个线程不会同时更新该变量。然而，从jdk 5之后，提供了粒度更细、量级更轻，并且在多核处理器具有高性能的原子操作类。因为原子操作类把竞争的范围缩小到单个变量上，这可以算是粒度最细的情况了。原子操作类相当于泛化的volatile变量，
Java中12个原子操作类
weixin_45743799的博客
02-03 135
Java 从 JDK 1.5 开始提供了 java.util.concurrent.atomic 包（以下简称Atomic包），这个包中的 原子操作类 提供了一种用法简单、性能高效、线程安全地更新一个变量的方式。 因为变量的类型有很多种，所以在 Atomic 包里一共提供了 12个 类，属于以下 4 种类型的原子更新方式： 原子更新基本类型。 AtomicBoolean：原子更新布尔类型。 Ato...
Java中的原子操作类
阿璐4r的博客
07-13 285
Java从JDK 1.5开始提供了java.util.concurrent.atomic包，这个包中的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式.Atomic包里的类基本都是使用Unsafe实现的包装类 1.原子更新基本类型类 AtomicBoolean：原子更新布尔类型。 AtomicInteger：原子更新整型 AtomicLong：原子更新长整型 以AtomicInteger为例： int addAndGet（int delta）：以原子方式将输入的数值与实例中的值（A
Java基础-Atomic原子类
最新发布
qq_45477639的博客
07-26 632
/枚举类//1.提供类的属性，声明为private final//2.声明为final的属性，在构造器中初始化。//3.通过公共的方法来调用属性//4.创建枚举类的对象:将类的对象声明public static finalpublic static final Season SPRING = new Season("spring", "春暖花开");
JAVA中的原子操作类
wjsshhx的专栏
03-31 1020
多线程情况下，要保证操作数据的原子性， 原子性：就是不能再往下细分的操作，JAVA 的原子操作的原理 主要是利用了CAS原理，限于篇幅 建议移步 大神的关于CAS原理的文章 以为为类操作的API和相关注释，直接上源码 原子更新基本类型类： package com.hhx.offline_tools.encode.Atomic; import java.util.concurrent.at
java原子操作类
CentOS
08-18 165
Java从JDK1.5开始提供了java.util.concurrent.atomic包，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。在Java并发比编程中，要想保证一些操作不被其他线程干扰，就需要保证原子性 ...
Java原子操作类
张小胖不胖
05-20 201
Java中Atomic包下，提供了一些简单、高效并且线程安全的更新一个变量的方式，包含四种类型的原子更新方式：原子更新基本类型、原子更新数组类型、原子更新引用类型，原子更新字段类。 原子更新基本类型： AtomicBoolean：原子更新布尔类型变量值 AtomicInteger：原子更新整型 AtomicLong：原子更新长整型 原子更新数组： AtomicIntegerA...
Java 原子操作类 Atomic
qq_44209336的博客
03-03 242
文章目录1 Atomic 类1.1 Atomic 是什么？1.2 具有原子性的原理 1 Atomic 类 1.1 Atomic 是什么？ Java从JDK1.5 开始提供了java.util.concurrent.atomic包（以下简称Atomic包），这个包中的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式。 Atomic包大致可以分为4类 原子更新基本类型 原子更新数组 原子更新引用 原子更新属性 Atomic只能保证读写安全（读写会加锁）,并不能保证线程安全。例如： 如
Java原子操作CAS原理解析
08-25
Java原子操作CAS原理解析 Java原子操作CAS原理解析是Java并发编程中的一种机制，用于解决多线程并行情况下使用锁造成的性能损耗。CAS操作包含三个操作数——内存位置（V）、预期原值（A）、新值(B)。如果内存位置的...
Java原子变量类原理及实例解析
08-25
Java原子变量类原理及实例解析 一、原子变量类简介 Java中的原子变量类是为了解决多线程环境下数据的一致性问题而设计的。它可以确保多线程环境下数据的原子性、可见性和有序性。原子变量类的主要特点是它可以在多...
java 原子性int_Java并发编程之原子操作类
weixin_39830917的博客
02-16 1080
原标题：Java并发编程之原子操作类原子操作类简介当更新一个变量的时候，多出现数据争用的时候可能出现所意想不到的情况。这时的一般策略是使用synchronized解决，因为synchronized能够保证多个线程不会同时更新该变量。然而，从jdk 5之后，提供了粒度更细、量级更轻，并且在多核处理器具有高性能的原子操作类。因为原子操作类把竞争的范围缩小到单个变量上，这可以算是粒度最细的情况了。原子操...
java并发之原子操作类和非阻塞算法
08-26
首先，原子操作类是Java并发编程的重要工具，它们提供了一种无需锁机制即可保证操作原子性的方法。这些类在`java.util.concurrent.atomic`包中定义，包括针对基本类型的`AtomicBoolean`, `AtomicInteger`, `...
java 原子类实现原理_Java原子类及内部原理
weixin_29351901的博客
02-17 1550
一、引入原子是世界上的最小单位，具有不可分割性。比如 a=0；(a非long和double类型) 这个操作是不可分割的，那么我们说这个操作是原子操作。再比如：a++；这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术(sychronized)来让它变成一个原子操作。但是，像i++这种非原子操作，我们除了使用synchroinz...
java中的原子操作类
qq_41820066的博客
11-17 399
java中的原子操作类
Java 提供的原子操作类
weixin_42679286的博客
07-13 342
java8中增加的原子类,基本思路就是分散热点，将 value 值分散到一个数组中，不同线程会命中到数组的不同槽中，各个线程只对自己槽中的那个值进行 CAS 操作。要获取 long 值，要将各个槽中的变量值累加返回。double类型的聚合器，需要传入一个double类型的二元操作，可以用来计算各种聚合操作，包括加乘等。long类型的聚合器，需要传入一个long类型的二元操作，可以用来计算各种聚合操作，包括加乘等。long类型的累加器，LongAccumulator的特例，只能用来计算加法，且从0开始计算。
Java并发编程 - 第七章 Java中的13个原子操作类
热门推荐
SongYu的博客
09-03 1万+
前言： 当程序更新一个变量时，如果多线程同时更新这个变量，可能得到期望之外的值，比如变量 i = 1，A 线程更新 i + 1，B 线程也更新 i + 1，经过两个线程操作之后可能 i 不等于 3，而是等于 2。 因为 A 和 B 线程在更新变量i的时候拿到的 i 都是 1，这就是线程不安全的更新操作，通常我们会使用 synchronized 来解决这个问题，synchronized 会保证多线程不会同时更新变量 i。 而 Java 从 JDK 1.5 开始提供了 java.util.concurrent.
java 原子操作类_Java中的13个原子操作类
weixin_29521135的博客
02-16 108
当程序更新一个变量时，如果多线程同时更新这个变量，可能得到期望之外的值，比如变量i=1，A线程更新i+1，B线程也更新i+1，经过两个线程操作之后可能i不等于3，而是等于2。因为A和B线程在更新变量i的时候拿到的i都是1，这就是线程不安全的更新操作，通常我们会使用synchronized来解决这个问题，synchronized会保证多线程不会同时更新变量i。而Java从JDK 1.5开始提供了ja...
Java并发编程：原子操作CAS详解
2. 掌握Java原子操作类的基本原理，了解处理器如何在硬件层面支持原子性。 3. 熟悉并能正确使用`AtomicInteger`、`AtomicLong`等基本类型原子更新类的常见方法，如`getAndIncrement()`、`compareAndSet()`等。 4. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值