【JUC并发编程系列】深入理解Java并发机制：从synchronized到CAS锁升级全过程(三、synchronized 前置知识)

最新推荐文章于 2024-10-14 20:53:59 发布
最新推荐文章于 2024-10-14 20:53:59 发布
阅读量1k 收藏 27
点赞数 25
分类专栏： JUC并发编程系列 文章标签： java JUC 并发编程 并发机制 synchronized CAS 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68020300/article/details/142187799
版权

文章目录

【JUC并发编程系列】深入理解Java并发机制：从synchronized到CAS锁升级全过程(三、synchronized 前置知识)

1. 基本概念

  1. 偏向锁→轻量锁（cas自旋）→重量级锁
  2. 重入锁概念/悲观锁与乐观锁
  3. 基于CAS手写-重入锁
  4. 基于CAS手写类似synchronized锁的升级过程

补充概念:

  • 偏向锁: 同一个线程在没有其他线程竞争锁的情况下，可以一直复用我们的锁，不会重复获取锁。

  • 轻量锁: 多个线程同时获取锁，只有一个线程获取锁，没有获取到锁的线程会通过CAS不断重试（可以配置重试次数）

  • 重量级锁: 重试多次如果没有获取到锁，则当前线程会变成阻塞----用户态切换到内核态/上下文切换

CAS ：

  • 优点：不需要用户态切换内核态，一直会在我们用户空间中自旋。

  • 缺点：有可能会非常的消耗到cpu资源（因为要做自旋）。

如何处理解决呢？

  • 控制循环次数

2. 重入锁

重入锁：当前线程如果已经获取到锁，则不会重复的获取锁，而是直接复用。

比如：我们的synchronized/lock

锁如果不具有重入性: 当前线程 递归调用方法中 有可能会发生死锁的问题。

3. 演示重入锁

使用 synchronized 锁

public class Test01 {
    public static void main(String[] args) {
        a();
    }
    public static  synchronized void a(){
        System.out.println("a");
        b();
    }
    public static  synchronized void b(){
        System.out.println("b");
        c();
    }
    public static  synchronized void c(){
        System.out.println("c");
    }
}

输出 abc

使用自己通过CAS实现的锁 不具备可重入性

public class Test02 {
    private static TestLock testLock = new TestLock();

    public static void main(String[] args) {
        a();
    }

    public static synchronized void a() {
        testLock.lock();
        System.out.println("a");
        b();
        testLock.unlock();

    }

    public static synchronized void b() {
        testLock.lock();
        System.out.println("b");
        c();
        testLock.unlock();
    }

    public static synchronized void c() {
        testLock.lock();
        System.out.println("c");
        testLock.unlock();
    }
}

输出 a

使用jdk并发包中自带的 ReentrantLock 锁

public class Test03 {
    private static ReentrantLock reentrantLock = new ReentrantLock();

    public static void main(String[] args) {
        a();
    }

    public static synchronized void a() {
        reentrantLock.lock();
        System.out.println("a");
        b();
        reentrantLock.unlock();

    }

    public static synchronized void b() {
        reentrantLock.lock();
        System.out.println("b");
        c();
        reentrantLock.unlock();
    }

    public static synchronized void c() {
        reentrantLock.lock();
        System.out.println("c");
        reentrantLock.unlock();
    }
}

输出 abc

4. 改造重入锁代码

public class TestLock {
    /**
     * initialValue = 0 表示没有线程使用
     * initialValue = 1 表示有一个线程正在使用
     */
    private AtomicInteger lockState = new AtomicInteger(0);
    /**
     * 获取到锁的线程
     */
    private Thread ownerLockThread;
    /**
     * 记录锁的重入次数
     */
    private int recursions;

