【多线程（五）】volatile关键字、原子性问题、AtomicInteger内存分析与源码分析、悲观锁和乐观锁

最新推荐文章于 2023-10-13 10:19:27 发布
最新推荐文章于 2023-10-13 10:19:27 发布
阅读量548 收藏 4
点赞数 8
分类专栏： JavaSE 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hihielite/article/details/128233950
版权

文章目录

5.原子性

5.1 volatile-问题

  • 代码分析
package com.hcx.myvolatile;

public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("小路同学");
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.setName("小皮同学");
        t2.start();

    }
}

package com.hcx.myvolatile;

public class Money {
    public static   int  money = 100000;
}


package com.hcx.myvolatile;

public class MyThread1 extends Thread{
    @Override
    public void run() {
        while(Money.money == 100000){

        }

        System.out.println("结婚基金已经不是十万了");
    }
}

public class MyThread2 extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Money.money = 90000;
    }
}

  • 运行结果
    在这里插入图片描述

    • 程序一直在线程1的While循环中跑，说明此时线程1认为共享数据money仍为100000，但是线程2在开启以后，抢到CPU的执行权，JVM调用run()方法，已经将共享数据修改为90000，此时线程1无法知道最新的数据。

2.2 volatile解决

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

  • 1.堆内存是唯一的，每一个线程都有自己的线程栈。
  • 2.每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。
  • 3.在线程中，每一次使用是从变量的副本中获取的
    以上案例出现的原因：
    在开启线程1和线程2后，线程1先抢到CPU的使用权，将堆内存的数据拷贝到自己的变量副本中，然后从副本中获取共享数据，此时线程1中变量副本的值为100000，线程2后抢到CPU的执行权，然后JVM调用run()方法，将共享数据money的值改为90000,然后拷贝到自己的副本中，再从自己的副本中获取共享数据。所以线程1的数据为100000，线程2的数据为90000。造成了上述出现的情况。
    Volatile关键字：强制线程每次在使用的时候，都会看一下共享区域最新的值。
    代码实现：使用volatile关键字解决
package com.hcx.myvolatile;

public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("小路同学");
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.setName("小皮同学");
        t2.start();

    }
}

package com.hcx.myvolatile;

public class Money {
    public static volatile   int  money = 100000;
}

package com.hcx.myvolatile;

public class MyThread1 extends Thread{
    @Override
    public void run() {
        while(Money.money == 100000){

        }

        System.out.println("结婚基金已经不是十万了");
    }
}

package com.hcx.myvolatile;

public class MyThread2 extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Money.money = 90000;
    }
}
  • 运行结果
    在这里插入图片描述

5.3 synchronized 解决

  • synchronized解决：

    • 1.线程获得锁
    • 2.清空变量副本
    • 3.拷贝共享变量最新的值到变量副本中
    • 4.执行代码
    • 5.将修改后变量副本中的值赋值给共享数据
    • 6.释放锁

  • 代码实现

package com.hcx.myvolatile2;

import com.hcx.myvolatile.MyThread2;

public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("小路同学");
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.setName("小皮同学");
        t2.start();

    }
}

package com.hcx.myvolatile2;

public class Money {
    public static Object lock = new Object();
    public static   int  money = 100000;
}


package com.hcx.myvolatile2;

public class MyThread1 extends Thread{
    @Override
    public void run() {
        while(true){
            synchronized (com.hcx.myvolatile2.Money.lock){
                if(Money.money!=100000){
                    System.out.println("结婚基金已经不是十万了");
                    break;
                }
            }
        }
    }
}


package com.hcx.myvolatile2;

import com.hcx.myvolatile.Money;

public class MyThread2 extends Thread {
    @Override
    public void run() {
        synchronized (com.hcx.myvolatile2.Money.lock) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Money.money = 90000;
        }
    }
}

5.4 原子性

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

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread myAtomThread = new MyAtomThread();
        for (int i = 0;i < 100; i++) {
            new Thread(myAtomThread).start();
        }
    }
}

package com.hcx.threadatom;

