python之线程、进程入门
进程、线程怎么区分？ 最简洁直白的话，多线程一般用于相当于几个人干一件事，多进程相当于几个人分别一件事干一遍。
1、线程
1.1 简单线程
import threading
def fo():
print("hello")
def f1(a1, a2):
fo()
t = threading.Thread(target=f1, args=(123, 11)) #创建一个子线程
t.start()
t = threading.Thread(target=f1, args=(123, 11)) #再创建一个子线程
t.start()
1.2 主线程等待子线程
import threading
import time
def fo():
print("hello")
def f1(a1, a2):
time.sleep(5)
fo()
t = threading.Thread(target=f1, args=(123, 11)) #创建一个子线程
t.setDaemon(False) #主线程是否等待子线程 ,True为不等待，False为等待；
t.start()
t = threading.Thread(target=f1, args=(123, 11))
t.setDaemon(True)
t.start()
输出结果为：
》》》 hello
只有一个结果，是因为第二个子线程没有执行完成，主线程已经执行完了
1.3 主线程等待，子线程执行
join（1） #最多等待1s
import time
def fo():
print("hello")
def f1(a1, a2):
time.sleep(5)
fo()
t = threading.Thread(target=f1, args=(123, 11))
t.start()
t.join()
t = threading.Thread(target=f1, args=(123, 11))
t.start()
j结果输出：
hello
hello
第一个hello出来之后，5s后第二个hello才出来，是因为当运行到t.join()时，等待第一子线程运行完，主线程才执行下一步
1.4 防止脏数据，线程锁
import threading, time
globals_num = 0
lock = threading.RLock()
def func():
lock.acquire() #锁住线程
global globals_num
globals_num +=1 #过程中只有当一个线程执行完毕，下一个线程开始执行
time.sleep(1)
print(globals_num)
lock.release() #解锁线程
for i in range(10):
t = threading.Thread(target = func) #创建十个线程
t.start()
1.5 event ，相当于集合点（可以想象红绿灯）
import threading
def do(event):
print("start")
event.wait() #默认false，线程等待 。。红灯
print("end")
event_obj = threading.Event()
for i in range(3):
t = threading.Thread(target=do, args=(event_obj,))
t.start()
#event_obj.clear() #false 改状态 红灯
inp = input(">>>>")
if inp == 'true' :
event_obj.set() #True 改状态绿灯
2、队列 （使用场景，排队， 12306， 游戏）
import queue
get 等
get_nowait ,不等
3、进程
3.1简单进程
import time
def f1(a1):
print(a1)
if __name__ == '__main__':
t = multiprocessing.Process(target=f1, args=(11,))
t.start()
t2 = multiprocessing.Process(target=f1, args=(12,))
t2.start()
结果：
11
12
3.2 进程之间不共享数据
from multiprocessing import Process
li = []
def foo(i):
li.append(i)
print(li)
if __name__ == '__main__':
for i in range(5):
p = Process(target=foo, args=(i,))
p.start()
结果：
[1]
[3]
[0]
[2]
[4]
3.3 进程数据共享
from multiprocessing import Process,Manager
def foo(i, dic):
dic[i] = 100 + i #第一个进程的dict={0;100},第二个进程在第一个的基础上增加dict[0] = 101
for k, v in dic.items():
print(k, v)
if __name__ == '__main__':
manager = Manager()
dic = manager.dict() #数据共享一般采用此类方法
for i in range(2):
p = Process(target=foo, args=(i, dic,))
p.start()
p.join()
结果：
0 100
0 100
1 101
5、进程池 pool
pool.apply 每一个任务都是排队进行,进程join()
pool.apply_async 每一个任务都是并发进行，可设置回调函数,无join(),进程daemon为True
from multiprocessing import Pool
import time
def f1(a):
time.sleep(3)
print(a)
return 100
def f2(arg):
print(arg)
if __name__ == '__main__':
pool = Pool(5) #进程池最大进程数
for i in range(10):
pool.apply_async(func=f1, args=(i,), callback=f2)
pool.close()
pool.join()
结果就不贴了，可以看到是5个进程输出，再5个进程输出
from multiprocessing import Pool
import time
def f1(a):
time.sleep(3)
print(a)
if __name__ == '__main__':
pool = Pool(5) #进程池最大进程数
for i in range(10):
pool.apply(func=f1, args=(i,))
pool.close()
pool.join()
每间隔3s输出一个结果
6、线程池
6.1简易线程池
import threading
import queue
import time
class ThreadPool:
def __init__(self, max_num =20):
self.queue = queue.Queue(max_num)
for i in range(max_num):
self.queue.put(threading.Thread)
def get_thread(self):
return self.queue.get()
def add_thread(self):
self.queue.put(threading.Thread)
def func(pool, args):
time.sleep(2)
pool.add_thread()
print(args)
p = ThreadPool(10)
for i in range(100):
thread = p.get_thread()
r = thread(target=func, args=(p, i))
r.start()
6.2 实际线程池
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):
time.sleep(5)
print(i)
for i in range(30):
ret = pool.run(action, (i,), callback)
time.sleep(5)
print(len(pool.generate_list), len(pool.free_list))
pool.close()
#pool.terminate()
