5 种 Python 线程锁

最新推荐文章于 2023-06-02 14:50:31 发布
最新推荐文章于 2023-06-02 14:50:31 发布
阅读量1.3k 收藏 21
点赞数 3
文章标签： python 开发语言
原文链接：https://baijiahao.baidu.com/s?id=1714105650396326932&wfr=spider&for=pc
版权

这里写目录标题

线程安全

线程安全是多线程或多进程编程中的一个概念，在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

线程安全的问题最主要还是由线程切换导致的，比如一个房间（进程）中有10颗糖（资源），除此之外还有3个小人（1个主线程、2个子线程），当小人A吃了3颗糖后被系统强制进行休息时他认为还剩下7颗糖，而当小人B工作后又吃掉了3颗糖，那么当小人A重新上岗时会认为糖还剩下7颗，但是实际上只有4颗了。

上述例子中线程A和线程B的数据不同步，这就是线程安全问题，它可能导致非常严重的意外情况发生，我们按下面这个示例来进行说明。

下面有一个数值num初始值为0，我们开启2条线程：

线程1对num进行一千万次+1的操作

线程2对num进行一千万次-1的操作

结果可能会令人咋舌，num最后并不是我们所想象的结果0：

import threading

num = 0

def add():
    global num
    for i in range(10_000_000):
        num += 1

def sub():
    global num
    for i in range(10_000_000):
        num -= 1
'''
add()和sub()两个线程同时对num进行操作
看结果，可以有以下推论：
1、同时操作不会是程序崩溃（num是int类型，int类型本身是线程安全的）
2、但是会操作结果呈现未知状态，说明这个流程是线程不安全的。因为线程运行的先后顺序是未知的。
'''

if __name__ == "__main__":
    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 结果三次采集
# num result : 669214
# num result : -1849179
# num result : -525674

上面这就是一个非常好的案例，想要解决这个问题就必须通过锁来保障线程切换的时机。

需要我们值得留意的是，在Python基本数据类型中list、tuple、dict本身就是属于线程安全的，所以如果有多个线程对这3种容器做操作时，我们不必考虑线程安全问题。(非常好的设计)

锁的作用

锁是Python提供给我们能够自行操控线程切换的一种手段，使用锁可以让线程的切换变的有序。

一旦线程的切换变的有序后，各个线程之间对数据的访问、修改就变的可控，所以若要保证线程安全，就必须使用锁。

threading模块中提供了5种最常见的锁，下面是按照功能进行划分：

  • 同步锁：lock（一次只能放行一个）

  • 递归锁：rlock（一次只能放行一个）

  • 条件锁：condition（一次可以放行任意个）

  • 事件锁：event（一次全部放行）

  • 信号量锁：semaphore（一次可以放行特定个）

1、Lock() 同步锁

基本介绍
Lock锁的称呼有很多，如：同步锁、互斥锁

它们是什么意思呢？如下所示：

互斥指的是某一资源同一时刻仅能有一个访问者对其进行访问，具有唯一性和排他性，但是互斥无法限制访问者对资源的访问顺序，即访问是无序的

同步是指在互斥的基础上（大多数情况），通过其他机制实现访问者对资源的有序访问

同步其实已经实现了互斥，是互斥的一种更为复杂的实现，因为它在互斥的基础上实现了有序访问的特点

下面是threading模块与同步锁提供的相关方法：

使用方式

同步锁一次只能放行一个线程，一个被加锁的线程在运行时不会将执行权交出去，只有当该线程被解锁时才会将执行权通过系统调度交由其他线程。

如下所示，使用同步锁解决最上面的问题：

import threading

num = 0

def add():
    lock.acquire()					# 同步锁
    global num
    for i in range(10_000_000):
        num += 1
    lock.release()


def sub():
    lock.acquire()					# 同步锁  一次只能一个
    global num
    for i in range(10_000_000):
        num -= 1
    lock.release()

