python之多线程 threading.Lock() 和 threading.RLock()

最新推荐文章于 2025-01-21 11:46:08 发布
转载 最新推荐文章于 2025-01-21 11:46:08 发布 · 413 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/my8100/p/7399600.html
文章标签：

#python

本文详细探讨了Python中线程同步的重要性和实现方法，包括使用threading.Lock()和threading.RLock()进行资源保护，避免多线程环境下的竞态条件，并通过实例展示了不同情况下锁的使用效果。

0.目录

2. threading.Lock() 的必要性
3.观察block
4.threading.RLock() 的应用场景

1.参考

Thread Synchronization Mechanisms in Python

count += 1 不是原子操作，三步操作可能被中断，通过lock将三步操作“封装”为一步操作，要么执行，要么不执行。

counter = 0

def process_item(item):
    global counter
    ... do something with item ...
    counter += 1

# The reason for this is that the increment operation is actually executed in three steps; 
#first, the interpreter fetches the current value of the counter,
# then it calculates the new value,
# and finally, it writes the new value back to the variable.
View Code

Atomic Operations #

The simplest way to synchronize access to shared variables or other resources is to rely on atomic operations in the interpreter.

An atomic operation is an operation that is carried out in a single execution step, without any chance that another thread gets control.

 

 What kinds of global value mutation are thread-safe?

python的原子操作

A global interpreter lock (GIL) is used internally to ensure that only one thread runs in the Python VM at a time. In general, Python offers to switch among threads only between bytecode instructions; how frequently it switches can be set via sys.setcheckinterval(). Each bytecode instruction and therefore all the C implementation code reached from each instruction is therefore atomic from the point of view of a Python program.

In theory, this means an exact accounting requires an exact understanding of the PVM bytecode implementation. In practice, it means that operations on shared variables of built-in data types (ints, lists, dicts, etc) that “look atomic” really are.

For example, the following operations are all atomic (L, L1, L2 are lists, D, D1, D2 are dicts, x, y are objects, i, j are ints):

L.append(x)
L1.extend(L2)
x = L[i]
x = L.pop()
L1[i:j] = L2
L.sort()
x = y
x.field = y
D[x] = y
D1.update(D2)
D.keys()

These aren’t:

i = i+1
L.append(L[-1])
L[i] = L[j]
D[x] = D[x] + 1

Operations that replace other objects may invoke those other objects’ __del__() method when their reference count reaches zero, and that can affect things. This is especially true for the mass updates to dictionaries and lists. When in doubt, use a mutex!
View Code

 

2. threading.Lock()  的必要性

#!usr/bin/env python
#coding:utf-8
import sys
import time
import random
import logging

import threading
import Queue


lock = threading.Lock()     #'function-call ownership'
rlock = threading.RLock()   #thread ownership

logging.basicConfig(level=logging.DEBUG,
                    format = '%(asctime)s - %(threadName)-10s - %(levelname)s - %(message)s')
logger = logging.getLogger()


count = 0

class MyThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        
    def run(self):
        global count
        
        for i in range(100):
            count += 1
        logger.debug('{} finished, count is {}'.format(self.name, count))     

def main():
    logger.debug('initial count: {}'.format(count))
    
    thread_list = [MyThread() for i in range(2)]
    for t in thread_list:
        t.start()
    for t in thread_list:
        t.join()   

    logger.debug('final count: {}'.format(count))


if __name__ == '__main__':
    main()
View Code

修改run函数代码的不同输出：

    def run(self):
        global count

        for i in range(100):
            count += 1
        logger.debug('{} finished, count is {}'.format(self.name, count))     
# 在切换线程之前，某一线程已经完成，两个线程顺序完成，结果几乎不会有误
# 2017-08-20 12:19:30,857 - MainThread - DEBUG - initial count: 0
# 2017-08-20 12:19:30,858 - Thread-1   - DEBUG - Thread-1 finished, count is 100
# 2017-08-20 12:19:30,858 - Thread-2   - DEBUG - Thread-2 finished, count is 200
# 2017-08-20 12:19:30,858 - MainThread - DEBUG - final count: 200        
        
        time.sleep(0.001)
        for i in range(100):
            count += 1
        logger.debug('{} finished, count is {}'.format(self.name, count)) 
