#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是在迭代创建每个进程

#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()