进程与线程 -- 多进程

进程状态

• 就绪态：运行的条件都已经具备，正在等在cpu执行
• 执行态：cpu正在执行其功能
• 等待态：等待某些条件满足，例如一个程序sleep了，此时处于等待态

multiprocessing模块

编写多进程的服务程序，可以使用Python提供的multiprocessing模块
multiprocessing模块提供了一个Process类来代表一个进程对象

创建多进程

• 通过Process实例，传入一个在进程中执行的函数和函数的参数，
  • 传入函数使用 target=run_proc，只需要函数名
  • 传入参数使用 args=('test',)，必须用元组类型
• 使用start()方法启动进程
• join()方法可以等待子进程结束后再继续运行

• 实例1：主进程和1个子进程

from multiprocessing import Process
import time

def run_proc():
    """子进程要执行的代码"""
    while True:
        print("----2----")
        time.sleep(1)

if __name__ == '__main__':
    p = Process(target=run_proc)
    p.start()
    while True:
        print("----1----")
        time.sleep(1)

----1----
----1----
----2----
----1----
----2----
...

• 实例2：主进程和2个子进程

from multiprocessing import Process
import time

def run_proc1():
    while True:
        print('Run child process1')
        time.sleep(0.5)

def run_proc2():
    while True:
        print('Run child process2')
        time.sleep(0.5)

if __name__ == '__main__':
    p1 = Process(target=run_proc1)
    p2 = Process(target=run_proc2)
    p1.start()
    p2.start()
    print('Child process end.')

Run child process1
Run child process1
Run child process2
Run child process1
Run child process2
...

• 实例3：向子进程传递参数

from multiprocessing import Process
import os

def run_proc(name):  # 子进程要执行的代码
    print('Run child process %s (%s)...' % (name, os.getpid()))

if __name__ == '__main__':
    print('Parent process %s.' % os.getpid())
    p = Process(target=run_proc, args=('test',))
    print('Child process will start.')
    p.start()
    p.join()
    print('Child process end.')

Parent process 3244.
Child process will start.
Run child process test (4716)...
Child process end.

• 实例4：向子进程传递多个参数

from multiprocessing import Process
import os
from time import sleep


def run_proc(name, age, **kwargs):
    for i in range(10):
        print('子进程运行中，name= %s,age=%d ,pid=%d...' % (name, age, os.getpid()))
        print(kwargs)
        sleep(0.2)

if __name__=='__main__':
    p = Process(target=run_proc, args=('test',18), kwargs={"m":20})
    p.start()
    sleep(1)  # 1秒中之后，立即结束子进程
    p.terminate()
    p.join()

子进程运行中，name= test,age=18 ,pid=3604...
{'m': 20}
子进程运行中，name= test,age=18 ,pid=3604...
{'m': 20}
子进程运行中，name= test,age=18 ,pid=3604...
{'m': 20}

课堂练习：

• 使用多进程计算并输出 0 ~ 3000 之内的素数
  分成3个进程
  进程1：0 ~ 1000
  进程2：1001 ~ 2000
  进程3：2001 ~ 3000

from multiprocessing import Process
import os

def isPrime(n):
    for x in range(2, n):
        if n % x == 0:
            return False
    else:
        return True

def proc(beg, end):
    for n in range(beg, end):
        if isPrime(n):
            print('%d:%d是素数' % (os.getpid(), n))

if __name__ == '__main__':
    p1 = Process(target=proc, args=(3, 1001))
    p2 = Process(target=proc, args=(1001, 2001))
    p3 = Process(target=proc, args=(2001, 3001))

    p1.start()
    p2.start()
    p3.start()
    print('end.')

小结

多进程强调是同时运行多个任务，不一定会节省运行时间

- end -