进程 线程 异步编程 websockets梳理

一 进程，多进程，进程池

进程：一个程序运行起来后，代码+用到的资源 称之为进程，它是操作系统分配资源的基本单元

一个进程至少一个线程才能运行，一条生产电视的流水线就是一个进程，每个工人就是线程。

一个进程中可以并发多个线程，每条线程并行执行不同的任务。

进程在执行过程中拥有独立的内存单元，而多个线程共享内存

import time
import os
from multiprocessing import Process

def long_time_task(i):
    print(os.getpid())
    time.sleep(i)
    print("结果:{}".format(8**20))

if __name__ == '__main__':
    print("当前木进程:{}".format(os.getpid()))
    start = time.time()
    p1 = Process(target=long_time_task,args=(1,))
    p2 = Process(target=long_time_task,args=(2,))
    print("等待所有子进程执行完成")
    p1.start()
    p2.start()
    p1.join() #为了让母进程阻塞,等待子进程完成在打印时间
    p2.join()
    end = time.time()
    print("用事{}秒".format(end-start))

创建子进程的几种方式

• apply()：同步阻塞执行，上一个子进程结束后才能进行下一个子进程（不推荐） apply(func, args=(), kwds={}, callback=None, error_callback=None)
• apply_async()：异步非阻塞执行，每个子进程都是异步执行的（并行）（推荐） apply(func, args=(), kwds={}, callback=None, error_callback=None)
• map()：同步阻塞    若子进程有返回值，且需集中处理，建议采用此种方式
• map_async()：异步非阻塞，若想统一处理结果，map_async 比 apply_async 更方便
• imap()：内存不够用可以采用此种方式，速度慢于 map()
• imap_unordered：imap() 的无序版本（不会按照调用顺序返回，而是按照结束顺序返回），返回迭代器实例

from multiprocessing import Pool, cpu_count
import os
import time


def long_time_task(i):
    print('子进程: {} - 任务{}'.format(os.getpid(), i))
    time.sleep(2)
    print("结果: {}".format(8 ** 20))


if __name__=='__main__':
    print("CPU内核数:{}".format(cpu_count()))
    print('当前母进程: {}'.format(os.getpid()))
    start = time.time()
    p = Pool(8)
    #for i in range(15):
    #    p.apply_async(long_time_task, args=(i,))
    p.map(long_time_task,range(5)) #第二个参数是个迭代器
    print('等待所有子进程完成。')
    p.close()
    p.join()  #join之前要close
    end = time.time()
    print("总共用时{}秒".format((end - start)))

 

# coding=utf-8

import multiprocessing
import time


def run(a):
    return a * a


data = []


def my_callback(result):
    data.append(result)


if __name__ == '__main__':
    st = time.time()
    pool = multiprocessing.Pool(6)

    # 总耗时：0.4497215747833252
    future = pool.map_async(run, range(20000))
    print(future.get())  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

    # # 总耗时：3.019148111343384
    # for i in range(20000):
    #     pool.apply_async(run, args=(i,), callback=my_callback)
    # 
    # print(data)

    pool.close()
    pool.join()
    print(f"总耗时：{time.time() - st}")

 多进程向同一文件写入数据

def callback(result):
    """回调函数"""
    with open('a.txt', 'a+', encoding="utf-8") as f:
        f.write(str(result) + "\n")


def run(num):
    return num * num


if __name__ == '__main__':
    pool = multiprocessing.Pool(6)
    for i in range(1000):
        pool.apply_async(run, args=(i, ), callback=callback)
    #pool.map_async(run, range(1000), callback=callback)
    pool.close()
    pool.join()

 

二 线程，多线程，线程池

线程：是操作系统能够进行运算调度的最小单位，被包含在进程中，

对CPU密集型代码(比如循环计算) - 多进程效率更高

对IO密集型代码(比如文件操作，网络爬虫) - 多线程效率更高。

 

import threading
import time


def long_time_task(i):
    print('当前子线程: {} 任务{}'.format(threading.current_thread().name, i))
    time.sleep(2)
    print("结果: {}".format(8 ** 20))


if __name__=='__main__':
    start = time.time()
    print('这是主线程：{}'.format(threading.current_thread().name))
    thread_list = []
    for i in range(1, 3):
        t = threading.Thread(target=long_time_task, args=(i, ))
        thread_list.append(t)

    for t in thread_list:
        t.start()

    for t in thread_list:
        t.join()

    end = time.time()
    print("总共用时{}秒".format((end - start)))

t.setDaemon(True) #主进程结束不再执行子进程

#!/usr/bin/env python
import time
import os
import  threading
from multiprocessing.pool import ThreadPool

def long_time_task(i):
    print(os.getpid())
    time.sleep(i)
    print("结果:{}".format(8**20))

if __name__ == '__main__':
    start = time.time()
    pool = ThreadPool(5)
    pool.map(long_time_task,range(9))
    pool.close()
    pool.join()
    end = time.time()
    print(f"总用时:{end-start}")

 

三 concurrent.futures

该方法是3.2后引入的新模块

• ThreadPoolExecutor：多线程编程
• ProcessPoolExecutor：多进程编程，适合计算密集型任务
• Executor：执行器，用于管理工作池
• Future：管理工作计算出的结果

import time
import requests
from concurrent.futures import ThreadPoolExecutor, as_completed, ProcessPoolExecutor
def fetch(url):
    r = requests.get(url)
    return r.json()['args']['a']


