多线程，多进程，协程

多线程：

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

特点

• 运行在一个CPU上
• 方便高效的线程之间内存共享，通信
• 线程之间切换开销比进程之间较小
• 本质上，计算机在同一时间还是处理了同一个事

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

多进程：

通俗解释：多进程就是拥有不同的生产线的工厂。

特点

• 一个CPU上只能运行一个进程，通常我们所说的电脑配置几核就是最大可以创建的进程(注意这里同时运行，因为电脑会切换进程，所以看起来电脑会同时运行的进程数会超过核数)
• 数据共享比较难
• 各个进程之间基本无影响，更稳定和安全，不因线程崩溃而整个系统崩溃
• 多进程的代码不易移植到其他机器上跑 因为系统相关性太强

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

asyncio

python 协程框架
通俗解释：IO密集型任务，一个用来协调的工具。
那么为什么要协调工作？
因为IO代表INPUT，OUTPUT很多，但是此时又不需要CPU的运算。也就是后来的代码全部需要前一个任务结束之后才能执行，很浪费时间。
举个例子：做爬虫时，在你请求第一个图片获得数据的时候，它会切换请求第二个图片或其他图片，等第一个图片获得所有数据后再切换回来，从而实现多线程批量下载的功能，速度超快。

本质：单线程

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

参考

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

[2] 莫烦python

来源：https://zhuanlan.zhihu.com/p/88129634