public class MyAtomThread implements Runnable {
    private  volatile  int  count = 0;//送冰淇淋的数量
    @Override
    public void run() {
        for (int i = 0;i < 100;i++) {
            //1.从共享数据中读取数据到本线程中
            //2.修改本线程栈中变量副本的值
            //3.会把本线程栈中变量副本的值赋值给共享数据。
            count++;
            System.out.println("已经送了"+count +"个冰淇淋");
        }
    }
}

  • 运行结果
    在这里插入图片描述

  • 思考:100个线程执行100次，最后应该打印结果为10000，为什么运行结果是9999呢？

    • 假如现在有A、B两个线程，堆内存的共享数据此时为100，此时A线程抢夺到CPU的执行权，然后将共享数据100拷贝到自己的变量副本中，然后做count++，也就是将101赋值给了自己的变量副本，这个时候，CPU 的执行权被B线程抢走，现在A线程还没有将自己变量副本的值写回到共享数据中，所以B线程读取的值为共享数据的最新值，还为100，然后B线程执行跟A线程一样的操作，count++后，变量副本的值也为101，所以导致最后的运行结果为9999，而不是10000。
      代码总结：count++ 不是一个原子性操作，他在执行的过程中，有可能被其他线程打断。

  • 综上，我们可以得出volatile关键字：

    • 只能保证线程每次在使用共享数据的时候是最新值。
    • 但是不能保证原子性。

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

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

import com.hcx.threadatom.MyAtomThread;

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread myAtomThread = new MyAtomThread();
        for (int i = 0;i < 100; i++) {
            new Thread(myAtomThread).start();
        }
    }
}

package com.hcx.threadatom2;

public class MyAtomThread implements Runnable {
    private  volatile  int  count = 0;//送冰淇淋的数量
    private Object lock = new Object();
    @Override
    public void run() {
        for (int i = 0;i < 100;i++) {
            //1.从共享数据中读取数据到本线程中
            //2.修改本线程栈中变量副本的值
            //3.会把本线程栈中变量副本的值赋值给共享数据。
            synchronized (lock) {
                count++;
                System.out.println("已经送了"+count +"个冰淇淋");
            }
        }
    }
}
  • 运行结果

在这里插入图片描述