if __name__ == "__main__":
    lock = threading.Lock()			# 创建同步锁

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 结果三次采集
# num result : 0
# num result : 0
# num result : 0

这样这个代码就完全变成了串行的状态，对于这种计算密集型I/O业务来说，还不如直接使用串行化单线程执行来得快，所以这个例子仅作为一个示例，不能概述锁真正的用途。

死锁现象

对于同步锁来说，一次acquire()必须对应一次release()，不能出现连续重复使用多次acquire()后再重复使用多次release()的操作，这样会引起死锁造成程序的阻塞，完全不动了，如下所示：

import threading

num = 0


def add():
    lock.acquire()  # 上锁
    lock.acquire()  # 死锁
    # 不执行
    global num
    for i in range(10_000_000):
        num += 1
    lock.release()
    lock.release()


def sub():
    lock.acquire()  # 上锁
    lock.acquire()  # 死锁
    # 不执行
    global num
    for i in range(10_000_000):
        num -= 1
    lock.release()
    lock.release()


if __name__ == "__main__":
    lock = threading.Lock() # 创建lock

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

with语句 （自动加锁、解锁）

由于threading.Lock()对象中实现了enter__()与__exit()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：

import threading

num = 0

def add():
    with lock:				# with语句lock的用法，自动加锁、解锁
        # 自动加锁
        global num
        for i in range(10_000_000):
            num += 1
        # 自动解锁


def sub():
    with lock:
        # 自动加锁
        global num
        for i in range(10_000_000):
            num -= 1
        # 自动解锁


if __name__ == "__main__":
    lock = threading.Lock()

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 结果三次采集
# num result : 0
# num result : 0
# num result : 0

2、RLock() 递归锁

基本介绍

递归锁是同步锁的一个升级版本，在同步锁的基础上可以做到连续重复使用多次acquire()后再重复使用多次release()的操作，但是一定要注意加锁次数和解锁次数必须一致，否则也将引发死锁现象。

下面是threading模块与递归锁提供的相关方法：
在这里插入图片描述
使用方式

以下是递归锁的简单使用，下面这段操作如果使用同步锁则会发生死锁现象，但是递归锁不会：

import threading

num = 0

def add():
    lock.acquire()					# 第一次上锁
    lock.acquire()					# 第二次上锁，这种写法 递归锁 能正常运行；同步锁会发生死锁；
    global num
    for i in range(10_000_000):
        num += 1
    lock.release()					# 不理解 递归锁存在的意义？？？
    lock.release()


def sub():
    lock.acquire()
    lock.acquire()
    global num
    for i in range(10_000_000):
        num -= 1
    lock.release()
    lock.release()


if __name__ == "__main__":
    lock = threading.RLock()   # 创建 递归锁 对象

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 结果三次采集
# num result : 0
# num result : 0
# num result : 0

with语句
由于threading.RLock()对象中实现了enter__()与__exit()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：

import threading

num = 0


def add():
    with lock:					# 递归锁和同步锁 都可以使用 with 语句，进行自动加锁、解锁
        # 自动加锁
        global num
        for i in range(10_000_000):
            num += 1
        # 自动解锁


def sub():
    with lock:
        # 自动加锁
        global num
        for i in range(10_000_000):
            num -= 1
        # 自动解锁


if __name__ == "__main__":
    lock = threading.RLock()

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 结果三次采集
# num result : 0
# num result : 0
# num result : 0

3、Condition() 条件锁

基本介绍

条件锁是在递归锁的基础上增加了能够暂停线程运行的功能。并且我们可以使用wait()与notify()来控制线程执行的个数。

注意：条件锁可以自由设定一次放行几个线程。

下面是threading模块与条件锁提供的相关方法：
在这里插入图片描述

使用方式
下面这个案例会启动10个子线程，并且会立即将10个子线程设置为等待状态。

然后我们可以发送一个或者多个通知，来恢复被等待的子线程继续运行：

import threading

currentRunThreadNumber = 0    # 当前运行线程的数量
maxSubThreadNumber = 10


