Python简单代码实现多进程与线程的一个框架通俗解释

显示全部楼层 · 2022-12-24 18:56:11

写在最前：最近印象比较深的一句话：

长期灌水垃圾sci论文会让你养成惰性，最终你将永远写不出高质量的论文 ------代彬

虽然我不太可能写出高质量的sci，但是关于自己的学习笔记应该要写的很认真。

以前认识不到做笔记的重要性，认为只要听懂了就好了。

笔记是为了自己整理思路，如果囫囵吞枣的学一遍，没有一个知识图谱，很快将会忘掉。

这篇多进程和多线程在网上一搜可能能搜到各种资源，讲的比我清楚的多，上一句就是我要做笔记的原因。

以上知识如果我在高中的时候知道，也许会去个更好的学校吧。

我之前写的东西，质量都比较差。

具体体现在：注释不够清楚，解释不够详细。纯粹为了凑数量，外行看来确实写了很多。

写笔记这件事还是不能骗自己。

不bibi了

多线程：通俗解释：计算机处理一大堆数据。计算机太懒了，觉得一个人处理这么多要花费很多时间。于是找了很多人都一块来处理。那么多人来处理这整个数据就叫多线程。我们可以简单理解为一条生产线上的所有工人。

特点Python简单代码实现

<pre> <code class="language-python">import threading # python多进程的包 
def thread_job(a):
 global lock # 将线程锁引入
 lock.acquire() # 开启线程锁
 print('This is an added Thread, number is %s' % threading.current_thread()) # 打印当前线程
 print(a)
 lock.release() # 释放线程锁
def main():
# 激活了多少线程
print(threading.active_count())
# 是哪些线程
print(threading.enumerate())
# 当前线程
print(threading.current_thread())
# 添加thread
a = 1
added_thread = threading.Thread(target=thread_job, args=(a,) name='T1') # args 为传入的参数,必须为tuple类型。name为名字，可以自己定义
# 执行thread
added_thread.start()
# 将此线程加到主线程上。表现的结果为主线程会是最后一个结束，不加的话在执行added_thread的job时，如果时间过长，表现为主线程先结束。
added_thread.join()
lock = threading.Lock() # 线程锁。意义在于如果有两个任务，第二个线程需要第一个线程返回的数据。则把第一个锁住。确保第一个执行了第二个词再执行。
main()</code></pre>
多进程：通俗解释：多进程就是拥有不同的生产线的工厂。

特点Python简单代码实现

<pre> <code class="language-python">import multiprocessing as mp
def job(a, d):
print('aaaaa')
# 与多线程很相似
p1 = mp.Process(target=job, args=(1,2), name='P1')
p1.start()
p1.join()
--------------------------------------------------------------------------
# 进程池
def job(x):
return x*x
def multicore():
pool = mp.Pool(processes=4) # 分配几个核
res = pool.map(job, range(10)) # map 表示可迭代的参数
print(res)
res = pool.apply_async(job, (2,)) # apply_async 表示只能是一个参数，不可迭代
print(res.get())
# 强行改成迭代的方法
multi_res = [pool.apply_async(job, (i,)) for i in range(10)]
print([re.get() for re in multi_res])
--------------------------------------------------------------------------
# 共享内存
value = mp.Value('d', 1)
array = mp.Array('i', [1,3,4]) # 不可是多维的
# 共享内存和进程锁
def job(v, num, l):
l.acquire() # 加上进程锁
for _ in range(10):
 time.sleep(0.1)
 v.value += num
 print(v.value)
l.release() # 释放线程锁
# 这个方法可以实现累加，不会出现断断续续的加
def multicore():
l = mp.Lock()
v = mp.Value('i', 0) # 共享了个i类型的数据0，i可以查表知道什么类型
p1 = mp.Process(target=job,args=(v,1,l))
p2 = mp.Process(target=job,args=(v,3,l))
p1.start()
p2.start()
p1.join()
p2.join()
multicore()</code></pre>
asyncio python 协程框架

通俗解释：IO密集型任务，一个用来协调的工具。

那么为什么要协调工作？

因为IO代表INPUT，OUTPUT很多，但是此时又不需要CPU的运算。也就是后来的代码全部需要前一个任务结束之后才能执行，很浪费时间。

举个例子：做爬虫时，在你请求第一个图片获得数据的时候，它会切换请求第二个图片或其他图片，等第一个图片获得所有数据后再切换回来，从而实现多线程批量下载的功能，速度超快。

本质：单线程python代码简单实现

<pre> <code class="language-python">import asyncio #引入协程框架
import time
async def job(t): # async代表这个方法可以异步
print('Start job ', t)
await asyncio.sleep(t) # await代表运行这个方法的时候可以切换到下一个程序
print('Job ', t, ' takes', t, ' s')
async def main(loop):
tasks = [loop.create_task(job(t)) for t in range(1,3)] # loop代表创建了协程的任务
await asyncio.wait(tasks)
t1 = time.time()
loop = asyncio.get_event_loop()
loop.run_until_complete(main(loop))
loop.close()
print('Async', time.time() - t1, ' s')</code></pre>
参考

[1] 进程与线程的一个简单解释

[2] 莫烦python

Python简单代码实现多进程与线程的一个框架通俗解释

相关帖子