python 多线程讲解（如何实现多线程，递归锁，互斥锁，信号量，事件等）

旧城等待， 2023-01-08 02:06 58阅读 0赞

## 什么是线程 ##

线程（Thread）也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。

## 为什么使用多线程 ##

线程在程序中是独立的、并发的执行流。与分隔的进程相比，进程中线程之间的隔离程度要小，它们共享内存、文件句柄和其他进程应有的状态。  
因为线程的划分尺度小于进程，使得多线程程序的并发性高。进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。  
线程比进程具有更高的性能，这是由于同一个进程中的线程都有共性多个线程共享同一个进程的虚拟空间。线程共享的环境包括进程代码段、进程的公有数据等，利用这些共享的数据，线程之间很容易实现通信。  
操作系统在创建进程时，必须为该进程分配独立的内存空间，并分配大量的相关资源，但创建线程则简单得多。因此，使用多线程来实现并发比使用多进程的性能要高得多。  
总结起来，使用多线程编程具有如下几个优点：

1.  进程之间不能共享内存，但线程之间共享内存非常容易
2.  操作系统在创建进程时，需要为该进程重新分配系统资源，但创建线程的代价则小得多。因此，使用多线程来实现多任务并发执行比使用多进程的效率高
3.  Python 语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了 Python 的多线程编程

## 线程实现 ##

threading模块  
普通创建

import threading
    
    def run(n,i):
        print("我是线程", n,i)
    
    
    if __name__ == '__main__':
        for i in range(10):
            t1 = threading.Thread(target=run, args=("A",i))
            t2 = threading.Thread(target=run, args=("B",i))
            t1.start()
            t2.start()

![20210118141621860.png_pic_center][]

传递参数的方法：

使用args 传递参数 threading.Thread(target=fun, args=(10, 100, 100))  
使用kwargs传递参数 threading.Thread(target=fun, kwargs=\{“a”: 10, “b”:100, “c”: 100\})  
同时使用 args 和 kwargs 传递参数 threading.Thread(target=fun, args=(10, ), kwargs=\{“b”: 100,“c”: 100\})

自定义线程

import threading
    
    class MyThread(threading.Thread):
        def __init__(self, n):
            super(MyThread, self).__init__()  # 重构run函数必须要写
            self.n = n
    
        def run(self):
            print("我是线程", self.n)
    
    
    if __name__ == "__main__":
        for i in range(10):
            t1 = MyThread("t1")
            t2 = MyThread("t2")
            t1.start()
            t2.start()

![20210118142137393.png_pic_center][]

守护线程  
使用setDaemon(True)把所有的子线程都变成了主线程的守护线程，因此当主进程结束后，子线程也会随之结束。所以当主线程结束后，整个程序就退出了。

import threading
    import time
    
    
    def run(n):
        print("task", n)
        time.sleep(1)  # 此时子线程停1s
        print('3')
        time.sleep(1)
        print('2')
        time.sleep(1)
        print('1')
    
    
    if __name__ == '__main__':
        t = threading.Thread(target=run, args=("t1",))
        t.setDaemon(True)  # 把子进程设置为守护线程，必须在start()之前设置
        t.start()
        print("end")

代码中  
t和print(“end”)是不同的线程,print(“end”)是主线程  
![2021011814274726.png_pic_center][]

主线程等待子线程结束  
为了让守护线程执行结束之后，主线程再结束，我们可以使用join方法，让主线程等待子线程执行。

import threading
    import time
    
    def run(n):
        print("task", n)
        time.sleep(1)       #此时子线程停1s
        print('3')
        time.sleep(1)
        print('2')
        time.sleep(1)
        print('1')
    
    if __name__ == '__main__':
        t = threading.Thread(target=run, args=("t1",))
        t.setDaemon(True)   #把子进程设置为守护线程，必须在start()之前设置
        t.start()
        t.join() # 设置主线程等待子线程结束
        print("end")

