python之多进程

多进程使用

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
进程和线程的操作方法基本是一致的

进程之间的数据是相互独立的
要想进程之间的数据进行共享，就要使用进程中特殊的队列----跟模块queue中的队列不一样，这里说的队列是进程特殊化的队列
"""

"""
#证明进程之间数据是相互独立的
from multiprocessing import Process

def f(arg,l):
    l.append(arg)
    print(arg,l)


if __name__ == '__main__':
    li = []   # 进程之间数据是相互独立的，所以每个进程向列表中添加元素不会影响其他进程的列表
    for i in range(10):
        p = Process(target=f,args=(i,li))
        p.start()
    print(li)
"""

"""
# 进程之间数据共享方法一
from multiprocessing import Process
from multiprocessing import queues
import multiprocessing

def f(arg,q):
    q.put(arg)
    print(arg,'个数：',q.qsize())


if __name__ == '__main__':
    q = queues.Queue(20,ctx=multiprocessing)   # 必须传递一个ctx参数，用来调用进程锁----进程模块调用锁的类是multiprocessing（multiprocessing.Lock()）
    for i in range(10):
        p = Process(target=f,args=(i,q))
        p.start()




# 进程之间数据共享方法二:使用数组----不常用
from multiprocessing import Process
from multiprocessing import Array
import multiprocessing

def f(arg,arr):
    arr[arg] += arg + 100
    for item in arr:
        print(item)
    print('======================')


if __name__ == '__main__':
    arr = Array('i',10)
    for i in range(10):
        p = Process(target=f,args=(i,arr))
        p.start()

"""
# 进程之间数据共享方法三：特殊的字典
#字典是在主进程中创建的，当主进程指向完毕，会断开和子进程的连接，这时子进程就找不到主进程中定义的字典，就会报错
from multiprocessing import Process
from multiprocessing import Manager


def f(arg,dic):
    dic[arg] = arg + 100
    print(dic.values())


if __name__ == '__main__':
    obj = Manager()
    dic = obj.dict()
    for i in range(10):
        p = Process(target=f,args=(i,dic))
        p.start()
        p.join()

 

进程锁

"""
进程锁和线程锁的使用方法基本一致
"""
import multiprocessing

lock = multiprocessing.Lock()   # 普通锁
lock1 = multiprocessing.RLock()  # 可嵌套多层锁
lock2 = multiprocessing.Semaphore()  # 信号量
event = multiprocessing.Event()  # 事件
con = multiprocessing.Condition()  #条件

 

进程池

#!/usr/bin/env python
# -*- coding: utf-8 -*-


from multiprocessing import Pool
import time


def f(arg):
    time.sleep(1)
    print(arg)


if __name__ == '__main__':
    pool = Pool(5)   # 创建一个有5个进程的进程池

    for i in range(30):
        # pool.apply(f, args=(i,))   # 从进程池中获取进程执行任务------该方法是以串行的方式来执行子进程的（一个子进程执行完后，再执行下一个子进程）
        pool.apply_async(f,args=(i,))   # 从进程池中获取进程执行任务----异步执行子进程

    # close()跟terminate()的区别在于close()会等待池中的worker进程执行结束再关闭pool,而terminate()则是直接关闭
    pool.close()  # 子进程都执行完成，关闭进程池
    # pool.terminate()  #直接关闭进程池----进程池中的任务没执行完也不用管
    pool.join()   # join用来等待进程池中的任务执行完毕，防止主进程在worker进程结束前结束。-----执行join之前要先执行close或terminate方法
    print('end')

 

进程池---多进程共享数据

#! /usr/bin/env python
# -*- coding: utf-8-*-

"""
Python中进程间共享数据，处理基本的queue，pipe和value+array外，还提供了更高层次的封装。使用multiprocessing.Manager可以简单地使用这些高级接口。 
Manager()返回的manager对象控制了一个server进程，此进程包含的python对象可以被其他的进程通过proxies来访问。从而达到多进程间数据通信且安全。
Manager支持的类型有list,dict,Namespace,Lock,RLock,Semaphore,BoundedSemaphore,Condition,Event,Queue,Value和Array。
使用Manager对象可用实现多进程之间的共享（list、dict。。。）
"""

from multiprocessing import Manager, Pool
import time
import random


def func(i, q, lock):
    time.sleep(random.random())
    lock.acquire()
    q.put(i)
    lock.release()


if __name__ == '__main__':
    manager = Manager()
    lock = manager.Lock()
    q = manager.Queue()
    pool = Pool(5)
    for i in range(100):
        pool.apply_async(func, args=(i, q, lock))
    pool.close()
    pool.join()
    print('队列消息个数： ', q.qsize())
    if q.qsize():
        for i in range(q.qsize()):
            print(i)