Python多任务之多线程开发

电玩女神 2024-04-08 13:10 41阅读 0赞

#### 目录 ####

*  1 线程的介绍
 *  2 多线程的使用
 *   *  2.1 导入线程模块
     *  2.2 线程类Thread参数说明
     *  2.3 启动线程
     *  2.4 多线程完成多任务的代码
     *  2.5 小结
 *  3 线程执行带有参数的任务
 *   *  3.1 线程执行带有参数的任务的介绍
     *  3.2 args参数的使用
     *  3.3 kwargs参数的使用
     *  3.4 小结
 *  4 线程的注意点
 *   *  4.1 线程的注意点介绍
     *  4.2 线程之间执行是无序的
     *  4.3 主线程会等待所有的子线程执行结束再结束
     *  4.4 线程之间共享全局变量
     *  4.5 线程之间共享全局变量数据出现错误问题
     *  4.6 小结
 *  5 互斥锁
 *   *  5.1 互斥锁的概念
     *  5.2 互斥锁的使用
     *  5.4 使用互斥锁完成2个线程对同一个全局变量各加100万次的操作
     *  5.3 小结
 *  6 死锁
 *   *  6.1 死锁的概念
     *  6.2 死锁示例
     *  6.3 避免死锁
     *  6.4 小结
 *  7 进程和线程的对比
 *   *  7.1 进程和线程的对比的三个方向
     *  7.2 关系对比
     *  7.3 区别对比
     *  7.4 优缺点对比
     *  7.5 小结

--------------------

## 1 线程的介绍 ##

在Python中，想要实现多任务除了使用进程，还可以使用线程来完成，线程是实现多任务的另外一种方式。

线程是进程中执行代码的一个分支，每个执行分支（线程）要想工作执行代码需要cpu进行调度 ，也就是说线程是cpu调度的基本单位，每个进程至少都有一个线程，而这个线程就是

我们通常说的主线程。多线程可以完成多任务

**多线程效果图:**  
![在这里插入图片描述][1ee4d8d176d84388b8b6b2ecb1a112e6.png]  
![在这里插入图片描述][52227ad92eb344ad89ae21cb3041ce5e.png]

*  线程是Python程序中实现多任务的另外一种方式，线程的执行需要cpu调度来完成。

## 2 多线程的使用 ##

### 2.1 导入线程模块 ###

#导入线程模块
    import threading

### 2.2 线程类Thread参数说明 ###

Thread(group , target , name , args , kwargs)

*  group: 线程组，目前只能使用None
 *  target: 执行的目标任务名
 *  args: 以元组的方式给执行任务传参
 *  kwargs: 以字典方式给执行任务传参
 *  name: 线程名，一般不用设置

### 2.3 启动线程 ###

启动线程使用start方法

### 2.4 多线程完成多任务的代码 ###

import threading
    import time
    # 唱歌任务
    def sing():
        # 扩展： 获取当前线程
        # print("sing当前执行的线程为：", threading.current_thread())
        for i in range(3):
            print("正在唱歌...%d" % i)
            time.sleep(1)
    # 跳舞任务
    def dance():
        # 扩展： 获取当前线程
        # print("dance当前执行的线程为：", threading.current_thread())
        for i in range(3):
            print("正在跳舞...%d" % i)
            time.sleep(1)
    if __name__ == '__main__':
        # 扩展： 获取当前线程
        # print("当前执行的线程为：", threading.current_thread())
        # 创建唱歌的线程
        # target： 线程执行的函数名
        sing_thread = threading.Thread(target=sing)
        # 创建跳舞的线程
        dance_thread = threading.Thread(target=dance)
        # 开启线程
        sing_thread.start()
        dance_thread.start()

**执行结果:**

正在唱歌...0
    正在跳舞...0
    正在唱歌...1
    正在跳舞...1
    正在唱歌...2
    正在跳舞...2

### 2.5 小结 ###

1.  导入线程模块
    
     *  import threading
2.  创建子线程并指定执行的任务
    
     *  sub\_thread = threading.Thread(target=任务名)
3.  启动线程执行任务
    
     *  sub\_thread.start()

## 3 线程执行带有参数的任务 ##

### 3.1 线程执行带有参数的任务的介绍 ###