    /**
     * 获取锁
     * 当前线程如果已经获取到锁则直接复用，不需要再次获取
     */
    public void lock() {
        //当前线程是否已经获取到锁
        if (ownerLockThread == Thread.currentThread()) {
            //重入次数+1
            recursions++;
            return;
        }
        /**
         * 将 initialValue 从 0 => 1
         * 如果有两个线程同时获取锁，最终只会有一个线程获取成功
         * 没有获取到锁会进行自旋
         */
        while (true) {
            if (lockState.compareAndSet(0, 1)) {
                //重入次数+1
                recursions++;
                //记录获取到锁的线程
                ownerLockThread = Thread.currentThread();
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    /**
     * 释放锁
     */
    public void unlock() {
        if (recursions > 0) {
            //重入次数-1
            recursions--;
            return;
        }
        //当重入次数为0的时候才会释放锁
        while (true) {
            if (lockState.compareAndSet(1, 0)) {
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

5. 轻量级改造重量级锁

1722674464503

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;

/**
 * @author 赵立
 */
public class TestLock {
    /**
     * initialValue = 0 表示没有线程使用
     * initialValue = 1 表示有一个线程正在使用
     */
    private AtomicInteger lockState = new AtomicInteger(0);
    /**
     * 获取到锁的线程
     */
    private Thread ownerLockThread;
    /**
     * 记录锁的重入次数
     */
    private int recursions;
    /**
     * 重试三次没有获取到锁被阻塞状态的线程
     */
    private LinkedBlockingDeque<Thread> notLockThreads = new LinkedBlockingDeque();

    /**
     * 获取锁
     * 当前线程如果已经获取到锁则直接复用，不需要再次获取
     */
    public void lock() {
        //当前线程是否已经获取到锁
        if (ownerLockThread == Thread.currentThread()) {
            //重入次数+1
            recursions++;
            return;
        }
        /**
         * 将 initialValue 从 0 => 1
         * 如果有两个线程同时获取锁，最终只会有一个线程获取成功
         * 没有获取到锁会进行自旋
         */
        /**
         * 每个线程获取锁的重试次数
         */
        int spinCount = 0;
        while (true) {
            if (spinCount > 3) {
                //重试次数大于三次 让我们当前线程变为阻塞状态
                notLockThreads.offer(Thread.currentThread());
                LockSupport.park();
                //唤醒此线程之后将重试次数改为0次
                spinCount = 0;
            }
            if (lockState.compareAndSet(0, 1)) {
                //重入次数+1
                recursions++;
                //记录获取到锁的线程
                ownerLockThread = Thread.currentThread();
                return;
            }
            spinCount++;//重试次数+1
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    /**
     * 释放锁
     */
    public void unlock() {
        if (recursions > 0) {
            //重入次数-1
            recursions--;
            return;
        }
        //当重入次数为0的时候才会释放锁
        while (true) {
            if (lockState.compareAndSet(1, 0)) {
                //唤醒所有没有获取到锁的线程，从新开始竞争锁的资源
                notifyNotLockThreads();
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    /**
     * 唤醒所有没有获取到锁的线程
     */
    public void notifyNotLockThreads() {
        notLockThreads.forEach((t) -> LockSupport.unpark(t));
    }
}

6. 公平锁与非公平锁

  • 公平锁：就是比较公平，根据请求锁的顺序排列，先来请求的就先获取锁，后来获取锁就最后获取到， 采用队列存放，类似于吃饭排队。

  • 非公平锁：不是根据根据请求的顺序排列， 通过争抢的方式获取锁。

比如当前 abcd 四个线程，假设A线程获取到锁，在释放锁时：

  • 公平锁：根据bcd 请求锁的顺序排列获取锁，B先获取到锁，然后B释放后再给C，以此类推。

  • 非公平锁：Bcd 同时竞争这把锁；谁能够抢成功 谁就获取锁成功。

非公平锁效率比较高

Synchronized是非公平锁

img

//公平锁
new  ReentramtLock()(true)
//非公平锁
new  ReentramtLock()(false)

公平锁演示

public class Test04 implements Runnable {
    private static int count = 0;
    // fair 为 true 时为公平锁
    private static Lock lock = new ReentrantLock(true);

    @Override
    public void run() {
        while (count < 200) {
            createCount();
        }
    }

    public void createCount() {
        System.out.print(Thread.currentThread().getName() + ",count:" + count+";   ");
        count++;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Test04()).start();
        }
    }
}

非公平锁演示

public class Test04 implements Runnable {
    private static int count = 0;
    // fair 为 true 时为公平锁
    private static Lock lock = new ReentrantLock(false);

    @Override
    public void run() {
        while (count < 200) {
            createCount();
        }
    }

    public void createCount() {
        System.out.println(Thread.currentThread().getName() + ",count:" + count);
        count++;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Test04()).start();
        }
    }
}

上一章节自定义的锁是非公平锁

/**
 * 唤醒所有没有获取到锁的线程
 */
public void notifyNotLockThreads() {
    /**
     * 非公平锁 会唤醒所有的阻塞线程
     */
    notLockThread.forEach((t) -> LockSupport.unpark(t));
   
}

改造为公平锁

/**
 * 唤醒所有没有获取到锁的线程
 */
public void notifyNotLockThreads() {  
    /**
     * 公平锁 取出当前队列中的第一个 取出成功时同时删除
     */
	LockSupport.unpark(notLockThreads.poll());
}

7. 偏向锁/轻量级锁/重量级锁应用场景

Synchronized 锁的升级过程

  • t1 线程 获取到锁 1毫秒就释放锁 t1线程1毫秒之后又唤醒t2线程竞争锁资源，t2竞争锁资源从阻塞=>就绪=>cpu调度=>竞争锁资源，在这个其中就会有锁的升级过程，由偏向锁 => 轻量级锁

  • 如果 t1 线程获取到锁之后 60s 才会释放锁 t2线程自旋60s ，那么 t2 直接阻塞就可以了

  1. 偏向锁：加锁和解锁不需要额外的开销，只适合于同一个线程访问同步代码块，无需额外的开销，如果多个线程同时竞争的时候，会撤销该锁。

  2. 轻量级锁：竞争的线程不会阻塞，提高了程序响应速度，如果始终得不到锁的竞争线程，则使用自旋的形式，消耗cpu资源，适合于同步代码块执行非常快的情况下，自旋（jdk1.7以后智能自转）

  3. 重量级锁： 线程的竞争不会使用自旋，不会消耗cpu资源，适合于同步代码执行比较长的时间。

偏向锁与重入锁之间有什么区别？

  • 偏向锁与重入锁实现的思路基本上相同

  • 偏向锁（对象头mark word 中会记录线程 id）

    • 当前只有一个线程的情况下，没有其他的线程竞争锁，该锁一直会被我们的该线程持有，不会立即释放锁

    • 必须要有另外的一个线程竞争该锁，才会撤销我们的偏向锁

  • 重入锁（会记录该线程的重入次数）

    • 当前线程如果已经获取到了锁，当前线程中的其他方法如果有需要获取锁的话，则直接复用

    • 当重入次数减到 0 的情况下才会通过 cas 改状态 (1,0) 即释放锁

无理 Java
关注
专栏目录
【JUC并发编程系列】深入理解Java并发机制：从用户态到内核态的探索（一、前置知识）
欢迎来到我的技术空间！我是一名经验丰富的Java开发工程师，热衷于分享我在软件开发领域的知识和心得。在这个博客里，您会发现一系列关于Java编程的文章，包括最佳实践、技术趋势、代码优化技巧以及一些有趣的项目案例。无论是初学者还是有经验的开发者，都能在这里找
08-27 1467
本文详尽解析了Java并发编程中的核心概念，从用户态与内核态的区别入手，深入探讨了线程安全同步的不同机制及其影响。通过对传统锁机制的分析，揭示了CAS算法的优势与潜在问题。同时，本文还阐述了上下文切换的原因以及如何有效减少其发生的策略，帮助读者更好地理解和优化Java并发程序。
【JUC并发编程系列】深入理解Java并发机制：CAS算法与原子类在Java中的实践应用(二、CAS)
欢迎来到我的技术空间！我是一名经验丰富的Java开发工程师，热衷于分享我在软件开发领域的知识和心得。在这个博客里，您会发现一系列关于Java编程的文章，包括最佳实践、技术趋势、代码优化技巧以及一些有趣的项目案例。无论是初学者还是有经验的开发者，都能在这里找
08-27 1465
本文深入探讨了Java并发编程中的CAS算法及其在原子类中的应用。首先介绍了CAS的基本原理和操作机制，随后详细讲解了原子类家族的各种成员及其使用场景。通过具体的代码示例，展示了如何利用AtomicInteger实现线程安全的计数，并探讨了CAS算法在实现过程中的潜在问题，如ABA问题及其解决方案。最后，通过手写简单的锁实现和解决ABA问题的案例，进一步加深了读者对CAS算法的理解。
JUC第一讲：Java并发知识体系详解 + 面试题汇总(P6熟练 P7精通)
Jet_qi的博客
09-17 675
面试时常常被面试官问到这个问题，Java并发包含实际业务开发中的方方面面。本篇文章是JUC第1讲，作为开篇，讲解Java 并发相关知识体系，包含理论基础，线程基础，synchronized，volatile，final关键字，JUC框架等内容。
JUC并发编程之synchronized内置锁
Eriksen的博客
03-04 741
JUC并发编程之synchronized内置锁
厚积薄发打卡Day49：狂神说Java之JUC并发编程＜CAS入门到“锁“小结＞(下)
COOLGWAYNE_TECH_BLOG
04-09 366
前言： 众所周知，B站是全中国最大的在线学习平台，此次学习打卡的教程来自【狂神说】与【寒食君】两位B站up主，欢迎大家一键三连???? 学习视频来源： 【狂神说Java】JUC并发编程最新版通俗易懂 寒食君：Java并发系列 博客回顾： Day26：狂神说Java之JUC并发编程＜代码+笔记＞（上） Day27：狂神说Java之JUC并发编程（中）——从 JMM 到 volatile 前置知识：学习JUC前需要对java的多线程有一定的掌握。 学习视频： 【狂神说Java】多线程详解 详细资
3.深入理解Java并发编程
陌陌龙的博客
06-24 893
深入理解Java并发编程
【Java面试题汇总】多线程、JUC、锁篇（2023版）
vincewm的博客
03-11 7583
线程和进程的区别、CAS的ABA问题、AQS、哪些地方使用了CAS、怎么保证线程安全、线程同步方式、synchronized的用法及原理、Lock、volatile、线程的六个状态、ThreadLocal、线程通信方式、创建方式、两种创建线程池的方法、线程池设置合适的线程数、线程安全的集合？ConcurrentHashMap、JUC
Java并发编程第4讲——Java中的锁（万字详解）
让~学习~成为一种习惯（橡 皮 人の技术博客）
08-11 2260
本篇文章介绍了Java中的6种锁。从锁的相关概念开始，逐一详细介绍synchronized关键字、ReentrantLock、Condition接口、读写锁ReentrantReadWriteLock、读写性能之王StampedLock以及CAS乐观锁。内容涉及各个的概念、实现原理、特性、常用方法、代码示例以及相互之间的比较。
并发编程 java锁机制
qq_43325216的博客
02-07 1048
并发环境下，会存在多个线程对同一个资源进行争抢的情况，假设线程A对资源正在进行修改，此时线程B又对同一资源进行了修改，就会导致数据不一致的问题。为了解决这个问题，很多编程语言引入了锁机制。通过一种抽象的“锁”来对资源进行锁定，当一个线程持有“锁”时，其他线程必须等待 ------ 在临界资源上对线程进行一种串行化处理。java中，悲观锁的实现是基于object的 ------ 也就是说，每个对象都拥有一把锁，这个锁存放在对象头中，记录了当前对象被哪个线程所占用（持有）。
Java并发编程：锁
rrq_0324的博客
12-02 958
1.1 Lock Lock接口的实现基本都是通过聚合了一个队列同步器AQS的子类来完成线程访问控制的。 package java.util.concurrent.locks; import java.util.concurrent.TimeUnit; public interface Lock { //调用该方法的当前线程将会获取锁 void lock(); //可中断的获取锁，即在锁的获取中可以中断当前线程 void lockInterruptibly() throws Inte
多线程与高并发——并发编程（3）
yangwei2048的博客
08-31 207
1、锁的分类 2、深入synchronized 3、深入ReentrantLock 4、深入ReentrantReadWriteLock
学习《Java并发编程》目录索引 (持续更新中)
热门推荐
Guizy
12-20 1万+
     写在前面：此系列为本人学习黑马《Java并发编程》所整理的笔记 ! 不局限于应用层开发, 更加深入理解多线程, 并发编程, 更有利于我们长久发展 ! 学习Java并发编程
Java高并发知识点
hanlin_zhao的博客
01-06 1009
java并发编程
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1427
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
初学java练习题【1】
lxt135744的博客
10-10 306
【代码】初学java练习题【1】
确保Spring Boot定时任务只执行一次方案
最新发布
2301_76419561的博客
10-14 153
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 645
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Spring Boot 整合 Minio
cmh1008611的博客
10-09 1048
5‌‌.Optional‌是Java 8引入的一个新的容器对象，它提供了非常丰富的API，主要是为了解决空指针异常的问题。Optional类允许你创建一个可能为null的值的容器，从而避免了直接使用null值可能导致的空指针异常。自动处理异常：在使用 @SneakyThrows 注解的方法中，如果抛出任何类型的检查性异常（即编译器要求显式捕获或声明的异常），Lombok 会自动将其包装成运行时异常（RuntimeException），从而避免了需要显式捕获或声明这些异常的麻烦。可以用于自动装配和依赖注入。
Java JUC并发编程实例：守护线程与Synchronized锁
本资源主要介绍Java并发编程中的Java.util.concurrent (JUC) 库，以及多线程和同步机制。首先，我们探讨了用户线程与守护线程的区别。在Java中，用户线程（非守护线程）是主线程执行的主要工作单元，它们不会自动随...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值