Lock锁重点

最新推荐文章于 2024-06-09 18:24:15 发布
最新推荐文章于 2024-06-09 18:24:15 发布
阅读量172 收藏
点赞数
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bubbleJessica/article/details/129806560
版权

回顾一下sleep和wait区别

  • sleep来自Thread类，wait来自Object类
  • sleep睡觉抱着锁不会释放锁，wait会释放锁
  • sleep可以在任何地方使用，而wait必须在同步代码块中使用
  • sleep需要捕获异常，而wait不需要

并发编程本质：充分利用CPU资源 

并发：多线程操作同一资源（CPU单核，模拟出来多条线程，天下武功，唯快不破，快速交替）

并行：多个人一起行走 （CPU多核，多个线程可以同时执行，线程池）

线程有几个状态 

public enum State {
        // 新生 
        NEW,
        // 运行
        RUNNABLE,
        // 阻塞
        BLOCKED,
        // 等待，死死地等
        WAITING,
        // 超时等待 （过时不等）    
        TIMED_WAITING,
        // 终止
        TERMINATED;
}

传统的synchronized锁

package com.kuang.demo01;

// 基本的卖票例子

/**
 * 真正的多线程开发，公司中的开发
 *  线程就是一个单独的资源类，没有任何附属的操作
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        // 并发 多线程操作同一个资源类
        final Ticket ticket=new Ticket();
        // 函数式接口
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"C").start();
    }

}

// 资源类 OOP
class Ticket{
    private int number=50;
    // 卖票的方式
    // synchronized 本质：队列，锁
    public synchronized void sale(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"票，剩余："+number);
        }
    }
}

Lock锁接口（常用ReentrantLock类可重入锁）

// 资源类 OOP
// Lock三部曲
// 1、new ReentrantLock()
// 2、lock.lock() 加锁
// 3、lock.unlock() 解锁
class Ticket2{
    private int number=30;
    Lock lock=new ReentrantLock();//可重入锁
    // 卖票的方式
    public void sale(){
        lock.lock();
        try{
            // 业务代码
            if (number>0){
                System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"票，剩余："+number);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

Synchronized和Lock区别

  • Synchronized是java关键字，Lock是Java类
  • Synchronized是自动释放锁的，而Lock必须手动释放锁，否则就会死锁
  • Synchronized适合锁少量的代码同步问题，而Lock适合锁大量的代码同步
  • Synchronized是无法判断获取锁的状态，而Lock可以判断是否获取到了锁
  • Synchronized是可重入锁，不可以中断的，非公平锁，而Lock是可重入锁，可判断，非公平锁（可设置）
  • Synchronized 线程1（获得锁，阻塞）线程2（阻塞，傻傻的等）而Lock不一定会等待下去

面试点：单例模式、排序算法、生产者和消费者、死锁 

传统的生产者和消费者

package com.kuang.pc;

// 线程之间的通信问题：生产者和消费者问题
// 线程交替执行 线程A B操作同一个变量
public class A {
    public static void main(String[] args) {
        Data data=new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

// 资源类
// 判断等待 业务 通知
class Data{
    private int number=0;
    public synchronized void increment() throws InterruptedException {
        while (number!=0){
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        while (number==0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }
}

注意点：当超过2个线程则判断等待时必须使用while，不能用if，因为会出现虚假唤醒情况（防止），即线程被唤醒，但不会通知、中断或者超时 

Lock版的生产者和消费者 

package com.kuang.pc;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class B {
    public static void main(String[] args) {
        Data2 data=new Data2();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

// 资源类
// 判断等待 业务 通知
class Data2{
    private int number=0;
    Lock lock=new ReentrantLock();
    Condition condition=lock.newCondition();

    public void increment() throws InterruptedException {
        lock.lock();
        try{
            // 业务
            while (number!=0){
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void decrement() throws InterruptedException {
        lock.lock();
        try{
            // 业务
            while (number==0){
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

Condition精准的通知和唤醒线程

package com.kuang.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
// 先执行线程A 再执行B 后执行C 一直保持这个顺序
public class C {
    public static void main(String[] args) {
        Data3 data=new Data3();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"C").start();
    }
}

class Data3{
    private Lock lock=new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    private int number=1;
    public void printA(){
        lock.lock();
        try {
            while (number!=1){
                condition1.await();
            }
            number=2;
            System.out.println(Thread.currentThread().getName()+"---->AAA");
            condition2.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            while (number!=2){
                condition2.await();
            }
            number=3;
            System.out.println(Thread.currentThread().getName()+"---->BBB");
            condition3.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            while (number!=3){
                condition3.await();
            }
            number=1;
            System.out.println(Thread.currentThread().getName()+"---->CCC");
            condition1.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

八锁现象

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;
// 结果都是先发短信后打电话
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{phone.sendMsg();},"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone.call();},"B").start();
    }
}

class Phone{
    // synchronized锁的对象是方法的调用者
    // 两个方法使用的是同一把锁，谁先获取到谁先执行
    public synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }
}

synchronized锁的对象是方法的调用者 两个方法使用的是同一把锁，谁先获取到谁先执行 

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;
// 3、增加了1个普通方法后，1s后先打印hello，等到了4s打印发短信
// 4、两个对象，两个同步方法，先打电话再发短信
public class Test2 {
    public static void main(String[] args) {
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        new Thread(()->{phone1.sendMsg();},"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //new Thread(()->{phone.hello();},"B").start();
        new Thread(()->{phone2.call();},"B").start();
    }
}

class Phone2{
    // synchronized锁的对象是方法的调用者
    // 两个方法使用的是同一把锁，谁先获取到谁先执行
    public synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

    //
    public void hello(){
        System.out.println("hello");
    }
}

这里两个对象调用即有2把锁，这时根据等待时间长短决定谁先执行 结果即先打电话后发短信

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;
// 5、增加2个静态的同步方法 一个对象调用
// 6、增加2个静态的同步方法  两个对象调用
// 结果：先发短信再打电话
public class Test3 {
    public static void main(String[] args) {
        // 两个对象都来自Class,记住锁的是Class（因为同步方法加了static）
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        new Thread(()->{phone1.sendMsg();},"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone2.call();},"B").start();
    }
}
class Phone3{
    // 类一加载就有了，锁的是Class模板
    public static synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }

}

加了static的同步方法，锁的是Class，所以不管是几个对象调用，谁先获取锁谁就先执行

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

// 7、1个静态同步方法 1个同步方法 1个对象
// 8、1个静态同步方法 1个同步方法 2个对象
public class Test4 {
    public static void main(String[] args) {
        // 两个对象都来自Class,记住锁的是Class（因为同步方法加了static）
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        new Thread(()->{phone1.sendMsg();},"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone2.call();},"B").start();
    }
}

class Phone4{
    // 类一加载就有了，锁的是Class模板
    public static synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    // synchronized锁的对象是方法的调用者
    public synchronized void call(){
        System.out.println("打电话");
    }
}

 先打电话再发短信因为静态同步方法锁的是Class，而普通同步方法锁的方法的调用者

bubbleJessica
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高薪程序员&面试题精讲系列66之你熟悉Lock锁吗？说说Lock锁的底层原理吧
一一哥
02-21 938
一. 面试题及剖析 1. 今日面试题 Lock锁有哪些实现类，分别有什么功能？ Lock锁的底层原理如何？ 你的项目中哪里用过可重入锁(ReentrantLock)？ 2. 题目剖析 在上一篇文章中，壹哥给大家介绍了Lock锁的基本特性，接下来我会继续介绍Lock锁的底层原理，这才是我们面试时的重中之重，并且会在本文中分析synchronize与Lock锁的区别。 二. Lock锁的底层原理分析 1. 底层原理(重点) 我们知道Lock是一个接口，平时在使用时，都是使用该接口的某个子类
【Java并发编程】显式锁：Lock接口
weixin_44735928的博客
08-17 693
Lock
Lock锁操作机制
m0_54202121的博客
04-21 2016
什么是Lock锁 Lock 锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允 许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对 象。Lock 提供了比 synchronized 更多的功能。 Lock 与的 Synchronized 区别 Lock 不是 Java 语言内置的，synchronized 是 Java 语言的关键字，因此是内置特性。Lock 是一个类，通过这个类可以实现同步访问； Lock 和 synchronized 有一点非常大的不同，采用 synch
Lock锁源码分析
weixin_58289438的博客
02-22 618
lock源码详解
Lock锁的使用
WeiLaiKeQiLx的博客
07-29 359
Lock锁的使用 首先简单介绍一下Lock锁 Lock是java1.5后的一个接口 咱们这使用它的一个接口实现**ReentrantLock** private Lock lock=new ReentrantLock(); @Async("doSomethingExecutor") public CompletableFuture<String> doSomething2(String message) throws InterruptedEx
21.Lock锁原理
纵横千里 捭阖四方 的专栏
09-18 2012
理解AQS是打开JUC的钥匙，而如果要知道如何开门，那必须搞清楚Lock加锁和释放锁的整个过程到底是怎样的。理解了AQS的功能之后，我们再来看一下Lock锁以及几种典型锁的完整实现过程。其中look就是加锁，而tryLock就是尝试加锁，释放锁就是unlock，condition的问题，我们后面再说。在Lock接口上的注释也注明了，实现该接口主要是单个类:重入锁ReentrantLock、读写锁ReadWriteLock，另外从jdk8开始又增加了优化的读写锁StampedLock。
2.Lock锁（重点）
yuan_boss的博客
07-21 157
2.Lock锁（重点） 文章目录2.Lock锁（重点）传统synchronized代码实现Lock锁synchronized与Lock锁区别 传统synchronized //真正的多线程开发，公司中的开发，要降低耦合性 //线程就是一个单独的资源类，没有任何附属操作(所以使用Lambda表达式) // 1.属性、方法 代码实现 public class SaleTicketDemo01 { public static void main(String[] args) { //并
面试题精讲系列之锁-synchronized与Lock锁
liuerchong的博客
03-20 1703
锁分类 Java锁分类 分类标准 分类 根据线程是否需要对资源加锁 悲观锁/乐观锁 根据多个线程是否能获取同一把锁 共享锁/独享(独占、排他)锁 根据锁是否能够重复获取 可重入锁/不可重入锁 根据锁的公平性进行区分 公平锁/非公平锁 当多个线程并发访问资源时，当使用synchronized时 锁升级(偏向锁/轻量级锁/重量级锁) 根据资源被锁定后，线程是否阻塞 自旋锁/适应性自旋锁 悲观锁 VS 乐观锁 首先我们来看看悲观锁与乐观锁。 其实这里无论是悲观锁还是乐观锁，都
Oracle Lock 锁
基于Oracle11G
07-08 2961
Oracle　RDBMS的封锁类型可分为如下三类
redis-distribute-lock:Redis分布式锁的try-with-resources实现
05-17
今天我们重点说一下基于redis的分布式锁，redis分布式锁的实现我们可以参照。 实现Redis分布式锁的最简单的方法就是在Redis中创建一个key，这个key有一个失效时间（TTL)，以保证锁最终会被自动释放掉。当客户端释放...
rust-lock-bug-detector:静态检测MIR上的双锁和冲突锁错误
04-09
锈锁错误检测器静态检测MIR上的双锁和冲突锁错误。 这项工作是对我们详细研究Rust的后续工作，该研究在PLDI'20中中的问题。 我很荣幸能与Chen Yilun Chen共同发表第一作者，并且能够与具有远见，知识渊博，勤奋工作...
react-focus-lock:这是一个陷阱！ 焦点锁定。 :unlocked:
04-28
重点任务。 它可以带您回去，因为您可以将用户“锁定”在组件内部。 任何其他情况，当您必须锁定用户的意图和焦点时，如果这正是a11y所要求的。值得信赖受到 ， ， ， 的信任，我们也会尽最大努力赢得您的信任！...
vue-focus-lock:这是一个陷阱！ 焦点锁定。 A11y util，用于确定焦点
05-09
重点任务。 它将带你回去。 您必须在每个模式对话框中使用它，否则您将很a11y 。 如何使用 只需用聚焦锁包裹东西，安装时聚焦就会moved inside 。 You can not leave this form < button @click =" onClick...
YOGA-S740:hackintosh
05-07
CFG lock: Disabled (changed)（重点！必须完成） DVMT: 160M (changed)（重点！必须完成） 重点！重点！重点！ CFG Lock 必须解锁 DVMT设置必须64M或者更高（设置最高最好之所以不使用-dvmt修复是因为能修改硬件就...
从Android应用层及Framework层的角度分析WakeLock锁机制
IT先森
11-20 2595
    从Android实战角度来分析分析WakeLock锁机制 前言   好久没有写点实战类型的博客了，最近一直都在捣鼓源码分析和项目相关事情，是时候来点实战类型的博客了。捯饬点啥实战的呢，正好前两天有一个同事询问我关于Android的WakeLock锁相关的问题，这里我们就从实战的角度出发来对Android的WakeLock锁机制分析一番。 注意：本篇的介绍是基于Android 7.xx平台为基础的，其中涉及的代码路径如下： frameworks/base/core/java/android/os/P
简单的项目部署脚本（转载）
u010230019的博客
06-09 658
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
最新发布
m0_74100417的博客
06-09 1467
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 478
修改菜品——后端Java
unique_lock解锁
04-24
在C++中，unique_lock是一个用于管理互斥锁的RAII（资源获取即初始化）类。它提供了一种更灵活的方式来管理互斥锁的加锁和解锁操作。 unique_lock的解锁操作非常简单，只需要调用其成员函数unlock()即可。例如： ```cpp #include <iostream> #include <mutex> std::mutex mtx; void foo() { std::unique_lock<std::mutex> lock(mtx); // 互斥锁已经在构造unique_lock对象时被加锁 // 执行一些需要保护的操作 // 解锁互斥锁 lock.unlock(); // 在解锁后可以执行一些不需要互斥保护的操作 // 再次加锁互斥锁 lock.lock(); // 执行一些需要保护的操作 // 解锁互斥锁 lock.unlock(); } int main() { foo(); return 0; } ``` 在上面的示例中，我们首先创建了一个std::mutex对象mtx，然后在函数foo()中创建了一个unique_lock对象lock，并将mtx作为参数传递给它。在unique_lock对象的构造函数中，互斥锁会被自动加锁。然后我们可以执行一些需要保护的操作。当我们调用lock.unlock()时，互斥锁会被解锁，这样我们就可以执行一些不需要互斥保护的操作。最后，我们可以再次调用lock.lock()来重新加锁互斥锁，并执行一些需要保护的操作。最后，当unique_lock对象超出作用域时，析构函数会自动解锁互斥锁。 需要注意的是，unique_lock对象的unlock()和lock()成员函数可以在任何时候调用，而不仅仅是在构造函数和析构函数中。这使得我们可以更灵活地控制互斥锁的加锁和解锁操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值