线程池与协程

池    标准模块（concurrent.futures） ProcessPoolExecutor   ThreadPoolExecutor

#1 介绍
concurrent.futures模块提供了高度封装的异步调用接口
ThreadPoolExecutor：线程池，提供异步调用
ProcessPoolExecutor: 进程池，提供异步调用
Both implement the same interface, which is defined by the abstract Executor class.

#2 基本方法
#submit(fn, *args, **kwargs)
异步提交任务

#map(func, *iterables, timeout=None, chunksize=1) 
取代for循环submit的操作

#shutdown(wait=True) 
相当于进程池的pool.close()+pool.join()操作
wait=True，等待池内所有任务执行完毕回收完资源后才继续
wait=False，立即返回，并不会等待池内的任务执行完毕
但不管wait参数为何值，整个程序都会等到所有任务执行完毕
submit和map必须在shutdown之前

#result(timeout=None)
取得结果

#add_done_callback(fn)
回调函数

import os
import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(i):
    print('thread', i ,os.getpid())
    time.sleep(1)
    print('thread %s end' % i)
tp = ThreadPoolExecutor(5)
if __name__ == '__main__':
    tp.submit(func, 1)
    tp.shutdown()
    print('主线程', os.getpid())
#thread 1 12492
#thread 1 end
#主线程 12492

import os
import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(i):
    print('thread', i ,os.getpid())
    time.sleep(1)
    print('thread %s end' % i)
if __name__ == '__main__':
    tp = ProcessPoolExecutor(5)
    tp.submit(func, 1)
    tp.shutdown()
    print('主线程', os.getpid())
#thread 1 10792
#thread 1 end
#主线程 3016

#线程中主线程与子线程的pid相同
#进程中主进程与子进程的pid不同

import os
import time
from concurrent.futures import ProcessPoolExecutor
def func(i):
    print('thread', i, os.getpid())
    time.sleep(1)
    print('thread %s end' % i)
    return i * '*'
def call_back(arg):
    print('call back:', os.getpid())
    print('ret:', arg.result())
if __name__ == '__main__':
    tp = ProcessPoolExecutor(5)
    ret_lst = []
    for i in range(20):
        tp.submit(func, i).add_done_callback(call_back)
    print('主线程', os.getpid())
#回调函数的pid和主进程中的pid相同

import time
from concurrent.futures import ThreadPoolExecutor
from threading import current_thread as cthread
def func(i):
    print('thread', i, cthread().ident)
    time.sleep(1)
    print('thread %s end' % i)
    return i * '*'
def call_back(arg):
    print('call back:', cthread().ident)
    print('ret:', arg.result())
tp = ThreadPoolExecutor(5)
ret_lst = []
for i in range(20):
    tp.submit(func, i).add_done_callback(call_back)
print('主线程', cthread().ident)
#回调函数的pid和子线程的pid相同

#进程池中回调函数是主进程中完成的
#线程池中回调函数是子线程中完成的

import time
from concurrent.futures import ThreadPoolExecutor
from threading import current_thread as cthread
def func(i):
    print('thread', i, cthread().ident)
    time.sleep(1)
    print('thread %s end' % i)

tp = ThreadPoolExecutor(5)
for i in range(20):
    tp.submit(func, i)
tp.shutdown()    #close  join
print('主线程')


import time
from concurrent.futures import ThreadPoolExecutor
def func(i):
    print('thread', i)
    time.sleep(1)
    print('thread %s end' % i)
    return i * '*'
tp = ThreadPoolExecutor(5)
res = tp.map(func, range(20))   #map取代了for+submit
for i in res:
    print(i)

回调函数：进程池—由主进程实现的

　　　　　线程池—由子线程实现的

线程池：实例化线程池  ThreadPoolExcutor    5*cpu_count

　　　　异步提交任务   submit / map

　　　　阻塞直到任务完成   shutdown

　　　　获取子线程的返回值   result

　　　　回调函数    add_done_callback

协程

进程：计算机中最小的资源分配单位

线程：计算机中能被CPU执行的最小单位

能开启的线程是有限的，而要处理的任务是无限的

协程：纤程（一条线程在多个任务之间来回切换）

切换这个动作是要浪费时间的，对于cpu、操作系统来说，协程是不存在的，只能看到线程

def consumer():
    g = produser()
    for num in g:
        print(num)
def produser():
    for i in range(100):
        yield i
consumer()
#由produser任务转换到consumer任务

更好的利用协程：一个线程的执行明确的切分开

当当前任务不得不陷入阻塞，在这个阻塞的过程中切换到另一个任务继续执行，只要程序还有任务要执行，当前线程永远不会阻塞

利用协程在多个任务陷入阻塞的时候进行切换来保证一个线程在处理多个任务的时候总是忙碌的，能够更加充分的利用cpu，抢占更多的时间片

无论是进程还是线程都是由操作系统来切换的，开启过多的线程或进程会给操作系统的调度增加负担

当我们使用协程的时候，协程在程序之间的切换操作系统感知不到，无论开多少个协程对操作系统来说都只是一个线程，操作系统的调度不会有任何压力

