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