前面我们使用线程执行的任务是没有参数的，假如我们使用线程执行的任务带有参数，如何给函数传参呢?  
Thread类执行任务并给任务传参数有两种方式:

*  args 表示以元组的方式给执行任务传参
 *  kwargs 表示以字典方式给执行任务传参

### 3.2 args参数的使用 ###

**示例代码:**

import threading
    import time
    # 带有参数的任务
    def task(count):
        for i in range(count):
            print("任务执行中..")
            time.sleep(0.2)
        else:
            print("任务执行完成")
    if __name__ == '__main__':
        # 创建子线程
        # args: 以元组的方式给任务传入参数
        sub_thread = threading.Thread(target=task, args=(5,))
        sub_thread.start()

**执行结果:**

任务执行中..
    任务执行中..
    任务执行中..
    任务执行中..
    任务执行中..
    任务执行完成

### 3.3 kwargs参数的使用 ###

**示例代码:**

import threading
    import time
    # 带有参数的任务
    def task(count):
        for i in range(count):
            print("任务执行中..")
            time.sleep(0.2)
        else:
            print("任务执行完成")
    if __name__ == '__main__':
        # 创建子线程
        # kwargs: 表示以字典方式传入参数
        sub_thread = threading.Thread(target=task, kwargs={
        "count": 3})
        sub_thread.start()

**执行结果:**

任务执行中..
    任务执行中..
    任务执行中..
    任务执行完成

### 3.4 小结 ###

*  线程执行任务并传参有两种方式:
    
     *  **元组方式传参(args)** ：元组方式传参一定要和参数的顺序保持一致。
     *  **字典方式传参(kwargs)**：字典方式传参字典中的key一定要和参数名保持一致。

## 4 线程的注意点 ##

### 4.1 线程的注意点介绍 ###

1.  线程之间执行是无序的
2.  主线程会等待所有的子线程执行结束再结束
3.  线程之间共享全局变量
4.  线程之间共享全局变量数据出现错误问题

### 4.2 线程之间执行是无序的 ###

import threading
    import time
    def task():
        time.sleep(1)
        print("当前线程:", threading.current_thread().name)
    if __name__ == '__main__':
       for _ in range(5):
           sub_thread = threading.Thread(target=task)
           sub_thread.start()

**执行结果:**

当前线程: Thread-1
    当前线程: Thread-2
    当前线程: Thread-4
    当前线程: Thread-5
    当前线程: Thread-3

**说明:**

*  线程之间执行是无序的，它是由cpu调度决定的 ，cpu调度哪个线程，哪个线程就先执行，没有调度的线程不能执行。
 *  进程之间执行也是无序的，它是由操作系统调度决定的，操作系统调度哪个进程，哪个进程就先执行，没有调度的进程不能执行。

### 4.3 主线程会等待所有的子线程执行结束再结束 ###

假如我们现在创建一个子线程，这个子线程执行完大概需要2.5秒钟，现在让主线程执行1秒钟就退出程序，查看一下执行结果，示例代码如下:

import threading
    import time
    # 测试主线程是否会等待子线程执行完成以后程序再退出
    def show_info():
        for i in range(5):
            print("test:", i)
            time.sleep(0.5)
    if __name__ == '__main__':
        sub_thread = threading.Thread(target=show_info)
        sub_thread.start()
        # 主线程延时1秒
        time.sleep(1)
        print("over")

**执行结果:**

test: 0
    test: 1
    over
    test: 2
    test: 3
    test: 4

**说明:**  
通过上面代码的执行结果，我们可以得知: **主线程会等待所有的子线程执行结束再结束**  
假如我们就让主线程执行1秒钟，子线程就销毁不再执行，那怎么办呢?

*  我们可以设置**守护主线程**  
    **守护主线程:**
 *  守护主线程就是主线程退出子线程销毁不再执行  
    **设置守护主线程有两种方式：**

1.  threading.Thread(target=show\_info, daemon=True)
2.  线程对象.setDaemon(True)  
    **设置守护主线程的示例代码:**