协程的本质就是一条线程，所以完全不会产生数据安全的问题

爬虫：访问过多的网页时协程可以增加效率

协程模块：greenlet（gevent的底层，切换的时候必须用switch）      gevent 直接用的，gevent可以提供更全面的功能

安装：pip3 install gevent

import time
import gevent
def eat():
    print('eating 1')
    time.sleep(1)
    print('eating 2')

def play():
    print('playing 1')
    time.sleep(1)
    print('playing 2')

g1 = gevent.spawn(eat)
g2 = gevent.spawn(play)   
#自动检测阻塞事件，遇见阻塞就会进行切换，但是有些阻塞他不认识
g1.join()
g2.join()  #阻塞知道g2结束

from gevent import time
import gevent
def eat():
    print('eating 1')
    time.sleep(1)
    print('eating 2')

def play():
    print('playing 1')
    time.sleep(1)
    print('playing 2')

g1 = gevent.spawn(eat)
g2 = gevent.spawn(play)
g1.join()
g2.join()
#eating 1      playing 1    eating 2       playing 2

from gevent import monkey
monkey.patch_all()   #自动检测下面所有import的阻塞
import time
import gevent

def eat():
    print('eating 1')
    time.sleep(1)
    print('eating 2')

def play():
    print('playing 1')
    time.sleep(1)
    print('playing 2')

g1 = gevent.spawn(eat)
g2 = gevent.spawn(play)
g1.join()
g2.join()

from gevent import time
import gevent
def eat():
    print('eating 1')
    time.sleep(3)
    print('eating 2')

def play():
    print('playing 1')
    time.sleep(1)
    print('playing 2')

g1 = gevent.spawn(eat)
g2 = gevent.spawn(play)
g1.join()
g2.join()
#eating 1
#playing 1
#playing 2
#eating 2

from gevent import monkey;monkey.patch_all()（下面导入的模块，自动检测内部的阻塞事件）

spawn(函数名)    产生一个协程任务，在遇到IO操作的时候帮助我们在多任务之间自动切换

join()　　阻塞，直到某个任务被执行完毕

join_all()     把要阻塞的全部放进去

value 属性    获取返回值

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

def eat():
    print('eating 1')
    time.sleep(1)
    print('eating 2')
    return 'eat finished'
def play():
    print('playing 1')
    time.sleep(1)
    print('playing 2')
    return 'play finished'
g1 = gevent.spawn(eat)
g2 = gevent.spawn(play)
gevent.joinall([g1, g2])
print(g1.value)
print(g2.value)
#eating 1
#playing 1
#eating 2
#playing 2
#eat finished
#play finished

爬虫

from gevent import monkey;monkey.patch_all()
import time
import gevent
import requests

url_lst = [
    'http://www.baidu.com',
    'http://www.4399.com',
    'http://www.7k7k.com',
    'http://www.sogou.com',
    'http://www.sohu.com',
    'http://www.sina.com',
    'http://www.jd.com',
    'https://www.luffycity.com/home',
    'https://www.douban.com']
def get_url(url):
    response = requests.get(url)
    if response.status_code == 200:
        print(url, len(response.text))

# start = time.time()
# for url in url_lst:
#     get_url(url)
# print(time.time()-start)
# 3.6362509727478027

start = time.time()
g_lst = []
for url in url_lst:
    g = gevent.spawn(get_url, url)
    g_lst.append(g)
gevent.joinall(g_lst)
print(time.time()-start)
#0.8195478916168213

#不可同时运行，因为内存的关系，上面的会快一些

# server
from gevent import monkey;monkey.patch_all()
import socket
import gevent
from threading import current_thread
def talk(conn):
    print('--->', current_thread())
    while True:
        conn.send(b'hello')
        print(conn.recv(1024))

sk = socket.socket()
sk.bind(('127.0.0.1', 8520))
sk.listen()

while True:
    conn, addr = sk.accept()
    gevent.spawn(talk,conn)

# client
import socket
from threading import Thread
def client():
    sk = socket.socket()
    sk.connect(('127.0.0.1', 8520))
    while True:
        print(sk.recv(1024))
        sk.send(b'byebye')

for i in range(5):
    Thread(target=client).start()

 

 

 

#########################################

协程
协程的本质
    在一条线程中执行多个任务，每个任务执行一段时间

扩展模块
greenlet 底层的协程模块
    帮助我们进行在任务之间的切换
    只是单纯的切换，不能帮我们规避IO操作

gevent
    能够自动帮我们检测程序中的IO操作
    并且在遇到IO操作的时候能帮助我们自动切换到不阻塞的任务执行

什么样的问题适合用协程来解决
    高IO、高并发

协程是用户级的切换
能够帮助我们让一条线程总是有执行要被执行
    这条线程总是在就绪和运行的状态之间切换
    能够抢占更多的cpu资源

线程池
    concurrent.futures
    ThreadPoolExcutor/ProcessPoolExcutor
    submit/map
    shutdown  等待池中的任务结束
    result()  获取任务的返回值
    add_done_callback 回调函数
        子线程/主进程执行