![20210118143258612.png_pic_center][]

多线程共享全局变量  
线程是进程的执行单元，进程是系统分配资源的最小单位，所以在同一个进程中的多线程是共享资源的。

import threading
    import time
    
    g_num = 100
    
    def work1():
        global g_num
        for i in range(3):
            g_num += 1
        print("in work1 g_num is : %d" % g_num)
    
    def work2():
        #global g_num
        print("in work2 g_num is : %d" % g_num)
    
    if __name__ == '__main__':
        t1 = threading.Thread(target=work1)
        t1.start()
        time.sleep(1)
        t2 = threading.Thread(target=work2)
        t2.start()

![20210118143929294.png_pic_center][]

互斥锁  
由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁，即同一时刻允许一个线程执行操作。线程锁用于锁定资源，你可以定义多个锁, 像下面的代码, 当你需要独占某一资源时，任何一个锁都可以锁这个资源，就好比你用不同的锁都可以把相同的一个门锁住是一个道理。

由于线程之间是进行随机调度，如果有多个线程同时操作一个对象，如果没有很好地保护该对象，会造成程序结果的不可预期，我们也称此为“线程不安全”。  
为了方式上面情况的发生，就出现了互斥锁(Lock)

如果不使用锁

import time, threading
    
    # 假定这是你的银行卡余额:
    balance = 0
    
    def change_it(n):
        # 先存后取，结果应该为0:
        global balance
        balance = balance + n
        balance = balance - n
    
    
    def run_thread(n):
        for i in range(1000000):
            change_it(n)
    
    t1 = threading.Thread(target=run_thread, args=(5,))
    t2 = threading.Thread(target=run_thread, args=(8,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print(balance)

![20210118145135895.png_pic_center][]

定义了一个共享变量balance，初始值为0，并且启动两个线程，先存后取，理论上结果应该为0，但是，由于线程的调度是由操作系统决定的，当t1、t2交替执行时，只要循环次数足够多，balance的结果就不一定是0了。

原因是因为高级语言的一条语句在CPU执行时是若干条语句，即使一个简单的计算：

balance = balance + n

也分两步：

x = balance + n
    balance = x

两条语句被执行多次就说不定不是0啦  
究其原因，是因为修改balance需要多条语句，而执行这几条语句时，线程可能中断，从而导致多个线程把同一个对象的内容改乱了。

两个线程同时一存一取，就可能导致余额不对，你肯定不希望你的银行存款莫名其妙地变成了负数，所以，必须确保一个线程在修改balance的时候，别的线程一定不能改。  
如果我们要确保balance计算正确，就要给change\_it()上一把锁，当某个线程开始执行change\_it()时，我们说，该线程因为获得了锁，因此其他线程不能同时执行change\_it()，只能等待，直到锁被释放后，获得该锁以后才能改。由于锁只有一个，无论多少线程，同一时刻最多只有一个线程持有该锁，所以，不会造成修改的冲突。创建一个锁就是通过threading.Lock()来实现：

import time, threading
    
    # 假定这是你的银行卡余额:
    balance = 0
    
    def change_it(n):
        # 先存后取，结果应该为0:
        global balance
        balance = balance + n
        balance = balance - n
    
    
    lock = threading.Lock()
    def run_thread(n):
        for i in range(1000000):
            # 先要获取锁:
            lock.acquire()
            try:
                # 放心地改吧:
                change_it(n)
            finally:
                # 改完了一定要释放锁:
                lock.release()
    
    
    t1 = threading.Thread(target=run_thread, args=(5,))
    t2 = threading.Thread(target=run_thread, args=(8,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print(balance)

![20210118145915427.png_pic_center][]

递归锁  
RLcok类的用法和Lock类一模一样，但它支持嵌套，在多个锁没有释放的时候一般会使用RLcok类。

import threading
    import time
    
    def Func(lock):
        global gl_num
        lock.acquire()
        gl_num += 1
        time.sleep(1)
        print(gl_num)
        lock.release()
    
    if __name__ == '__main__':
        gl_num = 0
        lock = threading.RLock()
        for i in range(10):
            t = threading.Thread(target=Func, args=(lock,))
            t.start()

![20210118150245161.png_pic_center][]

信号量（BoundedSemaphore类)  
互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

import time
    
    def run(n, semaphore):
        semaphore.acquire()   #加锁
        time.sleep(1)
        print("run the thread:%s\n" % n)
        semaphore.release()     #释放
    
    if __name__ == '__main__':
        num = 0
        semaphore = threading.BoundedSemaphore(5)  # 最多允许5个线程同时运行
        for i in range(22):
            t = threading.Thread(target=run, args=("t-%s" % i, semaphore))
            t.start()
        while threading.active_count() != 1:
            pass  # print threading.active_count()
        else:
            print('-----all threads done-----')

![20210118150708140.png_pic_center][]

事件（Event类）

python线程的事件用于主线程控制其他线程的执行，事件是一个简单的线程同步对象，其主要提供以下几个方法：

clear 将flag设置为“False”  
set 将flag设置为“True”  
is\_set 判断是否设置了flag  
wait 会一直监听flag，如果没有检测到flag就一直处于阻塞状态  
事件处理的机制：全局定义了一个“Flag”，当flag值为“False”，那么event.wait()就会阻塞，当flag值为“True”，那么event.wait()便不再阻塞。

#利用Event类模拟红绿灯
    import threading
    import time
    
    event = threading.Event()
    
    
    def lighter():
        count = 0
        event.set()     #初始值为绿灯
        while True:
            if 5 < count <=10 :
                event.clear()  # 红灯，清除标志位
                print("\33[41;1mred light is on...\033[0m")
            elif count > 10:
                event.set()  # 绿灯，设置标志位
                count = 0
            else:
                print("\33[42;1mgreen light is on...\033[0m")
    
            time.sleep(1)
            count += 1
    
    def car(name):
        while True:
            if event.is_set():      #判断是否设置了标志位
                print("[%s] running..."%name)
                time.sleep(1)
            else:
                print("[%s] sees red light,waiting..."%name)
                event.wait()
                print("[%s] green light is on,start going..."%name)
    
    light = threading.Thread(target=lighter,)
    light.start()
    
    car = threading.Thread(target=car,args=("MINI",))
    car.start()

![20210118151046519.png_pic_center][]

![在这里插入图片描述][20210118151120110.jpg_pic_center]  
本文主要转述来源  
https://www.cnblogs.com/luyuze95/p/11289143.html

[20210118141621860.png_pic_center]: /images/20221119/7d33b34373c84077b51e6c6afbdd2762.png
[20210118142137393.png_pic_center]: /images/20221119/941968ca0ace408bb5b6be545c928b50.png
[2021011814274726.png_pic_center]: /images/20221119/b838f17a7b1a49dbaac57846a0cb51f8.png
[20210118143258612.png_pic_center]: https://img-blog.csdnimg.cn/20210118143258612.png#pic_center
[20210118143929294.png_pic_center]: https://img-blog.csdnimg.cn/20210118143929294.png#pic_center
[20210118145135895.png_pic_center]: https://img-blog.csdnimg.cn/20210118145135895.png#pic_center
[20210118145915427.png_pic_center]: https://img-blog.csdnimg.cn/20210118145915427.png#pic_center
[20210118150245161.png_pic_center]: https://img-blog.csdnimg.cn/20210118150245161.png#pic_center
[20210118150708140.png_pic_center]: https://img-blog.csdnimg.cn/20210118150708140.png#pic_center
[20210118151046519.png_pic_center]: https://img-blog.csdnimg.cn/20210118151046519.png#pic_center
[20210118151120110.jpg_pic_center]: https://img-blog.csdnimg.cn/20210118151120110.jpg#pic_center