【并发编程】锁机制

已于 2023-05-14 11:13:29 修改
阅读量740 收藏 14
点赞数 8
分类专栏： # JUC专栏 文章标签： java 后端
于 2022-11-10 20:34:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47533244/article/details/127795865
版权

文章目录

1.锁的分类

  • 自旋锁：线程状态及上下文切换消耗系统资源，当访问共享资源的时间短，频繁上下文切换不值得。jvm实现，使线程在没有获得锁的时候，不被挂起，转而执行空循环，循环几次之后，如果还没能获得锁，则被挂起。

  • 阻塞锁：阻塞锁改变了线程的运行状态，让线程进入阻塞状态进行等待，当获得相应的信号（唤醒或者时间）时，才可以进入线程的准备就绪状态，转为就绪状态的所有线程，通过竞争，进入运行状态。

  • 重入锁：支持线程再次进入的锁，就像我们有房间的钥匙，可以多次进入房间类似。

  • 读写锁：两把锁，读锁跟写锁，写写互斥、读写互斥、读读共享。

  • 互斥锁：当线程抢占到资源，其他线程进不来。

  • 悲观锁： 总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。

  • 乐观锁：每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。

  • 公平锁：所有线程老老实实排队，对大家而言都很公平。

  • 非公平锁：一部分线程排着队，但是新来的线程可能插队。

  • 偏向锁：偏向锁使用了一种等到竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。

  • 独占锁：独占锁模式下，每次只能有一个线程能持有锁。

  • 共享锁：允许多个线程同时获取锁，并发访问共享资源。

2.深入理解Lock接口

（1）lock于synchronized的区别

  • synchronized是java内置的关键字，在jvm层面，Lock是个java类。
  • synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁。
  • synchronized会自动释放锁（线程在执行代码块的过程中发生异常会自动释放锁），Lock需要在finally中手动释放锁（unlock方法），否则会造成死锁。
  • 用synchronized关键字的两个线程1和线程2，如果当线程1获取锁，线程2等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不会一直等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了。
  • synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可中断、可公平（两者皆可）
  • Lock锁适合大量同步的代码的同步问题，而synchronized锁适合少量代码同步问题。

（2）Lock继承体系图

在这里插入图片描述

（3）Lock常用的API

  • lock()、unlock()加锁、解锁
public class LockTest {

    private Lock lock = new ReentrantLock();

    /**
     * 当前线程释放锁后，其他线程才可以获取到锁
     */
    public void lock(){
        lock.lock();
        try {
            System.out.println("线程"+Thread.currentThread().getName()+":获取到锁资源");
            Thread.sleep(2000L);
        }catch (Exception e){
            System.out.println("线程"+Thread.currentThread().getName()+":释放锁发生异常");
        }finally {
            lock.unlock();
            System.out.println("线程"+Thread.currentThread().getName()+":释放锁完毕");
        }
    }

    public static void main(String[] args) {

        LockTest lockTest = new LockTest();

        new Thread(()->{
            lockTest.lock();
        }).start();

        new Thread(()->{
            lockTest.lock();
        }).start();
    }
}

在这里插入图片描述

  • 尝试获取锁tryLock()，表示用来尝试获取锁，如果获取成功返回true，失败返回false。
public class LockTest {

    private Lock lock = new ReentrantLock();

    /**
     * 线程尝试获取线程锁，如果有其他线程占用，就返回false，无法拿到锁
     */
    public void lock(){
        if(lock.tryLock()){
            try {
                System.out.println("线程"+Thread.currentThread().getName()+":获取到锁资源");
                Thread.sleep(2000L);
            }catch (Exception e){
                System.out.println("线程"+Thread.currentThread().getName()+":释放锁发生异常");
            }finally {
                lock.unlock();
                System.out.println("线程"+Thread.currentThread().getName()+":释放锁完毕");
            }
        }else{
            System.out.println("线程"+Thread.currentThread().getName()+":尝试获取锁失败，其他线程持有锁");
        }
    }

    public static void main(String[] args) {

        LockTest lockTest = new LockTest();

        new Thread(()->{
            lockTest.lock();
        }).start();

        new Thread(()->{
            lockTest.lock();
        }).start();
    }
}

在这里插入图片描述

  • tryLock(3000,TimeUtil.MILLISECONDS)尝试获取锁，获取不到就等待3s，如果3s后还是获取不到就返回false
public class LockTest {

    private Lock lock = new ReentrantLock();

    /**
     * 线程尝试获取线程锁，如果有其他线程占用，就返回false，无法拿到锁
     */
    public void lock() throws InterruptedException {
        if(lock.tryLock(3000,  TimeUnit.MILLISECONDS)){
            try {
                System.out.println("线程"+Thread.currentThread().getName()+":获取到锁资源");
                Thread.sleep(5000L);
            }catch (Exception e){
                System.out.println("线程"+Thread.currentThread().getName()+":释放锁发生异常");
            }finally {
                lock.unlock();
                System.out.println("线程"+Thread.currentThread().getName()+":释放锁完毕");
            }
        }else{
            System.out.println("线程"+Thread.currentThread().getName()+":尝试获取锁失败，其他线程持有锁");
        }
    }

