Python进程池，线程池，协程池

线程池

import threading
import time
def myThread():
  for i in range(10):
    time.sleep()
    print('d')
sep=threading.Semaphore(1)
threadlist=[]
for name in ["a","b"]:
  mythd=threading.Thread(target=myThread,args=(name,))
  mythd.start()
  threadlist.append(myThread)
for thread in threadlist:
  thread.join()

进程池

import multiprocessing
import time
import os
def getdata(data):
  print('start')
  time.sleep(2)
  print(os.getpid())
  return data**data
if __name__=="__main__":
  mylist=[x for x in range(100)]
  pool=multiprocessing.Pool(processes=4)
  pool_outputs=pool.map(getdata,mylist)
  pool.close()
  pool.join()
  print(pool_outputs)

进程池

from multiprocessing import Barrier
import multiprocessing
import time
import os
def getdata(data):
  with myBarrier:
    print('start')
    time.sleep(2)
    print(os.getpid(),data)

if __name__=="__main__":
  myBarrier=multiprocessing.Barrier(3)
  mylist=[x for x in range(100)]
  processeslist=[]
  for data in mylist:
    pr=multiprocessing.Process(target=getdata,args(data,myBarrier))
    processeslist.append(pr)
    pr.start()
  for pr in processeslist:
    print('n')
    pr.join()

协程池

import gevent
import gevent.pool
import gevent.monkey
gevent.monkey.patch_all()#分布式冲突
def run_task(data):
  print(data)
if __name__=="__main__":
  mypool=gevent.pool.Pool(2)
  datalist=[x for x in range(10)]
  result=mypool.map(run_task,datalist)
  print(result)

使用异步进程池,且进程池中传递入的任务是方法,

import os
from multiprocessing import Pool

def run_process(fun):
    fun()
def one_process():
    print("执行")
if __name__ == '__main__':
    print('parent process %s.' % os.getpid())
    p = Pool() # 初始化进程池
    for i in range(5):
        p.apply_async(run_process, args=(one_process,)) # 追加任务 apply_async 是异步非阻塞的，就是不用等待当前进程执行完毕，随时根据系统调度来进行进程切换。
    p.close()
    p.join() # 等待所有结果执行完毕，会等待所有子进程执行完毕，调用join()之前必须先调用close()