low_threadpool
import queue
import threading
import time
class Mythreadpool:
def __init__(self,maxpool=10):
self.queue = queue.Queue(maxpool)
for i in range(maxpool):
self.queue.put(threading.Thread)
def get_thread(self):
return self.queue.get()
def add_thread(self):
self.queue.put(threading.Thread)
def func(i,p):
time.sleep(1)
print(i)
p.add_thread()
p = Mythreadpool()
for i in range(100):
thread = p.get_thread()
t = thread(target=func,args=(i,p,) )
t.start()
new_threadpool
import queue
import threading
import time
StopEvent = object()
class MyThread():
def __init__(self,maxpool=20):
self.queue = queue.Queue(maxpool)
self.maxpool = maxpool
self.terminal = False
self.generate_list = []
self.free_list = []
def run(self,target,args,callback=None):
w = (target,args,callback)
self.queue.put(w)
if len(self.free_list) == 0 and len(self.generate_list)<self.maxpool:
self.generate_thread()
def generate_thread(self):
t = threading.Thread(target=self.call)
t.start()
def call(self):
currnet_thread = threading.current_thread()
self.generate_list.append(currnet_thread)
event = self.queue.get()
while event != StopEvent:
func,arguments,callback = event
try:
result = func(*arguments)
success = True
except Exception as e:
success = False
result = e
if self.terminal:
event = StopEvent
else:
self.free_list.append(currnet_thread)
event = self.queue.get()
self.free_list.remove(currnet_thread)
else:
self.generate_list.remove(currnet_thread)
def close(self):
full_size = len(self.generate_list)
while full_size:
self.queue.put(StopEvent)
full_size -=1
def terminate(self):
self.terminal = True
while self.generate_list:
self.queue.put(StopEvent)
self.queue.empty()
def func(i):
print(i)
time.sleep(0.5)
def main():
pool = MyThread(5)
for i in range(50):
pool.run(target=func,args=(i,))
pool.terminate()
pool.close()
print(len(pool.generate_list))
if __name__ == '__main__':
main()
# def get_thread(self,target,args,callback = None):
# q = self.queue.get_nowait()
# if q:
# t = q(target=target,args=args)
# r = t.start()
# return callback(r)
# else:
# self.add_thread()
# def add_thread(self):
# self.queue.put(threading.Thread)
# def func(i):
# import time
# time.sleep(2)
# print(i)
# return i
# def fun1(i):
# print(i+100)
multiprocessing2
from multiprocessing import Pool
import time
def foo(i):
print(i)
time.sleep(2)
return i
def foo2(i):
print(i+1000)
def main():
pool = Pool(5)#初始化多少个
for i in range(0, 40):
pool.apply_async(func=foo, args=(i,),callback=foo2)#apply需要等待一个进程执行完才执行下一个
#，apply_async是并发执行，异步，并且可以设置回调函数，callback
pool.close()
# pool.terminate()
pool.join()
if __name__ == '__main__':
main()
final_threadpool
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import queue
import threading
import contextlib
import time
StopEvent = object()
class ThreadPool(object):
def __init__(self, max_num, max_task_num = None):
if max_task_num:
self.q = queue.Queue(max_task_num)
else:
self.q = queue.Queue()
self.max_num = max_num
self.cancel = False
self.terminal = False
self.generate_list = []
self.free_list = []
def run(self, func, args, callback=None):
"""
线程池执行一个任务
:param func: 任务函数
:param args: 任务函数所需参数
:param callback: 任务执行失败或成功后执行的回调函数，回调函数有两个参数1、任务函数执行状态；2、任务函数返回值（默认为None，即：不执行回调函数）
:return: 如果线程池已经终止，则返回True否则None
"""
if self.cancel:
return
if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:
self.generate_thread()
w = (func, args, callback,)
self.q.put(w)
def generate_thread(self):
"""
创建一个线程
"""
t = threading.Thread(target=self.call)
t.start()
def call(self):
"""
循环去获取任务函数并执行任务函数
"""
current_thread = threading.currentThread()
self.generate_list.append(current_thread)
event = self.q.get()
while event != StopEvent:
func, arguments, callback = event
try:
result = func(*arguments)
success = True
except Exception as e:
success = False
result = None
if callback is not None:
try:
callback(success, result)
except Exception as e:
pass
with self.worker_state(self.free_list, current_thread):
if self.terminal:
event = StopEvent
else:
event = self.q.get()
else:
self.generate_list.remove(current_thread)
def close(self):
"""
执行完所有的任务后，所有线程停止
"""
self.cancel = True
full_size = len(self.generate_list)
while full_size:
self.q.put(StopEvent)
full_size -= 1
def terminate(self):
"""
无论是否还有任务，终止线程
"""
self.terminal = True
while self.generate_list:
self.q.put(StopEvent)
self.q.queue.clear()
@contextlib.contextmanager
def worker_state(self, state_list, worker_thread):
"""
用于记录线程中正在等待的线程数
"""
state_list.append(worker_thread)
try:
yield
finally:
state_list.remove(worker_thread)
# How to use
pool = ThreadPool(5)
def callback(status, result):
# status, execute action status
# result, execute action return value
pass
def action(i):
print(i)
time.sleep(1)
for i in range(30):
ret = pool.run(action, (i,), callback)
time.sleep(5)
print(len(pool.generate_list), len(pool.free_list))
print(len(pool.generate_list), len(pool.free_list))
# pool.close()
pool.terminate()