if __name__ == '__main__':
    start = time.time()
    numbers = range(12)
    url = 'http://httpbin.org/get?a={}'
    # with ThreadPoolExecutor(max_workers=3) as executor:
    #     task_list = [executor.submit(fetch, url.format(n)) for n in range(12)]
    #     for future in as_completed(task_list):
    #         print(future.result())
    #map()方式
    with ThreadPoolExecutor(max_workers=3) as executor:
        future = executor.map(fetch, (url.format(n) for n in numbers))
    for result in future:
        print(result)
    print("total_time:", time.time() - start)

import numbers
import time
import requests
from concurrent.futures import ThreadPoolExecutor, as_completed, ProcessPoolExecutor


def fib(n):
    if n < 2:
        return 1
    return fib(n - 1) + fib(n - 2)


def call_back(future):
    """
    回调(可获得返回值和错误)
    """
    worker_execption = future.exception()
    if worker_execption:
        print("异常:", worker_execption)
    print(future.result())


def test(n):
    if n % 2 == 0:
        n / 0  #发生异常
    return n * 2


if __name__ == '__main__':
    numbers = range(20)
    start = time.time()
    with ProcessPoolExecutor(max_workers=3) as executor:
        # work_dict = {executor.submit(fib, i): i for i in numbers}  #字典{future:i}
        # print(work_dict)
        # for future in as_completed(work_dict):
        #     num = work_dict[future]
        #     try:
        #         data = future.result()
        #     except Exception as e:
        #         print(e)
        #     else:
        #         print(f"fib({num}={data})")
        #map方式
        # for num, result in zip(numbers, executor.map(fib, numbers)):
        #     print(f"fib({num}={result})")
        #通过add_done_callback获取结果和错误异常
        for i in numbers:
            executor.submit(test, i).add_done_callback(call_back)
        print(f"total_time:{time.time()-start}")

 

以上测试 都是map稍快一些，也更简洁。

 

四 协程异步IO(asyncio)

协程：又称微线程，是一种比线程更加轻量级的存在，最重要的是，协程不被操作系统内核管理，协程是完全由程序控制的(函数直间互相调用切换)。

 对于多核CPU，利用多进程+协程的方式，能充分利用CPU，获得极高的性能。

如同一个进程可以有很多线程一样，一个线程可以有很多协程。

异步是继多线程、多进程之后第三种实现并发的方式，主要用于IO密集型任务的运行效率提升,

协程概念是从 3.4 版本增加的，但 3.4 版本采用是生成器实现，为了将协程和生成器的使用场景进行区分，使语义更加明确，在 python 3.5 中增加了 async 和 await 关键字，用于定义原生协程。

python 中的 asyncio 库提供了管理事件、协程、任务和线程的方法，以及编写并发代码的原语，即 async 和 await。

异步IO的asyncio库使用事件循环驱动的协程实现并发。用户可主动控制程序，在认为耗时IO处添加await（yield from）。在asyncio库中，协程使用@asyncio.coroutine装饰，使用yield from来驱动，在python3.5中作了如下更改：

@asyncio.coroutine -> async

yield from -> await

async def：用于编写 协程函数；

await：等待 协程/任务 的执行完成

要真正运行一个协程，asyncio 提供了 3 种主要机制：

asyncio.run() 函数用来运行最高层级的入口点 main() 函数（参考上面示例）；
await 等待一个协程（对象）；
asyncio.create_task() 函数用来并发运行作为 asyncio 任务 的多个协程。
以上 3 种方式均可使 协程 被调度执行。

# coding=utf-8

import asyncio
from multiprocessing.connection import wait

async def coroutine_example():
    await asyncio.sleep(1)
    print('ok')
    return "ok"


coro = coroutine_example()

loop = asyncio.get_event_loop()
task = loop.create_task(coro)
print('运行情况：', task)

loop.run_until_complete(task)
print('再看下运行情况：', task.result())
loop.close()

 

import asyncio

def my_callback(future):
    print('返回值：', future.result())

async def coroutine_example():
    await asyncio.sleep(1)
    return 'ok'

coro = coroutine_example()

loop = asyncio.get_event_loop()

task = loop.create_task(coro)
task.add_done_callback(my_callback)

loop.run_until_complete(task)
loop.close()

 

async def coroutine_example(name):
    print("doing_name:", name)
    await asyncio.sleep(2)
    print('done_name:', name)
    return "wzy"


loop = asyncio.get_event_loop()
tasks = [
    loop.create_task(coroutine_example('wzy_' + str(i))) for i in range(3)
]
wait_core = asyncio.wait(tasks) #控制多任务
loop.run_until_complete(wait_core)
for task in tasks:
    print("wxh_result:", task.result())
loop.close()

import asyncio

a = []

def callback(future):
    print("111111", future.result())
    a.append(future.result())


async def coroutine_example(name):
    print("doing_name:", name)
    await asyncio.sleep(2)
    print('done_name:', name)
    return "wzy"


loop = asyncio.get_event_loop()
tasks = []
for i in range(3):
    task = loop.create_task(coroutine_example('Zarten_' + str(i)))
    task.add_done_callback(callback)
    tasks.append(task)
wait_coro = asyncio.wait(tasks)
loop.run_until_complete(wait_coro)
loop.close()
print("a:", a)

 

 

六 websockets

pass