def task():
    global currentRunThreadNumber
    thName = threading.currentThread().name

    condLock.acquire()  # 上锁
    print("start and wait run thread : %s" % thName)

    condLock.wait()  # 暂停线程运行、等待唤醒
    currentRunThreadNumber += 1
    print("carry on run thread : %s" % thName)

    condLock.release()  # 解锁


if __name__ == "__main__":
    condLock = threading.Condition()   # 创建条件锁

    for i in range(maxSubThreadNumber):
        subThreadIns = threading.Thread(target=task)
        subThreadIns.start()

    while currentRunThreadNumber < maxSubThreadNumber:
        notifyNumber = int(
            input("Please enter the number of threads that need to be notified to run："))  # 手动输入放行数量
		# 循环放行
        condLock.acquire()
        condLock.notify(notifyNumber)  # 放行
        condLock.release()

    print("main thread run end")

# 先启动10个子线程，然后这些子线程会全部变为等待状态
# start and wait run thread : Thread-1
# start and wait run thread : Thread-2
# start and wait run thread : Thread-3
# start and wait run thread : Thread-4
# start and wait run thread : Thread-5
# start and wait run thread : Thread-6
# start and wait run thread : Thread-7
# start and wait run thread : Thread-8
# start and wait run thread : Thread-9
# start and wait run thread : Thread-10

# 批量发送通知，放行特定数量的子线程继续运行
# Please enter the number of threads that need to be notified to run：5  # 放行5个
# carry on run thread : Thread-4
# carry on run thread : Thread-3
# carry on run thread : Thread-1
# carry on run thread : Thread-2
# carry on run thread : Thread-5

# Please enter the number of threads that need to be notified to run：5  # 放行5个
# carry on run thread : Thread-8
# carry on run thread : Thread-10
# carry on run thread : Thread-6
# carry on run thread : Thread-9
# carry on run thread : Thread-7

# Please enter the number of threads that need to be notified to run：1
# main thread run end

with语句
由于threading.Condition()对象中实现了enter__()与__exit()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：

import threading

currentRunThreadNumber = 0
maxSubThreadNumber = 10


def task():
    global currentRunThreadNumber
    thName = threading.currentThread().name    # 返回当前线程名称

    with condLock:    # with 用法
        print("start and wait run thread : %s" % thName)
        condLock.wait()  # 暂停线程运行、等待唤醒
        currentRunThreadNumber += 1
        print("carry on run thread : %s" % thName)


if __name__ == "__main__":
    condLock = threading.Condition()

    for i in range(maxSubThreadNumber):
        subThreadIns = threading.Thread(target=task)
        subThreadIns.start()

    while currentRunThreadNumber < maxSubThreadNumber:
        notifyNumber = int(
            input("Please enter the number of threads that need to be notified to run："))

        with condLock:   # with 用法
            condLock.notify(notifyNumber)  # 放行

    print("main thread run end")

4、Event() 事件锁

基本介绍

事件锁是基于条件锁来做的，它与条件锁的区别在于一次只能放行全部，不能放行任意个数量的子线程继续运行。

我们可以将事件锁看为红绿灯，当红灯时所有子线程都暂停运行，并进入“等待”状态，当绿灯时所有子线程都恢复“运行”。

下面是threading模块与事件锁提供的相关方法：

在这里插入图片描述

使用方式
事件锁不能利用with语句来进行使用，只能按照常规方式。

如下所示，我们来模拟线程和红绿灯的操作，红灯停，绿灯行：

import threading

maxSubThreadNumber = 3

def task():    
	thName = threading.currentThread().name    
	print("start and wait run thread : %s" % thName)    
	
	eventLock.wait()  # 暂停运行，等待绿灯    
	
	print("green light, %s carry on run" % thName)    
	print("red light, %s stop run" % thName)    
	
	eventLock.wait()  # 暂停运行，等待绿灯    
	print("green light, %s carry on run" % thName)    
	
	print("sub thread %s run end" % thName)


