并发编程之进程
作者：互联网
首先，我们呢需要了解什么是进程呢？
狭义：进程就是正在进行的程序
广义：是操作系统分配的基本单位
程序：是一个没有生命的实体，等待处理器赋予生命，一旦程序有了生命就变成进程了。
程序和进程的区别：
1、程序是指令和数据的有序集合，其本身没有任何含义，是一个静态的资源。
进程是程序在系统中的一次执行过程。
2、程序可以作为软件长期存在，进程是有一定的生命周期的。
进程三状态：
就绪态：运行的条件都已经满足，正在等待CPU执行 执行态：CPU正在执行器功能 等待态:等待某些条件满足
有了对进程的初步了解，那么怎样创建一个进程呢？
import time
# 导包
import multiprocessing
def test1():
while True:
print("大傻子")
time.sleep(1)
def test2():
while True:
print("小胖手")
time.sleep(1)
# 定义一个主函数来分别执行2个进程的代码
def main():
# 分别创建test1、test2 2个进程 target的值代表要执行的进程
p1 = multiprocessing.Process(target=test1)
p2 = multiprocessing.Process(target=test2)
# 启动p1和p2
p1.start()
p2.start()
# 程序入口 常规写法：
if __name__ == "__main__":
main()在这里，我们引入一个概念，并行与并发
我们举个例子，比如我们两个人在吃午饭。你在吃饭的整个过程中，吃了米饭、吃了蔬菜、吃了牛肉。吃米饭、吃蔬菜、吃牛肉这三件事其实就是并发执行的。对于你来说，整个过程中看似是同时完成的的。但其实你是在吃不同的东西之间来回切换的。
还是我们两个人吃午饭。在吃饭过程中，你吃了米饭、蔬菜、牛肉。我也吃了米饭、蔬菜和牛肉。我们两个人之间的吃饭就是并行的。两个人之间可以在同一时间点一起吃牛肉，或者一个吃牛肉，一个吃蔬菜。之间是互不影响的。
看到这里，是不是还是有点迷茫呢？我们再来看一张图，直观感受一下两者的区别
以上可以看出，
并行：同一时刻，多个任务同时执行
并发：同一时间，多个任务同时执行
并行与并发的区别：
微观上：并行是指同一时间点上，多个任务真正同时执行
宏观上：并发是指在一个时间段内，多个任务走走停停
有进程，当然就有子进程，我们代码实现一下吧！
# 导包
# import time
# from multiprocessing import Process
# 创建函数--子进程
def work1():
while True:
print("我是子进程嘻嘻嘻")
time.sleep(1)
# 程序入口
if __name__ == "__main__":
# 创建子进程对象
p1 = Process(target=work1)
# 启动
p1.start()
while True:
print("我是主进程，哈哈哈")
time.sleep(1)
深入了解process 参数说明： target:如果传递了函数的引用，就可以认为要执行该子进程的代码 args:给target指定的函数传递参数，参数以元组的形式传递，如果元组中只有一个值，需要加逗号 kwargs:给target指定的函数传递参数，参数以字典的形式传递 name:给进程起名字 group:指定进程组
import time
from multiprocessing import Process
# 创建函数--子进程
def work1(*args,**kwargs):
while True:
print(args)
print(kwargs)
time.sleep(1)
# 程序入口
if __name__ == "__main__":
# 创建子进程对象
p1 = Process(target=work1,args=("大木",19),kwargs={"性别":"男"})
# 启动
p1.start()
while True:
print("大木二货，哈哈哈")
time.sleep(1)说明：1、右键run的时候就会创建一个进程，这个进程就称为主进程
2、在程序中创建的work1为子进程
3、创建进程和启动进程时需要使用target参数和start()方法
4、根据题意来判断需不需要在process里传args和kwargs参数
注意：必须写程序入口
Process创建实例对象的常用方法： start:启动子进程 terminate:不管认为是否完成，立即终止子进程 join（[timeout]）：是否等待子进程结束之后,再执行主进程，或等待多少秒 is_alive:判断子进程是否还活着 Process创建实例对象的常用属性： name:进程名字 pid:进程的id--pid multiprocessing是一个模块
现在我们已经基本了解了进程，那么进程间是如何实现通信的呢？
# 进程间数据的隔离性
# 定义一个全局变量 列表
lst = [11,22]
# 导包
import multiprocessing
import time
# 第一个进程 向列表中添加数据
def work1():
for i in range(3):
lst.append(i)
time.sleep(1)
print(lst)
# 第二个进程对列表不做任何改变
def work2():
print(lst)
# 程序入口
if __name__ == '__main__':
p1 = multiprocessing.Process(target=work1)
p1.start()
# join（[timeout]）：是否等待子进程结束之后,再执行主进程，或等待多少秒
# 让p1这个进程执行完再执行p2
p1.join()
p2 = multiprocessing.Process(target=work2)
p2.start()
# 输出结果：[11, 22, 0]
# [11, 22, 0, 1]
# [11, 22, 0, 1, 2] 进程1操作之后的结果
# [11, 22] 进程2操作之后的结果
# 总结：进程间数据具有隔离性，进程之间不能共享全局变量队列：一种数据结构 特点：先进先出 当存满数据再次存储会出现阻塞的状况 当数据已经全部取完，再继续取数据也会出现阻塞
import multiprocessing
ret = multiprocessing.Queue(3) #该队列有3个值
#存数据 put
ret.put(11)
ret.put("22")
ret.put({"小明":"白白胖胖"})
# 检测是否为满
# print(ret.full())
# 检测是否为空
# print(ret.empty())
# 取数据 get
print(ret.get()) #11
print(ret.get()) #22
print(ret.get()) #[11,22]
# print(ret.get()) #阻塞
# get_nowait以异常的方式告诉我们已经取完数据了
print(ret.get_nowait())接下来，我们一起了解一下进程池！
进程池：需要创建多个进程比如成千上万个进程时，如果使用Process手动创建非常费时间
同步与异步：是提交任务的两种方式
同步：提交任务后在原地进行等待，直到任务运行完毕拿到任务的返回值才进行下一行代码
异步：提交完代码不在原地等待直接进行下一次
阻塞与非阻塞：
阻塞：程序一旦发生阻塞就会停在原地，并且立刻释放CPU资源
非阻塞：即使遇到I/O阻塞，也不会停在原地
# 定义一个池子，池子里有固定的进程数，有需求来了，
# 再进程池中加一个任务，如果任务满了则需等待
import multiprocessing
import os
import time
# 创建进程
def func(data):
print("进程%s--打印传入的参数%s" %(os.getpid(),data))
time.sleep(1)
# 程序入口：
if __name__ == '__main__':
# 创建进程池 参数代表最大进程数
po = multiprocessing.Pool(3)
for i in range(10):
# po.apply(func,args=(i,))
po.apply_async(func,args=(i,))
print("我是主进程")
po.close()
po.join()apply和apply_async提交方式的区别： apply:同步提交 按顺序执行 apply_async：异步提交 任务都是异步
今天，我们一起学习了进程、子进程、进程间的通信以及进程池，下节我们继续学习线程，拜拜！
标签：__,编程,print,并发,time,进程,import,multiprocessing 来源： https://blog.csdn.net/weixin_61422097/article/details/121710970