注册一个进程：
from multiprocessing import Process
import os
def func(args): # 在子进程里面。args接收一个参数，如果要接受多个参数使用*args
print(args)
print(111)
print('子进程：', os.getpid())
print('子进程的父进程:', os.getppid()) if __name__ == "__main__": # if里面的是父进程
p = Process(target=func, args=('参数',) # 注册，将函数func注册成一个进程,args是传入的参数，只穿一个参数要带逗号 p.start() # 启动进程，这里面启动的都是一个子进程
print(222) # 这也是一个进程，输出222和111的顺序不一定，因为是两个不同的进程。
print('父进程:', os.getpid()) # getpid()获取当前进程号
print('父进程的父进程:', os.getppid()) # 查看哪个进程创建了当前进程
多进程中的jion方法：
from multiprocessing import Process import time
def func(args1, args2):
print('#'*args1)
time.sleep(3)
print('#'*args2) if __name__ == "__main__": p = Process(target=func, args=(5,10)) p.start()
p.join() # join的作用就是感知一个子进程的结束，将异步的变成同步，子进程程序执行完才执行join()下面的代码
print("- " *10)
同时开启多个子进程：
from multiprocessing import Process import time
def func(args1, args2):
print('#'*args1)
time.sleep(3)
print('#'*args2) if __name__ == "__main__": p1 = Process(target=func, args=(5,10))
p1.start()
p2 = Process(target=func, args=(5,10))
p2.start()
p3 = Process(target=func, args=(5,10))
p3.start()
p4 = Process(target=func, args=(5,10))
p4.start() print("- " *10)
from multiprocessing import Process import time
def func(args1, args2):
print('#'*args1)
time.sleep(5) # 每个进程都睡5秒
print('#'*args2) if __name__ == "__main__": # 打印结果会看到进程谁先谁后打印不一定
for i in range(50): # 相当于50条路，有50辆车分别在每条路上跑，
p = Process(target=func, args=(1*i,2*i))
p.start()
p.join() # 这是会发现 执行完了 打印出来还有进程没结束，因为这时的p是检测最后一个进程执行结束，但最后一个进程结束不表示其他进程也结束了。
print('执行完了')
如下优化：
from multiprocessing import Process import time
def func(args1, args2):
print('#'*args1)
time.sleep(5) # 每个进程都睡5秒
print('#'*args2) if __name__ == "__main__": # 打印结果会看到进程谁先谁后打印不一定 p_list = []
for i in range(50): # 相当于50条路，有50辆车分别在每条路上跑，
p = Process(target=func, args=(1*i,2*i))
p_list.append(p) # 将所有进程加到一个列表里面
p.start()
[p.join() for p in p_list] # 列表推导式，所有进程执行完再执行最后一行代码
print('执行完了')
写多个文件：
from multiprocessing import Process import os
def func(filename, content):
with open(filename, 'w') as f:
f.write(content*10*'*') if __name__ == "__main__":
p_list = []
for i in range(5):
p = Process(target=func, args=('info%s'%i,i))
p_list.append(p)
p.start()
[p.join() for p in p_list]
print([i for i in os.walk(r'E:pycharm')]) # os.walk(r'路径') 查看这个文件夹家里面所有的文件
多进程的另外一种启动方式（基于继承）：
from multiprocessing import Process
import os class MyProcess(Process): # 继承Process类 def __init__(self, args1, args22):
super().__init__() # 注意写初始化方法，一定要使用super，因为它的父类本身就有__init__方法，写上这个方法就是交给父类的__init__方法去处理，如果自己有的就用自己的
self.args1 = args1
self.args2 = args2
def run(self): # 必须实现一个run方法，run方法是在子进程中执行的
print(os.getpid()) # 这个run方法会自动调用，就像下面这个被注释的start方法,其实已经被封装好了
print(self.pid) # 打印进程号同os.getpid()
print(self.name) # 打印进程的名字
print(self.args1, self.args2) # def start(self):
# self.run() if __name__ == '__main__':
print('主进程:', os.getpid())
p1 = MyProcess()
p1.start()
p2 = MyProcess()
p2.start()
进程之间的数据隔离问题：
from multiprocessing import Process
import os class MyProcess(Process):
def run(self):
global n # 声明一个全局变量n在子进程里面
n = 0
print('pid:%s'%self.pid, n) if __name__ == '__main__':
n = 100 # 定义一个变量n在父进程里面
p = MyProcess()
p.start()
p.join() # 通过join方法，先让子进程执行完毕，这是子进程里面的n就成了全局变量，看打印结果，
会发现，就是子进程中的n是全局的，父进程的n依旧是100，说明两个进程的全局不是同一个全局，是完全相互隔离的。如果非要让进程之间通信需要用到特殊方式，比如：管道，文件，套接字等方式。
print('pid:%s'%os.getpid(), n)
守护进程：
让子进程随着主进程的代码执行结束而结束，这个子进程就是守护进程。
使用p.daemon = True 进行设置守护进程
from multiprocessing import Process
import os
import time class MyProcess(Process):
def run(self):
while 1:
time.sleep(0.2)
print('hello') if __name__ == '__main__': # windows系统开进程一定要在这行代码下面起，否则会报错。
p = MyProcess()
p.daemon = True
p.start()
i = 0
while i < 5:
print('我是socket server')
time.sleep(1)
i += 1
进程操作的其他方法：
from multiprocessing import Processimport time class MyProcess(Process):
def run(self):
print(111) if __name__ == '__main__':
p = MyProcess() p.start()
print(p.is_alive()) # is_alive()查看进程是否还活着
# p.terminate() # terminate()杀死一个进程
time.sleep(1)
print(p.is_alive())