JUC并发编程四（深入理解CAS、原子引用、各种锁的理解）

已于 2022-03-19 14:45:46 修改
阅读量240 收藏
点赞数
分类专栏： Java基础学习 文章标签： java
于 2020-04-23 02:43:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41270824/article/details/105696524
版权

十九、深入理解CAS

大厂你必须要深入研究底层！有所突破！修行内功，操作系统，计算机网络原理
我们现在要学的是Java层面的CAS不是底层。

什么是CAS

之前有在juc的原子包中的AtomicInteger底层是用的CAS
CAS 是CPU的并发原语！就是CPU的指令

package com.kuang.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo2 {


    // CAS  compareAndSet : 比较并交换！
   public static void main(String[] args) {
       AtomicInteger atomicInteger = new AtomicInteger(2020);

        // 期望、更新
       // public final boolean compareAndSet(int expect, int update)
       // 如果我期望的值达到了，那么就更新，否则，就不更新, CAS 是CPU的并发原语！
       System.out.println(atomicInteger.compareAndSet(2020, 2021));
       System.out.println(atomicInteger.get());

       System.out.println(atomicInteger.compareAndSet(2020, 2021));
       atomicInteger.getAndIncrement();
       System.out.println(atomicInteger.get());
   }
}

Unsafe 类

Java无法操作内存。Java可以用native方法（比如多线程启动方法）操作C++，C++可以操作内存Unsafe类就相当于Java的后门，可以通过这个类操作内存

unsafe.objectFieldOffset获取内存地址偏移值
在这里插入图片描述
在这里插入图片描述
这个自增方法用了一个自旋锁判断
在这里插入图片描述
CAS 小结： 比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就 一直循环（因为底层是自旋锁）！

CAS里面有3个操作数：期望值、比较值、最后更新值
只要是CPU的东西有好处有坏处，好处就是自带原子性
缺点：
1、 循环会耗时
2、一次性只能保证一个共享变量的原子性
3、存在ABA问题

CAS ： ABA 问题（狸猫换太子）

两条线程操作同一个资源，线程A B ，这里有个值是A=1然后两个线程都拿到了，A这里有个cas操作期望值是1然后改成2，然后B这里速度快先有两个cas操作先把1改成了3然后再把3改成了1，这个时候对于A线程来说A还是1只是他不知道这个值已经变过了
在这里插入图片描述
aba问题代码：

package com.kuang.cas;
import java.util.concurrent.atomic.AtomicInteger;
public class CASaba {
    // CAS  compareAndSet : 比较并交换！

    public static void main(String[] args) {        
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        // 期望、更新
        // public final boolean compareAndSet(int expect, int update)        
        // 如果我期望的值达到了，那么就更新，否则，就不更新, CAS 是CPU的并发原语！        
        // ============== 捣乱的线程 ==================       
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        System.out.println(atomicInteger.get());

        // ============== 期望的线程 ================== 
        System.out.println(atomicInteger.compareAndSet(2020, 6666));
        System.out.println(atomicInteger.get());    
    } 
}

输出：

true
2021
true
2020
true
6666

如何解决这个问题？原子引用

二十、原子引用

说白了就是带版本号的原子操作
在这里插入图片描述
解决ABA 问题，引入原子引用！ 对应的思想：乐观锁！

AtomicStampedReference类带时间（版本）的原子引用类
构造器有两个参数
参数：1、初始值2、时间戳（类似于版本号）

