Python线程互斥锁

最新推荐文章于 2024-05-29 19:11:50 发布

芒种、

最新推荐文章于 2024-05-29 19:11:50 发布

阅读量863

点赞数

分类专栏： Python基础/进阶文章标签：多线程 python 并发编程

本文链接：https://blog.csdn.net/weixin_38739598/article/details/108234759

版权

Python基础/进阶专栏收录该内容

22 篇文章 2 订阅

订阅专栏

一、线程间共享全局变量

多线程开发的时候共享全局变量会带来资源竞争效果，数据不安全。

import threading
import time

g_num = 0
def test1(num):
    global g_num
    for i in range(num):
        g_num += 1
        print(f"test1--->{g_num}")
def test2(num):
    global g_num
    for i in range(num):
        g_num += 1
        print(f"test2--->{g_num}")
def main():
    t1 = threading.Thread(target=test1, args=(1000000,))
    t2 = threading.Thread(target=test2, args=(1000000,))
    t1.start()
    t2.start()
if __name__ == '__main__':
    main()

二、同步异步概念

同步的意思就是协同步调，按预定的先后次序执行。例如你先说完然后我再说。

大家不要将同步理解成一起动作，同步是指协同、协助、互相配合。

例如线程同步，可以理解为线程A和B一块配合工作，A执行到一定程度时要依靠B的某个结果，于是停下来示意B执行，B执行完将结果给A,然后A继续执行。

A强依赖B(对方)，A必须等到B的回复，才能做出下一步响应。即A的操作(行程)是顺序执行的，中间少了哪一步都不可以，或者说中间哪一步出错都不可以。

举个例子：

你去外地上学(人生地不熟)，突然生活费不够了；此时你决定打电话回家，通知家里转生活费过来，可是当你拨出电话时，对方一直处于待接听状态(即：打不通，联系不上)，为了拿到生活费，你就不停的oncall、等待，最终可能不能及时要到生活费，导致你今天要做的事都没有完成，而白白花掉了时间。

异步：

异步则相反，A并不强依赖B，A对B响应的时间也不敏感，无论B返回还是不返回，A都能继续运行；B响应并返回了，A就继续做之前的事情，B没有响应，A就做其他的事情。也就是说A不存在等待对方的概念。

举个例子：

在你打完电话发现没人接听时，猜想：对方可能在忙，暂时无法接听电话，所以你发了一条短信(或者语音留言，亦或是其他的方式)通知对方后便忙其他要紧的事了；这时你就不需要持续不断的拨打电话，还可以做其他事情；待一定时间后，对方看到你的留言便回复响应你，当然对方可能转钱也可能不转钱。但是整个一天下来，你还做了很多事情。或者说你找室友临时借了一笔钱，又开始happy的上学时光了。

对于多线程共享全局变量计算错误的问题，我们可以使用线程同步来进行解决。

三、互斥锁

当多个线程几乎同时修改一个共享数据的时候，需要进行同步控制，线程同步能够保证多个线程安全的访问竞争资源(全局内容)，最简单的同步机制就是使用互斥锁。

某个线程要更改共享数据时，先将其锁定，此时资源的状态为锁定状态，其他线程就能更改，直到该线程将资源状态改为非锁定状态，也就是释放资源，其他的线程才能再次锁定资源。互斥锁保证了每一次只有一个线程进入写入操作。从而保证了多线程下数据的安全性。

1.练习一使用互斥锁解决200万次的计算问题。

import threading
import time

g_num = 0
lock = threading.Lock() # 创建一个锁,默认不上锁

def test1(num):
    global g_num
    lock.acquire()
    for i in range(num):
        g_num += 1
    lock.release()
    print(f"test1--->{g_num}")

def test2(num):
    global g_num
    lock.acquire()
    for i in range(num):
        g_num += 1
    lock.release()
    print(f"test2--->{g_num}")

def main():
    t1 = threading.Thread(target=test1, args=(1000000,))
    t2 = threading.Thread(target=test2, args=(1000000,))
    t1.start()
    t2.start()

if __name__ == '__main__':
    main()

四、线程间使用非全局变量

from threading import Thread
import threading
import time

def test1():
    name = threading.current_thread().getName() # 获取当前线程的名字
    print(f"----thread name is {name}")
    g_num = 100
    if name == "Thread-1":
        g_num += 1
    # else:
    #     time.sleep(2)
    print(f"----thread is {name}, g_num is {g_num}")


def main():
    t1 = Thread(target=test1)
    t1.start()

    t2 = Thread(target=test1)
    t2.start()

if __name__ == '__main__':
    main()

非全局对于同一个函数来说.可以通过线程的名字来区分.

五、死锁

所谓死锁：是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源时，就会造成死锁。
尽管死锁很少发生，但一旦发生就会造成应用的停止响应。
产生死锁的代码:

import threading
import time

lockA = threading.Lock()
lockB = threading.Lock()