import threading
    import time
    # 测试主线程是否会等待子线程执行完成以后程序再退出
    def show_info():
        for i in range(5):
            print("test:", i)
            time.sleep(0.5)
    if __name__ == '__main__':
        # 创建子线程守护主线程 
        # daemon=True 守护主线程
        # 守护主线程方式1
        sub_thread = threading.Thread(target=show_info, daemon=True)
        # 设置成为守护主线程，主线程退出后子线程直接销毁不再执行子线程的代码
        # 守护主线程方式2
        # sub_thread.setDaemon(True)
        sub_thread.start()
        # 主线程延时1秒
        time.sleep(1)
        print("over")

**执行结果:**

test: 0
    test: 1
    over

### 4.4 线程之间共享全局变量 ###

**需求:**

1.  定义一个列表类型的全局变量
2.  创建两个子线程分别执行向全局变量添加数据的任务和向全局变量读取数据的任务
3.  查看线程之间是否共享全局变量数据

import threading
    import time
    # 定义全局变量
    my_list = list()
    # 写入数据任务
    def write_data():
        for i in range(5):
            my_list.append(i)
            time.sleep(0.1)
        print("write_data:", my_list)
    # 读取数据任务
    def read_data():
        print("read_data:", my_list)
    if __name__ == '__main__':
        # 创建写入数据的线程
        write_thread = threading.Thread(target=write_data)
        # 创建读取数据的线程
        read_thread = threading.Thread(target=read_data)
        write_thread.start()
        # 延时
        # time.sleep(1)
        # 主线程等待写入线程执行完成以后代码在继续往下执行
        write_thread.join()
        print("开始读取数据啦")
        read_thread.start()

**执行结果:**

write_data: [0, 1, 2, 3, 4]
    开始读取数据啦
    read_data: [0, 1, 2, 3, 4]

### 4.5 线程之间共享全局变量数据出现错误问题 ###

**需求:**

1.  定义两个函数，实现循环100万次，每循环一次给全局变量加1
2.  创建两个子线程执行对应的两个函数，查看计算后的结果

import threading
    # 定义全局变量
    g_num = 0
    # 循环一次给全局变量加1
    def sum_num1():
        for i in range(1000000):
            global g_num
            g_num += 1
        print("sum1:", g_num)
    # 循环一次给全局变量加1
    def sum_num2():
        for i in range(1000000):
            global g_num
            g_num += 1
        print("sum2:", g_num)
    if __name__ == '__main__':
        # 创建两个线程
        first_thread = threading.Thread(target=sum_num1)
        second_thread = threading.Thread(target=sum_num2)
        # 启动线程
        first_thread.start()
        # 启动线程
        second_thread.start()

**执行结果:**

sum1: 1210949
    sum2: 1496035

**注意点:**  
**多线程同时对全局变量操作数据发生了错误**  
**错误分析:**  
两个线程first\_thread和second\_thread都要对全局变量g\_num(默认是0)进行加1运算，但是由于是多线程同时操作，有可能出现下面情况：

1.  在g\_num=0时，first\_thread取得g\_num=0。此时系统把first\_thread调度为”sleeping”状态，把second\_thread转换为”running”状态，t2也获得g\_num=0
2.  然后second\_thread对得到的值进行加1并赋给g\_num，使得g\_num=1
3.  然后系统又把second\_thread调度为”sleeping”，把first\_thread转为”running”。线程t1又把它之前得到的0加1后赋值给g\_num。
4.  这样导致虽然first\_thread和first\_thread都对g\_num加1，但结果仍然是g\_num=1  
    **全局变量数据错误的解决办法:**  
    线程同步: 保证同一时刻只能有一个线程去操作全局变量 同步: 就是协同步调，按预定的先后次序进行运行。如:你说完，我再说, 好比现实生活中的对讲机  
    线程同步的方式:
5.  **线程等待(join)**
6.  **互斥锁**  
    **线程等待的示例代码:**

