多线程(五)线程同步(中)－Lock，Condition, ReadWriteLock

最新推荐文章于 2024-07-09 09:44:36 发布
最新推荐文章于 2024-07-09 09:44:36 发布
阅读量2.4k 收藏 1
点赞数
分类专栏： 多线程 文章标签： 多线程 Lock Condition RWL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012834750/article/details/68068115
版权

  线程同步（上）提到了七种同步方式，讲述了四种，剩下三种，大家可以继续深入了解下：
上篇博文地址：多线程(四) 线程同步(上)

<五>Lock 接口

Lock是java.util.concurrent.locks包下的接口，源码如下，注意相关接口：

package java.util.concurrent.locks;
import java.util.concurrent.TimeUnit;

 *
 * @see ReentrantLock
 * @see Condition
 * @see ReadWriteLock
 *
 * @since 1.5
 * @author Doug Lea
 */
public interface Lock {

    void lock();    

    void lockInterruptibly() throws InterruptedException;

    boolean tryLock();

    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock();

    Condition newCondition();
}

需要注意的类：
ReentrantLock：
public class ReentrantLock implements Lock, java.io.Serializable ｛｝

Condition ：接口
public interface Condition｛｝

ReadWriteLock 接口
public interface ReadWriteLock｛｝

ReentrantReadWriteLock：
public class ReentrantReadWriteLock
implements ReadWriteLock, java.io.Serializable｛｝

Lock的特性:

　　1).Lock不是Java语言内置的;

　　2).synchronized是在JVM层面上实现的,如果代码执行出现异常,JVM会自动释放锁,但是Lock不行,要保证锁一定会被释放,就必须将unLock放到finally{}中(手动释放);

　　3).在资源竞争不是很激烈的情况下,Synchronized的性能要优于ReetarntLock,但是在很激烈的情况下,synchronized的性能会下降几十倍;

　　4).ReentrantLock增加了锁:

　　　　a. void lock(); // 无条件的锁;

　　　　b. void lockInterruptibly throws InterruptedException;//可中断的锁;

解释:使用ReentrantLock如果获取了锁立即返回,如果没有获取锁,当前线程处于休眠状态,直到获得锁或者当前线程可以被别的线程中断去做其他的事情;但是如果是synchronized的话,如果没有获取到锁,则会一直等待下去;

　　　　c. boolean tryLock();//如果获取了锁立即返回true,如果别的线程正持有,立即返回false,不会等待;

　　　　d. boolean tryLock(long timeout,TimeUnit unit);//如果获取了锁立即返回true,如果别的线程正持有锁,会等待参数给的时间,在等待的过程中,如果获取锁,则返回true,如果等待超时,返回false;

ReentrantLock及ReadWriteLock的使用方式，推荐大家看这篇博文：锁对象Lock-同步问题更完美的处理方式

  在这里要介绍的是Condition：

Condition的特性:

　　　　1.Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。不同的是，Object中的这些方法是和同步锁捆绑使用的；而Condition是需要与互斥锁/共享锁捆绑使用的。

　　　　2.Condition它更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。
　　　　例如，假如多线程读/写同一个缓冲区：当向缓冲区中写入数据之后，唤醒”读线程”；当从缓冲区读出数据之后，唤醒”写线程”；并且当缓冲区满的时候，”写线程”需要等待；当缓冲区为空时，”读线程”需要等待。

　　　　 如果采用Object类中的wait(), notify(), notifyAll()实现该缓冲区，当向缓冲区写入数据之后需要唤醒”读线程”时，不可能通过notify()或notifyAll()明确的指定唤醒”读线程”，而只能通过notifyAll唤醒所有线程(但是notifyAll无法区分唤醒的线程是读线程，还是写线程)。 但是，通过Condition，就能明确的指定唤醒读线程。

示例代码：

package com.blog.spring.thread;

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

public class ConditionTask {

    private final Lock lock = new ReentrantLock();

    private final Condition addCondition = lock.newCondition();

    private final Condition subCondition = lock.newCondition();

