7.进程池与线程池

进程池与线程池 - 回调函数 - 协程

1.进程池与线程池

# 进程池与线程池
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import os,time,random

# 获取CPU处理器的逻辑核心数
print(os.cpu_count()) # 8  代表8核处理器

# 1. 进程池 ProcessPoolExecutor
"""
多个进程已提前在进程池中开辟了,可以并发,也可以并行
"""
def func(i):
    time.sleep(random.random())
    print(i, "执行任务~,当前进程号{}".format(os.getpid()))
    return i

if __name__ == "__main__":
    # 创建进程池对象
    """ProcessPoolExecutor(参数),默认参数是电脑硬件CPU核心数"""
    p = ProcessPoolExecutor() # 进程数量 = 参数
    # 异步提交任务
    """
    语法 :
        submit(函数,参数1,参数2,....)
    含义:
        进程池里有8个进程提前开辟好了,不要再一个一个开辟进程了,执行多个任务
    注意点:
        如果一个进程多时间内可以完成更多任务
        进程池就不会用更多进程辅助完成,可以节省系统资源
    """
    lst = []
    for i in range(10):
        obj = p.submit(func,i) #创建提交任务对象
        # obj.result() #获取函数返回值 不要加这里,会把异步变同步
        lst.append(obj)

    for i in lst:
        print(i.result(),"=1=") 

    # shutdown 等待进程池所有任务执行完毕后,在放行
    """
    result 和 shutdown 用一个就可以同步进程池和主进程
    """
    p.shutdown()
    print("进程池结束了~~")

# 2. 线程池 ThreadPoolExecutor
from threading import currentThread as ct
def func(i):
    time.sleep(0.2)
    print(i,"线程任务执行中..,当前线程号{}".format(ct().ident))
    return ct().ident
    
if __name__ == "__main__":
    # 创建线程池对象
    t = ThreadPoolExecutor() #线程数量 = 参数 * 5
    # 异步提交任务
    """
    语法 :
        submit(函数,参数1,参数2,....)
    """
    lst = []
    setvar = set()
    for i in range(100 ):
        obj = t.submit(func,i)
        lst.append(obj)
    for i in lst:
        setvar.add(i.result()) #获取线程号返回值,集合自动去重
    t.shutdown() # 等待线程池所有任务执行完毕后,在放行
    print(len(setvar)) #40 个线程 

# 3. 线程池 map 处理数据,返回迭代器
from threading import currentThread as ct

def func(i):
    time.sleep(random.random())
    print(i,"当前线程号{}".format(ct().ident))
    return i

if __name__ == "__main__":
    t = ThreadPoolExecutor()
    it = t.map(func,range(100))
    for i in it:
        print(i)
    t.shutdown()
    print("线程池执行结束~~")

"""
结论:
    无论是进程池还剩线程池,都是由固定的进程数或线程数完成的
    系统不会额外创建更多的进程或线程来完成任务
"""

2.回调函数

# 进程池与线程池的回调函数
"""
回调函数 : 回头调用一下函数

add_done_callback : 完成回收函数的调用
add_done_callback作用:
    可以在获取result返回值时,还是异步并发程序;
结论: 
    进程池的回调函数由主进程完成
    线程池的回调函数由对应子线程完成
"""
from concurrent.futures import ProcessPoolExecutor 
from concurrent.futures import ThreadPoolExecutor 
from threading import currentThread as ct
import os,time,random

# 1.进程池任务
def func(i):
    time.sleep(random.random())
    print(i,"当前进程号{}".format(os.getpid()))
    return i
    
def callback(obj):
    print("<===回调函数进程号{}===>".format(os.getpid()))
    print(obj.result())

if __name__ == "__main__":
    p = ProcessPoolExecutor()
    for i in range(20):
        obj = p.submit(func,i)
        # 异步获取当前进程返回值
        obj.add_done_callback(callback)
    p.shutdown()
    print("主进程执行结束~,进程号{}".format(os.getpid()))

# 2.线程池任务
def func(i):
    time.sleep(random.random())
    print(i,"当前线程号{}".format(ct().ident))
    return i

def callback(obj):
    print("-====回调函数线程号{}====".format(ct().ident))
    print(obj.result())
    
