[Python]多任务编程--线程

已于 2022-09-24 17:43:28 修改
阅读量917 收藏 9
点赞数 2
分类专栏： Python学习笔记 文章标签： python 开发语言
于 2022-09-21 13:53:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53022813/article/details/126964773
版权

在这里插入图片描述

前言

系列文章目录
[Python]目录
视频及资料和课件
链接：https://pan.baidu.com/s/1LCv_qyWslwB-MYw56fjbDg?pwd=1234
提取码：1234

文章目录

线程

1. 线程的介绍

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

2. 线程的概念

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

3. 线程的作用

多线程可以完成多任务

多线程效果图:
在这里插入图片描述

多线程的使用

1. 导入线程模块

#导入线程模块
import threading

2. 线程类Thread参数说明

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

  • group: 线程组，目前只能使用None
  • target: 执行的目标任务名（需要执行的函数或方法的函数名或方法名）
  • args: 以元组的方式给执行任务传参
  • kwargs: 以字典方式给执行任务传参
  • name: 线程名，一般不用设置(每个线程会有默认的线程名)

3. 启动线程

启动线程使用start方法

线程名.start()

4. 获取当前线程

threading.current_thread()

5. 多线程完成多任务的代码

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()

在这里插入图片描述

6. 获取当前线程名

threading.current_thread().name

线程执行带有参数的任务

1. 线程执行带有参数的任务的介绍

Thread类执行任务并给任务传参数有两种方式:
（1）args 表示以元组的方式给执行任务传参
（2）kwargs 表示以字典方式给执行任务传参

2. args参数的使用

