并发编程[Python基础]

  • Z时代
  • 2024-01-10
  • 分类：综合

python

并发编程

1、多道技术（基于单核背景下产生）

　　单道：指的是一条道路走到黑  -->  串行

　　　　比如：a，b需要使用cpu，a先试用，b等待a使用完成后，b才能使用cpu

　　多道：一条道路分配走

　　　　比如：a，b需要使用cpu，a先使用，b等待a，直到a进入“IO或执行时间过长”，a会（切换+保存状态），然后b可以使用cpu，待b执行遇到“IO或执行时间过长”，再将cpu执行权限交给a，直到两个程序结束

　　　　空间上的复用：（*******）

　　　　　　多个程序使用一个cpu

　　　　时间上的复用：（*******）

　　　　　　切换 + 保存状态

　　　　　　1.当执行程序遇到IO时，操作系统会将cpu的执行权限剥夺

　　　　　　　　优点：

　　　　　　　　　　cpu的执行效率提高

　　　　　　2.当执行程序遇到执行时间过长时，操作系统会将cpu的执行权限剥夺

　　　　　　　　缺点：

　　　　　　　　　　程序的执行效率低

2、并发与并行

　　并发：在单核（1个cpu）情况下，当执行a，b两个程序时，a先执行，当a遇到IO时，b开始争抢cpu的执行权限，再让b执行。看起来像同时运行

　　并行：在多核（多个cpu）情况下，当执行a，b两个程序时，a，b同时执行，他们是真正意义上的同时运行

3、进程

（1）什么是进程

　　进程是一个资源单位

（2）进程与程序

　　程序：一堆代码文件

　　进程：执行代码的过程，称之为进程

（3）进程调度（了解）

　　① 先来先服务调度算法

　　　　比如程序 a，b，若a先来，则先让a先服务，待a服务完毕后，b再服务

　　　　缺点：

　　　　　　执行效率低

　　② 短作业优先调度

　　　　执行时间越短，则先调度

　　　　缺点：

　　　　　　导致执行时间长的程序，需要等待所有时间短的程序执行完毕后，才能执行

　　现代操作系统的进程电镀算法： 时间片轮转法 + 多级反馈队列（知道）

　　③ 时间片轮转法

　　　　比如同时有10个程序需要执行，操作系统会给你10秒，然后时间片轮转法会将10秒分成10等份。


　　④ 多级反馈队列

　　　　1级别队列：优先级最高，先执行此队列中的程序

　　　　2级别队列：优先级以此类推

　　　　3级别队列：...

4、同步与异步

　　同步与异步指的是 "提交任务的方式"

　　同步（串行）：

　　　　两个a，b程序都要提交并执行，假如a先提交执行，b必须等a执行完成后，b才能提交任务

　　异步（并发）：

　　　　两个a，b程序都要提交并执行，假如a先提交执行，b无需等a执行完成，就可以直接提交任务

5、阻塞与非阻塞

　　阻塞：

　　　　凡是遇到IO操作都会阻塞

　　　　IO操作:

　　　　　　input()

　　　　　　output()

　　　　　　time.sleep()

　　　　　　文件的读写

　　　　　　数据的传输

　　非阻塞（不等待）：

　　　　只要不遇到IO阻塞，其他都是非阻塞（比如计算从1到100万的和）

6、进程的三种状态

　　就绪态：

　　　　同步和异步

　　运行态：程序的运行时间过长 ---> 会将程序返回给就绪态

　　　　非阻塞

　　阻塞态：

　　　　遇到IO操作

7、进程的两种创建方式（代码）

　　方式1：直接调用Process类

　　例1：

import time
from multiprocessing import Process
def task():    # 任务
print("start...")
    time.sleep(3)
print("end...")
if__name__ == "__main__":
# target=任务(函数地址) ---> 创建一个子进程
    p_obj = Process(target=task)
# 告诉操作系统去创建一个子进程
    p_obj.start()
# 告诉主进程，等待子进程结束后，再执行主进程
    p_obj.join()
print("正在执行当前主进程")

　　执行结果：

start...
end...
正在执行当前主进程

　　例2：

import time
from multiprocessing import Process
def task(name):    # 任务
print(f"start...{name}的子进程")
    time.sleep(3)
print(f"end...{name}的子进程")
if__name__ == "__main__":
# target=任务(函数地址) ---> 创建一个子进程
# 异步提交3个任务  (3个子进程)
    p_obj1 = Process(target=task, args=("apple", ))
    p_obj2 = Process(target=task, args=("orange", ))
    p_obj3 = Process(target=task, args=("banana", ))
# 告诉操作系统去创建一个子进程
    p_obj1.start()
    p_obj2.start()
    p_obj3.start()
# 告诉主进程，等待子进程结束后，再执行主进程
    p_obj1.join()
    p_obj2.join()
    p_obj3.join()
print("正在执行当前主进程")

　　执行结果：

# apple、orange、banana三个进程同时提交
start...apple的子进程
start...orange的子进程
start...banana的子进程
end...apple的子进程
end...orange的子进程
end...banana的子进程
正在执行当前主进程

　　方式二：继承Process类

import time
from multiprocessing import Process
class MyProcess(Process):
def run(self):
print(f"start...{self.name}的子进程")
        time.sleep(3)
print(f"end...{self.name}的子进程")
if__name__ == "__main__":
# 定义一个空列表，将所有的子进程放进去并for循环出来告诉主进程先执行子进程
    list1 = []
# 假设10个进程
for i in range(10):
        obj = MyProcess()
# 告诉操作系统去创建一个子进程
        obj.start()
        list1.append(obj)
for obj in list1:
# 告诉主进程，等待子进程结束后，再执行主进程
        obj.join()
print("正在执行当前主进程")

　　执行结果：

# 10个进程同时提交
start...MyProcess-1的子进程
start...MyProcess-2的子进程
start...MyProcess-3的子进程
start...MyProcess-4的子进程
start...MyProcess-5的子进程
start...MyProcess-6的子进程
start...MyProcess-7的子进程
start...MyProcess-8的子进程
start...MyProcess-9的子进程
start...MyProcess-10的子进程
end...MyProcess-1的子进程
end...MyProcess-2的子进程
end...MyProcess-3的子进程
end...MyProcess-4的子进程
end...MyProcess-5的子进程
end...MyProcess-6的子进程
end...MyProcess-7的子进程
end...MyProcess-8的子进程
end...MyProcess-9的子进程
end...MyProcess-10的子进程
正在执行当前主进程

8、问答题

（1）在单核情况下是否可以实现并行？

　　不可以，并行只能在多核情况下实现

（2）阻塞与同步是一样的吗？非阻塞与异步是一样的吗？

　　不一样

　　同步与异步：提交任务的方式

　　阻塞与非阻塞：进程的状态

　　补充：

　　　　异步非阻塞：异步非阻塞可将cpu的利用率最大化！        用在通过并发对程序进程操作

以上是 并发编程[Python基础] 的全部内容， 来源链接： utcz.com/z/530178.html

回到顶部