详解Lock锁

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

一.售票案例

        1.传统synchronized实现

package com.yu.lock;

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

public class Test2 {
    public static void main(String[] args) {
        Ticked ticked = new Ticked();
        new Thread(()->{for (int i = 0; i <40 ; i++)ticked.ticked();},"A").start();
        new Thread(()->{for (int i = 0; i <40 ; i++)ticked.ticked();},"B").start();
        new Thread(()->{for (int i = 0; i <40 ; i++)ticked.ticked();},"C").start();

    }
}

//传统synchronized锁
class Ticked{
    private int sum = 30;
    //卖票
    public synchronized void ticked(){
        if(sum>0){
            System.out.println(Thread.currentThread().getName()+"卖出第"+(sum--)+"张票，还剩"+sum+"张票");
        }
    }
}

        2.Lock实现

package com.yu.lock;

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

public class Test2 {
    public static void main(String[] args) {
        Ticked2 ticked2 = new Ticked2();
        new Thread(()->{for (int i = 0; i <40 ; i++)ticked2.ticked();},"A").start();
        new Thread(()->{for (int i = 0; i <40 ; i++)ticked2.ticked();},"B").start();
        new Thread(()->{for (int i = 0; i <40 ; i++)ticked2.ticked();},"C").start();
    }
}

//JUC--Lock锁

class Ticked2{
    private int sum = 30;
    Lock lock = new ReentrantLock();//获取Lock锁