元组方式传参(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. kwargs参数的使用

字典方式传参(kwargs): 字典方式传参字典中的key一定要和参数名保持一致。

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()

在这里插入图片描述

线程的注意点

1. 线程的注意点介绍

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

2. 线程之间执行是无序的

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

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()

在这里插入图片描述

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")

在这里插入图片描述

4. 主线程结束整个程序结束

要使得主线程结束整个程序结束，我们可以设置守护主线程

守护主线程:
守护主线程就是主线程退出子线程销毁不再执行

设置守护主线程有两种方式：

threading.Thread(target=show_info, daemon=True)

线程对象.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")

这里是引用

5. 线程之间共享全局变量

  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()

在这里插入图片描述

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

  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()

多线程同时对全局变量操作数据发生了错误
在这里插入图片描述

错误分析:
两个线程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

全局变量数据错误的解决办法:
线程同步: 保证同一时刻只能有一个线程去操作全局变量
同步: 就是协同步调，按预定的先后次序进行运行。如:你说完，我再说

线程同步的方式:
1.线程等待(join)
2.互斥锁

线程等待的示例代码:

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()

在这里插入图片描述

互斥锁

1.互斥锁的概念

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

注意:
互斥锁是多个线程一起去抢锁，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁。

互斥锁的作用就是保证同一时刻只能有一个线程去操作共享数据，保证共享数据不会出现错误问题.

使用互斥锁的好处确保某段关键代码只能由一个线程从头到尾完整地去执行

使用互斥锁会影响代码的执行效率，多任务改成了单任务执行

互斥锁如果没有使用好容易出现死锁的情况

2. 互斥锁的使用

互斥锁能够保证多个线程访问共享数据不会出现数据错误问题

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

互斥锁使用步骤:

# 创建锁
mutex = threading.Lock()

# 上锁
mutex.acquire()

...这里编写代码能保证同一时刻只能有一个线程去操作, 对共享数据进行锁定...

# 释放锁
mutex.release()

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

3. 使用互斥锁完成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()

    # 提示：加上互斥锁，哪个线程抢到这个锁我们决定不了，哪个线程抢到锁哪个线程先执行，没有抢到的线程需要等待
    # 加上互斥锁多任务瞬间变成单任务，性能会下降，也就是说同一时刻只能有一个线程去执行

在这里插入图片描述

死锁

1. 死锁的概念

死锁: 一直等待对方释放锁的情景就是死锁

现实社会中，男女双方吵架了，双方一直等待对方先道歉的这种行为就好比是死锁。

死锁的结果：会造成应用程序的停止响应，不能再处理其它任务了。

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()

下标越界，直接退出任务，锁没有得到释放，程序停止响应，不能再处理其它任务。
在这里插入图片描述

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()

在这里插入图片描述

进程和线程的对比

进程和线程都是完成多任务的一种方式

  1. 线程是依附在进程里面的，没有进程就没有线程。
  2. 一个进程默认提供一条线程，进程可以创建多个线程。
  3. 进程之间不共享全局变量
  4. 线程之间共享全局变量，但是要注意资源竞争的问题，解决办法: 互斥锁或者线程同步
  5. 创建进程的资源开销要比创建线程的资源开销要大
  6. 进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
  7. 线程不能够独立执行，必须依存在进程中
  8. 多进程开发比单进程多线程开发稳定性要强，某个进程挂掉不会影响其它进程。
  • 进程优缺点:
    • 优点：可以用多核
    • 缺点：资源开销大
  • 线程优缺点:
    • 优点：资源开销小
    • 缺点：不能使用多核
小炜1128
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python并发编程之多线程
02-24
二者在使用层面，有很大的相似性，因而不再详细介绍官网链接： 练习一：练习二：三个任务，一个接收用户输入，一个将用户输入的内容格式化成大写，一个将格式化后的结果存入文件主线程等待子线程结束无论是进程还是...
Python多线程编程
07-04
Python多线程编程文档说明 多进程编程 一、 multiprocessing 模块 1. multiprocessing 模块提供了多进程编程的能力 它的API非常类似于 threading 模块，但是也提供了一些threading 模块不具有的能力 相比于线程，它...
python开发gui线程_Python GUI教程（十一）：使用多线程保持GUI的响应
weixin_39692245的博客
12-11 508
本篇概要保持GUI程序响应sleep()冻结整个GUI程序开始、停止和重置我们的导航条使用多线程和pyqt信号改善按钮对进度栏的控制上一篇中我们创建了一个稍显复杂的GUI，并且编写了一些逻辑方法来控制一些按钮和部件的行为。其中，我们设置了三个按钮，用来控制进度条，但是功能还不是很完善。我们现在将其改进一下：第一个按钮用来启动进度栏；第二个按钮用来停止进度栏；第三个按钮用来重置进度栏； 在之前的Ma...
python_多进程、多线程
一个努力生活的人的博客
09-19 353
python 多进程，多线程
python多进程控制gui界面_Python优雅地终止了多进程和gui进程
weixin_39564527的博客
02-03 313
我使用glade作为我的gui并创建一个进程来运行我的gui。单击此应用程序将打开套接字。当我按下'send'时，它将把textfield中的任何内容发送到套接字。套接字接收这些数据并将其发回。问题是在我把数据发送到套接字之后，线程没有终止。在我关闭图形用户界面后，它还调用系统出口()但也会离开进程并且不会终止。我认为错误在于我如何实现我的流程或我的所有流程。有人能照一下这个吗？这也与我上一篇文章...
Python 多线程编程-01-threading 模块初识
一分耕耘一分收获
02-10 2249
1. 多线程基础知识 1.1 进程和线程的定义与区别？ 进程是一个执行中程序，每一个进程都有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据。操作系统管理其上面的所有进程，并为这些进程合理的安排时间。一个进程也可以通过 fork 或者 spawn 新的进程来执行其他任务。进程之间通过 IPC 进行通信。 进程的相关知识，可以看我的这个专栏：操作系统_一分耕耘一分收获-CSDN博客 线程和进程类似，但是它是在进程下工作的，一个进程可能拥有多个线程，彼此之间享有共同的上下文或者说数据空间。
python多线程编程-基础篇
princezf的博客
01-25 2903
一、学前须知 1、需掌握python基础语法、python文件操作、python模块应用 2、开发工具：pycharm、python3.6及以上版本 3、学习内容：进程、线程、多任务应用 二、多任务介绍 2.1概念： 多任务是指在同一时间内执行多个任务 2.2多任务的两种表现形式 并发（在一段时间内交替去执行多个任务） 并行（在一段时间内真正的同时一起执行多个任务） 三、进程 3.1进程的概念： 进程是资源分配的最小单位，他是操作系统进行资源分配和调度运行的基本单位。通俗理解：一个正在运行的一个
Python 多线程编程-09 Queue 模块框架
一分耕耘一分收获
02-18 770
1. 什么是线程安全？ 2. Python Queue 模块 2.1 Python Queue 实现的队列类 Python Queue 模块提供了同步的、线程安全的队列类， 这些队列都实现了锁原语，能够在多线程中直接使用。当必须在多个线程之间安全地交换信息时，它在线程编程中特别有用。 Queue 模块中实现的队列类有下面三种： 　　　　1、FIFO 队列，先入先出队列，其添加的第一个任务是第一个检索的任务； 　　　　2、LIFO 队列，后入先出队列，其最近添加的任务是第一个检索的（像堆栈...
Python 多线程编程-10 Queue 模块之 queue 类
一分耕耘一分收获
02-24 3171
ueue/queue 模块中的 queue 类是该模块最经典的类，它实现的是 FIFO队列，先入先出队列，其添加的第一个任务是第一个检索的任务，这也是日常生活中最经典的场景之一。
【python第三方库】python多线程编程---threading库
All_In_gzx_cc的博客
09-06 1930
multiprocess模块（python多进程库）完全模仿了threading模块的接口，二者在使用层面，有很大的相似性。
python 中的并发编程-多线程编程
qq_42898642的博客
06-13 1183
python中的多线程编程，干货满满哦
03-多任务-线程（python和linux高级编程阶段 代码和截图）
01-22
03-多任务-线程（python和linux高级编程阶段 代码和截图）03-多任务-线程（python和linux高级编程阶段 代码和截图）03-多任务-线程（python和linux高级编程阶段 代码和截图）03-多任务-线程（python和linux高级编程...
在Python下尝试多线程编程
12-23
多任务可以由多进程完成，也可以由一个进程内的多线程完成。 我们前面提到了进程是由若干线程组成的，一个进程至少有一个线程。 由于线程是操作系统直接支持的执行单元，因此，高级语言通常都内置多线程的支持，...
python中用“*”运算符复制列表时子列表实际上引用的是同一个列表，列表和嵌套列表的坑
ThreeS_tones的博客
05-21 1217
当你修改了一个子列表的元素时，所有的子列表都会随之改变。因为他们实际上都是同一个子列表的引用。输出如下，可以看到每个子列表中的第5个元素相同，并没有实现从0.8-1.2分布。先看一个例子，我想改变load的子列表中第五个元素，从0.8-1.2分布。的时候，Python实际上。
深入理解Python中None和““的区别
最新发布
m0_54701273的博客
05-27 398
在Python的世界里，None和空字符串""经常被用作默认值或用于表示缺省值的情况。尽管它们在某些语境下似乎可互换，但实际上None和""在Python中有着根本的区别。
Python 静态网页信息爬取
ThsPool的博客
05-22 1131
在当今数字化时代，数据的价值不言而喻。对于研究人员、开发者和数据分析师来说，能够从互联网的海量信息中提取所需数据，无疑是一项宝贵的技能。Python，作为一种广泛使用的编程语言，提供了多种工具来实现这一目标，其中便是处理静态网页内容的佼佼者。本文将详细介绍如何使用库从静态网页中提取有用信息，并提供一些实用的技巧和注意事项。
《Python编程从入门到实践》day36
m0_37565294的博客
05-22 1769
我们要编写一个名为“学习笔记”的Web应用程序，让用户能够记录感兴趣的主题，并在学习每个主题的过程中添加日志条目。django-admin startproject learning_log . # 新建一个名为learning_log的项目，末尾的句点让新项目使用合适的目录结构。运行命令ls，其输出表明Django有创建一个db.sqlite3.SQLite使用一种使用单个文件的数据库。# 包含4个文件（settings.py、urls.py、wsgi.py、__init__.py）
python梯度下降法求解三元线性回归系数，并绘制结果
2401_82997545的博客
05-25 715
theta = np.random.randn(4, 1) # 初始化参数。n_iterations = 1000 # 迭代次数。print("得到的参数为：", theta)# 梯度下降求解多元线性回归系数。eta = 0.1 # 学习率。m = 100 # 样本数。
Python多任务编程
09-10
Python多任务编程是指通过使用多进程、多线程或协程的方式实现同时执行多个任务的能力。 多进程编程是使用多个进程来执行任务，每个进程拥有自己独立的内存空间和系统资源，可以并行执行任务，提高程序的执行效率。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值