Python中创建进程的3种方式

Python 中创建进程的3种方式

1.使用multiprocessing模块创建进程：

```python
from multiprocessing import Process  # 导入模块
import time
import os

# 使用multiprocessing模块创建进程
def child_1(interval):  # 子程序1调用的方法
    print("子进程(%s)开始执行，父进程为(%s)" % (os.getpid(), os.getppid()))
    time_s = time.time()  # 开始计时
    time.sleep(interval)  # 程序将会被挂起interval秒
    time_e = time.time()  # 计时结束
    print("子进程(%s)执行时间为'%0.2f'秒" % (os.getpid(), time_e-time_s))


def child_2(interval):  # 子进程2调用的方法
    print("子进程（%s）开始执行，父进程为（%s）" % (os.getpid(), os.getppid()))
    time_s = time.time()
    time.sleep(interval)
    time_e = time.time()
    print("子进程(%s)执行时间为'%0.2f'秒" % (os.getpid(), time_e - time_s))


def main():  # 执行主程序
    print("-"*10+"父进程开始执行"+"-"*10)
    print("父进程PID：%s" % os.getpid())  # 打印当前程序的ID
    p1 = Process(target=child_1, args=(1,))  # 实例化进程p1
    p2 = Process(target=child_2, name="mrsoft", args=(2,))  # 实例化进程p2
    p1.start()  # 启动进程p1
    p2.start()  # 启动进程P2
    # 同时父进程仍然往下执行，判断p1,p2是否还在执行，是返还True
    print("p1.is_alive=%s" % p1.is_alive())
    print("p2.is_alive=%s" % p2.is_alive())
    # 打印p1和p2进程的别名和PID
    print("p1.name=%s" % p1.name)
    print("p1.pid=%s" % p1.pid)
    print("p2.name=%s" % p2.name)
    print("p2.pid=%s" % p2.pid)
    print("-"*10+"等待子进程"+"-"*10)
    p1.join()  # 等待p1进程结束
    p2.join()  # 等待p2进程结束
    print("-"*10+"父进程结束"+"-"*10)

if __name__ == '__main__':
    main()  # 调用main()函数

  2.使用Process子类创建进程
  

```python
from multiprocessing import Process  # 导入模块
import time
import os

 # 继承Process类
class SubProcess(Process):
    '''代码中定义了一个SubProcess子类，继承multiprocessing.Process父类。SubProcess子类中定义了两个方法：
    __init__()初始化方法和run()方法。在__init__()初始化方法中，调用multiprocessing.Process父类的__init__()
    初始化方法，否则父类初始化方法会被覆盖，无法启动进程。此外，在SubProcess子类中并没有定义start（）方法，
    但在主程序中调用了start（）方法，此时会自动执行SubProcess类的run方法
    '''
    # 由于Process类本身也有__init__（）初始化方法，这个子类相当于重写了父类的这个方法
    def __init__(self, interval, name=""):
        Process.__init__(self)  # 调用Process父类的初始化方法
        self.interval = interval  # 接收参数interval
        if name:  # 判断传递到额参数name是否存在
            self.name = name  # 如果传递参数name,则为子进程创建name属性，否则使用默认属性

    # 重写Process类的run()方法
    def run(self):
        print("子进程（%s）开始执行，父进程为（%s）" % (os.getpid(), os.getppid()))
        time_s = time.time()
        time.sleep(self.interval)
        time_e = time.time()
        print("子进程(%s)执行时间为'%0.2f'秒" % (os.getpid(), time_e-time_s))


if __name__ == '__main__':

    print("-"*10+"父进程开始执行"+"-"*10)
    print("父进程PID：%s" % os.getpid())  # 打印当前程序的ID
    p1 = SubProcess(interval=1)
    p2 = SubProcess(interval=2, name="mrsoft")
    # 对一个不包含target属性的Process类执行start()方法，就会运行这个类中的run()方法
    # 所以这里会执行p1.run()和p2.run()
    p1.start()
    p2.start()
    print("p1.is_alive=%s" % p1.is_alive())
    print("p2.is_alive=%s" % p2.is_alive())
    print("p1.name=%s" % p1.name)
    print("p1.pid=%s" % p1.pid)
    print("p2.name=%s" % p2.name)
    print("p2.pid=%s" % p2.pid)
    print("-"*10+"等待子进程"+"-"*10)
    p1.join()
    p2.join()
    print("-"*10+"父进程结束"+"-"*10)

3.使用进程池Pool类创建进程:

from multiprocessing import Pool  # 导入模块
import time
import os

def task(name):
    print("子进程（%s）开始执行task %s..." % (os.getpid(), name))
    time.sleep(1)  # 休眠1 秒


if __name__ == '__main__':
    print("父进程（%s）" % os.getpid())
    p = Pool(3)  # 创建一个进程池，最大进程数为3
    for i in range(10):  # 从0开始循环10次
        p.apply_async(task, args=(i,))  # 使用非阻塞的方式调用task()函数
    print("等待所有子进程结束...")
    p.close()  # 关闭进程池，关闭后不再接受新的请求
    p.join()   # 等待子进程结束
    print("所有子进程结束.")

运行的结果：