    public void ticked(){
        lock.lock();//加锁
        try {
            if(sum>0){
                System.out.println(Thread.currentThread().getName()+"卖出第"+(sum--)+"张票，还剩"+sum+"张票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();//解锁
        }
    }
}

        Lock接口的实现类 

                ReentrantLock：可重入锁（常用）--默认为非公平锁

                ReentrantReadWriteLock.ReadLock：读锁

                ReentrantReadWriteLock.WriteLock：写锁

                公平锁：十分公平，先来后到。

                非公平锁：十分不公平，可以插队。

二.Synchronized和Lock的区别

        1.Synchronized是内置的Java关键字，Lock是Java的一个接口

        2.Synchronized无法判断锁的状态，Lock可以判断是否获取到了锁

        3.Synchronized会自动释放锁，Lock必须手动释放锁，否则会死锁

        4.Synchronized 线程1（获得锁，阻塞），线程2（等待，傻傻的等），Lock锁不一定会等下去

        5.Synchronized可重入锁，不可以中断，非公平，Lock锁，可重入锁，可以判断锁，非公平（可以自己设置）

        6.Synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码块

三.生产者，消费者问题

        1.Synchronized版

package com.yu.lock;
//生产者消费者问题
/**
 * A  B  线程交替执行操作同一个sum
 * A sum+1
 * B sum-1
 */
public class Test3 {
    public static void main(String[] args) {
        Date date = new Date();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    date.number1();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    date.number2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    date.number1();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    date.number2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }

}

//传统消费者，生产者问题
class Date{

    private int sum = 0;

    public synchronized void number1() throws InterruptedException {

        if(sum!=0){//线程等待
            this.wait();
        }
        sum++;
        System.out.println(Thread.currentThread().getName()+"=>"+sum);
        this.notifyAll();//通知其他线程
    }

    public synchronized void number2() throws InterruptedException {

        if(sum==0){//线程等待
            this.wait();
        }
        sum--;
        System.out.println(Thread.currentThread().getName()+"=>"+sum);
        this.notifyAll();//通知其他线程
    }

}

        发现运行后的结果并不是我们想要的，其实这是出现了虚假唤醒，简单的来说就是线程可以唤醒，但不会被通知，中断或超时。所以需要将if判断改为while判断，就可以解决虚假唤醒问题

package com.yu.lock;
//生产者消费者问题
/**
 * A  B  线程交替执行操作同一个sum
 * A sum+1
 * B sum-1
 */
public class Test3 {
    public static void main(String[] args) {
        Date date = new Date();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    date.number1();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    date.number2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    date.number1();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    date.number2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }

}

//传统消费者，生产者问题
class Date{

    private int sum = 0;

    /**
     *  使用if判断会发生虚假唤醒，将if改为while即可
     */
    public synchronized void number1() throws InterruptedException {

        while(sum!=0){//线程等待
            this.wait();
        }
        sum++;
        System.out.println(Thread.currentThread().getName()+"=>"+sum);
        this.notifyAll();//通知其他线程
    }

    public synchronized void number2() throws InterruptedException {

        while(sum==0){//线程等待
            this.wait();
        }
        sum--;
        System.out.println(Thread.currentThread().getName()+"=>"+sum);
        this.notifyAll();//通知其他线程
    }

}

        2.Lock版

package com.yu.lock;

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

public class Test4 {
    public static void main(String[] args) {
        Date2 date2 = new Date2();

        new Thread(()->{for (int i = 0; i < 10; i++) {date2.number1();}},"A").start();
        new Thread(()->{for (int i = 0; i < 10; i++) {date2.number2();}},"B").start();
    }
}

class Date2{
    private int sum = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public void number1() {
        lock.lock();
        while (sum!=0){
            try {
                condition.await();//等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        sum++;
        System.out.println(Thread.currentThread().getName()+"=>"+sum);
        //通知其他线程
        condition.signalAll();//唤醒全部
        lock.unlock();
    }

    public void number2() {
        lock.lock();
        while (sum==0){
            //等待
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        sum--;
        System.out.println(Thread.currentThread().getName()+"=>"+sum);
        //通知其他线程
        condition.signalAll();
        lock.unlock();
    }
}

        这是时候可能有人会有疑问，Synchronized和Lock完成的都是一样的内容，何必要有Lock接口呢，要明白，任何一种新的技术，绝对不是仅仅覆盖原来的技术，一定会有优势或补充。

四.Condition的精准通知与唤醒

package com.yu.lock;

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

public class Test5 {
    public static void main(String[] args) {
        Date3 date3 = new Date3();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                date3.print1();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                date3.print2();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                date3.print3();
            }
        },"C").start();
    }
}

class Date3 {

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int num = 1;

    public void print1() {
        lock.lock();
        try {
            while (num != 1) {
                condition1.await();//A等待
            }
            System.out.println(Thread.currentThread().getName()+"=>"+num);
            num++;
            condition2.signal();//B唤醒
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();

        }
    }

    public void print2() {
        lock.lock();
        try {
            while (num!=2){
                condition2.await();//B等待
            }
            System.out.println(Thread.currentThread().getName()+"=>"+num);
            num++;
            condition3.signal();//C唤醒
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print3() {
        lock.lock();
        try {
            while (num!=3){
                condition3.await();//C等待
            }
            System.out.println(Thread.currentThread().getName()+"=>"+num);
            num=1;
            condition1.signal();//A唤醒
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

 五.8锁现象

        判断Synchronized锁到底锁的是什么!

        案例描述：有一个phone类，并实现的打电话和短信两个方法，方法都用Synchronized修饰，创建两个线程，分别运行打电话和发短信的方法，先执行发短信，并使程序sleep一秒，再执行打电话方法，判断先运行那个线程。

        1.标准情况下，两个线程先打印发短信还是打电话？

        2.发短信方法延迟4秒执行，两个线程先打印发短信还是打电话？

package com.yu.lock8;

//锁的8个问题
//1.标准情况下，先打印发短信还是打电话---发短信
//2.发短信延迟4秒，先打印发短信还是打电话---发短信
/**
 * 因为synchronized锁的对象是方法的调用者
 * 两个方法用的是同一个锁，谁先拿到谁先执行
 */

import java.util.concurrent.TimeUnit;

public class Test1 {

    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{phone.sendSms();},"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone.call();},"B").start();
    }

}

class Phone{

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

}

        3.增加了一个普通方法后！先执行发短信还是普通方法？

        4.两个对象，两个同步方法，两个线程先打印发短信还是打电话？

package com.yu.lock8;

import java.util.concurrent.TimeUnit;

//3.增加一个普通方法，先发短信还是hello--hello
//4.两个对象，两个同步方法，先打印发短信还是打电话---打电话
/**
 * 因为普通方法没有锁，不是同步方法
 * 锁的不是同一个实例对象，所以先执行打电话
 */

public class Test2  {

    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
        Phone1 phone2 = new Phone1();
        new Thread(()->{phone1.sendSms();},"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone2.call();},"B").start();
        //new Thread(()->{phone.hello();},"C").start();
    }

}

class Phone1{

    public synchronized void sendSms(){
        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");
    //}
}

        5.增加两个静态的同步方法，只有一个对象，两个线程先打印发短信还是打电话？

        6.两个对象！两个静态同步方法，两个线程先打印发短信还是打电话？

package com.yu.lock8;

import java.util.concurrent.TimeUnit;

//5.增加两个静态同步方法。只有一个对象，先执行发短信还是打电话--发短信
//5.增加两个静态同步方法。有两个对象，先执行发短信还是打电话--发短信

/**
 * 静态同步方法，类一加载就有了，锁的是Class模板，并不是锁的实例对象。
 * 两个对象的Class模板只有一个，
 */

public class Test3  {

    public static void main(String[] args) {
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        new Thread(()->{phone1.sendSms();},"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone2.call();},"B").start();
        //new Thread(()->{phone.hello();},"C").start();
    }

}

class Phone2{

    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

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

        7.一个静态同步方法，一个普通同步方法，一个对象，两个线程先打印发短信还是打电话？

        8.一个静态同步方法，一个普通同步方法，两个对象，两个线程先打印发短信还是打电话？

package com.yu.lock8;

import java.util.concurrent.TimeUnit;

//一个静态同步方法，一个普通同步方法，一个对象，先打印发短信还是打电话---打电话
//一个静态同步方法，一个普通同步方法，两个对象，先打印发短信还是打电话---打电话

/**
 * 静态同步方法锁的是Class模板，普通同步方法锁的是方法的调用对象
 * */

public class Test4 {
    public static void main(String[] args) {
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        new Thread(()->{phone1.sendSms();},"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone2.call();},"B").start();
        //new Thread(()->{phone.hello();},"C").start();
    }

}

class Phone3{

    public static synchronized void sendSms(){
        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");
    //}
}

        结论 ：1.Synchronized锁的对象是方法的调用者

                    2.static 静态方法，与类一起加载，Synchronized锁的是Class。

张凝羽
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#中lock用法详解
01-20
本文实例讲述了C#中lock的用法。分享给大家供大家参考。具体分析如下： lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。 先来看看执行过程，代码示例如下： lock 语句用于获取某个给定对象的互斥锁，执行一个语句，然后释放该锁。 lock-statement:(lock 语句：) 代码如下:lock(expression) embedded-statement(lock   (   表达式   )   嵌入语句) lock 语句的表达式必须表示一个引用类型的值。永远不会为 lock 语句中的表达式执行隐式装箱转换，
Java并发编程系列之十六：Lock锁
rhwayfun专栏
04-05 4757
Lock锁简介Lock锁机制是JDK 5之后新增的锁机制，不同于内置锁，Lock锁必须显式声明，并在合适的位置释放锁。Lock是一个接口，其由三个具体的实现：ReentrantLock、ReetrantReadWriteLock.ReadLock 和 ReetrantReadWriteLock.WriteLock，即重入锁、读锁和写锁。增加Lock机制主要是因为内置锁存在一些功能上局限性。比如无法中
java的Lock锁原理详解.docx
07-04
同样是锁，先说说synchronized和lock的区别： 1.synchronized是java关键字，是用c++实现的；而lock是用java类，用java可以实现 2.synchronized可以锁住代码块，对象和类，但是线程从开始获取锁之后开发者不能进行控制和了解；lock则用起来非常灵活，提供了许多api可以让开发者去控制加锁和释放锁等等。
Java多线程-新特征-锁(上)
weixin_34281477的博客
07-25 167
在Java5中，专门提供了锁对象，利用锁可以方便的实现资源的封锁，用来控制对竞争资源并发访问的控制，这些内容主要集中在java.util.concurrent.locks 包下面，里面有三个重要的接口Condition、Lock、ReadWriteLock。 Condition: Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对...
[锁 Lock] Lock lock = new ReentrantLock()之自增序列号
汤圆的博客
12-22 865
前言: 我们有一个业务场景，必须生成唯一的自增序列号(作为订单号，订单号的组成是 区县+年月日+后8位序列号，这里的序列号我们使用了 前缀， 例如自增为1的时候 后8位显示为 00000001), 使用介绍场景: tryLock 是防止自锁的一个重要方式。 //学习 tryLock tryLock()方法是有返回值的，返回值是Boolean类型。它表示的是用来尝试获取锁：成功获取则返回true；获取失败则返回false，这个方法无论如何都会立即返回。不会像synchroniz...
11.Lock锁
khmff的博客
04-05 603
1.创建Lock锁对象的方式：使用实现类ReentrantLock创建Lock对象。 (1)Lock lock=new ReentrantLock(); 注：相当于synchronized(this)。 (2)static Lock lock=new ReentrantLock(); 注：相当于synchronized(类.class)。 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.Reent
线程基础（八）Reentrantlock重入锁
踟蹰千年的博客
01-18 242
ReentrantLock ReentrantLock，一个可重入的互斥锁，它具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。 ReentrantLock基本用法 /** * 重入锁 */ public class ReentrantLockTest { int count =0; public static void mai...
并发编程——ReentrantLock
eyes++的博客
03-05 865
从Java 5开始，引入了一个高级的处理并发的包，它提供了大量更高级的并发功能，能大大简化多线程程序的编写。我们知道Java语言直接提供了synchronized关键字用于加锁，但这种锁一是很重，二是获取时必须一直等待，没有额外的尝试机制。而包提供的ReentrantLock用于替代synchronized加锁。
Lock的使用（二）——使用ReentrantLock类
qq_44307209的博客
08-22 213
可以先对线程进行分组，然后再唤醒指定组中的线程。Object类中的 wait(long timeout)方法相当于Condition类中的await(long time,TimeUnit unit)方法。Object类中的notifyAll()方法相当于Condition类中的signalAll()方法。Object类中的notify()方法相当于Condition类中的signal()方法。Object类中的wait()方法相当于Condition类中的await()方法。成功实现等待/通知模式。
并发编程7-Lock锁系列 ReentrantLock
ming13849012515的博客
05-15 653
目录 前言 加锁目的 Lock 锁的继承体系 Lock 顶层接口分析 可重入锁ReentrantLock ReentrantLock 公平锁和非公平锁是什么？有什么区别？ ReentrantLock源码分析 类的继承关系 类的内部类 Sync类 NonfairSync类 FairSyn类 类的属性 类的构造函数 核心函数分析 应用示例： 参考推荐： 前言 加锁目的 序列化访问临界资源，即同一时刻只能有一个线程访问临界资源(同步互斥访问) 首先明确：Lock
详解Linux文件锁flock
01-10
在多个进程同时操作同一份文件的过程中，很容易导致文件中的数据混乱，需要锁操作来保证... LOCK_SH，共享锁，多个进程可以使用同一把锁，常被用作读共享锁； LOCK_EX，排他锁，同时只允许一个进程使用，常被用作写
java 锁 Lock接口详解.docx
06-21
Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性...
对python多线程中互斥锁Threading.Lock的简单应用详解
09-19
今天小编就为大家分享一篇对python多线程中互斥锁Threading.Lock的简单应用详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
ReentrantLock(重入锁)功能详解和应用演示
xyz的专栏
07-07 747
例子 public class ReentrantLockTest { public static void main(String[] args) throws InterruptedException { ReentrantLock lock = new ReentrantLock(); for (int i = 1; i <= 3; i++) { lock.lock(); } for(int
线程锁--普通锁 Lock lock = new ReentrantLock();
qq_28958027的博客
09-03 1520
https://blog.csdn.net/u014236541/article/details/50301163
Java并发—java.util.concurrent.locks包
Rookie20190715的博客
08-28 287
Java并发—java.util.concurrent.locks包 一.synchronized的缺陷 synchronized是java中的一个关键字，也就是说是Java语言内置的特性。那么为什么会出现Lock呢？ 如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：...
Java并发编程知识点总结（十一）——ReentrantLock实现原理
XHHP
09-08 715
ReentrantLock意思为可重入锁，也就是能够多重加锁。并且加了多少次锁，也必须对应解锁多少次。此外，ReentrantLock支持公平锁和非公平锁，是基于AQS进行实现的。【基本功】不可不说的Java“锁”事公平锁：按照AQS的FIFO的同步队列的时间顺序获取锁，不会存在饥饿现象。非公平锁：有可能刚刚释放锁的线程又重新获得锁，可能会出现线程饥饿现象。下面我们来看下ReetrantLock和synchronizer之间的对比，如下图：AQS中实现了独占锁和共享锁的框架。
多线程(二) -- 管程(六) -- ReentrantLock详解
weixin_39724194的博客
07-16 746
概述： ReentrantLock，一个可重入的互斥锁，它具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。 基本使用： public class ReentrantLockTest1 { private Lock lock = new ReentrantLock(); public void test() { try { lock.lock(); for (int i =
java jar包如何运行或调用
最新发布
NLP与推荐算法
05-08 127
java服务启动
python中lock锁和阻塞_详解Python中的Lock和Rlock
06-13
在Python中，Lock和Rlock都是用来控制并发访问共享资源的工具，它们可以防止多个线程同时访问共享资源而产生冲突。 Lock和Rlock都是通过线程的acquire()和release()方法来控制的。在调用acquire()方法时，如果锁已经被其他线程占用，则当前线程会被阻塞，直到锁被释放为止。在调用release()方法时，线程会释放锁。 但是，Lock和Rlock有一些区别。 Lock是一个简单的锁，它只有两个状态：锁定和未锁定。当一个线程获得了锁，其他线程只能等待锁被释放。如果一个线程多次调用acquire()方法，那么它就会阻塞，直到调用相同次数的release()方法为止。 而Rlock是可重入锁，它可以被同一个线程多次请求。也就是说，一个线程可以在没有释放锁的情况下多次调用acquire()方法，而不会被阻塞。只有当一个线程调用了相同次数的release()方法时，锁才会被释放。 在多线程编程中，如果需要对同一个锁进行多次操作，那么就应该使用Rlock。对于其他情况，使用Lock即可。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值