网络编程-进程池，线程池，协程-28

最新推荐文章于 2024-07-12 16:16:27 发布

weixin_33686714

最新推荐文章于 2024-07-12 16:16:27 发布

阅读量85

点赞数

文章标签： python 操作系统

原文链接：http://www.cnblogs.com/jokezl/articles/10183078.html

版权

网络编程-进程池，线程池，协程-28

1.进程池\线程池(同步&异步阻塞&非阻塞)

提交任务的两种方式:
 同步调用:提交完一个任务之后,就在原地等待,等待任务完完整整地运行完毕拿到结果后,再执行下一行代码,
       会导致任务是串行执行的
 submit()之后通过result()拿到结果
 异步调用:提交完一个任务之后,不在原地等待,结果???,而是直接执行下一行代码,会导致任务是并发执行的
注:造进程时,从始至终都是建立进程池时建立的那几个进程,不会再新建进程
使用进程池的原因:任务数远远超过机器的承受能力


from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time,random,os

def task(name,n):
 print('%s%s is running' %(name,os.getpid()))
 time.sleep(random.randint(1,3))
 return n**2

if __name__ == '__main__':
 # print(os.cpu_count())
 p=ProcessPoolExecutor(4)#造进程池,括号内设置进程池的个数,如果不写或写None,默认会使用cpu的个数

 l=[]
 for i in range(10):
 # 同步提交
 # res=p.submit(task,'进程pid: ',i).result()#提交之后等待结果
 # print(res)

 # 异步提交
 future=p.submit(task,'进程pid: ',i)
 l.append(future)

 p.shutdown(wait=True) #wait默认为True.shutdown关闭进程池的入口,并且在原地等待进程池内
                      所有任务运行完毕

 for future in l:
 print(future.result())
 print('主')
 结果:
进程pid: 1904 is running
进程pid: 5888 is running
进程pid: 8696 is running
进程pid: 5208 is running
进程pid: 8696 is running
进程pid: 1904 is running
进程pid: 5888 is running
进程pid: 5208 is running
进程pid: 8696 is running
进程pid: 1904 is running
0
1
4
9
16
25
36
49
64
81
主




from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time,random,os
import requests


def get(url):
 print('%s GET %s' %(os.getpid(),url))
 time.sleep(3)
 response=requests.get(url) #发送请求,得到一个对象
 if response.status_code == 200:#状态码200代表下载成功
 res=response.text #将网页的内容下载下来
 else:
 res='下载失败'
 return res

def parse(future): #解析的工作是主进程进行的
 time.sleep(1)
 res=future.result()
 print('%s 解析结果为%s' %(os.getpid(),len(res))) 

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

 start=time.time()
 for url in urls:
 future=p.submit(get,url)
 #异步调用:提交完一个任务之后,不在原地等待,而是直接执行下一行代码,会导致任务是并发执行的,
  结果futrue对象会在任务运行完毕后自动传给回调函数
 future.add_done_callback(parse) #parse会在任务运行完毕后自动触发,然后接收一个参数future对象
#parse函数只能有一个参数,如果想有多个值,就需要将get返回的结果设置成一个元组,将值放入元组中
 p.shutdown(wait=True)


 print('主',time.time()-start)
 print('主',os.getpid())
结果:
6640 GET https://www.baidu.com
17012 GET https://www.sina.com.cn
1304 GET https://www.tmall.com
3564 GET https://www.jd.com
6660 GET https://www.python.org
4564 GET https://www.openstack.org
14664 GET https://www.baidu.com
6580 GET https://www.baidu.com
5780 GET https://www.baidu.com
11824 解析结果为2443
11824 解析结果为233351
11824 解析结果为570302
11824 解析结果为108548
11824 解析结果为2443
11824 解析结果为2443
11824 解析结果为2443
11824 解析结果为65099
11824 解析结果为48821
主 13.828495740890503
主 11824



多线程:
与进程不同,线程是谁腾出手谁来调用回执函数
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
from threading import current_thread
import time,random,os
import requests