if __name__ == "__main__":    
	eventLock = threading.Event()    # 事件锁

	for i in range(maxSubThreadNumber):        
		subThreadIns = threading.Thread(target=task)     # 创建线程   
		subThreadIns.start()    
		
		# 交替绿、红灯
		eventLock.set()  # 设置为绿灯    
		eventLock.clear()  # 设置为红灯    
		eventLock.set()  # 设置为绿灯
		
# start and wait run thread : Thread-1
# start and wait run thread : Thread-2
# start and wait run thread : Thread-3

# green light, Thread-1 carry on run
# red light, Thread-1 stop run
# green light, Thread-1 carry on run
# sub thread Thread-1 run end

# green light, Thread-3 carry on run
# red light, Thread-3 stop run
# green light, Thread-3 carry on run
# sub thread Thread-3 run end

# green light, Thread-2 carry on run
# red light, Thread-2 stop run
# green light, Thread-2 carry on run
# sub thread Thread-2 run end

5、Semaphore() 信号量锁

基本介绍

信号量锁也是根据条件锁来做的，它与条件锁和事件锁的区别如下：

  • 条件锁：一次可以放行任意个处于“等待”状态的线程
  • 事件锁：一次可以放行全部的处于“等待”状态的线程
  • 信号量锁：通过规定，成批的放行特定个处于“上锁”状态的线程

下面是threading模块与信号量锁提供的相关方法：
在这里插入图片描述

使用方式
以下是使用示例，你可以将它当做一段限宽的路段，每次只能放行相同数量的线程：

import threading
import time

maxSubThreadNumber = 6


def task():
    thName = threading.currentThread().name
    
    semaLock.acquire()
    print("run sub thread %s" % thName)
    time.sleep(3)
    semaLock.release()


if __name__ == "__main__":
    # 每次只能放行2个
    semaLock = threading.Semaphore(2)   # 信号量锁 可以限制每次放行线程的数量

    for i in range(maxSubThreadNumber):
        subThreadIns = threading.Thread(target=task)
        subThreadIns.start()


# run sub thread Thread-1
# run sub thread Thread-2

# run sub thread Thread-3
# run sub thread Thread-4

# run sub thread Thread-6
# run sub thread Thread-5

with语句

由于threading.Semaphore()对象中实现了enter__()与__exit()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：

import threading
import time

maxSubThreadNumber = 6


def task():
    thName = threading.currentThread().name
    with semaLock:	# with 信号量锁 semaphore
        print("run sub thread %s" % thName)
        time.sleep(3)


if __name__ == "__main__":

    semaLock = threading.Semaphore(2)

    for i in range(maxSubThreadNumber):
        subThreadIns = threading.Thread(target=task)
        subThreadIns.start()

锁关系浅析

上面5种锁可以说都是基于同步锁来做的，这些你都可以从源码中找到答案。

首先来看RLock递归锁，递归锁的实现非常简单，它的内部会维护着一个计数器，当计数器不为0的时候该线程不能被I/O操作和时间轮询机制切换。但是当计数器为0的时候便不会如此了：

def __init__(self):
    self._block = _allocate_lock()
    self._owner = None
    self._count = 0  # 计数器

而Condition条件锁的内部其实是有两把锁的，一把底层锁（同步锁）一把高级锁(递归锁)。

低层锁的解锁方式有两种，使用wait()方法会暂时解开底层锁同时加上一把高级锁，只有当接收到别的线程里的**notfiy()**后才会解开高级锁和重新上锁低层锁，也就是说条件锁底层是根据同步锁和递归锁的不断切换来进行实现的：

def __init__(self, lock=None):    
	if lock is None:        
		lock = RLock()  # 可以看到条件锁的内部是基于递归锁，而递归锁又是基于同步锁来做的    
		self._lock = lock    
		self.acquire = lock.acquire    
		self.release = lock.release    
		try:        
			self._release_save = lock._release_save    
		except AttributeError:        
			pass    
		try:        
			self._acquire_restore = lock._acquire_restore    
		except AttributeError:        
			pass    
		try:        
			self._is_owned = lock._is_owned    
		except AttributeError:        
			pass    
		self._waiters = _deque()

