精华内容
下载资源
问答
  • 共享资源:变量(静态或全局变量)、数据结构体、RAM表格、I/O设备等。OS在使用一些资源时候

    共享资源:

    变量(静态或全局变量)、数据结构体、RAM表格、I/O设备等。OS在使用一些资源时候,例如IO设备打印机,当任务1在使用打印机时候必须保证资源独享,避免其他任务修改打印内容导致出错,因此需要有资源共享机制。

    一般推荐使用互斥信号量对共享资源实现保护

    独占资源和创建临界区方法表

    方法优点何时使用
    开关中断能很快地结束访问共享资源,不推荐,会导致中断延迟访问共享资源时间小于中断关闭时间
    锁调度器不推荐,有悖ucos任务切换访问共享资源时间大于中断关闭时间,给调度器上锁时间短
    信号量信号量可能会造出优先级反转。然而,信号量方式的执行时间少于互斥信号量 方式所有的任务可以无限期等待对共享资源的访问
    互斥信号量推荐使用这种方法访问共享资源,有内置的优先级,时间较久当任务要访问的共享资源有截止时间

    只有开关中断才能任务和中断程序共享资源。其它只能用于任务相关的资源共享。

    关/开中断

    和CPU 相关的操作,其相关代码被放在与CPU相关的文件中(见CPU.H)。uC/OS-III 中与CPU相关的模块叫做uC/CPU。每种架构的CPU 都需要设置相适应的uC/CPU 文件。

    API注释
    CPU_SR_ALLOC()分配存储空间存储当前cpu的中断状态
    CPU_CRITICAL_ENTER()关全局中断
    CPU_CRITICAL_EXIT()开全局中断,恢复局部变量中存储的cpu中断状态

    只有这种方法才能任务和中断程序共享资源。只要关中断的时间不比系统本身的关中断时间长,就不会影响到系统的中断延时。

    锁调度器

    如果任务不需要和ISR 共享资源,就可以通过锁调度器来访问共享资源。
    实际上就是禁止任务调度已达到资源的独占

    API注释
    OSSchedLock()锁调度
    OSSchedUnlock()开调度

    注意,只有调度器被锁,中断是使能的,如果在处理临界段时中断发生,ISR程序就会被执行。在ISR 的末尾,uC/OS-III会返回原任务(即使ISR中有高优先级任务被就绪)。

    支持嵌套250 级。当OSSchedUnlock()与OSSchedLock()被调用的次数相同时调度器才被锁调度器影响了抢占式内核的初衷,内核行为实际与不可剥夺的内核已经是一样的了。

    信号量

    一种上锁机制,代码需要获取对应的钥匙才能访问共享资源(继续执行),我的理解是实际上只是对访问共享资源区的代码段进行上锁,如果没有获取到钥匙(信号量)则等待无法继续执行,只有别的任务施放了信号量之后才能继续执行下去。

    二进制信号量和计数型信号量:

    二进制信号量只能取0和1两个值,计数型信号量的信号量值大于1,计数型信号量的范围由OS_SEM_CTR决定,OS_SEM_CTR可以为8位,16位和32位,取值范围分别为:0~255,0~65535和0~4294967295。

    二值信号量用于那些一次只能一个任务使用的资源,比如I/O设备,打印机计,数型信号量用于某些资源可以同时被几个任务所使用,比如一个缓存池有10个缓存块,那么同时最多可以支持10个任务来使用内存池。

    应用中可以使用任意数量的信号量,但是一般用于IO保护,很多情况下,访问一个简短的共享资源时不推荐使用信号量,请求和释放信号量会消耗CPU时间。

    API注释
    OSSemCreate()创建一个信号量
    OSSemDel()删除一个信号量
    OSSemPend()等待一个信号量
    OSSemPendAbort()取消等待
    OSSemPoset()释放一个信号量
    OSSemSet()强制设置信号量值
    OS_SEM信号量类型

    定义一个信号量

    OS_SEM XXX 

    创建一个信号量

    void  OSSemCreate (OS_SEM *p_sem, //信号量结构体,其中OS_SEM_CTR Ctr表示信号量的值
                       CPU_CHAR *p_name,//名字
                       OS_SEM_CTR cnt,   //信号量初始值
                       OS_ERR *p_err)

    删除一个信号量

    OS_OBJ_QTY  OSSemDel(OS_SEM *p_sem,
                         OS_OPT opt, 
         //1.NO_PEND 仅当没有信号请求的时候才删除
         //2.ALWAYS 直接删除,不管有没有信号请求
                         OS_ERR *p_err)

    请求/等待一个信号量

    OS_SEM_CTR  OSSemPend(OS_SEM *p_sem, 
                          OS_TICK timeout,//等待的时间,如果为0:一直等待下去
                          OS_OPT opt,
             //1.暂时无效直接挂起 OS_OPT_PEND_BLOCKING
             //2.无效直接返回OS_OPT_PEND_NON_BLOCKING
                          CPU_TS *p_ts,//时间戳:记录接受信号量的时刻,0或者null则不需要时间戳。
                          OS_ERR *p_err)

    取消等待

    OS_OBJ_QTY  OSSemPendAbort(OS_SEM *p_sem,
                               OS_OPT opt,
                 //1. 仅终止等待该信号量的最高优先级任务
                 //2. 中止所有的等待该信号量的任务
                 //3. 禁止任务调度
                               OS_ERR *p_err)

    释放一个信号量

    OS_SEM_CTR OSSemPost(OS_SEM *p_sem,
                         OS_OPT opt,
                  //1. 仅发送给等待该信号量的最高优先级任务
                  //2. 发送给所有的等待该信号量的任务
                  //3. 禁止任务调度
                         OS_ERR *p_err)

    步骤:
    先定义OS_SEM
    Create创建信号量
    OSSemPend等待信号量
    OSSemPost释放信号量

    互斥信号量

    使用信号量访问共享资源会有优先级反转问题:高优先级A任务执行访问共享资源的时候被迫等待低优先级任务D释放信号量,此时会发生任务切换到低优先级。如果此时又有高一级的任务B中断了D的任务,虽然B任务比A任务优先级更低,也会发生任务调度。使得高优先级任务A实际上被拉到占用信号量的低优先级任务D同一优先级别,违背了实时RTOS。

    互斥信号量实际解决方法就是,将低优先级任务D的优先级临时提升至任务A同一优先级,等信号量释放后,再将任务D的优先级恢复,这样任务切换只在这两个任务之间执行(如果有比A更高的还是会切换)。

    API注释
    OSMutexCreate()创建一个互斥信号量
    OSMutexDel()删除一个互斥信号量
    OSMutexPend()等待一个互斥信号量
    OSMutexPendAbort()取消等待信号量
    OSMutexPost()释放一个互斥信号量

    创建互斥信号量

    void  OSMutexCreate(OS_MUTEX  *p_mutex,//指向互斥信号量的控制块
                        CPU_CHAR  *p_name, //互斥信号量名字
                        OS_ERR    *p_err)//调用此函数后返回的错误码

    请求/等待互斥信号量

    void  OSMutexPend(OS_MUTEX  *p_mutex, //指向互斥信号量的控制块
                      OS_TICK timeout,//指定等待互斥信号量的超时节拍,超时继续执行,0位一直等待
                      OS_OPT opt,//是否阻塞
                 //OS_OPT_PEND_BLOCKING无效挂起
                 //OS_OPT_PEND_NON_BLOCKING无效直接返回
                      CPU_TS *p_ts,//时间戳
                      OS_ERR *p_err)//错误码

    释放互斥信号量

    void  OSMutexPost(OS_MUTEX *p_mutex,//指向互斥信号量
    
                      OS_OPT opt,//指定是否进行任务调度操作
        //OS_OPT_POST_NONE不指定特定的选项
        //OS_OPT_POST_NO_SCHED 禁止在本函数内执行任务调度
    
                      OS_ERR *p_err)//错误码

    步骤:
    先定义OS_MUTEX xxxx
    Create创建信号量
    OSMutexPend等待信号量
    OSMutexPost释放信号量

    死锁:

    任务1需要的资源要等到任务2释放,任务2的资源需要等待任务1释放,造成死锁。
    (1)假定任务T1 所等待的事情发生,任务1被执行。
    (2)任务T1 申请M1。(mutex 1)
    (3)任务T1 访问资源R1。
    (4)中断发生,中断中使能了任务T2。由于任务T2 的优先级高于任务T1,CPU 切换到任务T2。
    (5)该中断即是任务T2 所等待的事件。
    (6)任务T2 申请M2 并占用资源R2。
    (7)任务T2 申请M1,但是M1 已被任务T1 占用。任务T2
    被挂起。
    (8)uC/OS-III 切换到任务T1。
    (9)此时任务T1 申请M2,但是M2 已经被任务T2 占用。

    此时,两个任务互相等待,这就算死锁。

    用以下方式防止死锁:
    1)同一个时间不要申请多于一个mutex
    2)不要直接地申请mutex(该申请放到器件驱动中和可重入函数中)
    3)在处理之前先获得全部所需要的mutex
    4)任务间以同样的顺序申请资源

    当申请信号量或mutex 时允许设置时间期限,这样能防止死锁,但是同样的死锁可能稍后再次出现。

    展开全文
  • MySQL:共享互斥锁 意向锁。

    千次阅读 2019-12-16 14:01:43
    MySQL:共享互斥锁 意向锁。

    经常听到数据库的锁机制,不同的数据库的不同实现不同, 听多了就头疼了,今天就把MySQL的锁整的明明白白:

    首先想一下为什么我们会需要锁,其实就是为了解决并发操作数据的,是一种控制并发的机制。

    乐观锁和悲观锁

    乐观锁和悲观锁其实是两种思想,用来指导实现锁的功能的不同实现思想,

    • 乐观锁是一种思想,它其实并不是一种真正的『锁』,它会先尝试对资源进行修改,在写回时判断资源是否进行了改变,如果没有发生改变就会写回,否则就会进行重试,在整个的执行过程中其实都没有对数据库进行加锁;
    • 悲观锁就是一种真正的锁了,它会在获取资源前对资源进行加锁,确保同一时刻只有有限的线程能够访问该资源,其他想要尝试获取资源的操作都会进入等待状态,直到该线程完成了对资源的操作并且释放了锁后,其他线程才能重新操作资源;

    在这两种指导思想下产生了对应的锁:

    乐观锁的实现

    我们可以对一行数据创建一个字段专门用来存放对这行数据操作时的时间戳,比如我们第一次读取的时候拿到时间戳 timestamep=111,a=2, id =1 ,然后提交a=3更新的时候,我们的update  tablename set a = 3  where id =1 timestamp=111 失败,说明这条数据被别的事务操作了。

    乐观锁是一种软并发控制,需要你设置好完整的逻辑处理。

    悲观锁的实现

    悲观锁也就是我们经常说的锁的概念,包括什么共享锁,互斥锁,读锁,写锁,意向共享锁,意向互斥锁,共享锁和读锁是一个概念,互斥锁和写锁一个概念,以此类推 意向共享锁也可以叫意向读锁, 意向互斥锁也可以叫意向写锁。

    这些锁的使用使用在哪里是有锁的使用范围的,也就是每种锁的粒度。MySQL的锁的粒度和引擎相关,我们今天就着重介绍一下InnoDB,因为这个是5.5.8版本以后的默认版本。

    注意:MySQL的引擎是表级别的,就是在创建表的时候指定,也就是说你一个数据库的不同表你可以指定不同引擎

    • MySQL的锁的粒度有:行级锁 和 表级锁。
    • MySQL的锁的作用:共享锁(读锁) 和 互斥锁(写锁)---------行级锁。
    • MySQL的意向锁是表级锁,

    意向锁

    • 意向共享锁:事务想要在获得表中某些记录的共享锁,需要在表上先加意向共享锁;
    • 意向互斥锁:事务想要在获得表中某些记录的互斥锁,需要在表上先加意向互斥锁;

    意向锁其实不会阻塞全表扫描之外的任何请求,它们的主要目的是为了表示是否有人请求锁定表中的某一行数据。

    有的人可能会对意向锁的目的并不是完全的理解,我们在这里可以举一个例子:如果没有意向锁,当已经有人使用行锁对表中的某一行进行修改时,如果另外一个请求要对全表进行修改,那么就需要对所有的行是否被锁定进行扫描,在这种情况下,效率是非常低的;不过,在引入意向锁之后,当有人使用行锁对表中的某一行进行修改之前,会先为表添加意向互斥锁(IX),再为行记录添加互斥锁(X),在这时如果有人尝试对全表进行修改就不需要判断表中的每一行数据是否被加锁了,只需要通过等待意向互斥锁被释放就可以了。

    各种锁之间的约束关系:

    展开全文
  • 互斥是并发进程之间由于共享资源而形成的间接制约关系。 Var mutex : semaphore := 1; //初值为1 Begin Parbegin(由部分开始) Process1: begin repeat(循环) wait(mutex);//进入区(P操作) critical ...

        用信号量实现互斥。互斥是并发进程之间由于共享资源而形成的间接制约关系。

        Var mutex : semaphore := 1; //初值为1

        Begin Parbegin(由部分开始) 

        Process1: begin repeat(循环) 

        wait(mutex);//进入区(P操作)

        critical section;//临界区(使用临界资源)

        signal(mutex); //退出区(V操作)释放

        remainder section;//剩余区

        until false;

        end;

        Process2:begin repeat 

        wait(mutex)

        critical section 

        signal(mutex);

        remainder section 

        until false;

        end;

        parend(两个进程代码完全一致)

        互斥需要调解两者使用资源的速度

        

        在实现互斥时应注意 wait(mutex) 和signal(mutex) 必须成对地出现。缺wait(mutex)(申请资源)将会引起系统混乱,不能保证对临界资源的互斥访问。缺signal(mutex)将会使该临界资源永久不会释放(系统当中某些进程将永远处于阻塞状态)

        

        

        

        

    展开全文
  • 经常听到数据库的锁机制,不同的数据库的不同实现不同, 听多了就头疼了,今天就把MySQL的锁整的明明白白: ...乐观锁是一种思想,它其实并不是一种真正的『锁』,它会先尝试对资源进行修改,在写回时判断资源是...

    经常听到数据库的锁机制,不同的数据库的不同实现不同, 听多了就头疼了,今天就把MySQL的锁整的明明白白:

    锁:

       首先想一下为什么我们会需要锁,其实就是为了解决并发操作数据的,是一种控制并发的机制。

    乐观锁和悲观锁:

       乐观锁和悲观锁其实是两种思想,用来指导实现锁的功能的不同实现思想,

    • 乐观锁是一种思想,它其实并不是一种真正的『锁』,它会先尝试对资源进行修改,在写回时判断资源是否进行了改变,如果没有发生改变就会写回,否则就会进行重试,在整个的执行过程中其实都没有对数据库进行加锁
    • 悲观锁就是一种真正的锁了,它会在获取资源前对资源进行加锁,确保同一时刻只有有限的线程能够访问该资源,其他想要尝试获取资源的操作都会进入等待状态,直到该线程完成了对资源的操作并且释放了锁后,其他线程才能重新操作资源;

     在这两种指导思想下产生了对应的锁:

    乐观锁的实现:

      我们可以对一行数据创建一个字段专门用来存放对这行数据操作时的时间戳,比如我们第一次读取的时候拿到时间戳 timestamep=111,a=2, id =1 ,然后提交a=3更新的时候,我们的update  tablename set a = 3  where id =1 timestamp=111 失败,说明这条数据被别的事务操作了。

     乐观锁是一种软并发控制,需要你设置好完整的逻辑处理。

    悲观锁的实现:

      悲观锁也就是我们经常说的锁的概念,包括什么共享锁,互斥锁,读锁,写锁,意向共享锁,意向互斥锁,

    共享锁和读锁是一个概念,互斥锁和写锁一个概念,以此类推 意向共享锁也可以叫意向读锁, 意向互斥锁也可以叫意向写锁。

    这些锁的使用使用在哪里是有锁的使用范围的,也就是每种锁的粒度。

    MySQL的锁的粒度和引擎相关,我们今天就着重介绍一下InnoDB,因为这个是5.5.8版本以后的默认版本,

    注意:MySQL的引擎是表级别的,就是在创建表的时候指定,也就是说你一个数据库的不同表你可以指定不同引擎

    MySQL的锁的粒度有:行级锁 和 表级锁。

    MySQL的锁的作用:共享锁(读锁) 和 互斥锁(写锁)---------行级锁。

    MySQL的意向锁是表级锁,

    意向锁:

      

    • 意向共享锁:事务想要在获得表中某些记录的共享锁,需要在表上先加意向共享锁;
    • 意向互斥锁:事务想要在获得表中某些记录的互斥锁,需要在表上先加意向互斥锁;

    意向锁其实不会阻塞全表扫描之外的任何请求,它们的主要目的是为了表示是否有人请求锁定表中的某一行数据

    有的人可能会对意向锁的目的并不是完全的理解,我们在这里可以举一个例子:如果没有意向锁,当已经有人使用行锁对表中的某一行进行修改时,如果另外一个请求要对全表进行修改,那么就需要对所有的行是否被锁定进行扫描,在这种情况下,效率是非常低的;不过,在引入意向锁之后,当有人使用行锁对表中的某一行进行修改之前,会先为表添加意向互斥锁(IX),再为行记录添加互斥锁(X),在这时如果有人尝试对全表进行修改就不需要判断表中的每一行数据是否被加锁了,只需要通过等待意向互斥锁被释放就可以了。

    各种锁之间的约束关系:

     

    展开全文
  • Qt多线程:使用互斥

    万次阅读 多人点赞 2018-09-04 22:08:06
    1、官方文档: QMutex类提供线程间的访问序列...通常最好将互斥对象与QMutexLocker一起使用,因为这样可以很容易地确保一致地执行锁定和解锁。 2、官方示例: QMutex mutex; int number = 6; v...
  • 进程互斥 定义:两个或两个以上的进程,不能同时进入关于同一组共享...我们把这些程序的片段称作临界区或临界段,它存在的目的是有效的防止竞争条件又能保证最大化使用共享数据。而这些并发进程必须有好的解决方案,...
  • 线程锁数据共享我们把上篇博客线程锁代码拿过来from threading import Thread,Lock import time n=100def task(): global n mutex.acquire() temp=n time.sleep(0.1) n=temp-1 mutex.release()if __name__ == ...
  • 首先要弄清楚,线程互斥锁的作用是要保护共享资源在同一时刻只能被同一线程操作,即保证某一线程在上锁到解锁这一过程中对共享资源的操作为原子的。现举例说明: 设有两个线程:线程A和线程B(线程A和B在程序运行...
  • 一、共享资源使用 1. 由于同一进程下的多线程是共用地址空间,因此就要考虑共享资源使用。如果没有一定的规则,那么共享资源的内容就会显得杂乱无章,这里引入了同步与互斥的概念! 2. 进行多线程编程,因为无法...
  • 互斥锁与条件变量配合使用

    千次阅读 2012-08-03 09:54:41
     对共享资源的访问, 要对互斥量进行加锁, 如果互斥量已经上了锁, 调用线程会阻塞, 直到互斥量被解锁. 在完成了对共享资源的访问后, 要对互斥量进行解锁。  死锁主要发生在有多个依赖锁存在时, 会在一个线程试图以...
  • 同步互斥

    千次阅读 2018-07-13 13:54:47
    要了解同步互斥先了解几个关于资源的概念,为什么会出现同步互斥,大多数是因为我们要对某一个资源进行争夺。在进程中出现的情况不多,多数是在进程中出现的,看下如如上图所示,现在有两个进程分别是进程A和进程B,...
  • 如何解决线程切换带来的原子性问题呢?答案是**保证多线程之间的互斥性。也就是说,在同一时刻只有一...**如果我们能够保证对共享变量的修改是互斥的,那么,无论是单核CPU还是多核CPU,都能保证多线程之间的原子性了。
  • 进程互斥

    2018-12-03 10:29:24
    两个或两个以上的进程,不能同时进入关于同一组共享变量的临界区域,否则可能发生与时间有关的错误,这种现象被称作进程互斥· 也就是说,一个进程正在访问临界资源,另一个要访问该资源的进程必须等待。 在多道程序...
  • 创建线程利用互斥实现线程共享变量通信 概述 1.1 课题目的和意义 掌握线程创建和终止加深对线程和进程概念的理解会用同步与互斥方法实现线程之间的通信 1.2内容和要求 软件界面上点创建线程 按钮创建三个生产者线程...
  • Linux多线程 互斥锁与条件变量使用

    千次阅读 2013-06-07 13:26:03
    2013/6/7 caichengyu 如果你认真看下去,必将学习到不少知识,如有错还希望您提...互斥量从本质上说就是一把锁, 提供对共享资源的保护访问。 1. 初始化: 线程的互斥量数据类型是pthread_mutex_t,使用之前要初始化。
  • 线程的互斥机制

    2017-06-07 22:06:45
    互斥锁的目的是为了保护公共资源(临界资源),但是互斥锁自身又要被多个线程所看到,因此互斥锁也是一个临界资源。因此在上锁和解锁的时候一定要保证原子操作,否则这个互斥锁就会变得毫无意义,使得多个线程依然...
  • 互斥锁与死锁

    2018-04-22 16:01:44
    在多线程程序中,多个线程可能会共用同一个...互斥锁是一个二元变量,其状态为开锁(允许0)和上锁(禁止1),将某个共享资源与某个特定互斥锁在逻辑上绑定(要申请该资源必须先获取锁)。 (1)访问公共资源前,必须申请...
  • 互斥锁与条件变量

    2016-09-16 23:05:50
     对共享资源的访问, 要对互斥量进行加锁, 如果互斥量已经上了锁, 调用线程会阻塞, 直到互斥量被解锁. 在完成了对共享资源的访问后, 要对互斥量进行解锁。  死锁主要发生在有多个依赖锁存在时, 会在一个线程试图以...
  • 互斥锁详解

    2014-08-29 16:33:59
    使用互斥锁 表 4–3 列出了用来处理互斥锁的函数。 表 4–3 互斥锁的例程 操作 相关函数说明 初始化互斥锁 pthread_mutex_init 语法 使互斥锁保持...
  • 互斥锁和条件变量的结合使用

    千次阅读 2014-10-30 21:43:47
    而条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足,他常和互斥锁一起使用使用时,条件变量被用来阻塞一个线程,当条件不满足时,线程往往解开相应的互斥锁并等待条件发生变化。一旦...
  • FreeRTOS篇章之互斥

    2020-02-25 15:06:37
    写在前面: 本文章旨在总结备份、方便以后查询,由于是个人总结,如有...在用于互斥的场合,互斥量从概念上可看作是与共享资源关联的令牌。一个任务想要合法地访问资源,其必须先成功地得到(Take)该资源对应的令牌...
  • 读者可以通过实验进一步理解进程间同步与互斥、临界区与临界资源的概念与含义,并学会Linux信号量的基本使用方法。 二、实验环境 硬件环境:计算机一台,局域网环境; 软件环境:Linux Ubuntu操作系统,gcc编译器。 ...
  • C++多线程系列(二)线程互斥

    千次阅读 2016-06-30 20:23:05
    所谓间接相互制约:一个系统中的多个线程必然要共享某种系统资源共享CPU,共享打印机。间接制约即源于资源共享,线程A在打印的时候其他线程就要等待,否则打印的数据将变得非常混乱。间接相互制约称为互斥互斥是...
  •  2、互斥量:为协调共同对一个共享资源的单独访问而设计的。  3、信号量:为控制一个具有有限数量用户资源而设计。  4、事 件:用来通知线程有一些事件已发生,从而启动后继任务的开始。   临界区(Critical ...
  • 互斥与同步

    2012-05-21 13:29:23
    互斥和同步是两个紧密相关而又容易混淆的概念: ...在大多数情况下,同步已经实现了互斥,特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源,如“第一类读写者模型”。
  • Linux线程浅析[线程的同步和互斥] ...例子:一栋大楼的建造,包含了质监局的检验和工程队的施工,那么假设质监局和工程队是两个线程,而大楼则为共享资源,首先相互排斥的原则为工程队施工的时候,质监局是不能进行检验
  • 进程同步和互斥

    千次阅读 2021-05-07 21:58:19
    同步和互斥
  • 1线程同步:互斥量,死锁

    千次阅读 2014-09-25 16:44:58
    A:共享资源,多个线程都可对共享资源操作。 B:线程操作共享资源的先后顺序不确定。 C:处理器对存储器的操作一般不是原子操作。 2互斥量 mutex操作原语 pthread_mutex_t pthread_mutex_init pthread_mutex_...
  • Python编程中,引入了对象互斥锁的概念,来保证共享数据操作的完整性。每个对象都对应于一个可称为” 互斥锁” 的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象。在Python中我们使用threading模块...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,294
精华内容 16,917
关键字:

共享资源互斥使用的目的是