package com.kuang.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class CASDemo {

    //AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题

    // 正常在业务操作，这里面比较的都是一个个对象
    //【参数：1、初始值2、时间戳（类似于版本号）】
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);

    // CAS  compareAndSet : 比较并交换！
    public static void main(String[] args) {

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp(); // 获得版本号
            System.out.println("a1=>"+stamp);

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            Lock lock = new ReentrantLock(true);

            atomicStampedReference.compareAndSet(1, 2,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);

            System.out.println("a2=>"+atomicStampedReference.getStamp());


            System.out.println(atomicStampedReference.compareAndSet(2, 1,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));

            System.out.println("a3=>"+atomicStampedReference.getStamp());

        },"a").start();


        // 乐观锁的原理相同！
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp(); // 获得版本号
            System.out.println("b1=>"+stamp);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(atomicStampedReference.compareAndSet(1, 6,
                    stamp, stamp + 1));

            System.out.println("b2=>"+atomicStampedReference.getStamp());

        },"b").start();

    }
}

注意：
Integer 使用了对象缓存机制，默认范围是 -128 ~ 127 ，推荐使用静态工厂方法 valueOf 获取对象实 例，而不是 new，因为 valueOf 使用缓存，而 new 一定会创建新的对象分配新的内存空间；
用integer.valueof（2）去创建对象，因为会使用缓存，用new的话会重新分配内存空间

注意，如果泛型是一个包装类，注意对象的引用问题。
在这里插入图片描述

二十一、各种锁的理解

1、公平锁、非公平锁

公平锁： 非常公平， 不能够插队，必须先来后到！
非公平锁：非常不公平，可以插队 （默认都是非公平）
之前也有讲到非公平锁比较公平因为1h和1s的问题，让1s去等1h

synchroized和lock都是默认非公平

public ReentrantLock() {
    sync = new NonfairSync(); 
}
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync(); 
}

2、可重入锁

可重入锁（递归锁）所有的锁都是可重入锁

比如这是一个大门，然后你拿到的外面大门的锁，就相当于拿到里面的锁，就可以进里面两个卧室的门
在这里插入图片描述

Synchronized版
package com.kuang.lock;

import javax.sound.midi.Soundbank;

// Synchronized
public class Demo01 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sms();
        },"A").start();


        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}

class Phone{

    public synchronized void sms(){
        System.out.println(Thread.currentThread().getName() + "sms");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        call(); // 这里也有锁
    }

    public synchronized void call(){
        System.out.println(Thread.currentThread().getName() + "call");
    }
}

输出：

Asms
Acall
Bsms
Bcall

分析：
第一个A进来之后先执行sms再执行一个call，这时候按照正常的逻辑A执行完sms之后是不是应该释放锁了？
但是我们无论怎么执行A都是先调用完sms和call之后再轮到B
原因：因为进来sms方法之后也会拿到里面那把锁，然后要等里面那个call方法执行完才会释放锁

Lock 版
package com.kuang.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo02 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();

        new Thread(()->{
            phone.sms();
        },"A").start();


        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}

class Phone2{
    Lock lock = new ReentrantLock();

    public void sms(){
        lock.lock(); // 细节问题：lock.lock(); lock.unlock(); // lock 锁必须配对，否则就会死在里面
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "sms");
            call(); // 这里也有锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            lock.unlock();
        }

    }

    public void call(){

        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

输出跟上面的synchroized是一样的

3、自旋锁

spinlock
在这里插入图片描述
我们来自定义一个锁测试
按照之前学的，do while循环然后用CAS去做一个比较，CAS是自旋锁的一个核心
用do while，while是没什么区别的，只要可以判断然后一直循环就行了

package com.kuang.lock;

import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class SpinlockDemo {

    // int   0
    // Thread  null
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    // 加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "==> mylock");

        // 自旋锁
        while (!atomicReference.compareAndSet(null,thread)){
System.out.println(Thread.currentThread().getName() + "==> mylock");
        }
    }


    // 解锁
    // 加锁
    public void myUnLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "==> myUnlock");
        atomicReference.compareAndSet(thread,null);
    }



}

测试
底层使用的CAS自旋锁

