【python】多线程的使用

Bertha 。 2022-11-24 14:09 108阅读 0赞

#### 1.线程 ####

线程是CPU调度的基本单位，线程不能独立存在，依附于进程  
线程与进程的使用非常相似，可以参考上一篇的笔记  
[【python】多进程的使用][python]

**线程的特点**

*  线程的执行是无序的，由CPU调度
 *  进程不能共享全局变量，线程是共享全局变量的，但要注意资源竞争问题
 *  主线程会等待子线程结束才能结束
 *  只要有一个线程不是守护主线程，主线程都会等待该子线程执行完之后再结束，期间其他守护主线程都可以继续执行

#### 2.线程的创建 ####

创建线程分为3步  
**1.导入线程包  
2.创建线程对象  
3.开始线程**

''' 第1步，导入线程包 '''
    import threading
    import time
    
    
    def run():
        print('run：当前的线程为', threading.current_thread())
        for i in range(5):
            print('跑')
            time.sleep(1)
    
    
    def eat():
        print('run：当前的线程为', threading.current_thread())
        for i in range(5):
            print('吃饭啦')
            time.sleep(1)
    
    
    if __name__ == '__main__':
        ''' 第2步，创建线程 '''
        # threading.Thread()的参数与进程类似
        # group: 线程组，目前只能使用None
        # target: 执行的目标任务名，一般是方法名
        # args: 以元组的方式给执行任务传参
        # kwargs: 以字典方式给执行任务传参
        # name: 线程名，一般不用设置
        # daemon：是否设置为守护主线程
        run_thread = threading.Thread(target=run)
        eat_thread = threading.Thread(target=eat)
        print('man：主线程为', threading.current_thread())
        ''' 第3步，开启线程 '''
        run_thread.start()
        eat_thread.start()

#### 3.守护主线程 ####

一般主线程要等子线程的任务结束之后才会结束，即使调用了exit()  
我们可以把子线程设置为守护主线程，这样一旦主线程要结束，子线程也会立即结束  
将子线程设置为主线程的方法有三种

...
    	run_thread = threading.Thread(target=run)
        eat_thread = threading.Thread(target=eat)
        print('man：主线程为', threading.current_thread())
        ''' 设置为守护主线程有三种方法 方法一：创建线程时指定daemon参数，threading.Thread(target=run,daemon=True) 方法二：设置setDaemon()方法，run_thread.setDaemon() 方法三：设置daemon属性，run_thread.daemon = True '''
        
        ''' 第3步，开启线程 '''
        run_thread.start()
        eat_thread.start()
        ...

#### 4.子线程传参 ####

如果子线程执行的任务需要参数，可以通过元组和字典两种方法指定参数

**args参数对应的是元组，元组里的元素位置要和被调用的方法里参数顺序一致  
kwargs参数对应的是字典，字典里的键要和被调用的方法里的参数名一致**

...
    if __name__ == '__main__':
        t1 = threading.Thread(target=run, args=('小明', 5))
        t2 = threading.Thread(target=eat, kwargs={ 'name': '小红', 't': 6})
        t1.start()
        t2.start()

#### 5.线程同步 ####

如果多个线程同时操作同一个全局变量，可能会造成资源竞争的问题导致数据出错，解决资源竞争问题的方法有两个  
分别是，线程同步和线程异步

**线程同步**，调用join()方法，等当前线程结束才会继续执行，但是这样失去了多线程的优势  
**线程异步**，互斥锁，保护共享数据，保证同一时刻只有一个线程可以访问公共资源，谁抢到锁谁就能访问资源，访问完之后释放资源

**互斥锁的使用有3步：创建锁、上锁、解锁**

# 创建锁
    mutex = threading.Lock()
    # 上锁
    mutex.acquire()
    # 这个部分的代码会被锁定，其他线程不能访问，直到释放锁
    
    # 释放锁
    mutex.release()

import threading
    
    g_num = 0
    # 第1步：创建锁
    mutex = threading.Lock()
    
    def task1():
        global g_num
        # 第2步：上锁
        mutex.acquire()
        try:
            for i in range(1000000):
                g_num += 1
        finally:
            # 第3步：解锁
            mutex.release()
        print(g_num)
    
    def task2():
        global g_num
        mutex.acquire()
        try:
            for i in range(1000000):
                g_num += 1
        finally:
            mutex.release()
        print(g_num)
    
    if __name__ == '__main__':
        t1 = threading.Thread(target=task1)
        t2 = threading.Thread(target=task2)
        t1.start()
        t2.start()

**注意**：在子线程结束之前（比如说return前）一定要释放锁，否则会造成死锁（一直等待对方释放锁的场景）

**对线程的补充：**

1.如果使用默认参数创建线程（daemon为False），主线程会等待所有子线程结束才结束

2.如果创建子线程设置守护主线程（daemon为True），则主线程结束就会立即结束所有子线程

3.如果子线程使用了join()方法，会阻塞主线程，直到结束。或者join()方法传入timeout，主线程会等待timeout时间，超时立即结束（当daemon为False，则timeout无效），总等待时间是timeout\*子线程数

#### 6.GIL锁 ####

由于历史原因，python（CPython）本身就带有全局解释器锁，即GIL(Global Interpreter Lock)，每个线程要执行，必须先得到GIL，然后每执行100条字节码，解释器就自动释放GIL锁。换句话说，如果是单进程，是不可能榨干CPU的

import multiprocessing
    import threading
    
    def loop():
        while True:
            pass
    
    for i in range(multiprocessing.cpu_count()):
        print(i)
        t = threading.Thread(target=loop)
        t.start()

但没关系，多进程可以达到占满CPU的目的，因为每个进程都有一个GIL锁

import multiprocessing
    
    def loop():
        while True:
            pass
    
    if __name__ == '__main__':
        for i in range(multiprocessing.cpu_count()):
            print(i)
            p = multiprocessing.Process(target=loop)
            p.start()

[python]: https://blog.csdn.net/qq_39147299/article/details/107831452