Event事件锁内部是基于条件锁来做的：

class Event:    
	def __init__(self):        
		self._cond = Condition(Lock())  # 实例化出了一个条件锁。        
		self._flag = False    

	def _reset_internal_locks(self):        # private!  
		called by Thread._reset_internal_locks by _after_fork()        
		self._cond.__init__(Lock())    
	
	def is_set(self):        
		"""Return true if and only if the internal flag is true."""        
		return self._flag    
	
	isSet = is_set

Semaphore信号量锁内部也是基于条件锁来做的：

class Semaphore:    
	def __init__(self, value=1):        
		if value < 0:            
			raise ValueError("semaphore initial value must be >= 0")        
		self._cond = Condition(Lock()) # 可以看到，这里是实例化出了一个条件锁        
		self._value = value

基本练习题

条件锁的应用

需求：一个空列表，两个线程轮番往里面加值（一个加偶数，一个加奇数），最终让该列表中的值为 1 - 100 ，且是有序排列的。

import threading

lst = []


def even():
    """加偶数"""
    with condLock:                    # with 自动加锁、解锁
        for i in range(2, 101, 2):
            # 判断当前列表的长度处于2是否能处尽
            # 如果能处尽则代表需要添加奇数
            # 否则就添加偶数
            if len(lst) % 2 != 0:
                # 添偶数
                lst.append(i)      # 先添加值
                condLock.notify()  # 告诉另一个线程，你可以加奇数了，但是这里不会立即交出执行权
                condLock.wait()    # 交出执行权，并等待另一个线程通知加偶数
            else:
                # 添奇数
                condLock.wait()  # 交出执行权，等待另一个线程通知加偶数
                lst.append(i)    
                condLock.notify()	
        condLock.notify()


def odd():
    """加奇数"""
    with condLock:					# 自动加锁、解锁
        for i in range(1, 101, 2):
            if len(lst) % 2 == 0:
                lst.append(i)
                condLock.notify()   # 
                condLock.wait()
        condLock.notify()


if __name__ == "__main__":
    condLock = threading.Condition()     # 条件锁

    addEvenTask = threading.Thread(target=even)
    addOddTask = threading.Thread(target=odd)

    addEvenTask.start()
    addOddTask.start()

    addEvenTask.join()   # join方法的作用是线程同步
    addOddTask.join()

    print(lst)

事件锁的应用

有2个任务线程来扮演李白和杜甫，如何让他们一人一句进行对答？文本如下：

杜甫：老李啊，来喝酒！
李白：老杜啊，不喝了我喝不下了！
杜甫：老李啊，再来一壶？
杜甫：…老李？
李白：呼呼呼…睡着了

代码如下：

import threading


def libai():
    event.wait()  
    print("李白：老杜啊，不喝了我喝不下了！")
    event.set()
    event.clear()
    event.wait()
    print("李白：呼呼呼...睡着了..")

def dufu():
    print("杜甫：老李啊，来喝酒！")
    event.set()  
    event.clear()
    event.wait()
    print("杜甫：老李啊，再来一壶？")
    print("杜甫：...老李？")
    event.set()


if __name__ == '__main__':

    event = threading.Event()    # 事件锁

    t1 = threading.Thread(target=libai)
    t2 = threading.Thread(target=dufu)

    t1.start()
    t2.start()
    t1.join()
    t2.join()
