Python并发编程之进程池与线程池

一.进程池与线程池

python标准模块concurrent.futures(并发未来)

　　1.concurrent.futures模块是用来创建并行的任务,提供了更高级别的接口,为了异步执行调用

　　2.concurrent.futures这个模块使用方便,接口都已封装完整

　　3.concurrent.futures模块即可以实现进程池也可以实现线程池

　　4.使用concurrent.futures模块导入进程池和线程池,如下:

　　　　from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

　　5.p = ProcessPoolExecutor(max_works)对于进程池如果不写max_works：默认的是cpu的数目,默认是4个
　　 p = ThreadPoolExecutor(max_works)对于线程池如果不写max_works：默认的是cpu的数目*5

　　6.如果是进程池，得到的结果如果是一个对象。我们得用一个.get()方法得到结果,但是现在用了concurent.future模块，我们可以用obj.result方法
　　　　p.submit(task,i) #相当于apply_async异步方法
　　　　p.shutdown() #默认有个参数wite=True (相当于close和join)

# 1.同步执行--------------
from  concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import os,time,random
def task(n):
    print('[%s] is running'%os.getpid())
    time.sleep(random.randint(1,3))  #I/O密集型的，，一般用线程，用了进程耗时长
    return n**2
if __name__ == '__main__':
    start = time.time()
    p = ProcessPoolExecutor()
    for i in range(10): #现在是开了10个任务， 那么如果是上百个任务呢，就不能无线的开进程，那么就得考虑控制
        # 线程数了，那么就得考虑到池了
        obj  = p.submit(task,i).result()  #相当于apply同步方法
    p.shutdown()  #相当于close和join方法
    print('='*30)
    print(time.time() - start)  #17.36499309539795


# 2.异步执行-----------
# from  concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
# import os,time,random
# def task(n):
#     print('[%s] is running'%os.getpid())
#     time.sleep(random.randint(1,3))  #I/O密集型的，，一般用线程，用了进程耗时长
#     return n**2
# if __name__ == '__main__':
#     start = time.time()
#     p = ProcessPoolExecutor()
#     l = []
#     for i in range(10): #现在是开了10个任务， 那么如果是上百个任务呢，就不能无线的开进程，那么就得考虑控制
#         # 线程数了，那么就得考虑到池了
#         obj  = p.submit(task,i)  #相当于apply_async()异步方法
#         l.append(obj)
#     p.shutdown()  #相当于close和join方法
#     print('='*30)
#     print([obj.result() for obj in l])
#     print(time.time() - start)  #5.362306594848633

基于concurrent.futures模块的进程池

from  concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
from threading import currentThread
import os,time,random
def task(n):
    print('%s:%s is running'%(currentThread().getName(),os.getpid()))  #看到的pid都是一样的，因为线程是共享了一个进程
    time.sleep(random.randint(1,3))  #I/O密集型的，，一般用线程，用了进程耗时长
    return n**2
if __name__ == '__main__':
    start = time.time()
    p = ThreadPoolExecutor() #线程池 #如果不给定值，默认cup*5
    l = []
    for i in range(10):  #10个任务 # 线程池效率高了
        obj  = p.submit(task,i)  #相当于apply_async异步方法
        l.append(obj)
    p.shutdown()  #默认有个参数wite=True (相当于close和join)
    print('='*30)
    print([obj.result() for obj in l])
    print(time.time() - start)  #3.001171827316284

基于concurrent.futures模块的线程池

引用进程池

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time,os,random
import requests
def get(url):
    print('%s GET %s'%(os.getpid(),url))
    time.sleep(3)
    response = requests.get(url)
    if response.status_code == 200:
        res = response.text
    else:
        res = '下载失败'
    return res

def parse(future):
    time.sleep(1)
    print('%s 解析结果为%s'%(os.getpid(),len(future.result())))

if __name__ == '__main__':
    urls = [
        'https://www.baidu.com',
        'https://www.sina.com.cn',
        'https://www.tmall.com',
        'https://www.jd.com',
        'https://www.python.org',
        'https://www.openstack.org',
        'https://www.baidu.com',
        'https://www.baidu.com',
        'https://www.baidu.com',

    ]
    p = ProcessPoolExecutor(4)
    start = time.time()
    for i in urls:
        future = p.submit(get,i)
        future.add_done_callback(parse)
    p.shutdown(wait = True)

    print('主',time.time() - start)

二.协程　

　　通常在Python中我们进行并发编程一般都是使用多线程或者多进程来实现的，对于计算型任务由于GIL的存在我们通常使用多进程来实现，而对与IO型任务我们可以通过线程调度来让线程在执行IO任务时让出GIL，从而实现表面上的并发。

　　其实对于IO型任务我们还有一种选择就是协程，协程是运行在单线程当中的“并发”，协程相比多线程一大优势就是省去了多线程之间的切换开销，获得了更大的运行效率。Python中的asyncio也是基于协程来进行实现的。在进入asyncio之前我们先来了解一下Python中怎么通过生成器进行协程来实现并发。