# 开头sleep导致两个线程几乎同时启动，结果可能有误
# 2017-08-20 12:24:59,046 - MainThread - DEBUG - initial count: 0
# 2017-08-20 12:24:59,048 - Thread-2   - DEBUG - Thread-2 finished, count is 124
# 2017-08-20 12:24:59,048 - Thread-1   - DEBUG - Thread-1 finished, count is 153
# 2017-08-20 12:24:59,048 - MainThread - DEBUG - final count: 153
        
        for i in range(10000):
            count += 1
        logger.debug('{} finished, count is {}'.format(self.name, count))  
# bytecodes足够导致两个线程交替运行，结果大概率有误      
# 2017-08-20 12:20:17,719 - MainThread - DEBUG - initial count: 0
# 2017-08-20 12:20:17,723 - Thread-1   - DEBUG - Thread-1 finished, count is 12438
# 2017-08-20 12:20:17,723 - Thread-2   - DEBUG - Thread-2 finished, count is 12616
# 2017-08-20 12:20:17,723 - MainThread - DEBUG - final count: 12616        
        
            
        with lock:
            for i in range(10000):
                count += 1
        logger.debug('{} finished, count is {}'.format(self.name, count))    
# lock直到某一线程完成，结果正确
# 2017-08-20 12:20:37,630 - MainThread - DEBUG - initial count: 0
# 2017-08-20 12:20:37,631 - Thread-1   - DEBUG - Thread-1 finished, count is 10000
# 2017-08-20 12:20:37,632 - Thread-2   - DEBUG - Thread-2 finished, count is 20000
# 2017-08-20 12:20:37,634 - MainThread - DEBUG - final count: 20000
        

        for i in range(10000):
            with lock:
                count += 1
        logger.debug('{} finished, count is {}'.format(self.name, count)) 
# 两个线程交替lock，结果正确        
# 2017-08-20 12:21:03,921 - MainThread - DEBUG - initial count: 0
# 2017-08-20 12:21:03,973 - Thread-1   - DEBUG - Thread-1 finished, count is 19979
# 2017-08-20 12:21:03,973 - Thread-2   - DEBUG - Thread-2 finished, count is 20000
# 2017-08-20 12:21:03,973 - MainThread - DEBUG - final count: 20000

 

3.观察block

    def run(self):
        global count

        all = range(10000)  #确保每个线程 +1 的次数
        while all != []: 
            if not lock.acquire(False):  #假设没有参数会导致block，则马上返回false当不block；否则返回true且acquire
                logger.debug('{} wait...{}'.format(self.name, len(all)))   
            else:
                try:
                    count += 1
                    all.pop()
                except Exception as err:
                    logger.debug('{} err, count is {}'.format(self.name, count))   
                finally:
                    # logger.debug('{} release {} {}'.format(self.name, count, len(all)))  #导致两个线程顺序执行？？？
                    lock.release()
        logger.debug('{} finished, count is {}'.format(self.name, count))

输出：

2017-08-20 12:32:55,204 - MainThread - DEBUG - initial count: 0
2017-08-20 12:32:55,210 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,210 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,210 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,210 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,210 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,210 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,210 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,211 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,213 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,213 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,213 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,213 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,214 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,214 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,214 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,214 - Thread-1   - DEBUG - Thread-1 wait...9925
2017-08-20 12:32:55,216 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,216 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,216 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,216 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,216 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,217 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,217 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,217 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,217 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,217 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,217 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,217 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,217 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,217 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,219 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,219 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,219 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,219 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,219 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,220 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,220 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,220 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,220 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,220 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,220 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,220 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,220 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,220 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,220 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,221 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,221 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,221 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,221 - Thread-2   - DEBUG - Thread-2 wait...6036
2017-08-20 12:32:55,226 - Thread-1   - DEBUG - Thread-1 finished, count is 13964
2017-08-20 12:32:55,236 - Thread-2   - DEBUG - Thread-2 finished, count is 20000
2017-08-20 12:32:55,236 - MainThread - DEBUG - final count: 20000

 