package com.kuang.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
//        ReentrantLock reentrantLock = new ReentrantLock();
//        reentrantLock.lock();
//        reentrantLock.unlock();

        // 底层使用的自旋锁CAS
        SpinlockDemo lock = new SpinlockDemo();


        new Thread(()-> {
            lock.myLock();

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }

        },"T1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()-> {
            lock.myLock();

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }

        },"T2").start();

    }
}

输出：

T1==> mylock
T2==> mylock
T2==> 自旋
T2==> 自旋
...........
T2==> 自旋
T2==> 自旋
T2==> 自旋
T1==> myUnlock
T2==> 自旋
T2==> myUnlock

解析：先是T1成功进入方法并且获得锁，然后T2进入方法但是获得锁失败，这个时候陷入了自旋，等待T1释放锁之后T2成功获得锁，然后才能释放锁

4、死锁

死锁是什么

在这里插入图片描述
死锁测试，怎么排除死锁：

package com.kuang.lock;

import com.sun.org.apache.xpath.internal.SourceTree;

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    public static void main(String[] args) {

        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new MyThread(lockA, lockB), "T1").start();
        new Thread(new MyThread(lockB, lockA), "T2").start();

    }
}


class MyThread implements Runnable{

    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName() + "lock:"+lockA+"=>get"+lockB);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (lockB){
                System.out.println(Thread.currentThread().getName() + "lock:"+lockB+"=>get"+lockA);
            }

        }
    }
}

解决问题
用idea的Terminal（终端）
排查死锁：
1、使用 jps -l 定位进程号
在这里插入图片描述
2、使用 jstack 进程号 找到死锁问题
在这里插入图片描述
面试，工作中！排查问题：
1、日志
2、堆栈信息（推荐）

怎么解开死锁？避免产生死锁的条件就可以了。

