系统相关
首页 > 系统相关> > 并发编程之进程

并发编程之进程

作者:互联网

首先,我们呢需要了解什么是进程呢?

狭义:进程就是正在进行的程序

广义:是操作系统分配的基本单位

程序:是一个没有生命的实体,等待处理器赋予生命,一旦程序有了生命就变成进程了。

程序和进程的区别:

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