Python—多进程

多线程链接：https://blog.csdn.net/weixin_42394170/article/details/95744871

线程替代方案

• subprocess

  • 完全跳过线程，使用进程
  • 是派生进程的主要替代方案
  • python2.4后引入

• multiprocessiong

  • 使用threadiing借口派生，使用子进程
  • 允许为多核或者多cpu派生进程，接口跟threading非常相似
  • python2.6

• concurrent.futures

  • 新的异步执行模块
  • 任务级别的操作
  • python3.2后引入

多进程

• 进程间通讯(InterprocessCommunication, IPC )

• 进程之间无任何共享状态

• 进程的创建

  • 直接生成Process实例对象， 案例19
  • 派生子类， 案例20

• 在os中查看pid，ppid以及他们的关系

  • 案例21

• 生产者消费者模型

  • JoinableQueue
  • 案例22
  • 队列中哨兵的使用, 案例23
  • 哨兵的改进， 案例24

**案例19**
import multiprocessing
import time

def fun(n):
    print("The time is %s"%time.ctime())
    time.sleep(n)

if __name__ == '__main__':
    p = multiprocessing.Process(target = fun,args = (5,))
    p.start()

**案例20**

#派生子类

import multiprocessing
import time

class MyProcess(multiprocessing.Process):
    def __init__(self,n):
        super().__init__()
        self.n = n

    def run(self):
        while True:
            print("The time is %s"%time.ctime())
            time.sleep(self.n)


if __name__ == '__main__':
    p = MyProcess(2)
    p.start()

**案例21**
import multiprocessing
import os

def fun(title):
    print(title)
    print("model name",__name__)
    #得到的是父亲进程
    print("parent process ",os.getppid())
    #得到的是本身自己的进程
    print("process ",os.getpid())

def f(name):
    fun("function f")
    print("hello",name)

if __name__ == '__main__':
    fun("main line")
    p = multiprocessing.Process(target = f,args = ("cc",))
    p.start()
    p.join()

# 结果：
# main line
# model name __main__
# parent process  10656
# process  13036
# function f
# model name __mp_main__
# parent process  13036
# process  1120
# hello cc

**案例22**
import multiprocessing
import time

def producer(sequeue,out_put):
    for i in sequeue:
        print("Into poducer",time.ctime())
        out_put.put(i)
    print("out of producer",time.ctime())

def consumer(in_put):
    print("Into consumer",time.ctime())
    while True:
        item = in_put.get()
        print("pull", item, "out of q")  # 此处替换为有用的工作
        in_put.task_done()  # 发出信号通知任务完成
    print("Out of consumer:", ctime())  ##此句未执行，因为q.join()收集到四个task_done()信号后，主进程启动，未等到print此句完成，程序就结束了

if __name__ == '__main__':
    q = multiprocessing.JoinableQueue()
    # 运行消费者进程
    cons_p = multiprocessing.Process(target=consumer, args=(q,))
    cons_p.daemon = True
    cons_p.start()

    # 生产多个项，sequence代表要发送给消费者的项序列
    # 在实践中，这可能是生成器的输出或通过一些其他方式生产出来
    sequence = [1, 2, 3, 4]
    producer(sequence, q)
    # 等待所有项被处理
    q.join()

**案例23**
import multiprocessing
from time import ctime

# 设置哨兵问题
#while True 一直循环，我们设置哨兵，可以退出循环
def consumer(input_q):
    print("Into consumer:", ctime())
    while True:
        item = input_q.get()
        if item is None:
            break
        print("pull", item, "out of q")
    print ("Out of consumer:", ctime()) ## 此句执行完成，再转入主进程


def producer(sequence, output_q):
    print ("Into procuder:", ctime())
    for item in sequence:
        output_q.put(item)
        print ("put", item, "into q")
    print ("Out of procuder:", ctime())

if __name__ == '__main__':
    q = multiprocessing.Queue()
    cons_p = multiprocessing.Process(target = consumer, args = (q,))
    cons_p.start()

    sequence = [1,2,3,4]
    producer(sequence, q)

    q.put(None)
    cons_p.join()

**案例24**
import multiprocessing
from time import ctime

def consumer(input_q):
    print ("Into consumer:", ctime())
    while True:
        item = input_q.get()
        if item is None:
            break
        print("pull", item, "out of q")
    print ("Out of consumer:", ctime())

def producer(sequence, output_q):
    for item in sequence:
        print ("Into procuder:", ctime())
        output_q.put(item)
        print ("Out of procuder:", ctime())

if __name__ == '__main__':
    q = multiprocessing.Queue()
    cons_p1 = multiprocessing.Process (target = consumer, args = (q,))
    cons_p1.start()

    cons_p2 = multiprocessing.Process (target = consumer, args = (q,))
    cons_p2.start()

    sequence = [1,2,3,4]
    producer(sequence, q)

    q.put(None)
    q.put(None)
#有几个进程就需要几个put
    cons_p1.join()
    cons_p2.join()