5.6 原子性 AtomicInteger

  • 概述：Java 从JDK1.5开始提供了java.util.concurrent.atomic包(简Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。因为变量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性(字段)。本次我们只讲解使用原子的方式更新基本类型，使用原子的方式更新基本类型Atomic包提供了以下3个类：
    • AtomicBoolean： 原子更新布尔类型
    • AtomicInteger： 原子更新整型
    • AtomicLong： 原子更新长整型
  • 以上3个类提供的方法几乎一模一样，所以本节仅以AtomicInteger为例进行讲解，AtomicInteger的常用方法如下 ：
    在这里插入图片描述
  • 代码实现
package com.hcx.threadatom3;

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomIntergerDemo1 {
    //public AtomicInteger(): 初始化一个默认值为0的原子型Integer
    //public AtomicInteger(int initialValue): 初始化一个指定值的原子型Integer
    public static void main(String[] args) {
        AtomicInteger ac = new AtomicInteger();
        System.out.println(ac);

        AtomicInteger ac2 = new AtomicInteger(10);
        System.out.println(ac2);

    }
}


package com.hcx.threadatom3;

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomIntergerDemo2 {
    //  int get():          获取值
    //  int getAndIncrement():      以原子方式将当前值加1，注意，这里返回的是自增前的值。
    //  int incrementAndGet():      以原子方式将当前值加1，注意，这里返回的是自增后的值。
    //  int addAndGet(int data):    以原子方式将参数与对象中的值相加，并返回结果。
    //  int getAndSet(int value):   以原子方式设置为newValue的值，并返回旧值。
    public static void main(String[] args) {
//        AtomicInteger ac1 = new AtomicInteger(10);
//        System.out.println(ac1.get());
//
//        AtomicInteger ac2 = new AtomicInteger(10);
//        int andIncrement = ac2.getAndIncrement();
//        System.out.println(andIncrement);
//        System.out.println(ac2.get());

//        AtomicInteger ac3 = new AtomicInteger(10);
//        int incrementAndGet = ac3.incrementAndGet();
//        System.out.println(incrementAndGet);

//        AtomicInteger ac4 = new AtomicInteger(10);
//        int i = ac4.addAndGet(20);
//        System.out.println(i);
//        System.out.println(ac4.get());

        AtomicInteger ac5 = new AtomicInteger(10);
        int andSet = ac5.getAndSet(20);
        System.out.println(andSet);
        System.out.println(ac5.get());
    }
}

5.7 AtomicInteger-内存解析

AtomicInteger原理：自旋锁+CAS算法
CAS算法：
在这里插入图片描述
我们来解释一下，首先还是一个堆内存，堆内存中有共享数据值为100，然后我开启了两个线程，一个线程为A线程，另一个线程为B线程，现在A线程跟B线程想要进行的事情是要将共享数据里边的值进行自增，也就是我们最后要把共享数据的值变成102，共享数据100相当于CAS算法中的内存值，假设A线程先抢到CPU的执行权，它接下来需要将内存值100读到自己的线程栈里边，读过来以后存到自己的变量副本中，此时这个值为旧的预期值，现在线程A需要进行自增， 是不是应该将101覆盖给了变量副本，那么变量副本里边现在变成了101，这个时候变量副本里边的值就是CAS算法中的要修改的值，此时B线程抢到了CPU的执行权，它同样将100读到变量副本当中，那么B线程，也有一个旧的预期值，然后线程B也进行了自增，将101覆盖给了变量副本，此时，B线程中要修改的值也为101，现在两个线程的自增都做完了，现在需要将101写到共享数据里面了，假设A线程先写， 它发现A里边的旧的预期值==内存值，表示这个内存值没有被其他线程操作过，所以就将A线程的101写到共享数据修改成功，我们B线程也需要往共享区域写，它发现旧的预期值！=内存值，表示有可能共享数据已经被其他线程操作过了，所以这个时候它修改失败，它需要将现在最新的内存值101再次读到自己的变量副本中，这个时候线程B的旧的预期值就变成101了，然后进行自增，并将102覆盖给变量副本，102就是要修改的值，然后将102写到堆内存的共享数据中。它发现第二次旧的预期值=内存值，所以修改成功。

5.8 AtomicInteger-源码解析

  • 代码实现
package com.hcx.threadatom4;

import com.hcx.threadatom.MyAtomThread;

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread myAtomThread = new MyAtomThread();
        for (int i = 0;i < 100; i++) {
            new Thread(myAtomThread).start();
        }
    }
}


package com.hcx.threadatom4;

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomThread implements Runnable {
//    private  volatile  int  count = 0;//送冰淇淋的数量
//    private Object lock = new Object();
    AtomicInteger ac = new AtomicInteger(0);
    @Override
    public void run() {
        for (int i = 0;i < 100;i++) {
            //1.从共享数据中读取数据到本线程中
            //2.修改本线程栈中变量副本的值
            //3.会把本线程栈中变量副本的值赋值给共享数据。
//            synchronized (lock) {
//                count++;
            int count = ac.incrementAndGet();
            System.out.println("已经送了"+count +"个冰淇淋");
//            }
        }
    }
}

  • 运行结果
    在这里插入图片描述

  • 源码解析
    在这里插入图片描述
    在这里插入图片描述

5.9 悲观锁和乐观锁

  • synchronized和CAS的区别：
    • 相同点：在多线程情况下，都可以保证共享数据的安全性。
    • 不同点 ：
      • synchronized总是从最坏的角度出发，认为每次获取数据的时候，别人都可能修改。所以在每次操作共享数据之前，都会上锁（悲观锁）
      • cas 是从乐观的角度出发，假设每次获取数据别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。如果别人修改过，那么我再次获取现在最新的值。如果别人没有修改过,那么我现在直接修改共享数据的值。（乐观锁）

小结

本篇文章介绍了 volatile 关键字的作用，通过一个用 volatile 关键字解决不了的送冰淇淋问题引出原子性的概念，介绍了JDK1.5使用原子的方式更新整数类型-AtomicInteger,并对AtomicInteger进行了内存分析和源码分析，最后还介绍了 synchronized和CAS的相同点与不同点，引出了悲观锁和乐观锁的概念。
更新不易，希望大家多多支持!!在这里插入图片描述

