Python案例-网络编程-线程池

线程池：

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7
import queue
import threading
import time
class ThreadPool:
def __init__(self,maxsize):
self.maxsize = maxsize
self._q = queue.Queue(maxsize)
for i in range(maxsize):
self._q.put(threading.Thread)
def get_thread(self):
return self._q.get()
def add_thread(self):
self._q.put(threading.Thread)

pool = ThreadPool(5)

def task(arg,p):
print(arg)
time.sleep(1)
p.add_thread

for i in range(100):
#threading.Thread类
t = pool.get_thread()
obj = t(target=task,args=(i,pool,))
obj.start()

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7
import threading
import time
import queue
import contextlib

stoptarget = object()

#自建一个线程池类
class ThreadPool(object):
#在构造方法中创建队列，传递队列长度参数maxsize
def __init__(self,maxsize,maxtasklist=None):
if maxtasklist:
self.q = queue.Queue(maxtasklist)
else:
self.q = queue.Queue(maxsize)
self.maxsize = maxsize
#任务执行完正常退出的标签
self.Nclose = False
#不管是否执行完，都退出的标签
self.Iclose = False
#正在被使用的线程列表
self.inuse_list = []
#空闲线程列表
self.free_list = []

def run(self,task,args,callback=None):
"""
#task 任务函数
#args 函数参数
#callback 不论结果的回调函数，其有两个参数：1、执行状态；2、返回值，default=None,既不执行回调函数
#返回值，如果线程池结束，返回True or None
"""

#如何是线程池正常执行后关闭的，退出
if self.Nclose:
return
#如果没有可用线程，且在用线程小于线程池最大数量，则补充一个线程，其作用为监听当前线程池的线程数，放在执行程序里相当于守护进程
if len(self.free_list) == 0 and len(self.inuse_list) < self.maxsize:
self.inuse_thread()
obj = (task,args,callback,)
self.q.put(obj)

#创建线程方法
def inuse_thread(self):
opj = threading.Thread(target=self.call)
opj.start()

#循环获取线程的方法
def call(self):
current_thread = threading.currentThread
#在忙碌的线程列表中添加
self.inuse_list.append(current_thread)
#获取队列中信息
event = self.q.get()
#判断获取的消息是否为停止，如果不是，则获得读取消息中的task，args，callback 字段内容
while event != stoptarget:
task,args,callback = event
#异常判断，如果只选task成功，在将返回值赋给result，并置success 为True
try:
result = task(*args)
success = True
#如果异常则置于False和None
except Exception as f:
success = False
result = None
#如果回调函数不为空则将success和result返回给回调函数，否则不执行回调函数
if callback is not None:
try:
callback(success, result)
except Exception as f:
pass
with self.worker_state(self.free_list, current_thread):
#如任务异常退出，则给队列里输入stoptarget的消息
if self.Iclose:
event = stoptarget
#否则继续获取消息
else:
event = self.q.get()
else:
#将已经执行完的线程从忙碌线程列表中去掉
self.inuse_list.remove(current_thread)

#执行完所有的任务后，正常关闭
def Nclose(self):
self.Nclose = True
full_size = len(self.inuse_list)
while full_size:
self.q.put(stoptarget)
full_size -= 1

#无论是否还有任务，终止线程，此为异常关闭
def Iclose(self):
self.Iclose = True
while self.Iclose:
self.q.put(stoptarget)
self.q.empty()

#用于记录线程中正在等待的线程数，这里使用上下文模块的上下文管理方法处理之
@contextlib.contextmanager
def worker_state(self, state_list, worker_thread):
state_list.append(worker_thread)
#生成迭代器
try:
yield
finally:
state_list.remove(worker_thread)
#创建线程池为5个线程的对象
pool = ThreadPool(5)

#此为回调函数
def callback(status,result):
print(status,result)

#此为模拟的task
def action(i):
print(i)

#100个任务请求
for i in range(100):
t = pool.run(action,(i,),callback)

time.sleep(2)
print(len(pool.inuse_list), len(pool.free_list))