4.threading.RLock() 的应用场景

Problems with Simple Locking

lock = threading.Lock()

def get_first_part():
    with lock: # any thread that attempts to acquire the lock will block, even if the same thread is already holding the lock. 
        ... fetch data for first part from shared object
    return data    
 
def get_second_part():
    with lock:
        ... fetch data for second part from shared object
    return data  
    
def get_both_parts():
    with lock:  # other thread may modify the resource between the two calls
        first = get_first_part()
        # between the two calls
        second = get_second_part()
    return first, second    
    
# While simple locks will block if the same thread attempts to acquire the same lock twice, 
# a re-entrant lock only blocks if another thread currently holds the lock. 
rlock = threading.RLock()

 

转载于:https://www.cnblogs.com/my8100/p/7399600.html

深入理解 Python 中的 threading.Lock：并发编程的基石
这家伙很懒，什么都没有留下
10-25 1594
threading.Lock 是 Python 中用于实现线程间互斥锁的基本工具。通过正确使用锁，可以保护共享资源免受数据竞争和不一致问题的困扰。本文介绍了 threading.Lock 的基本概念、使用方法、注意事项以及两个使用案例，希望能帮助读者深入理解并掌握这一工具。在实际编程中，应该根据具体需求选择合适的同步原语和策略来实现并发控制。
python多线程之线程锁（Lock）和递归锁（RLock）实例
专业资深测试者，多年质量管理经验，浪迹网游、金融、房产、招聘及海外行业多年，CDSN百万原创阅读，公众号500+原创文章，提倡测试左移、风险、越权、假设、探索测试，喜欢用抽象思维模式思考和技术探讨，自动化、性能、安全测试实施者，感谢关注！
03-15 1734
一、线程锁 Threading模块为我们提供了一个类，Threading.Lock锁。我们创建一个该类对象，在线程函数执行前，“抢占”该锁，执行完成后，“释放”该锁，则我们确保了每次只有一个线程占有该锁。这时候对一个公共的对象进行操作，则不会发生线程不安全的现象了。 1、我们先建立了一个threading.Lock类对象lock,在run方法里，我们使用lock.acquire()...
Python线程锁 threading.Lock()介绍
qq_42310545的博客
01-21 2261
在 Python 中，线程锁（Thread Lock）是一种同步原语，用于在多线程环境中协调线程之间的访问，避免多个线程同时访问共享资源时出现竞态条件（Race Condition）。线程锁确保在任何时刻只有一个线程可以访问特定的资源。为了实现线程锁，Python的threading模块提供了Lock类，下面将先简单介绍下Lock类的一些基础概念和用法。
线程锁的使用 （with语句加普通锁写法）
zhouxuan612的博客
09-23 1514
with语句 Python Threading中的Lock模块有acquire()和release()两种方法，这两种方法与with语句的搭配相当于，进入with语句块时候会先执行acquire()方法，语句块结束后会执行release方法。 import threading import time lock = threading.Lock() class Singleton(): def __init__(self): time.sleep(1) @clas
Python 多线程编程(二):threading 模块中 Lock 类的用法详解
热门推荐
frank 的专栏
12-23 3万+
在前面一篇博文《Python多线程编程(一）：threading 模块 Thread 类的用法详解 》 我有简单介绍怎么利用 threading 模块进行多线程的编码。 但那只是多线程编码最简单的部分，真正难的其实是多个线程之间的通信和数据同步。 大概可以这样讲，多线程最难的是如何正确协调各个线程修改同一份数据。 以卖票的例子作为说明。 买票有多个窗口，假设有 3 个好了，窗口之间共享一个票池，每...
python threading lock_python之多线程 threading.Lock() 和 threading.RLock()
weixin_39862716的博客
11-30 516
python之多线程 threading.Lock() 和 threading.RLock()
python threading lock和rlock_正确使用threading.RLock
weixin_39999730的博客
12-22 363
I'm creating a utility in Python that reads data in from a file on startup on a separate thread so that the rest of the GUI components can load. The data gets stored into a list and then appended to a...
Python应用实战：python多线程-多线程安全问题&lock与rlock.zip
03-21
总的来说，理解并正确使用锁和可重入锁是解决Python多线程安全问题的关键。在编写多线程程序时，合理地引入锁机制可以防止数据竞争，确保程序的正确性。但同时，过度使用锁可能导致程序的复杂性和性能下降，因此在...
Python线程协作threading.Condition实现过程解析
09-17
总结来说，`threading.Condition`在Python多线程环境中提供了一种灵活的同步机制，通过控制线程的执行顺序和等待状态，确保线程安全地共享资源。它特别适用于那些需要等待特定条件满足才能继续执行的场景。在实际...
python使用threading获取线程函数返回值的实现方法
09-21
`threading`模块是Python的标准库之一，它提供了线程管理的功能，包括创建、同步和控制线程。然而，Python的`threading`模块本身并不直接支持获取线程函数的返回值，这需要我们通过一些额外的方式来实现。以下将详细...
python threading lock_python的threading模块中threading.RLock和threading.Lock | 学步园
weixin_39972777的博客
11-30 309
python的threading模块中threading.RLock和threading.Lock | 学步园
Python 线程,with的作用(自动获取和释放锁Lock)
houyanhua1的专栏
10-14 1万+
import threading import time num=0 #全局变量多个线程可以读写，传递数据 mutex=threading.Lock() #创建一个锁 class Mythread(threading.Thread): def run(self): global num with mutex: #with Lock的作用相当于自动获
【python】详解threading模块：lock、Rlock的使用（二）
brucewong0516的博客
08-08 2万+
在之前的【python】多线程threading详解一文中，是有对多线程进行一个详细的梳理的。其中就提到了线程锁这一功能。主要基于Rlock实现。本文将进一步总结，丰富线程锁内容。 在使用多线程的应用下，如何保证线程安全，以及线程之间的同步，或者访问共享变量等问题是十分棘手的问题，也是使用多线程下面临的问题，如果处理不好，会带来较严重的后果，使用python多线程中提供Lock 、Rlock 、...
python threading.Lock()
robert198837的专栏
12-08 2561
''' Created on 2013-12-7 @author: Administrator ''' import threading,time b=50 l=threading.Lock() def threadcode():     global b     print "thread %s invoked " % threading.current
python模块学习（threading模块中的Lock类和RLock类）
去海里喂鱼的博客
11-09 616
学习版本3.5.2 Lock类：一个线程对资源进行加锁操作之后其它线程就必须等它释放锁之后才能对该资源进行操作。acquire()与acquire_lock()都是加锁操作，release()与release_lock()都是释放锁操作，locked()与locked_lock()都是查询当前锁的状态。 RLock类：线程对资源进行加锁操作后，该线程还能继续对该资源加锁，加锁和释放锁的数量需要
Python threading中lock的使用
锅炉房刘大爷的博客
03-28 3万+
在多线程中使用lock可以让多个线程在共享资源的时候不会“乱”，例如，创建多个线程，每个线程都往空列表l中添加一个数字并打印当前的列表l，如果不加锁，就可能会这样：# encoding=utf8 import threading import time lock = threading.Lock() l = [] def test1(n): lock.acquire() l.append...
python中thread.Lock()和thread.RLock()的区别
IT之一小佬的博客
09-03 1095
python中thread.Lock()和thread.RLock()的区别
python threading Lock
yuanzhoulvpi的博客
10-21 357
python threading Lock
python threading.lock
Claroja
08-07 476
threading.Lock() threading.RLock() 递归所，同一线程可以被多次acquire，如果使用RLock，那么acquire和release必须成对出现，调用了n次acquire锁请求，则必须调用n次的release才能在线程中释放锁对象 Lock.acquire([blocking]) Lock.release() thread.Lock thread.RLock 参考： https://www.jb51.net/article/154462.htm ...
self.lock = threading.Lock() with self.lock
最新发布
04-30
<think>好的，我现在要帮用户解决关于Python中threading.Lock()的正确使用，特别是与with语句结合的问题。首先，我得回顾一下用户的问题，确保我理解正确。 用户问的是如何正确使用threading.Lock()，以及self.lock = threading.Lock()和with self.lock的结合用法。他们可能是在多线程编程中遇到了资源竞争的问题，想要确保线程安全。用户可能已经知道Lock的基本概念，但需要更具体的代码示例和最佳实践。 接下来，我需要回忆Python中Lock的机制。根据引用[1]和[3]，Lock和RLock的区别在于RLock允许同一线程多次acquire，而Lock不行。但用户这里提到的是threading.Lock()，所以应该使用普通的Lock。 用户提到with语句，这让我想到上下文管理器，Lock对象支持上下文管理协议，所以使用with可以自动获取和释放锁，避免忘记释放导致死锁。引用[3]中提到acquire和release必须成对出现，使用with语句能很好地保证这一点。 接下来，我需要构建一个示例代码，展示如何将Lock作为实例变量，并在方法中使用with self.lock。比如，在一个类中初始化self.lock，然后在需要线程安全的方法中使用with语句。 然后，我需要分步骤解释代码。首先创建Lock实例，接着在需要同步的代码块前获取锁，使用with自动管理。还要强调锁的范围应尽量小，避免不必要的性能损耗。 用户可能还会关心常见错误，比如忘记释放锁，或者错误地共享锁实例。需要指出这些情况，并给出避免方法，比如使用with语句，或确保每个实例有自己的锁。 最后，根据用户的要求生成相关问题。比如Lock与RLock的区别，处理死锁的方法，以及多线程数据共享的技术。这些扩展问题可以帮助用户深入理解。 检查引用内容是否适用。引用[1]和[3]提到了RLock和Lock的区别，但用户的问题是关于Lock的，所以主要参考这些引用来强调正确使用acquire和release的必要性，以及with语句的优势。 总结回答结构：先介绍Lock的作用，然后给出代码示例，分步解释，常见错误及解决方法，最后相关问题。确保内容清晰，符合用户需求，并正确应用引用中的知识点。</think>### Python中threading.Lock()与`with`语句的结合用法 #### 1. threading.Lock()基础作用 线程锁用于解决多线程并发操作共享资源时的竞争问题。通过`acquire()`获取锁和`release()`释放锁，保证临界区代码的原子性执行[^3]。 #### 2. 推荐结合`with`语句的用法 ```python import threading class SharedCounter: def __init__(self): self.value = 0 self.lock = threading.Lock() # 创建Lock实例 def increment(self): with self.lock: # 自动获取和释放锁 self.value += 1 print(f"Current value: {self.value}") ``` #### 3. 关键步骤解析 - **创建锁对象**：通过`self.lock = threading.Lock()`将锁作为实例属性 - **上下文管理器**：`with self.lock`语句等价于： ```python self.lock.acquire() try: # 临界区代码 finally: self.lock.release() ``` - **原子操作保证**：在`with`代码块内对`self.value`的操作不会被其他线程中断 #### 4. 典型错误场景 ```python # 错误示例：忘记释放锁 def unsafe_increment(self): self.lock.acquire() # 获取锁 self.value += 1 # 若后续代码抛出异常，锁将无法释放 ``` #### 5. 最佳实践建议 1. **锁作用域最小化**：只在必要代码段加锁 2. **避免嵌套锁**：`threading.Lock()`不支持重入，重复获取会导致死锁 3. **实例级锁策略**：建议为每个资源实例创建独立锁 ```python class DatabaseConnection: def __init__(self): self.lock = threading.Lock() self.connection = create_connection() def query(self, sql): with self.lock: # 保证连接操作的线程安全 return self.connection.execute(sql) ``` #### 6. 性能优化提示 - 当需要同时锁定多个资源时，应**按固定顺序获取锁**，避免死锁 - 对于读多写少场景，可考虑使用`threading.RLock()`或更高级的同步原语 $$ \text{锁持有时间} \propto \frac{1}{\text{系统吞吐量}} $$ （公式说明：锁持有的时间越长，系统并发性能越低）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值