进程：
import os
import time
print(os.getpid()) # 进程id
time.sleep(1000)
print(os.getpid())
# 4核 —— 4个进程
# 一个进程 —— cpu
# 多进程 —— 4个进程
创建进程num1：
import os
import time
from multiprocessing import Process
def process1():
print('process1 : ',os.getpid())
time.sleep(10)
if __name__ == '__main__':
print(os.getpid())
p = Process(target=process1)
p.start()
创建进程2：
import os
import time
from multiprocessing import Process
def process1(n,name,num = 20):
print('process1 : ',os.getpid())
print('n : ',n,name,num)
time.sleep(10)
if __name__ == '__main__':
print(os.getpid())
p = Process(target=process1,args=[1,'alex',30])
p.start()
进程与子进程：
# 主进程
# 子进程
# 父进程
import os
import time
from multiprocessing import Process
def func():
print(os.getpid(),os.getppid())
time.sleep(1)
if __name__ == '__main__':
print(os.getpid(),os.getppid()) # process id,parent process id
Process(target=func).start() # func
print('*'*20)
time.sleep(0.5)
print('*'*40)
# p = Process(target=func)
# p.start()
# 主进程默认会等待子进程执行完毕之后才结束
# 主进程和子进程之间的代码是异步的
# 为什么主进程要等待子进程结束 回收一些子进程的资源
# 开启一个进程是有时间开销的 ：操作系统响应开启进程指令，给这个进程分配必要的资源
同步控制：
import os
from multiprocessing import Process
def func(exp):
print(os.getpid(),os.getppid())
result = eval(exp)
with open('file','w') as f:
f.write(str(result))
if __name__ == '__main__':
print(os.getpid(),os.getppid()) # process id,parent process id
# 3*5+5/6
p = Process(target=func,args=['3*5']) # func
p.start()
ret = 5/6
p.join() # join方法能够检测到p进程是否已经执行完了，阻塞知道p执行结束
with open('file') as f:
result = f.read()
ret = ret + int(result)
print(ret)
开启多个进程：
import os
import time
from multiprocessing import Process
def process(n):
print(os.getpid(),os.getppid())
time.sleep(1)
print(n)
if __name__ == '__main__':
p_lst = []
for i in range(10):
p = Process(target=process,args=[i,])
p.start()
p_lst.append(p)
for p in p_lst:p.join() # 检测p是否结束 如果没有结束就阻塞直到结束 如果已经结束了就不阻塞
print('求和')
开启进程的第二种方式：
import os
from multiprocessing import Process
class Myprocess(Process):
def __init__(self,*args):
super().__init__()
self.args = args
def run(self):
print(os.getpid(),self.name,self.pid)
for name in self.args:
print('%s和女主播聊天'%name)
if __name__ == '__main__':
print(os.getpid())
p = Myprocess('yuan','wusir')
p.start() # 在执行start的时候，会帮我们主动执行run方法中的内容
进程中的数据隔离：
from multiprocessing import Process
n = 100
def func():
global n
n += 1
print('son : ',n)
if __name__ == '__main__':
p = Process(target=func)
p.start()
p.join()
print(n)
守护进程：
import time
from multiprocessing import Process
def func():
print('son start')
while True:
time.sleep(1)
print('son')
def func2():
print('start :in func2')
time.sleep(5)
print('end : in func2')
if __name__ == '__main__':
p = Process(target=func)
# 在一个进程开启之前可以设置它为一个守护进程
p.daemon = True
p.start()
Process(target=func2).start()
time.sleep(2)
print('在主进程中')
# 分析：
# 主进程的代码 大概在2s多的时候就结束了
# p2子进程实在5s多的时候结束
# 主进程结束
# p是在什么时候结束的？
# p是在主进程的代码执行完毕之后就结束了
# 主进程会等待子进程的结束而结束
# 守护进程的意义：
# 子进程会随着主进程代码的执行结束而结束
# 注意：守护进程不会关系主进程什么时候结束，我只关心主进程中的代码什么时候结束
# 守护进程的作用：
# 守护主进程，程序报活
# 主进程开启的时候 建立一个守护进程
# 守护进程只负责每隔1分钟 就给检测程序发一条消息
进程中的其他方法：
# import time
# from multiprocessing import Process
#
# def func():
# print('wahaha')
# time.sleep(20)
# print('wahaha end')
# if __name__ == '__main__':
# p = Process(target=func)
# p.start()
# print(p.is_alive())
# time.sleep(1)
# p.terminate() # 在主进程中结束一个子进程
# print(p.is_alive())
# time.sleep(0.5)
# print(p.is_alive())
# # print(p.pid)
# # print(p.name)
import time
from multiprocessing import Process
def foo():
print(123)
time.sleep(1)
print("end123")
def bar():
print(456)
time.sleep(3)
print("end456")
if __name__ == '__main__':
p1=Process(target=foo)
p2=Process(target=bar)
p1.daemon=True
p1.start()
p2.start()
time.sleep(0.1)
print("main-------")