Process 创建子类

assert self._popen is None, 'cannot start a process twice'

Python assert（断言）用于判断一个表达式，在表达式条件为false 的时候触发异常。 断言可以在条件不满足程序运行的情况下直接返回错误，而不必等待程序运行后出现崩溃的情况，例如我们的代码只能在Linux 系统下运行，可以先判断当前系统是否符合条件。

父类创建接口，子类根据需求去实现接口(方法)

创建进程有两种方法，用Process去创建进程，第二种是创建类去继承Process类

from multiprocessing import Process
import time

class MyClass(Process):
    def run(self):
        while True:
            print("-----test-----")
            time.sleep(1)#切换进程用的

if __name__ == "__main__":
    p = MyClass()
    p.start()#为啥创建对象之后只调用start方法就可以调用子类的run方法， 这是因为父类Process中就有start方法去调用run方法这个过程
    while True:
        print("-----main----")
        time.sleep(1)
Result：
-------main------
------test-------
父类提供一个run接口，子类对run方法进行重写，这样创建对象的时候就运行子类的run方法 这是一种模式

主进程等待Process子进程先结束

def test():
    while True:
        print("-----test-----")
        time.sleep(1)#切换进程用的

if __name__ == "__main__":
    p = Process(target=test)
    p.start()
result:

-----test-----
-----test-----
-----test-----
-----test-----

..

因为我们知道进程是python中最小的资源分配单元，也就是进程中间的数据，内存是不共享的，每启动一个进程，都要独立分配资源和拷贝访问的数据，所以等待子进程结束收回分配资源

 

join([timeout])：阻塞当前上下文环境的进程程，直到调用此方法的进程终止或到达指定的timeout（可选参数）。
意思就是子进程结束才会执行主进程，另外只要看到中括号代表可写可不写

def test():
    while True:
        print("-----test-----")
        time.sleep(1)#切换进程用的

if __name__ == "__main__":
    p = Process(target=test)
    p.start()
　　 p.join()#主进程执行到这句语句的时候会阻塞这儿，等待前面的p.start()执行完也就是等待前面的子进程执行完。
假如：

if __name__ == "__main__":
    p = Process(target=test)
    p.start()
　　 p.join(2)#主进程执行到这句语句的时候会阻塞这儿，等待前面的p.start()执行完也就是等待前面的子进程执行完。
　　print（"---main----"）表示2秒之后会执行执行主进程打印--main--

 

 

Python中的多进程是通过multiprocessing包来实现的，和多线程的threading.Thread差不多，它可以利用multiprocessing.Process对象来创建一个进程对象。这个进程对象的方法和线程对象的方法差不多也有start(), run(), join()等方法，其中有一个方法不同Thread线程对象中的守护线程方法是setDeamon，而Process进程对象的守护进程是通过设置daemon属性来完成的。

下面说说Python多进程的实现方法，和多线程类似

2.Python多进程实现方法一

from multiprocessing import  Process

def fun1(name):
    print('测试%s多进程' %name)

if __name__ == '__main__':
    process_list = []
    for i in range(5):  #开启5个子进程执行fun1函数
        p = Process(target=fun1,args=('Python',)) #实例化进程对象
        p.start()
        process_list.append(p)

    for i in process_list:
        p.join()

    print('结束测试')

结果

测试Python多进程
测试Python多进程
测试Python多进程
测试Python多进程
测试Python多进程
结束测试

Process finished with exit code 0

上面的代码开启了5个子进程去执行函数，我们可以观察结果，是同时打印的，这里实现了真正的并行操作，就是多个CPU同时执行任务。我们知道进程是python中最小的资源分配单元，也就是进程中间的数据，内存是不共享的，每启动一个进程，都要独立分配资源和拷贝访问的数据，所以进程的启动和销毁的代价是比较大了，所以在实际中使用多进程，要根据服务器的配置来设定。

3.Python多进程实现方法二

类进程要有一个run方法

还记得python多线程的第二种实现方法吗?是通过类继承的方法来实现的，python多进程的第二种实现方式也是一样的

from multiprocessing import  Process

class MyProcess(Process): #继承Process类
    def __init__(self,name):
        super(MyProcess,self).__init__()
        self.name = name

    def run(self):
        print('测试%s多进程' % self.name)


if __name__ == '__main__':
    process_list = []
    for i in range(5):  #开启5个子进程执行fun1函数
        p = MyProcess('Python') #实例化进程对象
        p.start()
        process_list.append(p)

    for i in process_list:
        p.join()

    print('结束测试')

结果

测试Python多进程
测试Python多进程
测试Python多进程
测试Python多进程
测试Python多进程
结束测试

Process finished with exit code 0

效果和第一种方式一样。

我们可以看到Python多进程的实现方式和多线程的实现方式几乎一样。

Process类的其他方法

构造方法：

Process([group [, target [, name [, args [, kwargs]]]]])
　　group: 线程组 
　　target: 要执行的方法
　　name: 进程名
　　args/kwargs: 要传入方法的参数

实例方法：
　　is_alive()：返回进程是否在运行,bool类型。
　　join([timeout])：阻塞当前上下文环境的进程程，直到调用此方法的进程终止或到达指定的timeout（可选参数）。
　　start()：进程准备就绪，等待CPU调度
　　run()：strat()调用run方法，如果实例进程时未制定传入target，这star执行t默认run()方法。
　　terminate()：不管任务是否完成，立即停止工作进程

属性：
　　daemon：和线程的setDeamon功能一样
　　name：进程名字
　　pid：进程号