Java多线程 JUC并发编程 （第三天）

最新推荐文章于 2024-07-17 17:49:38 发布
最新推荐文章于 2024-07-17 17:49:38 发布
阅读量1.1k 收藏
点赞数
分类专栏： JUC 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43092820/article/details/117885898
版权

多线程进阶=>JUC并发编程


19、深入理解CAS


19.1、什么是 CAS

代码实现：

package com.feimai.test.JUCTest.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class Test {

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

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

        System.out.println(atomicInteger.compareAndSet(2021, 2022));
        System.out.println(atomicInteger.get());

        atomicInteger.getAndIncrement();

    }
}

19.2、Unsafe 类

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述


   CAS:比较当前工作内存中的值，和主内存中的值，如果这个值是期望的，那么执行操作，如果不是就一直循环

缺点：
   1、循环会耗时
   2、一次性只能保证一个共享变量的原子性
   3、ABA问题

19.3、ABA 问题

在这里插入图片描述

代码实现：

package com.feimai.test.JUCTest.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class Test {

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

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

        System.out.println(atomicInteger.compareAndSet(2022, 2021));
        System.out.println(atomicInteger.get());

        // ============== 期望的线程 ==================
        System.out.println(atomicInteger.compareAndSet(2021, 2022));
        System.out.println(atomicInteger.get());

        atomicInteger.getAndIncrement();

    }
}

20、原子引用

  解决ABA 问题，引入原子引用！ 对应的思想：乐观锁！

   带版本号 的原子操作！

代码实现：

package com.feimai.test.JUCTest.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

public class Test02 {

    public static void main(String[] args) {
        //AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题
        // 正常在业务操作，这里面比较的都是一个个对象
        AtomicStampedReference<Long> atomicStampedReference = new AtomicStampedReference(2L,1);

        // CAS compareAndSet : 比较并交换！
        new Thread(()->{
            System.out.println("a1 = " + atomicStampedReference.getStamp());// 获得版本号

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(2L, 5L,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a2 = " + atomicStampedReference.getStamp());

            System.out.println(atomicStampedReference.compareAndSet(5L, 2L,
                    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(2L, 5L,
                    stamp, stamp + 1));
            System.out.println("b2 = " + atomicStampedReference.getStamp());
        },"B").start();
    }
}

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

在这里插入图片描述


21、各种锁的理解


21.1、公平锁、非公平锁

   公平锁： 非常公平， 不能够插队，必须先来后到！

   非公平锁：非常不公平，可以插队 （默认都是非公平）

ReentrantLock 锁的源码分析：

public ReentrantLock() {
sync = new NonfairSync();
} 

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

21.2、可重入锁

在这里插入图片描述

Synchronized版 代码：

package com.feimai.test.JUCTest.lock;

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

// Synchronized
public class Test01 {

    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");
        call();
    }

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

Lock版 代码：

package com.feimai.test.JUCTest.lock;

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

public class Test02 {
    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(); lock.unlock();
    // lock 锁必须配对，否则就会死在里面
    Lock lock = new ReentrantLock();
    public void sms(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " : sms");
            call(); // 这里也有锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

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

21.3、 自旋锁

SpinLock
在这里插入图片描述
自定义一个 自旋锁，代码：

package com.feimai.test.JUCTest.lock;

import java.sql.Time;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

// 自旋锁
public class SpinLockTest {
    AtomicReference<Thread> atomicReference = new AtomicReference<>();
    // 加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"--> myLock");
        // 自旋锁
        while(!atomicReference.compareAndSet(null,thread)){

        }
    }

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

    public static void main(String[] args) throws InterruptedException {
    	// ReentrantLock reentrantLock = new ReentrantLock();
		// reentrantLock.lock();
		// reentrantLock.unlock();
    	
	    // 底层使用的自旋锁CAS
        SpinLockTest lockTest = new SpinLockTest();

        new Thread(()->{
            lockTest.myLock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lockTest.myUnlock();
            }
        },"A").start();

        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            lockTest.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lockTest.myUnlock();
            }
        },"B").start();
    }
}

