• Java之原子性问题的解决

    2. 原子性

    2.1 volatile-问题

    代码分析 :

    1. package com.itheima.myvolatile;
    2. ​
    3. public class Demo {
    4.     public static void main(String[] args) {
    5.         MyThread1 t1 = new MyThread1();
    6.         t1.setName("小路同学");
    7.         t1.start();
    8. ​
    9.         MyThread2 t2 = new MyThread2();
    10.         t2.setName("小皮同学");
    11.         t2.start();
    12.     }
    13. }
    14. package com.itheima.myvolatile;
    15. ​
    16. public class Money {
    17.     public static int money = 100000;
    18. }
    19. package com.itheima.myvolatile;
    20. ​
    21. public class MyThread1 extends  Thread {
    22.     @Override
    23.     public void run() {
    24.         while(Money.money == 100000){
    25. ​
    26.         }
    27. ​
    28.         System.out.println("结婚基金已经不是十万了");
    29.     }
    30. }
    31. ​
    32. package com.itheima.myvolatile;
    33. ​
    34. public class MyThread2 extends Thread {
    35.     @Override
    36.     public void run() {
    37.         try {
    38.             Thread.sleep(10);
    39.         } catch (InterruptedException e) {
    40.             e.printStackTrace();
    41.         }
    42. ​
    43.         Money.money = 90000;
    44.     }
    45. }
    ​

    程序问题 : 女孩虽然知道结婚基金是十万，但是当基金的余额发生变化的时候，女孩无法知道最新的余额。

    2.2 volatile解决

    以上案例出现的问题 :

    当A线程修改了共享数据时，B线程没有及时获取到最新的值，如果还在使用原先的值，就会出现问题

    1，堆内存是唯一的，每一个线程都有自己的线程栈。

    2 ，每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。

    3 ，在线程中，每一次使用是从变量的副本中获取的。

    Volatile关键字 : 强制线程每次在使用的时候，都会看一下共享区域最新的值

    代码实现 : 使用volatile关键字解决

    1. package com.itheima.myvolatile;
    2. ​
    3. public class Demo {
    4.     public static void main(String[] args) {
    5.         MyThread1 t1 = new MyThread1();
    6.         t1.setName("小路同学");
    7.         t1.start();
    8. ​
    9.         MyThread2 t2 = new MyThread2();
    10.         t2.setName("小皮同学");
    11.         t2.start();
    12.     }
    13. }
    14. package com.itheima.myvolatile;
    15. ​
    16. public class Money {
    17.     public static volatile int money = 100000;
    18. }
    19. package com.itheima.myvolatile;
    20. ​
    21. public class MyThread1 extends  Thread {
    22.     @Override
    23.     public void run() {
    24.         while(Money.money == 100000){
    25. ​
    26.         }
    27. ​
    28.         System.out.println("结婚基金已经不是十万了");
    29.     }
    30. }
    31. ​
    32. package com.itheima.myvolatile;
    33. ​
    34. public class MyThread2 extends Thread {
    35.     @Override
    36.     public void run() {
    37.         try {
    38.             Thread.sleep(10);
    39.         } catch (InterruptedException e) {
    40.             e.printStackTrace();
    41.         }
    42. ​
    43.         Money.money = 90000;
    44.     }
    45. }
    46. ​

    2.3 synchronized解决

    synchronized解决 :

    1 ，线程获得锁

    2 ，清空变量副本

    3 ，拷贝共享变量最新的值到变量副本中

    4 ，执行代码

    5 ，将修改后变量副本中的值赋值给共享数据

    6 ，释放锁

    代码实现 :

    1. package com.itheima.myvolatile2;
    2. ​
    3. public class Demo {
    4.     public static void main(String[] args) {
    5.         MyThread1 t1 = new MyThread1();
    6.         t1.setName("小路同学");
    7.         t1.start();
    8. ​
    9.         MyThread2 t2 = new MyThread2();
    10.         t2.setName("小皮同学");
    11.         t2.start();
    12.     }
    13. }
    14. package com.itheima.myvolatile2;
    15. ​
    16. public class Money {
    17.     public static Object lock = new Object();
    18.     public static volatile int money = 100000;
    19. }
    20. package com.itheima.myvolatile2;
    21. ​
    22. public class MyThread1 extends  Thread {
    23.     @Override
    24.     public void run() {
    25.         while(true){
    26.             synchronized (Money.lock){
    27.                 if(Money.money != 100000){
    28.                     System.out.println("结婚基金已经不是十万了");
    29.                     break;
    30.                 }
    31.             }
    32.         }
    33.     }
    34. }
    35. package com.itheima.myvolatile2;
    36. ​
    37. public class MyThread2 extends Thread {
    38.     @Override
    39.     public void run() {
    40.         synchronized (Money.lock) {
    41.             try {
    42.                 Thread.sleep(10);
    43.             } catch (InterruptedException e) {
    44.                 e.printStackTrace();
    45.             }
    46. ​
    47.             Money.money = 90000;
    48.         }
    49.     }
    50. }

    2.4 原子性

    概述 : 所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行，多个操作是一个不可以分割的整体。

    代码实现 :

    1. package com.itheima.threadatom;
    2. ​
    3. public class AtomDemo {
    4.     public static void main(String[] args) {
    5.         MyAtomThread atom = new MyAtomThread();
    6. ​
    7.         for (int i = 0; i < 100; i++) {
    8.             new Thread(atom).start();
    9.         }
    10.     }
    11. }
    12. class MyAtomThread implements Runnable {
    13.     private volatile int count = 0; //送冰淇淋的数量
    14. ​
    15.     @Override
    16.     public void run() {
    17.         for (int i = 0; i < 100; i++) {
    18.             //1,从共享数据中读取数据到本线程栈中.
    19.             //2,修改本线程栈中变量副本的值
    20.             //3,会把本线程栈中变量副本的值赋值给共享数据.
    21.             count++;
    22.             System.out.println("已经送了" + count + "个冰淇淋");
    23.         }
    24.     }
    25. }

    代码总结 : count++ 不是一个原子性操作, 他在执行的过程中,有可能被其他线程打断

    2.5 volatile关键字不能保证原子性

    解决方案 : 我们可以给count++操作添加锁，那么count++操作就是临界区中的代码，临界区中的代码一次只能被一个线程去执行，所以count++就变成了原子操作。

    1. package com.itheima.threadatom2;
    2. ​
    3. public class AtomDemo {
    4.     public static void main(String[] args) {
    5.         MyAtomThread atom = new MyAtomThread();
    6. ​
    7.         for (int i = 0; i < 100; i++) {
    8.             new Thread(atom).start();
    9.         }
    10.     }
    11. }
    12. class MyAtomThread implements Runnable {
    13.     private volatile int count = 0; //送冰淇淋的数量
    14.     private Object lock = new Object();
    15. ​
    16.     @Override
    17.     public void run() {
    18.         for (int i = 0; i < 100; i++) {
    19.             //1,从共享数据中读取数据到本线程栈中.
    20.             //2,修改本线程栈中变量副本的值
    21.             //3,会把本线程栈中变量副本的值赋值给共享数据.
    22.             synchronized (lock) {
    23.                 count++;
    24.                 System.out.println("已经送了" + count + "个冰淇淋");
    25.             }
    26.         }
    27.     }
    28. }

    2.6 原子性_AtomicInteger

    概述：java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。因为变

    量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性(字段)。本次我们只讲解

    使用原子的方式更新基本类型，使用原子的方式更新基本类型Atomic包提供了以下3个类：

    AtomicBoolean： 原子更新布尔类型

    AtomicInteger： 原子更新整型

    AtomicLong： 原子更新长整型

    以上3个类提供的方法几乎一模一样，所以本节仅以AtomicInteger为例进行讲解，AtomicInteger的常用方法如下：

    public AtomicInteger()：                 初始化一个默认值为0的原子型Integer