    private static int num = 0;
    private List<String> lists = new LinkedList<String>();

    public void add() {
        lock.lock();

        try {
            System.out.println("==============当前添加线程："+Thread.currentThread().getName()+"================");
            while(lists.size() == 3) {//当集合已满,则"添加"线程等待
                System.out.println("当前集合大小为: " + lists.size()+"-->集合已满，添加线程"+Thread.currentThread().getName()+"开始等待，去唤醒减少线程");
                this.subCondition.signal();
                addCondition.await();
            }

            num++;
            String str="元素" + num;
            lists.add(str);
            System.out.println("添加 [" + str + "]");
            System.out.println("当前集合大小为: " + lists.size());
            System.out.println("当前添加线程为: " + Thread.currentThread().getName());
            System.out.println("==============去唤醒减少线程================");
            this.subCondition.signal();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {//释放锁
            lock.unlock();
        }
    }


    public void sub() {
        lock.lock();

        try {
            System.out.println("==============当前减少线程："+Thread.currentThread().getName()+"================");
            while(lists.size() == 0) {//当集合为空时,"减少"线程等待
                System.out.println("当前集合大小为: " + lists.size()+"-->集合为空，减少线程"+Thread.currentThread().getName()+"开始等待,去唤醒添加线程");
                addCondition.signal();
                subCondition.await();
            }

            num--;
            String str = lists.get(0);
            lists.remove(0);
            System.out.println("移除 [" + str + "]");
            System.out.println("当前集合大小为: " + lists.size());
            System.out.println("当前减少线程为: " + Thread.currentThread().getName());
            System.out.println("===============去唤醒添加线程===============");
            addCondition.signal();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


}



//测试类
package com.blog.spring.thread;

public class TestCondition {

    public static void main(String[] args) {

        final ConditionTask task = new ConditionTask();

        final ConditionTask task = new ConditionTask();

        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    task.add();
                }
            },"添加线程"+i).start();
        }

        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    task.sub();
                }
            },"减少线程"+i).start();
        }
}

运行结果：