import threading
    # 定义全局变量
    g_num = 0
    # 循环1000000次每次给全局变量加1
    def sum_num1():
        for i in range(1000000):
            global g_num
            g_num += 1
        print("sum1:", g_num)
    # 循环1000000次每次给全局变量加1
    def sum_num2():
        for i in range(1000000):
            global g_num
            g_num += 1
        print("sum2:", g_num)
    if __name__ == '__main__':
        # 创建两个线程
        first_thread = threading.Thread(target=sum_num1)
        second_thread = threading.Thread(target=sum_num2)
        # 启动线程
        first_thread.start()
        # 主线程等待第一个线程执行完成以后代码再继续执行，让其执行第二个线程
        # 线程同步： 一个任务执行完成以后另外一个任务才能执行，同一个时刻只有一个任务在执行
        first_thread.join()
        # 启动线程
        second_thread.start()

**执行结果:**

sum1: 1000000
    sum2: 2000000

### 4.6 小结 ###

*  线程执行执行是无序的
 *  主线程默认会等待所有子线程执行结束再结束，设置守护主线程的目的是主线程退出子线程销毁。
 *  线程之间共享全局变量，好处是可以对全局变量的数据进行共享。
 *  线程之间共享全局变量可能会导致数据出现错误问题，可以使用线程同步方式来解决这个问题。
    
     *  线程等待(join)

## 5 互斥锁 ##

### 5.1 互斥锁的概念 ###

互斥锁: 对共享数据进行锁定，保证同一时刻只能有一个线程去操作。  
注意:

*  互斥锁是**多个线程一起去抢**，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁。  
    **为了更好的理解互斥锁，请看下面的图:**

![在这里插入图片描述][025f2b2616be482f93e8490014203252.png]

### 5.2 互斥锁的使用 ###

threading模块中定义了Lock变量，这个变量本质上是一个函数，通过调用这个函数可以获取一把互斥锁。  
**互斥锁使用步骤:**

# 创建锁
    mutex = threading.Lock()
    # 上锁
    mutex.acquire()
    ...这里编写代码能保证同一时刻只能有一个线程去操作, 对共享数据进行锁定...
    # 释放锁
    mutex.release()

**注意点:**

*  **acquire和release方法之间的代码同一时刻只能有一个线程去操作**
 *  **如果在调用acquire方法的时候 其他线程已经使用了这个互斥锁，那么此时acquire方法会堵塞，直到这个互斥锁释放后才能再次上锁。**

### 5.4 使用互斥锁完成2个线程对同一个全局变量各加100万次的操作 ###

import threading
    # 定义全局变量
    g_num = 0
    # 创建全局互斥锁
    lock = threading.Lock()
    # 循环一次给全局变量加1
    def sum_num1():
        # 上锁
        lock.acquire()
        for i in range(1000000):
            global g_num
            g_num += 1
        print("sum1:", g_num)
        # 释放锁
        lock.release()
    # 循环一次给全局变量加1
    def sum_num2():
        # 上锁
        lock.acquire()
        for i in range(1000000):
            global g_num
            g_num += 1
        print("sum2:", g_num)
        # 释放锁
        lock.release()
    if __name__ == '__main__':
        # 创建两个线程
        first_thread = threading.Thread(target=sum_num1)
        second_thread = threading.Thread(target=sum_num2)
        # 启动线程
        first_thread.start()
        second_thread.start()
        # 提示：加上互斥锁，那个线程抢到这个锁我们决定不了，那线程抢到锁那个线程先执行，没有抢到的线程需要等待
        # 加上互斥锁多任务瞬间变成单任务，性能会下降，也就是说同一时刻只能有一个线程去执行

**执行结果:**

sum1: 1000000
    sum2: 2000000

**说明:**  
通过执行结果可以地址**互斥锁能够保证多个线程访问共享数据不会出现数据错误问题**

### 5.3 小结 ###

*  互斥锁的作用就是保证同一时刻只能有一个线程去操作共享数据，保证共享数据不会出现错误问题
 *  使用互斥锁的好处确保某段关键代码只能由一个线程从头到尾完整地去执行
 *  使用互斥锁会影响代码的执行效率，多任务改成了单任务执行
 *  互斥锁如果没有使用好容易出现死锁的情况

## 6 死锁 ##

### 6.1 死锁的概念 ###

死锁: 一直等待对方释放锁的情景就是死锁  
为了更好的理解死锁，来看一个现实生活的效果图:  
![在这里插入图片描述][157127459fd841dd949e468a5f796fb2.png]

**说明:**  
现实社会中，男女双方一直等待对方先道歉的这种行为就好比是死锁。  
**死锁的结果**

