concurrent（简介）
进程或线程的使用。
concurrent（了解）
【线程进程区别】
-
线程是共享内存空间。
-
进程是内存独立状态。
同一个进程的线程之间可以直接交流。
两个进程想通信,必须通过一个中间代理来实现。
使用多线程能充分利用 CPU 来提供程序的执行效率。
每一个进程启动时都会最先产生一个线程，即主线程，然后主线程会再创建其他的子线程。
一个进程可包含多个线程。
【同步异步】
| 同步 | 提交了一个任务,必须等任务执行完了(拿到返回值),才能执行下一行代码。 相当于执行任务的串行执行。 |
| 异步 | 交了一个任务,无需等执行完,可以直接执行下一行代码。 |
concurrent（参数列表）
| concurrent.futures |
模块提供了高度封装的异步调用接口。 |
| ThreadPoolExecutor |
线程池,提供异步调用 |
| ProcessPoolExecutor |
进程池,提供异步调用 |
| subprocess |
子进程操作 |
| result(timeout=None) |
取得结果 |
| add_done_callback(fn) |
回调函数 |
| submit(fn, *args, **kwargs) |
异步提交任务 |
| wait=True |
等待池内所有任务执行完毕回收完资源后才继续 |
| wait=False |
立即返回,并不会等待池内的任务执行完毕， 但不管wait参数为何值,整个程序都会等到所有任务执行完毕 |
| shutdown(wait=True) |
相当于进程池的pool.close()+pool.join()操作 |
| map(func, *iterables, timeout=None, chunksize=1) |
取代for循环submit的操作。 |
concurrent（参考代码）
简单的多线程操作
from concurrent.futures import ThreadPoolExecutor
import time
def task(i):
print(f"在执行任务{i}")
print("假设这是一个URL请求的地址....")
time.sleep(5)
pool = ThreadPoolExecutor(2) # 4个线程
for i in range(20):
pool.submit(task, i)上一个例子的简化版（map）
# 例子-map用法
from concurrent.futures import ThreadPoolExecutor
from threading import Thread, currentThread
import time
def task(i):
print(f"{currentThread().name} 在执行任务{i}")
time.sleep(1)
if __name__ == "__main__":
pool = ThreadPoolExecutor(4)
pool.map(task, range(0, 20)) # map取代了for+submit
multiprocessing（简介）
进程的进阶用法。
multiprocessing（了解）
multiprocessing-模块用来开启子进程。
功能:支持子进程,通信和共享数据,执行不同执行的同步。
提供->Process,Queue,Pipe,Lock等组件。
multiprocessing（参数列表）
Process类 | |
| 由该类实例化得到的对象,可用来开启一个子进程。 【语法】 Process([group [, target [, name [, args [, kwargs]]]]]) group (暂时忽略) 参数未使用,值始终为None。 target (函数) 表示调用对象,即子进程要执行的任务。 args (函数的参数) 表示调用对象的位置参数元组,args=(1,2,'mike')。 kwargs (暂时忽略) 表示调用对象的字典,kwargs={'name':'mike','age':'18'}。 |
常用函数 | |
| start() |
(启动进程)调用该子进程中的run() |
| run() |
(进程启动时运行的方法)正是它去调用target指定的函数。 |
| terminate() |
(强制终止进程),不会进行任何清理操作,如果创建了子进程， 该子进程就成了僵尸进程,使用该方法需要特别小心这种情况， 如果还保存了一个锁那么也将不会被释放,进而导致死锁。 |
| is_alive() |
进程仍然运行,返回True。 |
| join([timeout]) |
主进程等待终止(主进程处于等的状态） |
| daemon |
默认值为False,如果设为True,代表子进程为后台运行的守护进程, 父进程终止时,子进程也随之终止,并且设定为True后。 |
| name |
进程的名称 |
| pid文章来源：https://www.toymoban.com/news/detail-767474.html |
进程的pid文章来源地址https://www.toymoban.com/news/detail-767474.html |
multiprocessing（参考代码）
单进程
import multiprocessing
import time
def func(msg):
for i in range(20):
print(msg, i)
time.sleep(1)
if __name__ == "__main__":
p = multiprocessing.Process(target=func, args=("input content....",))
p.start()
p.join()
print("Sub-process done.")
多进程
import multiprocessing
import time
def fc1(msg):
for i in range(3):
print("{}:黄岛主 正在进行任务{}....".format(msg, i + 1))
time.sleep(1)
print(">>>>>> {}大佬 任务完成".format(msg))
def fc2(msg):
for i in range(2):
print("{}:欧阳锋 正在进行任务{}....".format(msg, i + 1))
time.sleep(1)
print(">>>>>> {}大佬 任务完成".format(msg))
def fc3(msg):
for i in range(5):
print("{}:段大师 正在进行任务{}....".format(msg, i + 1))
time.sleep(1)
print(">>>>>> {}大佬 任务完成".format(msg))
def fc4(msg):
for i in range(2):
print("{}:洪七公 正在进行任务{}....".format(msg, i + 1))
time.sleep(1)
print(">>>>>> {}大佬 任务完成".format(msg))
if __name__ == "__main__":
pool = multiprocessing.Pool(processes=4) # CPU核数
result = []
person = ["东邪", "西毒", "南帝", "北丐"]
result.append(pool.apply_async(fc1, (person[0],)))
result.append(pool.apply_async(fc2, (person[1],)))
result.append(pool.apply_async(fc3, (person[2],)))
result.append(pool.apply_async(fc4, (person[3],)))
pool.close()
pool.join()
print("全部OK....")
多线程队列
import multiprocessing as mp
def job(x):
res = 0
for i in range(4):
res += i
x.put(res)
if __name__ == "__main__":
# 定义一个多线程队列，用来存储结果
q = mp.Queue()
# 定义两个线程函数，用来处理同一个任务
# Process / Thread
p1 = mp.Process(target=job, args=(q,))
p2 = mp.Process(target=job, args=(q,))
# 分别启动、连接两个线程
p1.start()
p2.start()
p1.join()
p2.join()
fc1 = q.get()
fc2 = q.get()
print(fc1 + fc2)
进程锁
# 防止不同进程之间抢占共享资源
import multiprocessing as mp
import time
def job(v, num, l):
l.acquire() # 锁住
for _ in range(5):
time.sleep(1)
v.value += num # 获取共享内存
print("value=", v.value)
l.release() # 释放
def multicore():
lock = mp.Lock() # 定义一个进程锁
value = mp.Value("i", 20) # 定义共享内存
p1 = mp.Process(target=job, args=(value, 1, lock)) # 需要将lock传入
p2 = mp.Process(target=job, args=(value, 3, lock))
p1.start()
p2.start()
p1.join()
p2.join()
if __name__ == "__main__":
multicore()
到了这里，关于Python__模块(TIME-进程/线程)__concurrent / multiprocessing的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