==============当前添加线程：添加线程0================
添加 [元素1]
当前集合大小为: 1
当前添加线程为: 添加线程0
==============去唤醒减少线程================
==============当前添加线程：添加线程6================
添加 [元素2]
当前集合大小为: 2
当前添加线程为: 添加线程6
==============去唤醒减少线程================
==============当前添加线程：添加线程9================
添加 [元素3]
当前集合大小为: 3
当前添加线程为: 添加线程9
==============去唤醒减少线程================
==============当前添加线程：添加线程1================
当前集合大小为: 3-->集合已满，添加线程添加线程1开始等待，去唤醒减少线程
==============当前添加线程：添加线程2================
当前集合大小为: 3-->集合已满，添加线程添加线程2开始等待，去唤醒减少线程
==============当前添加线程：添加线程3================
当前集合大小为: 3-->集合已满，添加线程添加线程3开始等待，去唤醒减少线程
==============当前添加线程：添加线程4================
当前集合大小为: 3-->集合已满，添加线程添加线程4开始等待，去唤醒减少线程
==============当前添加线程：添加线程5================
当前集合大小为: 3-->集合已满，添加线程添加线程5开始等待，去唤醒减少线程
==============当前添加线程：添加线程7================
当前集合大小为: 3-->集合已满，添加线程添加线程7开始等待，去唤醒减少线程
==============当前减少线程：减少线程3================
移除 [元素1]
当前集合大小为: 2
当前减少线程为: 减少线程3
===============去唤醒添加线程===============
==============当前添加线程：添加线程8================
添加 [元素3]
当前集合大小为: 3
当前添加线程为: 添加线程8
==============去唤醒减少线程================
==============当前减少线程：减少线程0================
移除 [元素2]
当前集合大小为: 2
当前减少线程为: 减少线程0
===============去唤醒添加线程===============
==============当前减少线程：减少线程1================
移除 [元素3]
当前集合大小为: 1
当前减少线程为: 减少线程1
===============去唤醒添加线程===============
==============当前减少线程：减少线程2================
移除 [元素3]
当前集合大小为: 0
当前减少线程为: 减少线程2
===============去唤醒添加线程===============
==============当前减少线程：减少线程4================
当前集合大小为: 0-->集合为空，减少线程减少线程4开始等待,去唤醒添加线程
添加 [元素1]
当前集合大小为: 1
当前添加线程为: 添加线程1
==============去唤醒减少线程================
==============当前减少线程：减少线程5================
移除 [元素1]
当前集合大小为: 0
当前减少线程为: 减少线程5
===============去唤醒添加线程===============
==============当前减少线程：减少线程6================
当前集合大小为: 0-->集合为空，减少线程减少线程6开始等待,去唤醒添加线程
==============当前减少线程：减少线程7================
当前集合大小为: 0-->集合为空，减少线程减少线程7开始等待,去唤醒添加线程
==============当前减少线程：减少线程8================
当前集合大小为: 0-->集合为空，减少线程减少线程8开始等待,去唤醒添加线程
==============当前减少线程：减少线程9================
当前集合大小为: 0-->集合为空，减少线程减少线程9开始等待,去唤醒添加线程
添加 [元素1]
当前集合大小为: 1
当前添加线程为: 添加线程2
==============去唤醒减少线程================
添加 [元素2]
当前集合大小为: 2
当前添加线程为: 添加线程3
==============去唤醒减少线程================
添加 [元素3]
当前集合大小为: 3
当前添加线程为: 添加线程4
==============去唤醒减少线程================
当前集合大小为: 3-->集合已满，添加线程添加线程5开始等待，去唤醒减少线程
移除 [元素1]
当前集合大小为: 2
当前减少线程为: 减少线程4
===============去唤醒添加线程===============
添加 [元素3]
当前集合大小为: 3
当前添加线程为: 添加线程7
==============去唤醒减少线程================
移除 [元素2]
当前集合大小为: 2
当前减少线程为: 减少线程6
===============去唤醒添加线程===============
移除 [元素3]
当前集合大小为: 1
当前减少线程为: 减少线程7
===============去唤醒添加线程===============
移除 [元素3]
当前集合大小为: 0
当前减少线程为: 减少线程8
===============去唤醒添加线程===============
当前集合大小为: 0-->集合为空，减少线程减少线程9开始等待,去唤醒添加线程
添加 [元素1]
当前集合大小为: 1
当前添加线程为: 添加线程5
==============去唤醒减少线程================
移除 [元素1]
当前集合大小为: 0
当前减少线程为: 减少线程9
===============去唤醒添加线程===============

读写锁很重要,特在此保留一份：

package com.blog.spring.thread;

import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Created by hxf on 17/3/29.
 */
public class ReadWriteLockTest {

    public static void main(String[] args) {
        final Data data = new Data();
        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                public void run() {
                    for (int j = 0; j < 5; j++) {
                        data.set(new Random().nextInt(30));
                    }
                }
            }).start();
        }
        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                public void run() {
                    for (int j = 0; j < 5; j++) {
                        data.get();
                    }
                }
            }).start();
        }
    }

    static class Data {
        private int data;// 共享数据
        private ReadWriteLock rwl = new ReentrantReadWriteLock();
        public void set(int data) {
            rwl.writeLock().lock();// 取到写锁
            try {
                System.out.println(Thread.currentThread().getName() + "准备写入数据");
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.data = data;
                System.out.println(Thread.currentThread().getName() + "写入" + this.data);
            } finally {
                rwl.writeLock().unlock();// 释放写锁
            }
        }

        public void get() {
            rwl.readLock().lock();// 取到读锁
            try {
                System.out.println(Thread.currentThread().getName() + "准备读取数据");
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "读取" + this.data);
            } finally {
                rwl.readLock().unlock();// 释放读锁
            }
        }
    }
}

运行结果：