if __name__ == "__main__":
    t = ThreadPoolExecutor()
    for i in range(100):
        obj = t.submit(func,i)
        obj.add_done_callback(callback)
    t.shutdown()
    print("主线程号{}".format(ct().ident))

3.协程

# 协程 : 记住终极版本4就行
"""
进程是资源分配的最小单位
线程是程序调度的最小单位
协程是线程实现的最小单位
总结:
    在进程一定的情况下,开辟多个线程
    在线程一定的情况下,开辟多个协程
    提高更大的并发,充分利用CPU
"""

# 利用协程改写生产者消费者模型
# 1.迭代器
def producer():
    for i in range(100):
        yield  i
def consumer(gen):
    for i in range(10):
        print(next(gen))

gen = producer() #初始化生成器对象
consumer(gen)

# 2.greenlet 协程早期版本
"""
switch() 与到阻塞可以来回切换任务,但是需要手动完成
"""
from greenlet import greenlet
import time

def eat():
    print("吃吃~~")
    g2.switch()
    time.sleep(2)
    print("喝喝喝~")
    
def play():
    print("玩玩玩~")
    time.sleep(2)
    print("乐乐乐~")
    g1.switch()
    
g1 = greenlet(eat)
g2 = greenlet(play)
g1.switch()

# 3. gevent 版本 (遇到阻塞自动识别,但是不能识别所有阻塞)
import gevent
def eat():
    print("吃吃~~")
    # time.sleep(2) time不能识别
    gevent.sleep(2)
    print("喝喝喝~")
    
def play():
    print("玩玩玩~")
    gevent.sleep(2)
    print("乐乐乐~")
g1 = gevent.spawn(eat) #创建协程对象g1
g2 = gevent.spawn(play) #创建协程对象g2
g1.join() 
g2.join()
print("主线程结束~~")

# 4.协程的终极形态(猴子补丁)  记住这个就行
from gevent import monkey 
monkey.patch_all() #猴子补丁
"""
上面两行可以写在一行,用分号隔开
猴子补丁 : 可以把接下来引入的所有模块中的阻塞
                自动识别出来,自动遇到阻塞就切换任务
1. spawn(函数,参数1,参数2...) 创建协程
2. join 直到某个协程任务执行完毕之后,放行
3. value 获取协程任务中的返回值
4. joinall 等待所有协程任务执行完毕之后,放行(参数是一个列表)
"""
import time,gevent
def eat():
    print("吃吃~~")
    time.sleep(2)
    print("喝喝喝~")
    return "吃完了~"
    
def play():
    print("玩玩玩~")
    time.sleep(2)
    print("乐乐乐~")
    return "玩完了~"

g1 = gevent.spawn(eat) # 创建协程对象g1
g2 = gevent.spawn(play) # 创建协程对象g2
gevent.joinall([g1,g2]) # 等待所有协程任务执行完毕之后,放行
print(g1.value)
print(g2.value)
print("主线程结束~~")

4.协程案例

# 协程案例 : 爬虫
# 基本语法:
import requests
response = requests.get("http://www.baidu.com") # 返回响应对象
print(response) #<Response [200]>
print(response.status_code) #200  获取状态码 
res = response.apparent_encoding
print(res) # utf-8 获取网页中字符编码
response.encoding = res # 设置编码集,防止乱码
print(response.text) # 获取网页内容

# 爬虫
from gevent import monkey ; monkey.patch_all()
import time,gevent,requests

url_lst =[
	"http://www.baidu.com",
	"http://www.taobao.com/",
	"http://www.jd.com/",
	"http://www.4399.com/",
	"http://www.7k7k.com/",
	"http://www.baidu.com",
	"http://www.taobao.com/",
	"http://www.jd.com/",
	"http://www.4399.com/",
	"http://www.7k7k.com/",
]

# 1.正常爬取
def get_url(url):
    response = requests.get(url)
    if response.status_code == 200:
        print(response.text)
""""""
startime = time.time()
for i in url_lst:
    get_url(i)
endtime = time.time()
print("所用时间是{}".format(endtime - startime)) #所用时间是3.013963222503662

# 2.异步多协程爬取
lst = []
startime = time.time()
for i in url_lst:
    g = gevent.spawn(get_url,i)
    lst.append(g)
gevent.joinall(lst)
endtime = time.time()
print("所用时间是{}".format(endtime - startime)) #所用时间是2.8483333587646484