python thread process pool

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 ‘Process will start.’
p.start()
p.join()
print ‘Process end.’

三、在multiprocessing中使用pool
如果需要多个子进程时可以考虑使用进程池(pool)来管理
from multiprocessing import Pool

from multiprocessing import Pool
import os, time

def long_time_task(name):
print ‘Run task %s (%s)…’ % (name, os.getpid())
start = time.time()
time.sleep(3)
end = time.time()
print ‘Task %s runs %0.2f seconds.’ % (name, (end - start))

if name==’main‘:
print ‘Parent process %s.’ % os.getpid()
p = Pool() # if Pool(5) , 5 tasks will run together
for i in range(5):
p.apply_async(long_time_task, args=(i,))
print ‘Waiting for all subprocesses done…’
p.close()
p.join()
print ‘All subprocesses done.’
pool创建子进程的方法与Process不同，是通过
p.apply_async(func,args=(args))实现，一个池子里能同时运行的任务是取决你电脑的cpu数量，如我的电脑现在是有4个cpu，那会子进程task0,task1,task2,task3可以同时启动，task4则在之前的一个某个进程结束后才开始

三、多个子进程间的通信
多个子进程间的通信就要采用第一步中说到的Queue，比如有以下的需求，一个子进程向队列中写数据，另外一个进程从队列中取数据，

coding:gbk

from multiprocessing import Process, Queue
import os, time, random

写数据进程执行的代码:

def write(q):
for value in [‘A’, ‘B’, ‘C’]:
print ‘Put %s to queue…’ % value
q.put(value)
time.sleep(random.random())

读数据进程执行的代码:

def read(q):
while True:
if not q.empty():
value = q.get(True)
print ‘Get %s from queue.’ % value
time.sleep(random.random())
else:
break

if name==’main‘:
# 父进程创建Queue，并传给各个子进程：
q = Queue()
pw = Process(target=write, args=(q,))
pr = Process(target=read, args=(q,))
# 启动子进程pw，写入:
pw.start()
# 等待pw结束:
pw.join()
# 启动子进程pr，读取:
pr.start()
pr.join()
# pr进程里是死循环，无法等待其结束，只能强行终止:
print
print ‘所有数据都写入并且读完’

四、关于上面代码的几个有趣的问题

if name==’main‘:
# 父进程创建Queue，并传给各个子进程：
q = Queue()
p = Pool()
pw = p.apply_async(write,args=(q,))
pr = p.apply_async(read,args=(q,))
p.close()
p.join()

print
print ‘所有数据都写入并且读完’
如果main函数写成上面的样本，本来我想要的是将会得到一个队列，将其作为参数传入进程池子里的每个子进程，但是却得到
RuntimeError: Queue objects should only be shared between processes through inheritance
的错误，查了下，大意是队列对象不能在父进程与子进程间通信，这个如果想要使用进程池中使用队列则要使用multiprocess的Manager类

if name==’main‘:
manager = multiprocessing.Manager()
# 父进程创建Queue，并传给各个子进程：
q = manager.Queue()
p = Pool()
pw = p.apply_async(write,args=(q,))
time.sleep(0.5)
pr = p.apply_async(read,args=(q,))
p.close()
p.join()

print
print ‘所有数据都写入并且读完’
这样这个队列对象就可以在父进程与子进程间通信，不用池则不需要Manager，以后再扩展multiprocess中的Manager类吧
关于锁的应用，在不同程序间如果有同时对同一个队列操作的时候，为了避免错误，可以在某个函数操作队列的时候给它加把锁，这样在同一个时间内则只能有一个子进程对队列进行操作，锁也要在manager对象中的锁

coding:gbk

from multiprocessing import Process,Queue,Pool
import multiprocessing
import os, time, random

写数据进程执行的代码:

def write(q,lock):
lock.acquire() #加上锁
for value in [‘A’, ‘B’, ‘C’]:
print ‘Put %s to queue…’ % value
q.put(value)
lock.release() #释放锁

读数据进程执行的代码:

def read(q):
while True:
if not q.empty():
value = q.get(False)
print ‘Get %s from queue.’ % value
time.sleep(random.random())
else:
break

if name==’main‘:
manager = multiprocessing.Manager()
# 父进程创建Queue，并传给各个子进程：
q = manager.Queue()
lock = manager.Lock() #初始化一把锁
p = Pool()
pw = p.apply_async(write,args=(q,lock))
pr = p.apply_async(read,args=(q,))
p.close()
p.join()