wu_zhiyuan
关注
  • 3
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python多线程系列—Lock锁(三)
weixin_54542209的博客
08-04 1901
3、线程安全是指某个函数，函数库在多线程环境中被调用时，能够正确地处理多个线程之间的共享变量，使程序正确完成。2、线程锁释放的两种情况：等待(IO)导致python解释器锁释放，线程执行时长达到指定的阈值0.005秒。由于线程的执行随时会发生切换，造成了不可预料的结果，出现线程不安全。1、一个进程中可以有多个线程，且线程共享所有进程中的资源。2、多个线程同时操作一个东西，可能会导致数据混乱的情况。1、RLock是递归锁，支持锁多次【推荐使用】1、使用线程锁Lock解决线程安全问题。账户余额: -200。..
python线程中同步锁详解
09-20
主要为大家详细介绍了python线程中同步锁的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Python多线程编程之多线程加锁操作示例
09-20
主要介绍了Python多线程编程之多线程加锁操作,涉及Python线程创建、加锁、释放锁等相关操作技巧,需要的朋友可以参考下
5 - 线程 - Windows 10 - Python 的 5 种线程锁 - 控制线程切换
Muxiu
04-18 2468
目录线程安全Tips线程的切换线程锁的基础核心构成总结1. Lock() 同步锁线程锁 - 同步锁的实现方法with 关键字 - 上下文管理器 - 同步锁死锁现象2. RLock() 递归锁简介线程锁 - 递归锁的实现方法with 关键字 - 上下文管理器 - 递归锁3. Condition() 条件锁条件锁调用 —— 必上递归锁的 wait() 与 notify()线程锁 - 条件锁的实现方法with 关键字 - 上下文管理器 - 条件锁4. Event() 事件锁基本介绍线程锁 - 事件锁的实现方法事
python进阶--多线程，锁的问题
weixin_39399079的博客
01-27 1565
1、先了解一下锁的理论知识。 此为不上锁的脚本。运行后，任务之间会来回切换，互相争抢资源。 来看一下上锁释放锁的脚本。如果是多个线程，当任务开始的时候，会争相抢夺这个锁，谁先抢到，谁先上锁，任务执行完，释放锁，下一个任务继续执行。避开了争资源的情况。 接上面的脚本。 ...
Python 多线程编程-02-threading 模块-锁的使用
一分耕耘一分收获
02-11 3577
1. 线程同步 1.1 线程同步概念 多线程编程有一个非常重要的方面：同步。此处的同步不是指一起行动，而是协同步调，多个线程按预定的先后次序进行运行。 常见的有两种情况： a）例如某些资源，数据库的某个表格、某个文件，不希望（也不应该）被多个线程同时执行，这样就会产生竞争。那么如何协调这种竞争，可以理解为线程同步。这种内存中的资源可以理解为临界区。 b）需要若干个线程按照特定的顺序完成一组工作，如线程 a 打开文件，输入文字，线程...
Python：创建线程、多线程的加锁、解锁机制
博樽
09-24 3144
线程的背景知识、创建线程、 交替获得CPU时间片、多线程抢夺同一个变量、线程 加锁、解锁机制
python 线程安全和锁
Deng872347348的博客
10-21 2054
python 线程安全和锁
Python－线程锁的使用
了解➔熟悉➔掌握➔精通
01-06 4278
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 当有多个线程，且它们同时访问同一资源时，需要考虑如何避免线程冲突。解决办法是使用线程锁。锁由Python的threading模块提供，并且它最多被一个线程所持有。当一个线程试图获取一个已经锁在资源上的锁时，该线程通常会暂停运行，直到这个锁被释放。看看下面的不具备锁功能的例子： #!/usr/bin/env python3 # -*- coding:utf-
python 线程锁
weixin_42610010的博客
12-30 304
在 Python 中，我们可以使用 threading 模块中的 Lock 类来实现线程锁。 使用方法如下： import threadinglock = threading.Lock() # 获取锁 lock.acquire() # 进行线程安全的操作 # 释放锁 lock.release() 当一个线程调用 acquire() 方法获取锁时，如果锁已经被另一个线程持有，则当前线程会被阻...
线程与线程锁---python版本
hleisurely的博客
07-20 116
进程和线程 现代的操作系统基本上都是支持多任务的操作系统 那？什么叫多任务呢，简单而言，就是操作系统可以同时运行多个任务。 就像是上图这种，可以同时运行多个任务，当然还有很多的后台应用也在默默的运行着，只是没有显示在桌面而已 这里就要谈到单核和多核CPU了 单核CPU在执行任务时，通常都是任务1执行一个单位时间，任务2执行一个单位时间，，再切换到任务3，任务4… 这样反复切换。表面而言，这些任务切换时都是交替执行的，但是，由于CPU执行速度实在太快，肉眼感知就像所有的任务都是在同时执行一样。 多核CP
Python全局锁中如何合理运用多线程（多进程）
09-18
主要介绍了Python全局锁中如何合理运用多线程（多进程）,需要的朋友可以参考下
python线程锁(thread)学习示例
12-25
复制代码 代码如下:# encoding: UTF-8import threadimport time# 一个用于在线程中执行的函数def func(): for i in range(5): print ‘func’ time.sleep(1) # 结束当前线程 # 这个方法与thread.exit_thread()...
python线程里哪种模块比较适合
12-17
在Python中可使用的多线程模块主要有两个，thread和threading模块。thread模块提供了基本的线程和锁的支持，建议新手不要使用。threading模块允许创建和管理线程，提供了更多的同步原语。 thread模块函数： start_...
python多线程中 锁的概念 threading.Lock
qq_18668137的博客
12-25 1911
1.概念： 资源加锁是怎么回事，其实并不是给资源加锁, 而是用锁去锁定资源，你可以定义多个锁, 像下面的代码, 当你需要独占某一资源时，任何一个锁都可以锁这个资源，就好比你用不同的锁都可以把相同的一个门锁住是一个道理. import threading import time counter = 0 counter_lock = threading.Lock() #只是定义...
Python多线程1，threading.thread创建多线程&全局变量解锁和锁定,1threadingThread,加锁
baidu_28126759的博客
02-09 488
Python多线程1，threading.thread创建多线程&全局变量解锁和锁定,1threadingThread,加锁 1、开启两个线程分别执行函数 import time import threading def sing(): for i in range(5): # 子线程 print("----正在唱------") time.sleep(1) def dance(): for i in range(5): # 子线程
python多线程中使用锁的简单用例
最新发布
博客
06-02 528
需要注意的是，在使用锁或其他同步机制时，要避免死锁问题，即多个线程因为互相等待对方释放锁而无法继续执行的情况。因此，在编写代码时，要仔细考虑锁的获取和释放顺序，避免出现死锁问题。然后，在访问共享资源的代码块前获取锁，在访问完成后释放锁。这样，同一时刻只有一个线程能够访问共享资源，从而避免了数据竞争和其他问题。在Python中，我们可以使用多种同步机制来保护共享资源的访问，包括锁、信号量、条件变量等。以下是一个简单的使用锁的示例，该示例启动两个线程并让它们分别对共享变量。首先，我们需要创建一个锁对象，使用。
【python多线程中的锁你知道几种？】
weixin_41777118的博客
04-27 2223
1. `threading.Lock`：这是最基础的锁对象，不属于任何线程，在Python中，它是一个同步原语对象。一次只有一个线程可以获得锁。如果一个线程试图获得一个已经被其他线程拿着的锁，那么这个线程就会被阻塞，直到拥有锁的线程释放。 2. `threading.RLock`：可重入锁（`RLock`），允许同一线程多次获取锁，但是每次获取锁都需要释放，通常用于递归函数。如果使用Lock，那么在同一个线程多次获取锁时会产生死锁。 3. `threading.Semaphore`…………………………………
python 线程如何加锁
03-22
在 Python 中，可以使用 threading 模块中的 Lock 对象来实现线程锁。具体实现方式如下： 1. 创建一个 Lock 对象： lock = threading.Lock() 2. 在需要加锁的代码块前调用 acquire() 方法： lock.acquire() 3. 在代码块执行完毕后调用 release() 方法释放锁： lock.release() 这样可以确保同一时刻只有一个线程可以访问被锁定的代码块，从而避免多个线程同时修改同一数据造成的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值