Process类中的参数介绍：
1.group参数未使用,值始终为none
2.target表示调用对象,即子进程要执行的任务
3.args 表示调用对象的位置参数元组.args = (1,2,"egon")
4.kwargs表示调用对象的字典,kwargs = {"name":"eng","age":18}
5.name为子进程的名称
创建进程的两种方法
直接使用from multiprocessing import Process
自定义一个类,继承Process类,重写run方法,如果需要传参,重写inin并调用super()来执行父类的init
给要执行的函数传参数
两种传参方式
Args = (1,)元组
Kwargs = {"n":1}字典
列
def func(x,y):
print(x)
time.sleep(1)
print(y)
if __name__ == "__main__":
p = Process(target=func,args =("妹子","来玩啊"))#这是func需要接受的参数的传递方式
p.start()
print("父类进程执行结束!")
#执行结果
父类程执行结果!
妹子
来玩啊
Process类中个方法的介绍:
1.p.start() 启动进程,并调用该进程中的p.run()
2.prun() 进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类中一定要实现该方法
3.p.terminate()强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法需要特别小心这种情况,如果p还保存了一个锁那么也将不会被释放,进而导致死锁
4.p.is_alive()如果怕仍然运行,返回True
5.p.jion([timeout]) 主线程等待p终止(强调:是主线程处于等的状态,,而p处于运行的状态).timeout是可选的超时时间,需要强调的是,p.jion只能jion住start开启的进程,而不能jion住run开启的进程
jion方法的例子
等待子进程结束,然后继续往下执行
def func(x,y):
print(x)
time.sleep(1)
print(y)
if __name__ == "__main__":
p = Process(target=func,args=("妹子","来玩啊!"))
p.start()
print("我这里是异步的啊")#这里相对于子进程还是异步的
p.jion()#只有在jion的地方才会阻塞,将子进程和主进程之间的异步改为同步
print("父进程执行结束")
#打印的结果
我这里是异步的啊
妹子
来玩啊
父进程执行结束
怎样开启多个进程呢?for循环所有的子进程异步执行,然后多有的子进程全部执行完之后,我在执行主进程
看代码
例子
#下面的注释按照编码去看,别忘了
首先引入
import time
import os
from multiprocessing import Process
def func(x,y):
print(x)
#time.sleep(1)#进程切换:如果没有这个时间间隔,name你会发现func执行结果是打印一个x然后一个y,在打印一个x一个y,不会出现打印多个x然后打印y的情况,因为两个打印举例太近了而且执行的也非常快,
但是如果你这段程序运行慢的话,你就会发现进程之间的切换
print(y)
if __name__ == "__main__":
p_list = []
for i in range(10):
p = Process(target=func,args=("姑娘%s"%i,"来玩啊!"))
p_list.append(p)
p.start()
[ap.join() for ap in p_list]#这是解决办法,前提是我们的子进程全部都已经取执行了,那么我再一次给所有正在执行的的子进程加上jion,那么主进程据需要等着多有子进程执行结束才会继续执行自己的程序了,并且保障了所有子进程是异步执行的
#p.jion()#1.如多加到for循环里面,那么所有子进程就全部变为同步了,因为for循序也是主进程的,训话第一次的时候,一个进程去执行了,然后这个进程就jion住了,
那么for循环就不会继续执行了,等着第一个子进程执行结束才会继续执行for循环取创建第二个子进程.
# #2、如果我不想这样的，也就是我想所有的子进程是异步的，然后所有的子进程执行完了再执行主进程
#p.join() #3、如果这样写的话，多次运行之后，你会发现会出现主进程的程序比一些子进程先执行完，因为我们p.join()是对最后一个子进程进行了join，也就是说如果这最后一个子进程先于其他子进程执行完，那么主进程就会去执行，而此时如果还有一些子进程没有执行完，而主进程执行
#完了，那么就会先打印主进程的内容了，这个cpu调度进程的机制有关系，因为我们的电脑可能只有4个cpu，我的子进程加上住进程有11个，虽然我for循环是按顺序起进程的，但是操作系统一定会按照顺序给你执行你的进程吗，答案是不会的，操作系统会按照自己的算法来分配进
# #程给cpu去执行，这里也解释了我们打印出来的子进程中的内容也是没有固定顺序的原因，因为打印结果也需要调用cpu，可以理解成进程在争抢cpu，如果同学你想问这是什么算法，这就要去研究操作系统啦。那我们的想所有子进程异步执行，然后再执行主进程的这个需求怎么解决啊
print('不要钱~~~~~~~~~~~~~~~~！')
同事对一个文件进行操作,同事创建多个文件
import time
import os
import re
from multiprocessing import Process
#多进程同事对一个文件进行写操作
def func(x,y,i):
with open(x,"a",encoding="utf-8")as f:
print("当前进程$s拿到的文件的光标位置>>%s"%s(os.getpid(),f.tell()))
f.write(y)
#多进程同时创建多个文件
# def func(x,y):
# with open (x,'w',encoding="utf-8")as f:
# f.write(y)
if __name__ =="__main__":
p_list = []
for i in range(10):
p = Process(target=func,args=("can_do_girl_list.txt","姑娘%s"%i,i))
# p = Process(target=func,args=('can_do_girl_info%s.txt'%i,'姑娘电话0000%s'%i))
p_list.append(p)
p.start()
[ap.join() for ap in p_list] # 这就是个for循环，只不过用列表生成式的形式写的
with open('can_do_girl_lists.txt', 'r', encoding='utf-8') as f:
data = f.read()
all_num = re.findall('d+', data) # 打开文件，统计一下里面有多少个数据，每个数据都有个数字，所以re匹配一下就行了
print('>>>>>', all_num, '.....%s' % (len(all_num)))
# print([i in in os.walk(r'你的文件夹路径')])
print('不要钱~~~~~~~~~~~~~~~~！')
Process类中自带封装的各属性的介绍
1 p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
2 p.name:进程的名称
3 p.pid：进程的pid
4 p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
5 p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
继承的形式创建进程:
class MyProcess(Process): #自己写一个类，继承Process类
#我们通过init方法可以传参数，如果只写一个run方法，那么没法传参数，因为创建对象的是传参就是在init方法里面，面向对象的时候，我们是不是学过
def __init__(self,person):
super().__init__()
self.person=person
def run(self):
print(os.getpid())
print(self.pid)
print(self.pid)
print('%s 正在和女主播聊天' %self.person)
# def start(self):
# #如果你非要写一个start方法，可以这样写，并且在run方法前后，可以写一些其他的逻辑
# self.run()
if __name__ == '__main__':
p1=MyProcess('Jedan')
p2=MyProcess('太白')
p3=MyProcess('alexDSB')
p1.start() #start内部会自动调用run方法
p2.start()
# p2.run()
p3.start()
p1.join()
p2.join()
p3.join()