博客

1、使用multiprocessing模块创建进程

具体代码实现:

from multiprocessing import Process     # 导入模块
import time
# 执行子进程代码
def test(interval):
    time.sleep(interval)
    print('我是子进程')
# 执行主程序
def main():
    print('主进程开始')
    p = Process(target=test,args=(1,))  # 实例化Procss进程类
    p.start()                           	# 启动子进程
    print('主进程结束')

if __name__ == '__main__':
    main()

运行程序，控制台输出

2、创建系统主线程与子线程输出

具体代码实现:

import os
from multiprocessing import Process     # 导入模块
import time
# 执行子进程代码
def test(interval):
    time.sleep(interval)
    print('我是子进程')
# 执行主程序
def child_2(interval):
    print("子进程（%s）开始执行，父进程为（%s）" % (os.getpid(), os.getppid()))
    t_start = time.time()  # 计时开始
    time.sleep(interval)  # 程序将会被挂起interval秒
    t_end = time.time()  # 计时结束
    print("子进程（%s）执行时间为'%0.2f'秒" % (os.getpid(), t_end - t_start))


def child_1(interval):
    print("子进程（%s）开始执行，父进程为（%s）" % (os.getpid(), os.getppid()))
    t_start = time.time()  # 计时开始
    time.sleep(interval)  # 程序将会被挂起interval秒
    t_end = time.time()  # 计时结束
    print("子进程（%s）执行时间为'%0.2f'秒" % (os.getpid(), t_end - t_start))


def main():
    print('主进程开始')
    print("------父进程开始执行-------")
    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
    # 同时父进程仍然往下执行，如果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("------等待子进程-------")
    p1.join()  # 等待p1进程结束
    p2.join()  # 等待p2进程结束
    print("------父进程执行结束-------")                    	# 启动子进程
    print('主进程结束')

if __name__ == '__main__':
    main()

运行程序，控制台输出

3、使用Process子类创建进程

具体代码实现:

# -*- coding:utf-8 -*-
from multiprocessing import Process
import time
import os

#继承Process类
class SubProcess(Process):
    # 由于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()))
        t_start = time.time()
        time.sleep(self.interval)
        t_stop = time.time()
        print("子进程(%s)执行结束，耗时%0.2f秒"%(os.getpid(),t_stop-t_start))

if __name__=="__main__":
    print("------父进程开始执行-------")
    print("父进程PID：%s" % os.getpid())                  # 输出当前程序的ID
    p1 = SubProcess(interval=1,name='mrsoft')
    p2 = SubProcess(interval=2)
    #对一个不包含target属性的Process类执行start()方法，就会运行这个类中的run()方法，
    #所以这里会执行p1.run()
    p1.start()  # 启动进程p1
    p2.start()  # 启动进程p2
    # 输出p1和p2进程的执行状态，如果真正进行，返回True,否则返回False
    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("------等待子进程-------")
    p1.join() # 等待p1进程结束
    p2.join() # 等待p2进程结束
    print("------父进程执行结束-------")

运行程序，控制台输出

4、使用进程池Pool创建进程

具体代码实现:

# -*- coding=utf-8 -*-
from multiprocessing import Pool
import os, time

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不再接收新的请求
    p.join()    # 等待子进程结束
    print('所有子进程结束.')

运行程序，控制台输出

5、队列简介

示例代码：

# -*- coding:utf-8 -*-
from multiprocessing import Process

def plus():
    print('-------子进程1开始------')
    global g_num
    g_num += 50
    print('g_num is %d'%g_num)
    print('-------子进程1结束------')

def minus():
    print('-------子进程2开始------')
    global g_num
    g_num -= 50
    print('g_num is %d'%g_num)
    print('-------子进程2结束------')

g_num = 100 # 定义一个全局变量
if __name__ == '__main__':
    print('-------主进程开始------')
    print('g_num is %d'%g_num)
    p1 = Process(target=plus)   # 实例化进程p1
    p2 = Process(target=minus)  # 实例化进程p2
    p1.start()                  # 开启进程p1
    p2.start()                  # 开启进程p2
    p1.join()                   # 等待p1进程结束
    p2.join()                   # 等待p2进程结束
    print('-------主进程结束------')

运行程序，控制台输出




由此可见，队列需要用特殊手段：



我们可以使用

多线程队列

的使用




具体代码的实现：

#coding=utf-8
from multiprocessing import Queue

if __name__ == '__main__':
    q=Queue(3) # 初始化一个Queue对象，最多可接收三条put消息
    q.put("消息1")
    q.put("消息2")
    print(q.full())  # 返回False
    q.put("消息3")
    print(q.full()) # 返回True

    # 因为消息列队已满，下面的try都会抛出异常，
    # 第一个try会等待2秒后再抛出异常，第二个try会立刻抛出异常
    try:
        q.put("消息4",True,2)
    except:
        print("消息列队已满，现有消息数量:%s"%q.qsize())

    try:
        q.put_nowait("消息4")
    except:
        print("消息列队已满，现有消息数量:%s"%q.qsize())

    # 读取消息时，先判断消息列队是否为空，再读取
    if not q.empty():
        print('----从队列中获取消息---')
        for i in range(q.qsize()):
            print(q.get_nowait())
    # 先判断消息列队是否已满，再写入
    if not q.full():
        q.put_nowait("消息4")

运行程序，控制台输出

6、使用队列在进程间通信

步骤：向队列中写入数据、从队列读取数据

具体代码实现：

# -*- coding: utf-8 -*-
from multiprocessing import Process, Queue
import  time

# 向队列中写入数据
def write_task(q):
    if not q.full():
        for i in range(5):
            message = "消息" + str(i)
            q.put(message)
            print("写入:%s"%message)
# 从队列读取数据
def read_task(q):
    time.sleep(1)       					# 休眠1秒
    while not q.empty():
        print("读取:%s" % q.get(True,2)) 	# 等待2秒，如果还没读取到任何消息，
                                         	# 则抛出"Queue.Empty"异常

if __name__ == "__main__":
    print("-----父进程开始-----")
    q = Queue()  # 父进程创建Queue，并传给各个子进程
    pw = Process(target=write_task, args=(q,))	# 实例化写入队列的子进程，并且传递队列
    pr = Process(target=read_task, args=(q,))	# 实例化读取队列的子进程，并且传递队列
    pw.start()   # 启动子进程 pw，写入
    pr.start()   # 启动子进程 pr，读取
    pw.join()    # 等待 pw 结束
    pr.join()    # 等待 pr 结束
    print("-----父进程结束-----")

运行程序，控制台输出