续写青春.
关注
  • 8
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
Java并发问题之乐观锁与悲观锁
08-28
"Java并发问题之乐观锁与悲观锁" 在 Java 中，并发问题是非常重要的，因为多线程的存在会引起数据的不一致性和安全性问题。为了解决这些问题，Java 提供了多种锁机制，其中最常见的就是乐观锁和悲观锁。 悲观锁...
Volatile关键字与原子性操作
daijingxin的博客
02-09 4250
目录什么是原子性操作什么是Volatile关键字为什么需要原子性操作Volatile能不能实现原子性操作？Volatile关键字常用的场景CUDA编程实现原子性操作的方法 什么是原子性操作 原子性操作具有不可分割性。比如 i=0 这个操作是不可分割的，那么我们说这个操作时原子操作。再比如： i++； 这个操作实际是 i = i + 1； 是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们
Java多线程，原子性（synchronized与volatile以及Atomic的区别）
Stars____的博客
02-27 860
多线程概念 1.是指同一时间运行多个应用程序。 2.CPU处理多个程序时，实际上是在多个程序中快速切换，让使用者感觉是在同时运行，对CPU而言还是轮流执行。 并行和并发 1.并行：同一时刻，有多个指令在多个CPU上同时执行。 2.并发：同一时刻，有多个指令在同一CPU上交替执行。 进程和线程 1.进程：正在运行的程序。 独立性：进程是能独立运行的基本单位，也是操作系统分配和调度资源的独立单位。 动态性：实际是程序的一次执行过程，进程是动态产生，动态消亡的。 并发性：任何进程可以同其他的进程同时执行。 2
volatile 变量和 atomic 变量有什么不同？
weixin_73855020的博客
08-15 485
volatile 变量：使用 volatile 关键字修饰的变量可以确保对该变量的读取和写入操作对其他线程是可见的。volatile变量：适用于对变量的读取和写入操作都是简单的赋值操作，并且需要保证对其他线程的可见性。volatile变量：volatile 关键字只能保证对单个变量的读取和写入操作的可见性，不能保证复合操作的原子性。Atomic变量提供了一组原子操作方法，可以保证对变量的操作是原子的，同时也具有可见性。volatile 变量保证了对变量的读取和写入操作的可见性，但不能保证复合操作的原子性。
jAVA 之 volatile、Atomic 一系列问题
坚持就是胜利的博客
05-22 605
说到valatile，那他是什么？能干什么？怎么用呢？让我们来进一步了解。 Volatile 是jvm多线程轻量级的同步机制 如果不在多线程的条件下使用volatile那么将无任何意义. Volatile有哪些特性？ 1. 保证可见性（某一个线程修改主内存中的值，那么其他线程就会马上得到同通知） 2. 不保证原子性（不保证在多个线程同时操作同一个变量的时候，不会出现写覆盖） 3. 禁止指令...
java进阶笔记之volatile和atomic原子操作
huitoukest的专栏
03-24 847
前言 概念简介 简称 全称 说明 CAS Compare and Swap 比较并交换 JUC java.util.concurrent java的一个类包，主要用于并发控制 概念说明 在现代计算机的cpu中，cpu对数据的读写取分为两个步奏， 第一步：cpu从cpu自带的高速缓存(可能有L1、L2甚至L3等多级高速缓存)中查询对象，如果找到即使用。 第二步：如果第一步中c...
java多线程编程之慎重使用volatile关键字
09-04
在Java多线程编程中，volatile关键字扮演着重要的角色，它确保了被声明为volatile的变量在多个线程之间的可见性。然而，尽管volatile能够提供一定程度的线程安全，但并不能保证所有操作都是原子性的。这正是为什么在...
Java多线程Atomic包操作原子变量与原子类详解
08-28
也就是说，如果多个线程修改同一个原子变量，尽管操作是原子的，但它们之间可能看不到彼此的修改，除非使用了`synchronized`或`volatile`关键字来确保内存可见性。 总的来说，Java的`Atomic`包提供了一组强大的工具...
学习Java多线程之volatile域
09-02
Java多线程中的volatile关键字是Java提供的一个较弱的同步机制，用于解决多线程环境下的数据一致性问题。volatile确保了变量在多个线程之间的可见性，并限制了指令重排序，但并不保证原子性。 首先，理解Java内存...
Java 多线程与并发(5-26)-关键字- volatile详解.pdf
07-22
Java中的`volatile`关键字是多线程编程中一个重要的概念，它主要解决了两个核心问题：可见性和有序性。在Java内存模型（JMM）中，`volatile`关键字确保了线程之间的通信更加有效和安全。 **一、防止指令重排序** ...
volatile和atomicInteger的区别理解特性
水镜先生的博客
02-22 4252
volatile和atomicInteger的理解
JAVA JUC 之读写锁的实现（一）
tongkp的专栏
07-26 219
基于javaJUC(java.util.concurrent)包的读写锁的实现 定义一个线程对象 package readwritelock; /** * @author tongke * @email tongkp@126.com * @create 2020-07-26 10:25 */ public class WaitNode { int type = 0; //0 为想获取独占锁的线程， 1为想获取共享锁的线程 Thread thread = null; .
java的悲观锁和乐观锁
weixin_43162044的博客
10-17 2063
AtomicInteger，他的底层是Unsafe，他保证修改变量的时候是一个原子操作，我们现在想修改Account中的共享变量，修改之前我们要知道修改的成员变量的偏移位置，我们通过Unsafe对象里面一个方法，参数是修改的类型，变量名。线程只有占有了锁，才能去操作共享变量，每次只有一个线程占锁成功，获取锁失败的线程，都得停下来等待。无需加锁，每次只有一个线程能成功修改共享变量，其它失败的线程不需要停止，不断重试直至成功。锁时，如果锁已被占用，都会做几次重试操作，减少阻塞的机会。支持，且线程数不应超过。
线程池，Volatile，原子性类AtomicInteger，乐观锁悲观锁，并发工具类Hashtable，ConcurrentHashMap类，Semaphore类
weixin_41431242的博客
09-07 606
一、线程的状态 没有就绪状态 线程状态 具体含义 NEW 一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。 RUNNABLE 当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把..
三、原子操作之AtomicInteger
最新发布
jysf98746的博客
10-13 227
在 java 中，当我们在多线程情况下，对一个整型变量做加减操作时，如果不加任何的多线程并发控制，大概率会出现线程安全问题，也就是说当多线程同时操作一个整型变量的增减时，会出现运算结果错误的问题。第 1 个方法是先获取值，之后再对原值做增 1 操作，注意获取的值是变更之前的值。在这个包下面，还有很多类似的工具类，也是对基本类型原子操作的封装，如。大家记住，在多线程并发下，所有不是原子性的操作但需要保证原子性时，都需要进行原子操作处理，否则会出现线程安全问题。所谓原子操作，就是一个独立且不可分割的操作。
演示AtomicInteger的使用
qingcyb的博客
03-10 171
import java.util.concurrent.CountDownLatch; import java.util.concurrent.atomic.AtomicInteger; /** * 演示AtomicInteger的使用 */ public class AtomicIntegerTest { private static AtomicInteger count =...
JAVA学习-AtomicInteger(亲测)
gb4215287的博客
12-20 240
java中Integer自增
原子类之AtomicIntegerArray
nobaldnolove的博客
07-17 280
原子类之AtomicIntegerArray
Volatile关键字能保证原子性么？
ch98000的博客
08-19 1435
说到这个 volatile 这个关键字，阿粉觉得看过阿粉文章的，肯定都对这个关键字那是非常的熟悉的，因为做Java开发的，在面试的时候，如果涉及到多线程，那么面试官有不少人会询问关于 volatile 这个关键字的使用，以及他的作用，今天阿粉就来说说这个 volatile 关键的的作用，以及他的一些特性。其实在阿粉的感知中，一般用这个变量，很多都是为了保证他的可见性，就比如定义的一个全局变量，在其中有个循环来判断这个变量的值，有一个线程修改了这个参数的时候，这个循环会停止，跳转到之后去执行。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

续写青春.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值