创建多进程Process

注册一个进程：

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())