class Thread_1(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        self.foo()
        self.bar()

    def foo(self):
        lockA.acquire()
        print(f"{self.name}得到lockA {time.ctime()}")
        lockB.acquire()
        print(f"{self.name}得到lockB {time.ctime()}")

        lockB.release()
        print(f"{self.name}释放lockB {time.ctime()}")
        lockA.release()
        print(f"{self.name}释放lockA {time.ctime()}")

    def bar(self):
        lockB.acquire()
        print(f"{self.name}得到lockB {time.ctime()}")
        lockA.acquire()
        print(f"{self.name}得到lockA {time.ctime()}")

        lockA.release()
        print(f"{self.name}释放lockA {time.ctime()}")
        lockB.release()
        print(f"{self.name}释放lockB {time.ctime()}")


if __name__ == '__main__':
    for i in range(10):
        t = Thread_1()
        t.start()

六、解决死锁办法

1. 递归锁

递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。

上面的例子如果使用RLock代替Lock，则不会发生死锁，

二者的区别是：

递归锁可以连续acquire多次，每acquire一次计数器加1，
只要计数不为0，就不能被其他线程抢到。只有计数为0时，才能被其他线程抢到acquire。释放一次计数器-1
而互斥锁只能加锁acquire一次，想要再加锁acquire，就需要release解之前的锁

import threading
import time

lockB = lockA = threading.RLock()

class Thread_1(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        self.foo()
        self.bar()

    def foo(self):
        lockA.acquire()
        print(f"{self.name}得到lockA {time.ctime()}")
        lockB.acquire()
        print(f"{self.name}得到lockB {time.ctime()}")

        lockB.release()
        print(f"{self.name}释放lockB {time.ctime()}")
        lockA.release()
        print(f"{self.name}释放lockA {time.ctime()}")

    def bar(self):
        lockB.acquire()
        print(f"{self.name}得到lockB {time.ctime()}")
        lockA.acquire()
        print(f"{self.name}得到lockA {time.ctime()}")

        lockA.release()
        print(f"{self.name}释放lockA {time.ctime()}")
        lockB.release()
        print(f"{self.name}释放lockB {time.ctime()}")

if __name__ == '__main__':
    for i in range(10):
        t = Thread_1()
        t.start()

2. Semaphore（信号量）

Semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

实例：(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5)：

import threading
import time

seamphore = threading.Semaphore(5)

def foo():
    seamphore.acquire()
    time.sleep(2)
    print("ok")
    seamphore.release()
for i in range(10):
    t = threading.Thread(target=foo)
    t.start()

3. condition实现线程通信

threading.Condition() 可以理解为更加高级的锁，比 Lock 和 Rlock 的用法更高级，能处理一些复杂的线程同步问题。threading.Condition() 创建一把资源锁（默认是Rlock），提供 acquire() 和 release() 方法，用法和 Rlock 一致。此外 Condition 还提供 wait()、Notify() 和 NotifyAll() 方法。

wait()：线程挂起，直到收到一个 Notify() 通知或者超时（可选参数），wait() 必须在线程得到 Rlock 后才能使用。

Notify() ：在线程挂起的时候，发送一个通知，让 wait() 等待线程继续运行，Notify() 也必须在线程得到 Rlock 后才能使用。 Notify(n=1)，最多唤醒 n 个线程。

NotifyAll() ：在线程挂起的时候，发送通知，让所有 wait() 阻塞的线程都继续运行。

import threading,time

def TestA():
    cond.acquire()
    print('李白：看见一个敌人，请求支援')
    cond.wait()
    print('李白：好的')
    cond.notify()
    cond.release()

def TestB():
    time.sleep(2)
    cond.acquire()
    print('亚瑟：等我...')
    cond.notify()
    cond.wait()
    print('亚瑟：我到了，发起冲锋...')

if __name__=='__main__':
    cond = threading.Condition()
    testA = threading.Thread(target=TestA)
    testB = threading.Thread(target=TestB)
    testA.start()
    testB.start()
    testA.join()
    testB.join()

4. Event实现线程通信

hreading.Event() 原理是在线程中立了一个 Flag ，默认值是 False ，当一个或多个线程遇到 event.wait() 方法时阻塞，直到 Flag 值变为 True 。threading.Event() 通常用来实现线程之间的通信，使一个线程等待其他线程的通知，把 Event 传递到线程对象中。

event.wait() ：阻塞线程，直到 Flag 值变为 True

event.set() ：设置 Flag 值为 True

event.clear() ：修改 Flag 值为 False

event.isSet() : 仅当 Flag 值为 True 时返回

下面这个例子，主线程启动子线程后 sleap 2秒，子线程因为 event.wait() 被阻塞。当主线程醒来后执行 event.set() ，子线程才继续运行，两者输出时间差 2s。

mport threading
import datetime,time

class thread(threading.Thread):
    def __init__(self, threadname):
        threading.Thread.__init__(self, name='线程' + threadname)
        self.threadname = int(threadname)

    def run(self):
        event.wait()
        print('子线程运行时间：%s'%datetime.datetime.now())

if __name__ == '__main__':
    event = threading.Event()
    t1 = thread('0')
    #启动子线程
    t1.start()
    print('主线程运行时间：%s'%datetime.datetime.now())
    time.sleep(2)
    # Flag设置成True
    event.set()
    t1.join()

threading.active_count()：返回当前存活的线程对象的数量
threading.current_thread()：返回当前线程对象
threading.enumerate()：返回当前所有线程对象的列表
threading.get_ident()：返回线程pid
threading.main_thread()：返回主线程对象

芒种、

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Python线程互斥锁

一、线程间共享全局变量多线程开发的时候共享全局变量会带来资源竞争效果，数据不安全。import threadingimport timeg_num = 0def test1(num): global g_num for i in range(num): g_num += 1 print(f"test1--->{g_num}")def test2(num): global g_num for i in range(num):
复制链接

扫一扫

专栏目录