在这里插入图片描述


21.4、死锁

  死锁是什么
在这里插入图片描述

死锁测试，怎么排除死锁：

package com.feimai.test.JUCTest.lock;

import java.util.concurrent.TimeUnit;

public class DeadLockTest {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        MyThread myThread1 = new MyThread(lockA,lockB);
        MyThread myThread2 = new MyThread(lockB,lockA);

        new Thread(myThread1,"T1").start();
        new Thread(myThread2,"T2").start();
    }
}

class MyThread implements Runnable{

    private String lock_A;
    private String lock_B;

    public MyThread(String lock_A, String lock_B) {
        this.lock_A = lock_A;
        this.lock_B = lock_B;
    }

    @Override
    public void run() {
        synchronized(lock_A){
            System.out.println(Thread.currentThread().getName() +" lock: "+lock_A+" -->get: "+lock_B);

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

            synchronized(lock_B){
                System.out.println(Thread.currentThread().getName() +" lock: "+lock_B+" -->get: "+lock_A);
            }
        }
    }
}

在这里插入图片描述

   解决问题：

   1、使用 jps -l 定位进程号
在这里插入图片描述

   2、使用 jstack 进程号 找到死锁问题

在这里插入图片描述
  找到最后一行，查看具体死锁的代码

在这里插入图片描述


