• 多线程JUC 第2季 多线程的原子性

    一 多线程原子性

    1.1 基本数据类型原子

    atomicInteger， atomicLong，atomicBoolean

    1.代码countdownlatch

    1. package com.ljf.thread.atomic;
    2.  
    3. import java.util.concurrent.CountDownLatch;
    4. import java.util.concurrent.atomic.AtomicInteger;
    5.  
    6. class MyNumber
    7. {
    8.     AtomicInteger atomicInteger = new AtomicInteger();
    9.  
    10.     public void addPlusPlus()
    11.     {
    12.         atomicInteger.getAndIncrement();
    13.     }
    14. }
    15. /**
    16.  * @ClassName: AtomicDemo
    17.  * @Description: TODO
    18.  * @Author: admin
    19.  * @Date: 2023/11/06 22:24:14 
    20.  * @Version: V1.0
    21.  **/
    22. public class AtomicDemo {
    23.  
    24.     public static void main(String[] args) throws InterruptedException {
    25.         MyNumber myNumber = new MyNumber();
    26.         CountDownLatch ct=new CountDownLatch(10);
    27.         for(int k=1;k<=10;k++){
    28.             new Thread(new Runnable() {
    29.                 @Override
    30.                 public void run() {
    31.                     for(int k=0;k<30;k++){
    32.                         myNumber.addPlusPlus();
    33.                     }
    34.                     ct.countDown();
    35.                 }
    36.             },String.valueOf(k)).start();
    37.         }
    38.         ct.await();
    39.         System.out.println("");
    40.         System.out.println(Thread.currentThread().getName()+"\t"+"result: "+myNumber.atomicInteger.get());
    41.     }
    42. }

    结果：

    1.2 原子数组类型

    1.AtomicIntegerArray 2.AtomicLongArray  3. AtomicReferenceArray

    1.3 引用数据类型

    1.AtomicReference

    2.AtomicStampedReference  携带版本号的引用类，解决修改过几次

    3.AtomicMarkableReference  原子更新带有标记位 解决是否修改过  状态戳  true/false

    1.4 字段级别原子更新

    1.4.1 介绍作用

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

    2.AtomicLongFieldUpdater   原子更新对象中Long类型字段的值。

    3.AtomicReferenceFieldUpdater  原子更新引用数据类型字段的值

    目的：以一种线程安全的方式操作非线程安全的对象内的某些字段。更新的对象属性必须使用public volatile修饰符。因为对象的属性修改类型原子类都是抽象类，所有每次使用都必须使用静态方法newUpdate()方法创建一个更新器，并且需要设置想要更新的类和属性。 

    1.4.2 代码

    1.4.2.1 原始锁的方式

    1.原始锁方式

    1. public class AtomicDemo {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         CountDownLatch countDownLatch=new CountDownLatch(10);
    4.         PayInfo  payInfo =new PayInfo();
    5.         for(int k=0;k<10;k++){
    6.             new Thread(()->{
    7.                 try {
    8.                     for (int m = 0; m < 1000; m++) {
    9.                         payInfo.add();
    10.                         //payInfo.transferMoney(payInfo);
    11.                     }
    12.                 }
    13.                 catch (Exception e){
    14.                     e.printStackTrace();
    15.                 }
    16.                 finally {
    17.                     countDownLatch.countDown();
    18.                 }
    19.             }).start();
    20.         }
    21.         countDownLatch.await();
    22.         System.out.println(Thread.currentThread().getName()+"\t"+payInfo.money);
    23.     }
    24. }

    资源类

    1. public class PayInfo {
    2.     String bankName = "icbc";
    3.     int money = 0;
    4.    // public volatile int money = 0;
    5.     public synchronized  void add(){
    6.         money++;
    7.     }
    8. //    AtomicIntegerFieldUpdater<PayInfo> atomicIntegerFieldUpdater=AtomicIntegerFieldUpdater.newUpdater(PayInfo.class,"money");
    9. //    public void transferMoney(PayInfo payInfo){
    10. //        atomicIntegerFieldUpdater.getAndIncrement(payInfo);
    11. //    }
    12. }

    3.结果

    1.4.2.2 字段级别的更新

    1.资源类

    1. public class PayInfo {
    2.     String bankName = "icbc";
    3.    // int money = 0;
    4.     public volatile int money = 0;
    5.     public synchronized  void add(){
    6.         money++;
    7.     }
    8.     AtomicIntegerFieldUpdater<PayInfo> atomicIntegerFieldUpdater=AtomicIntegerFieldUpdater.newUpdater(PayInfo.class,"money");
    9.     public void transferMoney(PayInfo payInfo){
    10.         atomicIntegerFieldUpdater.getAndIncrement(payInfo);
    11.     }
    12. }

    2.代码

    1. public class AtomicDemo {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         CountDownLatch countDownLatch=new CountDownLatch(10);
    4.         PayInfo  payInfo =new PayInfo();
    5.         for(int k=0;k<10;k++){
    6.             new Thread(()->{
    7.                 try {
    8.                     for (int m = 0; m < 1000; m++) {
    9.                         //payInfo.add();
    10.                         payInfo.transferMoney(payInfo);
    11.                     }
    12.                 }
    13.                 catch (Exception e){
    14.                     e.printStackTrace();
    15.                 }
    16.                 finally {
    17.                     countDownLatch.countDown();
    18.                 }
    19.             }).start();
    20.         }
    21.         countDownLatch.await();
    22.         System.out.println(Thread.currentThread().getName()+"\t"+payInfo.money);
    23.     }
    24. }

    3.结果

    1.5 LongAdder与LongAccumlator

    1.5.1 介绍

    LongAdder 只能用来计算加法，且从零开始计算。

    LongAccumulator提供了自定义的函数操作。

    1.5.2 代码

    1. public class LongAdderDemo {
    2.     public static void main(String[] args) {
    3.         LongAdder  longAdder=new LongAdder();
    4.         longAdder.increment();
    5.         longAdder.increment();
    6.         System.out.println("result:"+longAdder.toString());
    7.         LongAccumulator longAccumulator = new LongAccumulator(new LongBinaryOperator()
    8.         {
    9.             @Override
    10.             public long applyAsLong(long left, long right)
    11.             {
    12.                 System.out.println("left:"+left+" right:"+right);
    13.                 return left + right;
    14.             }
    15.         },9);
    16.  
    17.         longAccumulator.accumulate(1);//1
    18.         longAccumulator.accumulate(3);//4
    19.  
    20.         System.out.println(longAccumulator.get());
    21.     }
    22. }

    结果：

    1.6  四种原子操作计数的比较

    1.代码

    1. package com.ljf.thread.atomic;
    2.  
    3. import java.util.concurrent.atomic.AtomicLong;
    4. import java.util.concurrent.atomic.LongAccumulator;
    5. import java.util.concurrent.atomic.LongAdder;
    6.  
    7. /**
    8.  * @ClassName: Clik
    9.  * @Description: TODO
    10.  * @Author: admin
    11.  * @Date: 2023/12/24 10:51:07 
    12.  * @Version: V1.0
    13.  **/
    14. public class Clik {
    15.     int number = 0;
    16.     public synchronized void clickBySynchronized()
    17.     {
    18.         number++;
    19.     }
    20.  
    21.     AtomicLong atomicLong = new AtomicLong(0);
    22.     public void clickByAtomicLong()
    23.     {
    24.         atomicLong.getAndIncrement();
    25.     }
    26.  
    27.     LongAdder longAdder = new LongAdder();
    28.     public void clickByLongAdder()
    29.     {
    30.         longAdder.increment();
    31.     }
    32.  
    33.     LongAccumulator longAccumulator = new LongAccumulator((x, y) -> x + y,0);
    34.     public void clickByLongAccumulator()
    35.     {
    36.         longAccumulator.accumulate(1);
    37.     }
    38. }

    2.调用类

    1. package com.ljf.thread.atomic;
    2.  
    3. import java.util.concurrent.CountDownLatch;
    4.  
    5. /**
    6.  * @ClassName: AccumulatorCompareDemo
    7.  * @Description: TODO
    8.  * @Author: admin
    9.  * @Date: 2023/12/24 10:51:51 
    10.  * @Version: V1.0
    11.  **/
    12. public class AccumulatorCompareDemo {
    13.         public static final int _1W = 10000;
    14.         public static final int threadNumber = 50;
    15.     public static void main(String[] args) throws InterruptedException {
    16.         long startTime;
    17.         long endTime;
    18.         Clik  clik=new Clik();
    19.         CountDownLatch countDownLatch1 = new CountDownLatch(threadNumber);
    20.         CountDownLatch countDownLatch2 = new CountDownLatch(threadNumber);
    21.         CountDownLatch countDownLatch3 = new CountDownLatch(threadNumber);
    22.         CountDownLatch countDownLatch4 = new CountDownLatch(threadNumber);
    23.  
    24.         startTime = System.currentTimeMillis();
    25.         for (int i = 1; i <=threadNumber; i++) {
    26.             new Thread(() -> {
    27.                 try {
    28.                     for (int j = 1; j <=100 * _1W; j++) {
    29.                         clik.clickBySynchronized();
    30.                     }
    31.                 } finally {
    32.                     countDownLatch1.countDown();
    33.                 }
    34.             },String.valueOf(i)).start();
    35.         }
    36.         countDownLatch1.await();
    37.         endTime = System.currentTimeMillis();
    38.         System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t clickBySynchronized: "+clik.number);
    39. //
    40.         startTime = System.currentTimeMillis();
    41.         for (int i = 1; i <=threadNumber; i++) {
    42.             new Thread(() -> {
    43.                 try {
    44.                     for (int j = 1; j <=100 * _1W; j++) {
    45.                         clik.clickByAtomicLong();
    46.                     }
    47.                 } finally {
    48.                     countDownLatch2.countDown();
    49.                 }
    50.             },String.valueOf(i)).start();
    51.         }
    52.         countDownLatch2.await();
    53.         endTime = System.currentTimeMillis();
    54.         System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t clickByAtomicLong: "+clik.number);
    55. //
    56. //
    57. //
    58.         startTime = System.currentTimeMillis();
    59.         for (int i = 1; i <=threadNumber; i++) {
    60.             new Thread(() -> {
    61.                 try {
    62.                     for (int j = 1; j <=100 * _1W; j++) {
    63.                         clik.clickByLongAdder();
    64.                     }
    65.                 } finally {
    66.                     countDownLatch3.countDown();
    67.                 }
    68.             },String.valueOf(i)).start();
    69.         }
    70.         countDownLatch3.await();
    71.         endTime = System.currentTimeMillis();
    72.         System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t clickByLongAdder: "+clik.number);
    73.  
    74. //
    75.         startTime = System.currentTimeMillis();
    76.         for (int i = 1; i <=threadNumber; i++) {
    77.             new Thread(() -> {
    78.                 try {
    79.                     for (int j = 1; j <=100 * _1W; j++) {
    80.                         clik.clickByLongAccumulator();
    81.                     }
    82.                 } finally {
    83.                     countDownLatch4.countDown();
    84.                 }
    85.             },String.valueOf(i)).start();
    86.         }
    87.         countDownLatch4.await();
    88.         endTime = System.currentTimeMillis();
    89.         System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t clickByLongAccumulator: "+clik.number);
    90.  
    91.     }
    92.  
    93.  
    94.  
    95. }

  • 相关阅读:
    uniapp中实现圆形进度条的方式有哪些？
    python——基础排坑+经验总结(持续更新)
    【WPF】Dispatcher 与消息循环
    24PL-18-50-1836、12PN-4.1-50-1836比例电磁铁控制器
    React 为什么使用map来渲染列表 而不是其他循环方法
    内省机制（操作javaBean的信息）
    C++内存管理
    微信公众号迁移详细步骤
    使用pydumpck反编译pyintaller生成的exe文件 python3.10
    【Vue3】vue3中组合式Api的setup写法快速入门上手起步
  • 原文地址：https://blog.csdn.net/u011066470/article/details/134255972