public AtomicInteger(int initialValue)：  初始化一个指定值的原子型Integer
​
int get():                              获取值
int getAndIncrement():                   以原子方式将当前值加1，注意，这里返回的是自增前的值。
int incrementAndGet():                   以原子方式将当前值加1，注意，这里返回的是自增后的值。
int addAndGet(int data):                 以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
int getAndSet(int value):                以原子方式设置为newValue的值，并返回旧值。

    代码实现 :

    1. package com.itheima.threadatom3;
    2. ​
    3. import java.util.concurrent.atomic.AtomicInteger;
    4. ​
    5. public class MyAtomIntergerDemo1 {
    6. //    public AtomicInteger()：                  初始化一个默认值为0的原子型Integer
    7. //    public AtomicInteger(int initialValue)： 初始化一个指定值的原子型Integer
    8.     public static void main(String[] args) {
    9.         AtomicInteger ac = new AtomicInteger();
    10.         System.out.println(ac);
    11. ​
    12.         AtomicInteger ac2 = new AtomicInteger(10);
    13.         System.out.println(ac2);
    14.     }
    15. ​
    16. }
    1. package com.itheima.threadatom3;
    2. ​
    3. import java.lang.reflect.Field;
    4. import java.util.concurrent.atomic.AtomicInteger;
    5. ​
    6. public class MyAtomIntergerDemo2 {
    7. //    int get():                获取值
    8. //    int getAndIncrement():     以原子方式将当前值加1，注意，这里返回的是自增前的值。
    9. //    int incrementAndGet():     以原子方式将当前值加1，注意，这里返回的是自增后的值。
    10. //    int addAndGet(int data):   以原子方式将参数与对象中的值相加，并返回结果。
    11. //    int getAndSet(int value):  以原子方式设置为newValue的值，并返回旧值。
    12.     public static void main(String[] args) {
    13. //        AtomicInteger ac1 = new AtomicInteger(10);
    14. //        System.out.println(ac1.get());
    15. ​
    16. //        AtomicInteger ac2 = new AtomicInteger(10);
    17. //        int andIncrement = ac2.getAndIncrement();
    18. //        System.out.println(andIncrement);
    19. //        System.out.println(ac2.get());
    20. ​
    21. //        AtomicInteger ac3 = new AtomicInteger(10);
    22. //        int i = ac3.incrementAndGet();
    23. //        System.out.println(i);//自增后的值
    24. //        System.out.println(ac3.get());
    25. ​
    26. //        AtomicInteger ac4 = new AtomicInteger(10);
    27. //        int i = ac4.addAndGet(20);
    28. //        System.out.println(i);
    29. //        System.out.println(ac4.get());
    30. ​
    31.         AtomicInteger ac5 = new AtomicInteger(100);
    32.         int andSet = ac5.getAndSet(20);
    33.         System.out.println(andSet);
    34.         System.out.println(ac5.get());
    35.     }
    36. }

    2.7 AtomicInteger-内存解析

    AtomicInteger原理 : 自旋锁 + CAS 算法

    CAS算法：

    有3个操作数（内存值V， 旧的预期值A，要修改的值B）

    当旧的预期值A == 内存值 此时修改成功，将V改为B

    当旧的预期值A！=内存值 此时修改失败，不做任何操作

    并重新获取现在的最新值（这个重新获取的动作就是自旋）

    2.8 AtomicInteger-源码解析

    代码实现 :

    1. package com.itheima.threadatom4;
    2. ​
    3. public class AtomDemo {
    4.     public static void main(String[] args) {
    5.         MyAtomThread atom = new MyAtomThread();
    6. ​
    7.         for (int i = 0; i < 100; i++) {
    8.             new Thread(atom).start();
    9.         }
    10.     }
    11. }
    1. package com.itheima.threadatom4;
    2. ​
    3. import java.util.concurrent.atomic.AtomicInteger;
    4. ​
    5. public class MyAtomThread implements Runnable {
    6.     //private volatile int count = 0; //送冰淇淋的数量
    7.     //private Object lock = new Object();
    8.     AtomicInteger ac = new AtomicInteger(0);
    9. ​
    10.     @Override
    11.     public void run() {
    12.         for (int i = 0; i < 100; i++) {
    13.             //1,从共享数据中读取数据到本线程栈中.
    14.             //2,修改本线程栈中变量副本的值
    15.             //3,会把本线程栈中变量副本的值赋值给共享数据.
    16.             //synchronized (lock) {
    17. //                count++;
    18. //                ac++;
    19.             int count = ac.incrementAndGet();
    20.             System.out.println("已经送了" + count + "个冰淇淋");
    21.            // }
    22.         }
    23.     }
    24. }
    25. ​

    源码解析 :

    1. //先自增，然后获取自增后的结果
    2. public final int incrementAndGet() {
    3.         //+ 1 自增后的结果
    4.         //this 就表示当前的atomicInteger（值）
    5.         //1    自增一次
    6.         return U.getAndAddInt(this, VALUE, 1) + 1;
    7. }
    8. ​
    9. public final int getAndAddInt(Object o, long offset, int delta) {
    10.         //v 旧值
    11.         int v;
    12.         //自旋的过程
    13.         do {
    14.             //不断的获取旧值
    15.             v = getIntVolatile(o, offset);
    16.             //如果这个方法的返回值为false，那么继续自旋
    17.             //如果这个方法的返回值为true，那么自旋结束
    18.             //o 表示的就是内存值
    19.             //v 旧值
    20.             //v + delta 修改后的值
    21.         } while (!weakCompareAndSetInt(o, offset, v, v + delta));
    22.             //作用：比较内存中的值，旧值是否相等，如果相等就把修改后的值写到内存中，返回true。表示修改成功。
    23.             //                                 如果不相等，无法把修改后的值写到内存中，返回false。表示修改失败。
    24.             //如果修改失败，那么继续自旋。
    25.         return v;
    26. }

    2.9 悲观锁和乐观锁

    synchronized和CAS的区别 :

    相同点：在多线程情况下，都可以保证共享数据的安全性。

    不同点：synchronized总是从最坏的角度出发，认为每次获取数据的时候，别人都有可能修改。所以在每 次操作共享数据之前，都会上锁。（悲观锁）

    cas是从乐观的角度出发，假设每次获取数据别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。

    如果别人修改过，那么我再次获取现在最新的值。

    如果别人没有修改过，那么我现在直接修改共享数据的值.(乐观锁）

  • 相关阅读:
    DevEco Studio 3.1差异化构建打包，提升多版本应用开发效率
    Sermant运行流程学习笔记，速来抄作业
    在autodl搭建stable-diffusion-webui+sadTalker
    微服务 - 应用性能监测 · 链路追踪 · 概念规范 · 产品接入 · 方法级追踪 · 创建指标跨度
    介绍几个主流社媒平台的特点，以及如何通过这些社媒渠道开展营销活动
    [图解]软件开发中的糊涂用语-04-为什么要追究糊涂用语
    python gui（六）全局设定
    C语言之程序环境和预处理（2）
    Java多线程-简单使用Lock(锁)
    计算机系统基本概念
  • 原文地址：https://blog.csdn.net/qq_69748833/article/details/133531740