print
print ‘所有数据都写入并且读完’

1、新建单一进程
如果我们新建少量进程，可以如下：

import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
if name == “main“:
p = multiprocessing.Process(target=func, args=(“hello”, ))
p.start()
p.join()
print “Sub-process done.”
2、使用进程池
是的，你没有看错，不是线程池。它可以让你跑满多核CPU，而且使用方法非常简单。
注意要用apply_async，如果落下async，就变成阻塞版本了。
processes=4是最多并发进程数量。

import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
if name == “main“:
pool = multiprocessing.Pool(processes=4)
for i in xrange(10):
msg = “hello %d” %(i)
pool.apply_async(func, (msg, ))
pool.close()
pool.join()
print “Sub-process(es) done.”
3、使用Pool，并需要关注结果
更多的时候，我们不仅需要多进程执行，还需要关注每个进程的执行结果，如下：

import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
return “done ” + msg
if name == “main“:
pool = multiprocessing.Pool(processes=4)
result = []
for i in xrange(10):
msg = “hello %d” %(i)
result.append(pool.apply_async(func, (msg, )))
pool.close()
pool.join()
for res in result:
print res.get()
print “Sub-process(es) done.”

process：

coding:utf-8

import random
from time import sleep
import sys
import multiprocessing
import os
#

需求分析：有大批量数据需要执行，而且是重复一个函数操作（例如爆破密码），如果全部开始线程数N多，这里控制住线程数m个并行执行，其他等待

#
lock=multiprocessing.Lock()#一个锁
def a(x):#模拟需要重复执行的函数
lock.acquire()#输出时候上锁，否则进程同时输出时候会混乱，不可读
print ‘开始进程：’,os.getpid(),’模拟进程时间:’,x
lock.release()

sleep(x)#模拟执行操作

lock.acquire()
print ‘结束进程：’,os.getpid(),’预测下一个进程启动会使用该进程号’
lock.release()
list=[]
for i in range(10):#产生一个随机数数组，模拟每次调用函数需要的输入，这里模拟总共有10组需要处理
list.append(random.randint(1,10))

pool=multiprocessing.Pool(processes=3)#限制并行进程数为3
pool.map(a,list)#创建进程池，调用函数a，传入参数为list,此参数必须是一个可迭代对象,因为map是在迭代创建每个进程

process again：

coding:utf-8

import threading
import random
import Queue
from time import sleep
import sys
#

需求分析：有大批量数据需要执行，而且是重复一个函数操作（例如爆破密码），如果全部开始线程数N多，这里控制住线程数m个并行执行，其他等待

#

继承一个Thread类，在run方法中进行需要重复的单个函数操作

class Test(threading.Thread):
def init(self,queue,lock,num):
#传递一个队列queue和线程锁，并行数
threading.Thread.init(self)
self.queue=queue
self.lock=lock
self.num=num
def run(self):
#while True:#不使用threading.Semaphore，直接开始所有线程，程序执行完毕线程都还不死，最后的print threading.enumerate()可以看出
with self.num:#同时并行指定的线程数量，执行完毕一个则死掉一个线程
#以下为需要重复的单次函数操作
n=self.queue.get()#等待队列进入
lock.acquire()#锁住线程，防止同时输出造成混乱
print ‘开始一个线程：’,self.name,’模拟的执行时间：’,n
print ‘队列剩余：’,queue.qsize()
print threading.enumerate()
lock.release()
sleep(n)#执行单次操作，这里sleep模拟执行过程
self.queue.task_done()#发出此队列完成信号
threads=[]
queue=Queue.Queue()
lock=threading.Lock()
num=threading.Semaphore(3)#设置同时执行的线程数为3，其他等待执行

启动所有线程

for i in range(10):#总共需要执行的次数
t=Test(queue,lock,num)
t.start()
threads.append(t)
#吧队列传入线程，是run结束等待开始执行，放下面单独一个for也行，这里少个循环吧
n=random.randint(1,10)
queue.put(n)#模拟执行函数的逐个不同输入

吧队列传入线程，是run结束等待开始执行

for t in threads:

n=random.randint(1,10)

queue.put(n)

等待线程执行完毕

for t in threads:
t.join()
queue.join()#等待队列执行完毕才继续执行，否则下面语句会在线程未接受就开始执行
print ‘所有执行完毕’
print threading.active_count()
print threading.enumerate()