*  会造成应用程序的停止响应，不能再处理其它任务了。

### 6.2 死锁示例 ###

**需求:**  
根据下标在列表中取值, 保证同一时刻只能有一个线程去取值

import threading
    import time
    # 创建互斥锁
    lock = threading.Lock()
    # 根据下标去取值， 保证同一时刻只能有一个线程去取值
    def get_value(index):
        # 上锁
        lock.acquire()
        print(threading.current_thread())
        my_list = [3,6,8,1]
        # 判断下标释放越界
        if index >= len(my_list):
            print("下标越界:", index)
            return
        value = my_list[index]
        print(value)
        time.sleep(0.2)
        # 释放锁
        lock.release()
    if __name__ == '__main__':
        # 模拟大量线程去执行取值操作
        for i in range(30):
            sub_thread = threading.Thread(target=get_value, args=(i,))
            sub_thread.start()

### 6.3 避免死锁 ###

*  在合适的地方释放锁

import threading
    import time
    # 创建互斥锁
    lock = threading.Lock()
    # 根据下标去取值， 保证同一时刻只能有一个线程去取值
    def get_value(index):
        # 上锁
        lock.acquire()
        print(threading.current_thread())
        my_list = [3,6,8,1]
        if index >= len(my_list):
            print("下标越界:", index)
            # 当下标越界需要释放锁，让后面的线程还可以取值
            lock.release()
            return
        value = my_list[index]
        print(value)
        time.sleep(0.2)
        # 释放锁
        lock.release()
    if __name__ == '__main__':
        # 模拟大量线程去执行取值操作
        for i in range(30):
            sub_thread = threading.Thread(target=get_value, args=(i,))
            sub_thread.start()

### 6.4 小结 ###

*  使用互斥锁的时候需要注意死锁的问题，要在合适的地方注意释放锁。
 *  死锁一旦产生就会造成应用程序的停止响应，应用程序无法再继续往下执行了。
 *

## 7 进程和线程的对比 ##

Python多任务之多进程开发：[https://blog.csdn.net/ZGL\_cyy/article/details/126556605][https_blog.csdn.net_ZGL_cyy_article_details_126556605]

### 7.1 进程和线程的对比的三个方向 ###

1.  关系对比
2.  区别对比
3.  优缺点对比

### 7.2 关系对比 ###

1.  线程是依附在进程里面的，没有进程就没有线程。
2.  一个进程默认提供一条线程，进程可以创建多个线程。  
    ![img][]

### 7.3 区别对比 ###

1.  进程之间不共享全局变量
2.  线程之间共享全局变量，但是要注意资源竞争的问题，解决办法: 互斥锁或者线程同步
3.  创建进程的资源开销要比创建线程的资源开销要大
4.  进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
5.  线程不能够独立执行，必须依存在进程中
6.  多进程开发比单进程多线程开发稳定性要强

### 7.4 优缺点对比 ###

*  进程优缺点:
    
     *  优点：可以用多核
     *  缺点：资源开销大
 *  线程优缺点:
    
     *  优点：资源开销小
     *  缺点：不能使用多核

### 7.5 小结 ###

*  进程和线程都是完成多任务的一种方式
 *  多进程要比多线程消耗的资源多，但是多进程开发比单进程多线程开发稳定性要强，某个进程挂掉不会影响其它进程。
 *  多进程可以使用cpu的多核运行，多线程可以共享全局变量。
 *  线程不能单独执行必须依附在进程里面

[1ee4d8d176d84388b8b6b2ecb1a112e6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/79207e3f7f8c4142b27047eaafcf92a3.png
[52227ad92eb344ad89ae21cb3041ce5e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/0ee31271dbfa4d76879e1db549a532c7.png
[025f2b2616be482f93e8490014203252.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/72b040e2db9b44edaa23226c38ca5586.png
[157127459fd841dd949e468a5f796fb2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/afc2cb8122d54d9e9ebd98df2f821309.png
[https_blog.csdn.net_ZGL_cyy_article_details_126556605]: https://blog.csdn.net/ZGL_cyy/article/details/126556605
[img]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/28a929aef29c4af1ad45d5c05fe98d65.png