Thread-0准备写入数据
Thread-0写入9
Thread-0准备写入数据
Thread-0写入15
Thread-0准备写入数据
Thread-0写入14
Thread-1准备写入数据
Thread-1写入17
Thread-1准备写入数据
Thread-1写入27
Thread-1准备写入数据
Thread-1写入26
Thread-1准备写入数据
Thread-1写入22
Thread-1准备写入数据
Thread-1写入19
Thread-2准备写入数据
Thread-2写入18
Thread-2准备写入数据
Thread-2写入6
Thread-2准备写入数据
Thread-2写入16
Thread-2准备写入数据
Thread-2写入18
Thread-2准备写入数据
Thread-2写入29
Thread-3准备读取数据
Thread-4准备读取数据
Thread-5准备读取数据
Thread-5读取29
Thread-4读取29
Thread-3读取29
Thread-0准备写入数据
Thread-0写入24
Thread-0准备写入数据
Thread-0写入16
Thread-5准备读取数据
Thread-4准备读取数据
Thread-3准备读取数据
Thread-3读取16
Thread-4读取16
Thread-5读取16
Thread-4准备读取数据
Thread-3准备读取数据
Thread-5准备读取数据
Thread-4读取16
Thread-5读取16
Thread-3读取16
Thread-5准备读取数据
Thread-4准备读取数据
Thread-3准备读取数据
Thread-5读取16
Thread-3读取16
Thread-4读取16
Thread-3准备读取数据
Thread-5准备读取数据
Thread-4准备读取数据
Thread-5读取16
Thread-3读取16
Thread-4读取16
Process finished with exit code 0

思考:比较Condition与ReadWriteLock（ReentrantReadWriteLock是实现类）运行结果的区别？原因是啥？

Condition中的锁为：
private final Lock lock = new ReentrantLock();

结果显示：写入和写入互斥，读取和写入互斥，读取和读取互斥
不能并发执行，效率较低。Condition能够精确唤醒某种条件的线程（注意观察上面运行结果，如果拥有这种条件的线程数就一个，那么就能精确到线程,否则就是其中一个线程（随机唤醒）。），但不能并发执行－即所有线程之间都是互斥的。
  那么在这思考下Condition与Object(wait/notify,notifyAll)有什么区别？

ReadWriteLock中的锁为：
private ReadWriteLock rwl = new ReentrantReadWriteLock();

结果显示：虽然写入和写入互斥了，读取和写入也互斥了，但是读取和读取之间不互斥了，能够并发执行读取数据，相对效率较高，我想现在应该能很好的理解下面这句话了:

  在资源竞争不是很激烈的情况下,Synchronized的性能要优于ReetarntLock,但是在很激烈的情况下,synchronized的性能会下降几十倍;