　　cpu正在运行一个任务,会在两种情况下切走去执行其他的任务,一种情况是该任务发送了阻塞,另外一种情况是该任务计算的时间过长或由一个优先级更高的程序替代了它。以下就是两种情况的案例:

'''
1、协程：
    单线程实现并发
    在应用程序里控制多个任务的切换+保存状态
    优点：
        应用程序级别速度要远远高于操作系统的切换
    缺点：
        多个任务一旦有一个阻塞没有切，整个线程都阻塞在原地
        该线程内的其他的任务都不能执行了

        一旦引入协程，就需要检测单线程下所有的IO行为,
        实现遇到IO就切换,少一个都不行，以为一旦一个任务阻塞了，整个线程就阻塞了，
        其他的任务即便是可以计算，但是也无法运行了

2、协程序的目的：
    想要在单线程下实现并发
    并发指的是多个任务看起来是同时运行的
    并发=切换+保存状态
'''

#串行执行
import time

def func1():
    for i in range(10000000):
        i+1

def func2():
    for i in range(10000000):
        i+1

start = time.time()
func1()
func2()
stop = time.time()
print(stop - start)


#基于yield并发执行
import time
def func1():
    while True:
        yield

def func2():
    g=func1()
    for i in range(10000000):
        i+1
        next(g)

start=time.time()
func2()
stop=time.time()
print(stop-start)

单纯地切换反而会降低运行效率

import time
def func1():
    while True:
        print('func1')
        yield

def func2():
    g=func1()
    for i in range(10000000):
        i+1
        next(g)
        time.sleep(3)
        print('func2')
start=time.time()
func2()
stop=time.time()
print(stop-start)

yield不能检测IO，实现遇到IO自动切换

　　对于单线程下，我们不可避免程序中出现io操作，但如果我们能在自己的程序中（即用户程序级别，而非操作系统级别）控制单线程下的多个任务能在一个任务遇到io阻塞时就切换到另外一个任务去计算，这样就保证了该线程能够最大限度地处于就绪态，即随时都可以被cpu执行的状态，相当于我们在用户程序级别将自己的io操作最大限度地隐藏起来，从而可以迷惑操作系统，让其看到：该线程好像是一直在计算，io比较少，从而更多的将cpu的执行权限分配给我们的线程。

协程的本质就是在单线程下，由用户自己控制一个任务遇到io阻塞了就切换另外一个任务去执行，以此来提升效率。为了实现它，我们需要找寻一种可以同时满足以下条件的解决方案：

#1. 可以控制多个任务之间的切换，切换之前将任务的状态保存下来，以便重新运行时，可以基于暂停的位置继续执行。

#2. 作为1的补充：可以检测io操作，在遇到io操作的情况下才发生切换

协程慨念

需要强调的是：

#1. python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其他线程运行）
#2. 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率（！！！非io操作的切换与效率无关）

对比操作系统控制线程的切换，用户在单线程内控制协程的切换

优点如下：

#1. 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
#2. 单线程内就可以实现并发的效果，最大限度地利用cpu

缺点如下：

#1. 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
#2. 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

总结协程特点：

必须在只有一个单线程里实现并发
修改共享数据不需加锁
用户程序里自己保存多个控制流的上下文栈
附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））

Gevent介绍

安装:pip3 install gevent

　　Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。

#用法
g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1，spawn括号内第一个参数是函数名，如eat，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数eat的

g2=gevent.spawn(func2)

g1.join() #等待g1结束  g2.join() #等待g2结束 #或者上述两步合作一步：gevent.joinall([g1,g2])  g1.value#拿到func1的返回值

遇到IO阻塞时会自动切换任务

import gevent
def eat(name):
    print('%s eat 1' %name)
    gevent.sleep(2)
    print('%s eat 2' %name)

def play(name):
    print('%s play 1' %name)
    gevent.sleep(1)
    print('%s play 2' %name)


g1=gevent.spawn(eat,'egon')
g2=gevent.spawn(play,name='egon')
g1.join()
g2.join()
#或者gevent.joinall([g1,g2])
print('主')

View Code

上述gevent.sleep(2)模拟的是gevent可以识别的io阻塞,

而time.sleep(2)或其他的阻塞,gevent是不能直接识别的需要用下面一行代码,打补丁,就可以识别了

from gevent import monkey;monkey.patch_all()必须放到被打补丁者的前面，如time，socket模块之前

或者我们干脆记忆成：要用gevent，需要将from gevent import monkey;monkey.patch_all()放到文件的开头

from gevent import monkey;monkey.patch_all()

import gevent import time def eat(): print('eat food 1') time.sleep(2) print('eat food 2') def play(): print('play 1') time.sleep(1) print('play 2') g1=gevent.spawn(eat) g2=gevent.spawn(play_phone) gevent.joinall([g1,g2]) print('主')

来源：oschina

链接：https://my.oschina.net/u/4355136/blog/3831665

标签

gevent

def