无极的移动代码
关注
专栏目录
JUC并发编程
wunianisme的博客
03-04 300
JUC是什么? JUC，即java.util.concurrent包的缩写，是java原生的并发包和一些常用的工具类。 线程基础知识 线程和进程 进程：计算机中运行中的程序，如QQ.exe等。 线程：进程中执行的具体的任务，如打字、自动保存等。 一个进程可以包含多个线程，一个进程至少有一个线程。Java程序至少有两个线程：GC线程和Main线程。 并发和并行 并发：多个线程操作同一个资源并且交替...
JUC并发编程（十九）-深入理解CAS
二总的猫
02-26 348
19、深入理解CAS 19.1. CAS是什么 CAS : CompareAndSwarp ,比较并交换 package com.interview.concurrent.cas; import java.util.concurrent.atomic.AtomicInteger; /** * @author yangxj * @description 描述： compare...
JUC并发
qq_24090609的博客
03-21 298
什么是JUC 线程和进程 进程：一个程序，QQ.exe Music.exe 程序的集合； 一个进程往往可以包含多个线程，至少包含一个！ Java默认有几个线程？ 2 个 mian、GC 线程：开了一个进程 Typora，写字，自动保存（线程负责的） 对于Java而言：Thread、Runnable、Callable 线程有几个状态： public enum State { // 新生 NEW, // 运行 RUNNABLE, // 阻塞 BLOCKED, // 等待，死死地等 WAIT
JUC(并发编程)
热门推荐
abc98526的博客
04-17 1万+
1.什么是JUC? JUC是指javaUtil包中的三个操作线程的包! 2.线程进程和程序 程序(Program):是一个静态的概念，一般对应于操作系统中的一个可执行的文件 ，比如：我们要启动酷狗听音乐，则对应酷狗可执行程序。当我们双击酷狗，则加载 程序到内存中，开始执行该程序，于是产生了"进程". 进程:执行中的程序叫做进程(Process),是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如:我们在用酷狗听音乐，也可以使用wps写文档，也可以同时用浏览器查看网页。可以通过
【JUC并发编程】
蛋饼吧的博客
06-19 1487
JUC是Java Util Concurrent的缩写,是Java SE 5.0中新增的一个包,主要提供了在并发编程中使用的工具类和框架。JUC包含了许多用于多线程编程的工具类和接口,如锁、原子变量、线程池、阻塞队列等。这些工具类和接口可以帮助开发者更方便地进行多线程编程,从而提高程序的并发性能和可靠性。JUC包中的工具类和接口都是线程安全的,可以在多线程环境下安全地使用。它们的设计和实现都是基于并发编程的最佳实践和原则,可以有效地避免线程安全问题的发生。
JUC并发编程与源码分析视频课.zip
12-16
《JUC并发编程与源码分析视频课》是一门深入探讨Java并发编程的课程，主要聚焦于Java Util Concurrency（JUC）库的使用和源码解析。JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更...
java并发编程专题（十）----(JUC原子类)基本类型详解
08-18
Java并发编程专题（十）----(JUC原子类)基本类型详解 本资源主要介绍了Java JUC原子类基本类型的相关知识点，包括AtomicInteger、AtomicLong、AtomicBoolean等基本类型的使用方法和原理。通过对原子操作和 일반操作...
深入分析Java并发编程之CAS
08-24
在Java并发编程中，CAS（Compare and Swap）是一种无锁算法，用于在多线程环境中实现对共享变量的原子性更新。相比于传统的锁机制，如`synchronized`和`Lock`，CAS具有更低的开销，因为它避免了线程阻塞。本文将深入...
深入理解高并发编程
qq_67447208的博客
09-09 886
线程可以有效降低程序的开发和维护成本，同时提升复杂应用程序的性能。在服务器应用程序中，可以提升资源利用率以及系统吞吐率，线程还可以简化JVM的实现，垃圾收集器通常在一个或多个专门的线程中运行，在许多重要的Java应用中，都在一定程度生用到了线程。
JUC并发编程，看这一篇就够了
一个沉迷Java，无法自拔的Coder
07-25 6847
数万字长文，搭配代码，带你学习JUC并发编程；看了狂神的课程以及自己做的笔记
JUC并发编程（详细，稳妥）
qq_38837032的博客
10-09 864
一、相关包： java.util.concurrent java.util.concurrent.atomic java.util.concurrent.locks java.util.function 二、创建一个线程的方式： Thread、Runable、Callable 详情资料：https://blog.csdn.net/qq_38837032/article/details/118195966. 三、进程与线程： 1、进程是一段正在执行的程序，是资源分配的基本单元，而线程是CPU调度的基本单元。
JUC并发编程入门
最新发布
qq_37605486的博客
03-24 426
JUC是java.util.concurrent包的缩写，包结构如下，说白了就是并发场景多线程编程的工具类。JUC就是在并发场景下，怎么让程序尽量通过有限的硬件，高效的处理请求，并且保证程序“线程安全”。1、先有进程，然后进程可以创建线程，线程是依附在进程里面的，线程里面可以包含多个协程2、进程之间不共享全局变量，线程之间共享全局变量，但是要注意资源竞争的问题。
最全的JUC并发图
Ailen
03-28 455
JUC并发编程详解
m0_68006260的博客
03-23 783
1、什么是JUC？ java.util.concurrnet java.util.concurrent.atomic java.util.concurrent.locks 2、进程和线程 进程：一个程序的实例 线程：是一个进程的实体，CPU调度和分配的基本单位 java默认有两个线程，main方法和GC 开启线程的方式：Thread、Runnable、Callable Java本质是无法开启线程的，是调用本地方法(c++)来开启线程的，java无法操作硬件。 3、并发、并行 并发编程：
Java并发编程深度解析：从原子操作到线程池
这份资源全面地讲解了Java并发工具包的各个方面，从基础的原子操作到高级的线程池管理，对于想要深入理解Java并发编程的开发者来说，是一份宝贵的参考资料。通过学习，开发者可以更好地设计和实现高并发、高性能的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

无极的移动代码

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

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

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

打赏作者

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

抵扣说明：

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

余额充值