多任务编程(持续更新...)

itesting-coder

于 2024-06-27 17:56:55 发布

阅读量1k

点赞数 31

文章标签：服务器 linux 运维

本文链接：https://blog.csdn.net/weixin_53317674/article/details/139994848

版权

1.多任务介绍

多任务是指在同一时间内执行多个任务，例如: 现在电脑安装的操作系统都是多任务操作系统，可以同时运行着多个软件。

多任务的最大好处是充分利用CPU资源，提高程序的执行效率。

多任务的执行方式:1.并发 2.并行

并发:在一段时间内交替去执行任务。对于单核cpu处理多任务,操作系统轮流让各个软件交替执行.

并行:对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的软件，多个内核是真正的一起执行软件。这里需要注意多核cpu是并行的执行多任务，始终有多个软件一起执行。

2.进程

1.概念

一个正在运行的程序或者软件就是一个进程，它是操作系统进行资源分配的基本单位，也就是说每启动一个进程，操作系统都会给其分配一定的运行资源(内存资源)保证进程的运行。

注意:

一个程序运行后至少有一个进程，一个进程默认有一个线程，进程里面可以创建多个线程，线程是依附在进程里面的，没有进程就没有线程。

2.多进程的使用

导入进程包
- import multiprocessing
创建子进程并指定执行的任务
- sub_process = multiprocessing.Process (target=任务名)
启动进程执行任务
- sub_process.start()

1. Process进程类的说明

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

group：指定进程组，目前只能使用None
target：执行的目标任务名
name：进程名字
args：以元组方式给执行任务传参
kwargs：以字典方式给执行任务传参

Process创建的实例对象的常用方法:

start()：启动子进程实例（创建子进程）
join()：等待子进程执行结束
terminate()：不管任务是否完成，立即终止子进程

Process创建的实例对象的常用属性:

name：当前进程的别名，默认为Process-N，N为从1开始递增的整数

2.多进程完成多任务的代码

import multiprocessing
import time


# 跳舞任务
def dance():
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)


# 唱歌任务
def sing():
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()

执行结果:

唱歌中...
跳舞中...
唱歌中...
跳舞中...
唱歌中...
跳舞中...
唱歌中...
跳舞中...
唱歌中...
跳舞中...

3.获取进程编号

获取当前进程编号
- os.getpid()
获取当前父进程编号
- os.getppid()
获取进程编号可以查看父子进程的关系

4.进程执行带有参数的任务

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

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程
    # args: 以元组的方式给任务传入参数
    sub_process = multiprocessing.Process(target=task, args=(5,))
    sub_process.start()

kwargs 表示以字典方式给执行任务传参

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程

    # kwargs: 表示以字典方式传入参数
    sub_process = multiprocessing.Process(target=task, kwargs={"count": 3})
    sub_process.start()

5.进程注意点

进程之间不共享全局变量
主进程会等待所有的子进程执行结束再结束

假如我们就让主进程执行0.5秒钟，子进程就销毁不再执行，那怎么办呢?

我们可以设置守护主进程 或者在主进程退出之前 让子进程销毁

守护主进程:

守护主进程就是主进程退出子进程销毁不再执行
子进程对象.daemon = True

子进程销毁:

子进程执行结束

子进程对象.terminate()

import multiprocessing
import time


# 定义进程所需要执行的任务
def task():
    for i in range(10):
        print("任务执行中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建子进程
    sub_process = multiprocessing.Process(target=task)
    # 设置守护主进程，主进程退出子进程直接销毁，子进程的生命周期依赖与主进程
    # sub_process.daemon = True
    sub_process.start()

    time.sleep(0.5)
    print("over")
    # 让子进程销毁
    sub_process.terminate()
    exit()

    # 总结： 主进程会等待所有的子进程执行完成以后程序再退出
    # 如果想要主进程退出子进程销毁，可以设置守护主进程或者在主进程退出之前让子进程销毁

2.线程

1.概念

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

2.多线程使用

导入线程模块
- import threading
创建子线程并指定执行的任务
- sub_thread = threading.Thread(target=任务名)
启动线程执行任务
- sub_thread.start()

1.参数说明

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

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

2.代码实现

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

3.线程的注意点

线程执行执行是无序的,它是由cpu调度决定的，cpu调度哪个线程，哪个线程就先执行，没有调度的线程不能执行。
主线程默认会等待所有子线程执行结束再结束，设置守护主线程的目的是主线程退出子线程销毁。

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

threading.Thread(target=show_info, daemon=True)
线程对象.setDaemon(True)

线程之间共享全局变量，好处是可以对全局变量的数据进行共享。
线程之间共享全局变量可能会导致数据出现错误问题，可以使用线程同步方式来解决这个问题。
- 线程等待(join)
- 互斥锁

4.互斥锁

互斥锁的作用就是保证同一时刻只能有一个线程去操作共享数据，保证共享数据不会出现错误问题
acquire和release方法之间的代码同一时刻只能有一个线程去操作
如果在调用acquire方法的时候其他线程已经使用了这个互斥锁，那么此时acquire方法会堵塞，直到这个互斥锁释放后才能再次上锁。
互斥锁能够保证多个线程访问共享数据不会出现数据错误问题
使用互斥锁的好处确保某段关键代码只能由一个线程从头到尾完整地去执行
使用互斥锁会影响代码的执行效率，多任务改成了单任务执行
互斥锁如果没有使用好容易出现死锁的情况

5.死锁

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

6.进程和线程的对比

1.关系对比

线程是依附在进程里面的，没有进程就没有线程。
一个进程默认提供一条线程，进程可以创建多个线程。

2.区别对比

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

3.优缺点对比

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

最大的优势就是协程极高的执行效率。因为函数切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。

第二大优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

3.GIL(全局解释器锁)--面试常问

GIL是Python解释器为了保证线程安全而引入的一个内部机制，但同时也成为了制约Python并发性能的一大因素。

1.概念

全局解释器锁是一种互斥锁，被Python解释器用来确保任何时刻只有一个线程在执行Python字节码。这意味着，尽管Python支持多线程编程，但在单个进程中，无论有多少个线程，同一时间仅能有一个线程在CPU上执行。即使在多核系统上，也无法利用多个处理器核心同时执行Python字节码。

2.工作原理

GIL的主要作用是为了防止在解释器级别发生数据竞争。因为Python的对象模型是非线程安全的，没有GIL的话，多个线程可能会同时修改Python对象，造成不可预测的结果。每当线程开始执行或者从I/O操作恢复执行时，它都会尝试获取GIL。一旦获得GIL，该线程就可以安全地执行Python字节码，直至释放GIL以便其他线程获取。