参考文章：(http://www.cnblogs.com/Wanted-Tao/p/6378942.html)；
http://blog.csdn.net/ghsau/article/details/7461369；

上篇文章：多线程(四) 线程同步(上)－synchronized,volatile

淡淡的倔强
关注
专栏目录
ReentrantLock，Condition，ReentrantReadWriteLock.ReadLock，ReentrantReadWriteLock.WriterLock简介
临窗，听雨声
05-23 445
ReentrantLock重入锁 重入锁，在需要同步的代码部分进行锁定，使用完毕之后一定要释放锁。 实例方式： ReentrantLock lock = new ReentrantLock(true) ; 后面有个 Boolean 类型的 fair 参数，是标识该锁是否公平的，默认 不公平，公平的意思就是 锁的给与基于调用顺序，先调用的，先获取，不公平则是遵循cpu调用规则，默认...
多线程安全——Lock和ReadWriteLock
城南孔乙己的专栏
01-28 2730
概念 （1）Lock和ReadWriteLock是两大锁的根接口，Lock代表实现类是ReentrantLock（可重入锁），ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock。 Lock 接口支持那些语义不同（重入、公平等）的锁规则，可以在非阻塞式结构的上下文（包括 hand-over-hand 和锁重排算法）中使用这些规则。主要的实现是 ReentrantLock。 ReadWriteLock 接口以类似方式定义了一些读取者可以共享而写入者独占的锁。此包
lock锁的condition原理
qq_16047373的博客
04-26 293
首先Condition维护了一个AQS单向链表，当调用await()时将当前线程加入到链表中，然后调用signal（）会从链表头部拿出一个节点放到ReenTranLock维护的双向链表中，去抢锁，如果抢锁成功就执行，如果调用signalAll就是把所有的Condition链表节点都加入到ReenTranLock维护的双向链表中去抢锁。 ...
Java多线程技术-Lock/Condition
weixin_30587025的博客
01-18 54
在java1.5中Lock对象来实现同步的效果，而且使用上更方便。 使用ReentrantLock实现同步 public class MyService { private Lock lock = new ReentrantLock(); public void methodA(){ try { lock....
java多线程解说【柒】_锁实现：Lock/Condition的例子
xinzun的专栏
02-06 517
java多线程解说【伍】_锁实现：ReentrantLock的实现 java多线程解说【陆】_锁实现：Condition的实现 前两篇文章中我们分析了Reentrantlock和Condition的实现，从中我们知道，它们都是基于队列的先进先出机制，通过构建节点排队的方式完成的调度。这里还有一个问题，就是当一个节点尝试去修改公共的变量值的时候，如何保证这个修改操作的原子性和一致性，这就
java多线程之Lock/Condition简介
weixin_30871293的博客
07-11 64
在java多线程中，可以使用synchronized关键字实现线程之间的同步互斥，在jdk1.5中增加的ReentrantLock也能实现同样的效果，并且功能更加强大。 比如具有嗅探锁定，多路分支通知等功能，在使用上比synchronized更加灵活。 1.Object类中的wait()方法相当于Condition类中的await()方法 2.Object类中的wait(long timeo...
多线程/并发编程——同步工具类(CountDownLatch、Semaphore、ReadWriteLock、CyclicBarrier )
qq_42583242的博客
10-04 546
多线程/并发编程——同步工具类 文章目录多线程/并发编程——同步工具类一、CountDownLatch二、Semaphore三、ReadWriteLock四、CyclicBarrier 上一篇文章中，我们详细剖析了并发工具包 J.U.C 的底层实现 AQS 的细节，不过只解释了基于 AQS 的最常用的同步工具锁 ReentrantLock。诚然 ReentrantLock 是很常用、很重要的一个同步工具类。不过基于 AQS 其实还有很多同步工具类，下面我们就来学习一下这些同步工具类的简单实用 本篇文章中只
Linux多线程同步机制—读写锁(Read-Write Lock)
最新发布
wjianwei666的专栏
07-09 840
读写锁（Read-Write Lock）是一种线程同步机制，用于管理对共享资源的访问。与互斥锁（Mutex）不同，读写锁允许多个线程同时以读模式访问共享资源，但只允许一个线程以写模式访问资源。这种机制特别适用于读操作远多于写操作的场景，可以显著提高程序的并发性能。自定义实现读写锁代码需要开发者更深入地理解读写锁的底层实现原理。完全自行实现读写锁的逻辑，通过互斥锁、条件变量以及自定义的读计数和写标志来管理读写操作的同步。// 定义读写锁结构体// 互斥锁，用于保护读写锁的内部状态。
Java并行编程-lock中使用多条件condition（生产者消费者模式实例）
热门推荐
记忆力不好的博客
06-05 2万+
Java 并发包下的提供Lock，Lock相对于Synchronized可以更好的解决线程同步问题，更加的灵活和高效，并且ReadWriteLock锁还能实现读、写的分离。但线程间仅仅互斥是不够的，还需要通信，本篇的内容是基于上篇之上，使用Lock如何处理线程通信。阻塞队列(BlockingQueue)就是使用condition的和lock实现的。可以查看：Java并发编程-阻塞队列(Blockin
Lock锁与Condition详解
7me
09-02 6268
目录引子重新认识Lock接口你了解Condition接口吗Condition接口与示例Condition如何实现 引子 三个线程分别打印A、B、C，要求按ABC的顺序循环打印10次。 ReentrantLock和Conditon实现 import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; pub
线程高级篇-Lock锁和Condition条件
banbi9574的博客
02-08 655
浅谈Synchronized: 　　synchronized是Java的一个关键字,也就是Java语言内置的特性,如果一个代码块被synchronized修饰了,当一个线程获取了对应的锁,执行代码块时,其他线程 便只能一直等待,等待获取锁的线程释放锁,而获取锁的线程释放锁会有三种情况: 　　1).获取锁的线程执行完该代码块,然后线程释放对锁的占有; 　　2).线程执行发生异常,此...
JAVA多线程1——ReentrantLock与synchronized的区别和适用场景
lxs1995的博客
11-26 2815
首先说明可重入锁的概念，即一个线程尝试去获取自己已经持有的锁，可以成功获取，而其他线程不可以获取。这样做的优点简而言之是——递归无阻塞的同步机制。若锁不是可重入的，在子类的同步方法中调用父类的同步方法，会无法第二次获取子对象的锁，导致死锁。
java 并发编程lock使用详解
gmHappy
06-11 558
浅谈Synchronized: synchronized是Java的一个关键字,也就是Java语言内置的特性,如果一个代码块被synchronized修饰了,当一个线程获取了对应的锁,执行代码块时,其他线程 便只能一直等待,等待获取锁的线程释放锁,而获取锁的线程释放锁会有三种情况: 1).获取锁的线程执行完该代码块,然后线程释放对锁的占有; 2).线程执行发生异常,此时JVM会让线程自动释放锁; ...
Lock(ReentrantLock)、ReadWriteLock(ReentrantReadWriteLock)、Condition(多路通知功能)
嗯哼的博客
05-18 730
原文链接：https://blog.csdn.net/qq_39150049/article/details/112798911 目录 一.synchronized的缺陷 二.Lock接口的特性及基本方法 接口的特性 接口基本的方法： 三、ReentrantLock介绍及实例 ReentrantLock类常见方法： lock声明为局部变量，使用lock: lock声明为类的属性，使用lock trylock的使用 lockInterruptibly的使用 四、ReadWriteLoc
Java锁机制
chenguangyun123的博客
01-09 210
内置锁     Java提供了一种内置的锁机制来支持原子性：同步代码块(synchronized 关键字 )，同步代码块包含两部分：一个作为锁的对象的引用，一个作为由这个锁保护的代码块。 synchronized {     //代码块 }      每个Java对象都可以用做一个实现同步的锁，这些锁被秒为内置锁（Intrinsic Lock）或监视锁（Monitor Loc...
读写锁(read-write lock)机制-----多线程同步问题的解决
zhanggf的博客
01-12 4429
读写锁(read-write lock) 一 综述     在一些程序中存在读者写者问题，也就是说，对某些资源的访问会  存在两种可能的情况，一种是访问必须是排它行的，就是独占的意思，这称作写操作；另一种情况就是访问方式可以是共享的，就是说可以有多个线程同时去访问某个资源，这种就称作读操作。这个问题模型是从对文件的读写操作中引申出来的。     读写锁比起mutex具有更高的适用性，具有更高
Java并发包之Lock锁和Condition条件
02-23 1497
一、Synchronized synchronized是Java的一个关键字,也就是Java语言内置的特性,如果一个代码块被synchronized修饰了,当一个线程获取了对应的锁,执行代码块时,其他线程便只能一直等待,等待获取锁的线程释放锁,而获取锁的线程释放锁会有三种情况： 1. 获取锁的线程执行完该代码块,然后线程释放对锁的占有。 2. 线程执行发生异常,此时JVM会让线程自动释放锁。...
Java多线程锁机制深度解析
"这篇文章除了介绍ReentrantLock的使用外，还涉及多线程中的锁机制，可能包括其他类型的锁以及它们的应用场景。" 在多线程编程中，锁是确保线程安全和数据一致性的重要工具。这篇文章将探讨其中的一种——可重入锁...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值