    public static void main(String[] args) {

        LockTest lockTest = new LockTest();

        new Thread(()->{
            try {
                lockTest.lock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(()->{
            try {
                lockTest.lock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

在这里插入图片描述

3.自定义实现可重入锁

（1）可重入锁简介

  • 可重入锁，指的是以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象上的锁，而其他线程是不可以的。
  • synchronized和ReetrantLock都是可重入锁。
  • 可重入锁的意义就在于防止死锁。
  • 实现原理是通过为每个锁关联一个请求计数器和一个占有它的线程。当计数为0时，认为锁是未被占有的，线程请求一个未被占用的锁时，JVM将记录锁的占有者，并且将请求计数器置为1。
  • 如果同一个线程再次请求这个锁，计数器将递增。
  • 每次占用线程退出同步块，计数器将递减，直到计数器为0，锁被释放。
  • 关于父类和子类的锁的重入：子类覆盖了父类的synchonized方法，然后调用父类中的方法，此时如果没有可重入的锁，那么这段代码将会产生死锁。

（2）伪代码案例

class A
public synchronized methodA(){
	methodB();
}

public synchronized methodB(){
}

#当线程调用A类的对象methodA同步方法，如果其他线程没有获取A类的对象锁，那么当前线程就获得点钱A类对象的锁，然后执行methodB同步方法，当前线程能够在次获取A类对象的锁，其他线程是不可以的，这就是可重入锁。

（3）自定义锁发生死锁问题

  • 自定义锁继承ReentrantLock类重写lock和unlock方法
public class MyLock extends ReentrantLock {

    //定义锁的标志位
    private boolean isHoldLock = false;

    /**
     * 同一时刻，能且仅能有一个线程获取到锁
     * 其他线程只能等待该线程释放锁之后才能获取到锁
     */
    @Override
    public synchronized void lock() {
        //判断是否有当前线程持有锁，如果有就进入等待
        if (isHoldLock) {
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //将锁的标志置成true，表示当前线程持有锁
        isHoldLock = true;
    }

    @Override
    public synchronized void unlock() {
        //唤醒等待的线程
        notify();
        //释放锁资源
        isHoldLock = false;
    }
}
  • 定义ReentryDemo创建两个方法A、B其中在A方法中调用B方法
public class ReentryDemo {

    private Lock lock = new MyLock();

    public void methodA(){
        lock.lock();
        System.out.println("进入方法A");
        methodB();
        lock.unlock();
    }

    public void methodB(){
        lock.lock();
        System.out.println("进入方法B");
        lock.unlock();
    }

    public static void main(String[] args) {
        ReentryDemo reentryDemo = new ReentryDemo();
        reentryDemo.methodA();
    }

}
  • 上面这段代码看似没有问题，但其实已经造成了死锁。
  • 运行结果：

在这里插入图片描述

  • jconsole调出java管控台，查看当前运行的线程，发现并没有出现死锁的现象。

在这里插入图片描述

  • 回到代码分析原因

在这里插入图片描述

  • 解决办法：将自定义的锁改成可重入锁，当同一线程再次访问的时候，允许再次获取锁。

（4）自定义可重入锁

  • 自定义锁继承ReentrantLock类重写lock和unlock方法
public class MyLock extends ReentrantLock {

    private boolean isHoldLock = false;

    //当前线程实例
    private Thread holdLockThread = null;

    //重入的次数
    private int reentryCount = 0;

    /**
     * 同一时刻，能且仅能有一个线程获取到锁
     * 其他线程只能等待该线程释放锁之后才能获取到锁
     */
    @Override
    public synchronized void lock() {
        //判断当前线程是否持有锁，并且是不是同一个线程重复进入
        if(isHoldLock && Thread.currentThread() != holdLockThread){
            try{
                wait();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        holdLockThread = Thread.currentThread();
        isHoldLock = true;
        //记录加锁的次数
        reentryCount++;
    }

    @Override
    public synchronized void unlock() {
        //判断当前线程是否是持有锁的线程，是，重入次数减1，不是就不做处理
        if(Thread.currentThread() == holdLockThread){
            reentryCount--;
            if(reentryCount == 0){
                notify();
                isHoldLock = false;
            }
        }
    }
}

  • 测试代码和上面相同，此处省略

  • 执行结果：

在这里插入图片描述

  • 分析原因：

在这里插入图片描述
在这里插入图片描述

（5） 一个线程执行同步代码时，再次重入该锁过程中，如果抛出异常，会释放锁吗？

  • 注意：如果有涉及锁的操作的业务方法的时候，都要加上try-catch-finally，在finally中释放锁资源。
  • 锁不释放的案例

在这里插入图片描述

public class ReentryDemo {

    private Lock lock = new MyLock();

    private int num = 0;

    public void methodA() throws InterruptedException {

        lock.lock();
        System.out.println("进入方法A");
        methodB();
        Thread.sleep(3000L);
        if (num == 0) {
            num++;
            int a = 1 / 0;
        }
        lock.unlock();
    }

    public void methodB() {
        lock.lock();
        System.out.println("进入方法B");
        lock.unlock();
    }

    public static void main(String[] args) {
        ReentryDemo reentryDemo = new ReentryDemo();
        new Thread(() -> {
            try {
                reentryDemo.methodA();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                reentryDemo.methodA();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

在这里插入图片描述

  • 修改代码优化
public class ReentryDemo {

    private Lock lock = new MyLock();

    private int num = 0;

    public void methodA() {
        try {
            lock.lock();
            System.out.println("进入方法A");
            methodB();
            Thread.sleep(3000L);
            if (num == 0) {
                num++;
                int a = 1 / 0;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void methodB() {
        try {
            lock.lock();
            System.out.println("进入方法B");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentryDemo reentryDemo = new ReentryDemo();
        new Thread(() -> {
            reentryDemo.methodA();
        }).start();

        new Thread(() -> {
            reentryDemo.methodA();
        }).start();
    }

}

在这里插入图片描述

互联网小阿祥
关注
  • 8
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java并发编程进阶——并发锁
行者无疆的博客
03-14 4159
1 JAVA 多线程锁介绍 1.1 悲观锁 定义：悲观锁指对数据被外界修改持保守态度，认为数据很容易就会被其他线程修改（很悲观），所以在数据被处理前先对数据进行加锁，并在整个数据处理过程中，使数据处于锁定状态。 悲观锁的实现：开发中常见的悲观锁实现往往依靠数据库提供的锁机制，即在数据库中，在对数据记录操作前给记录加排它锁。如果获取锁失败，则说明数据正在被其他线程修改，当前线程则等待或者抛出异常。如果获取锁成功，则对记录进行操作，然后提交事务后释放排它锁。 实例：Java 中的 synchronized 关键
并发锁的学习
winkooxx
10-09 324
锁 锁的定义 锁是用来协调多个线程并发访问同一共享资源时带来的安全问题，频繁用锁必然会带来性能问题，但不用锁又会造成安全问题 1）从性能上分：乐观锁和悲观锁 乐观锁：CAS自旋锁，是非常经典的乐观锁，并发性能比较好，但是自旋会造成很大的开销，悲观的认为当前环境下并发情况不是很很严重，任务提交时才才判断是否冲突 悲观锁：悲观的认为当前环境下并发情况是很严重的，所有的任务在执行时都要加上锁，保证了安全型，失去了并发性，并发性能差 乐观锁：无锁，在数据提交时才去判断是否发生冲突，version 悲观锁：每
Java并发编程之显式锁机制详解
08-29
主要为大家详细介绍了Java并发编程之显式锁机制的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
并发编程的锁机制：synchronize和lock
李云龙的意大利面
11-14 637
并发编程中，锁是经常需要用到的。我们一起了解一下Java中的锁机制：Synchronized和Lock 1.锁的种类 锁的种类很多，包括自旋锁，自旋锁的其他种类、阻塞锁、可重入锁、读写锁、互斥锁、悲观锁、乐观锁、公平锁等等。我们了解一下如下几种锁：可重入锁、读写锁、可中断锁、公平锁 1.1可重入锁 如果所具备可重入性，则称为可重入锁。synchronized和ReentrantLock都是可重入锁，可重入性可以理解为表明锁的分配机制：基于线程的分配，而不是基于方法调用的分配。例如，当一个线程执行到m
深入理解 Java 并发锁
静默虚空的专栏
01-13 1080
???? 本文以及示例源码已归档在 javacore 一、并发锁简介 确保线程安全最常见的做法是利用锁机制（Lock、sychronized）来对共享数据做互斥同步，这样在同一个时刻，只有一个线程可以执行某个方法或者某个代码块，那么操作必然是原子性的，线程安全的。 在工作、面试中，经常会听到各种五花八门的锁，听的人云里雾里。锁的概念术语很多，它们是针对不同的问题所提出的，通过简单的梳理，也不难理...
并发 - 锁机制
最新发布
weixin_43191747的博客
04-03 943
乐观锁总是假设最好的情况，认为共享资源每次被访问的时候不会出现问题，线程可以不停地执行，无需加锁也无需等待，只是在提交修改的时候去验证对应的资源是否被其它线程修改了。一般使用版本号机制或 CAS 算法，在 Java 中java.util.concurrent.atomic包下面的原子变量类（比如AtomicInteger、LongAdder）就是使用了乐观锁的一种实现方式 CAS 实现的。版本号机制。
线程并发和锁的了解
筑基修士@韩跑跑
11-03 417
多理解多操作
并发编程下的锁机制，乐观锁、悲观锁、共享锁、排他锁、分布式锁、锁降级原理篇
12-21
一、悲观锁 比较悲观，担心拿数据时被别人修改，所以查询时先加锁在修改，保证操作时别人修改不了，期间需要访问该数据的都会等待。...其他用户可以并发读取数据， 但不能修改，增加，删除数据。资源共享。 select name
锁机制基础 - 并发编程 Part 1
07-29
锁机制基础
Java多线程并发编程和锁原理解析
08-25
在Java多线程并发编程中，锁机制是非常重要的，乐观锁和悲观锁是两种常见的锁机制。乐观锁顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有...
【高并发基础】基本锁算法及原理
qq_43840665的博客
07-22 379
系列综述：💞目的：本系列是个人整理为了秋招面试的，整理期间苛求每个知识点，平衡理解简易度与深入程度。🥰来源：材料主要源于多处理器编程的艺术进行的，每个知识点的修正和深入主要参考各平台大佬的文章，其中也可能含有少量的个人实验自证。🤭结语：如果有帮到你的地方，就和！！🌈。
锁与并发总结
黑猫
03-06 253
锁与并发面试总结 2022
JAVA基础-多线程中锁机制
骑牛小道士
11-22 2259
JAVA基础-多线程锁机制
线程锁机制
qq_41694204的博客
09-29 193
互斥量（也称为互斥锁）出自POSIX线程标准，可以用来同步同一进程中的各个线程。当然如果一个互斥量存放在多个进程共享的某个内存区中，那么还可以通过互斥量来进行进程间的同步。 互斥量，从字面上就可以知道是相互排斥的意思，它是最基本的同步工具，用于保护临界区（共享资源），以保证在任何时刻只有一个线程能够访问共享的资源。 /* Initialize a mutex. */ int pthread...
给你讲明白MySQL的乐观锁和悲观锁
m0_69234258的博客
12-07 2058
彻底明白MySQL的乐观锁和悲观锁
Java源码学习之并发编程-锁-Java中8种锁机制
weixin_37627646的博客
07-14 790
​ 在ReentrantLock中包含了公平锁和非公平锁两种锁。 如果你用默认的构造函数来创建ReentrantLock对象，默认的锁策略就是非公平的。 ​ 多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。 优点：所有的线程都能得到资源，不会饿死在队列中。 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。 公平锁图示： 图示1： ​ 咱们重新回到第一张图，就是线程1刚刚释放锁之后，线程2还没来得及重新加锁的那个状
java高并发的处理--锁机制
zhigang1007的博客
12-27 8893
对于我们开发的网站，如果网站的访问量非常大的话，那么我们就需要考虑相关的并发访问问题了。而并发问题是绝大部分的程序员头疼的问题， 但话又说回来了，既然逃避不掉，那我们就坦然面对吧~今天就让我们一起来研究一下常见的并发和同步吧。 为了更好的理解并发和同步，我们需要先明白两个重要的概念:同步和异步    1、同步和异步的区别和联系  　　所谓同步，可以理解为在执行完一个函数或方
并发编程---锁
weixin_45063957的博客
08-06 173
1、锁的分类 自旋锁： 线程状态及上下文切换消耗系统资源，当访问共享资源的时间短，频繁上下文切换不值得。jvm实现，使线程在没获得锁的时候，不被挂起，转而执行空循环，循环几次之后，如果还没能获得锁，则被挂起 阻塞锁：阻塞锁改变了线程的运行状态，让线程进入阻塞状态进行等待，当获得相应的信号（唤醒或者时间）时，才可以进入线程的准备就绪状态，转为就绪状态的所有线程，通过竞争，进入运行状态 重入锁:支持线程再次进入的锁,就跟我们有房间钥匙，可以多次进入房间类似 读写锁： 两把锁，读锁跟写锁，写写互斥、读写互
多线程——并发锁的集结号
追梦
08-27 791
上次我们说了一下多线程的管理，今天我们来看一下多线程的锁。 1、不同的加锁方式 类锁：在代码中的方法上加了static和synchronized的锁，或者synchronized(xxx.class）的代码段 对象锁：在代码中的方法上加了synchronized的锁，或者synchronized(this）的代码段 ··············· 今天我们总结了一下多线程中的锁，以后我们会继续分享关于锁的学习。
Java 并发编程硬核资料.pdf
09-19
Java 并发编程硬核资料

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

互联网小阿祥

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

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

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

打赏作者

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

抵扣说明：

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

余额充值