def get(url):
    print('%s GET %s' %(current_thread().name,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)
    res=future.result()
    print('%s 解析结果为%s' %(current_thread().name,len(res)))

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=ThreadPoolExecutor(4)#设置线程池,如果不写默认为cpu的个数乘以5

    for url in urls:
        future=p.submit(get,url)
        future.add_done_callback(parse)

    p.shutdown(wait=True)

    print('主',current_thread().name) 


同步调用指的是提交任务之后,等着结果,等待不一定是因为阻塞,也可能是因为进行数据运算
阻塞状态制的是程序遇到IO操作时所处的运行状态

2.协程

1. 目标:
    在线程下实现并发
        并发(多个任务看起来是同时执行就是并发):切换+保存状态
2. 协程:
    协程是‘单线程实现并发’
    注意:协程是程序员意淫出来的东西,操作系统里只有进程和线程的概念(操作系统调度的最小单位是线程)
3.使用场景
    在单线程下实现多个任务间遇到IO问题就切换就可以降低单线程的IO时间,从而最大限度地提升单线程的效率   

gevent模块:

Python通过yield提供了对协程的基本支持，但是不完全。而第三方的gevent为Python提供了比较完善的协程支持。

gevent是第三方库，通过greenlet实现协程，其基本思想是：

当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。

由于切换是在IO操作时自动完成，所以gevent需要修改Python自带的一些标准库，这一过程在启动时通过monkey patch完成：

from gevent import monkey; monkey.patch_socket()
import gevent

def f(n):
    for i in range(n):
        print gevent.getcurrent(), i

g1 = gevent.spawn(f, 5)
g2 = gevent.spawn(f, 5)
g3 = gevent.spawn(f, 5)
g1.join()
g2.join()
g3.join()

运行结果：

<Greenlet at 0x10e49f550: f(5)> 0
<Greenlet at 0x10e49f550: f(5)> 1
<Greenlet at 0x10e49f550: f(5)> 2
<Greenlet at 0x10e49f550: f(5)> 3
<Greenlet at 0x10e49f550: f(5)> 4
<Greenlet at 0x10e49f910: f(5)> 0
<Greenlet at 0x10e49f910: f(5)> 1
<Greenlet at 0x10e49f910: f(5)> 2
<Greenlet at 0x10e49f910: f(5)> 3
<Greenlet at 0x10e49f910: f(5)> 4
<Greenlet at 0x10e49f4b0: f(5)> 0
<Greenlet at 0x10e49f4b0: f(5)> 1
<Greenlet at 0x10e49f4b0: f(5)> 2
<Greenlet at 0x10e49f4b0: f(5)> 3
<Greenlet at 0x10e49f4b0: f(5)> 4

可以看到，3个greenlet是依次运行而不是交替运行。

要让greenlet交替运行，可以通过gevent.sleep()交出控制权：

def f(n):
    for i in range(n):
        print gevent.getcurrent(), i
        gevent.sleep(0)

执行结果：

<Greenlet at 0x10cd58550: f(5)> 0
<Greenlet at 0x10cd58910: f(5)> 0
<Greenlet at 0x10cd584b0: f(5)> 0
<Greenlet at 0x10cd58550: f(5)> 1
<Greenlet at 0x10cd584b0: f(5)> 1
<Greenlet at 0x10cd58910: f(5)> 1
<Greenlet at 0x10cd58550: f(5)> 2
<Greenlet at 0x10cd58910: f(5)> 2
<Greenlet at 0x10cd584b0: f(5)> 2
<Greenlet at 0x10cd58550: f(5)> 3
<Greenlet at 0x10cd584b0: f(5)> 3
<Greenlet at 0x10cd58910: f(5)> 3
<Greenlet at 0x10cd58550: f(5)> 4
<Greenlet at 0x10cd58910: f(5)> 4
<Greenlet at 0x10cd584b0: f(5)> 4

3个greenlet交替运行，

把循环次数改为500000，让它们的运行时间长一点，然后在操作系统的进程管理器中看，线程数只有1个。

当然，实际代码里，我们不会用gevent.sleep()去切换协程，而是在执行到IO操作时，gevent自动切换，代码如下：

from gevent import monkey; monkey.patch_all()
import gevent
import urllib2

def f(url):
    print('GET: %s' % url)
    resp = urllib2.urlopen(url)
    data = resp.read()
    print('%d bytes received from %s.' % (len(data), url))

gevent.joinall([
        gevent.spawn(f, 'https://www.python.org/'),
        gevent.spawn(f, 'https://www.yahoo.com/'),
        gevent.spawn(f, 'https://github.com/'),
])

运行结果：

GET: https://www.python.org/
GET: https://www.yahoo.com/
GET: https://github.com/
45661 bytes received from https://www.python.org/.
14823 bytes received from https://github.com/.
304034 bytes received from https://www.yahoo.com/.

从结果看，3个网络操作是并发执行的，而且结束顺序不同，但只有一个线程。

小结

使用gevent，可以获得极高的并发性能，但gevent只能在Unix/Linux下运行，在Windows下不保证正常安装和运行。

由于gevent是基于IO切换的协程，所以最神奇的是，我们编写的Web App代码，不需要引入gevent的包，也不需要改任何代码，仅仅在部署的时候，用一个支持gevent的WSGI服务器，立刻就获得了数倍的性能提升。

posted on 2018-12-27 09:16 漫天飞雪世情难却阅读( ...) 评论( ...) 编辑收藏

转载于:https://www.cnblogs.com/jokezl/articles/10183078.html

weixin_33686714

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
网络编程-进程池，线程池，协程-28

网络编程-进程池，线程池，协程-28 1.进程池\线程池(同步&异步阻塞&非阻塞)提交任务的两种方式: 同步调用:提交完一个任务之后,就在原地等待,等待任务完完整整地运行完毕拿到结果后,再执行下一行代码, 会导致任务是串行执行的 submit()之后通过result()拿到结果异步调用:提交完一个任务之后,不...
复制链接

扫一扫