别訆我小内脏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java并发编程-3.pdf
05-28
Java并发编程中的多线程协作机制 在 Java 并发编程中，多线程协作机制是非常重要的一部分。多线程协作机制是指在多线程编程中，多个线程之间如何协作、同步和通信，以达到共同完成某个任务的目的。Java 提供了多种...
JUC并发编程「公开课第三讲」.pdf
02-02
### JUC并发编程公开课第三讲知识点总结 #### 一、线程池基本概念与优势 1. **定义**: 线程池是一种管理线程执行任务的机制，它通过限制运行线程的数量来提高系统资源利用率。具体而言，线程池会将待处理的任务放...
Java多线程并发编程--Java并发包（JUC）
weixin_38227386的博客
07-03 644
Java多线程并发–Java并发包（JUC）
Java多线程 JUC并发编程 （第二天）
别訆我小内脏的博客
06-13 1189
多线程进阶=>JUC并发编程 9、读写锁 ReadWriteLock 代码实现 package com.feimai.test.JUCTest.rw; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLo.
Java核心技术之- 多线程并发-JUC总结-并发编程
Aili的博客
05-24 481
1. 线程基础线程的创建与启动方式- 线程生命周期管理- 线程的状态转换- 线程同步与互斥- 程优先级设置2. 线程间通信- synchronized 关键字及其实现原理- wait() ， notify() ，notifyAll()，join()方法的使用- Lock 和 Condition 的使用- volatile 关键字的使用 - 原子类的使用- ConcurrentHashMap 和 ConcurrentLinkedQueue 的使用- CountD
java并发编程和多线程总结
卓越之识论道，平常之识论事，狭隘之识论人
07-17 1198
java并发编程和多线程总结
JUC(并发编程)
abc98526的博客
04-17 1万+
1.什么是JUC? JUC是指javaUtil包中的三个操作线程的包! 2.线程进程和程序 程序(Program):是一个静态的概念，一般对应于操作系统中的一个可执行的文件 ，比如：我们要启动酷狗听音乐，则对应酷狗可执行程序。当我们双击酷狗，则加载 程序到内存中，开始执行该程序，于是产生了"进程". 进程:执行中的程序叫做进程(Process),是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如:我们在用酷狗听音乐，也可以使用wps写文档，也可以同时用浏览器查看网页。可以通过
JUC并发编程面试题
weixin_45081813的博客
04-06 2525
文章目录1. 并行和并发有什么区别？2. 线程和进程的基本概念、线程的基本状态以及状态之间的关系？3.守护线程是什么？4.创建线程有哪几种方式？5. sleep() 和 wait() 有什么区别？6.线程的 run() 和 start() 有什么区别？7.创建线程池有哪几种方式？8.在 Java 程序中怎么保证多线程的运行安全？9.什么是死锁？怎么防止死锁？10.synchronized 和 volatile 的区别是什么？11.synchronized 和 Lock 有什么区别？12.synchroniz
JUC并发编程
热门推荐
识时务者的个人博客
07-08 14万+
JUC并发编程 JUC简介 进程、线程的关系 Java默认有两个线程 线程的六种状态 并发、并行的关系： Lock锁 Synchronized 和 Lock的区别 8锁现象 问题一 : 在标准情况下，两个线程先打印 发短信 还是 打电话 ？ 问题二 : 在发短信方法中，延迟4秒，两个线程先打印 发短信 还是 打电话？ 问题三 : Phone类增加一个普通方法，线程B调用，那么两个线程先打印 发短信
Java：多线程和JUC详解
游手好闲
01-06 1351
Java多线程和JUC详解
JUC编程java多线程并发详细总结
butcher的博客
08-08 1036
1、什么是JUC JUC即Java.util.concurrent包， 2、进程与线程 一个进程可以包含多个线程，至少包含一个 java默认有两个线程（main、 gc） 对于Java而言，创建线程的方式：进程Thread、实现Runnable接口、实现Callback接口 java并不能直接开启线程，它使调了底层c++的方法。 并发：多个线程操作一个资源，一个CUP 并行：多个线程同时执行，多个CPU 3、线程的状态 由源码 NEW :新建 RUNNABLE, 就绪 BLOCKED, 阻塞
JUC并发编程视频教程
11-28
* 颠覆一些你以为"正确"的认知，纠正其它同类视频的错误* 100+ 张手绘图 & 流程图，帮助你形成正确的"多线程世界观"* 以知识点为主线、穿插讲解"应用"，"原理"和"多线程设计模式"，多维度学懂并发主讲内容第一章：...
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC（Java Utilities for ...
kechengsheji2021.zip
07-30
kechengsheji2021.zip
1cfa8b474c28bb76433ab12fc99ee5ad.jpeg
最新发布
07-30
1cfa8b474c28bb76433ab12fc99ee5ad.jpeg
TwineCompile571GetItSetup.7z
07-30
JomiTech TwineCompile 是一款集成在 C++Builder IDE 中的插件，旨在通过多种技术显著减少 C++ 编译、构建和生成的时间。以下是 TwineCompile 的一些关键能力和特点： 集成编译优化：TwineCompile 通过多线程、文件缓存和自动后台编译等技术，直接集成到 C++Builder IDE 中，优化编译过程。 编译器封装：它不是 C++ 编译器，而是将 Embarcadero 经典和 CLANG 编译器封装在一个构建系统中，优化文件和项目的构建方式。 IDE 支持：TwineCompile 通过 GetIt 包管理器提供，支持安装它的 IDE。对于旧版 IDE 或没有活跃更新订阅的 IDE，可以购买许可证以获得支持。 版本兼容性：TwineCompile 5.x 支持 C++Builder 10.2 至 C++Builder 12.0，而 TwineCompile 4.x 支持 C++Builder 5 至 C++Builder 10.1。
SCI一区】淘金算法GRO-CNN-BiLSTM-Mutilhead-Attention多变量时序预测含源码 5642.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-BiLSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-BiLSTM-Mutilhead-Attention回归预测
Java并发编程详解：JUC工具包与多线程实战
"这是一份关于JUC高并发编程的狂神笔记，旨在帮助读者从入门到精通。笔记配合狂神在B站的同步课程，提供了深入浅出的学习材料，涵盖了Java并发API的核心内容。" Java并发编程是现代软件开发中的重要技能，尤其在...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值