Python中，线程池与进程池的shutdown用法，定时器，协程介绍，greenlet与gevent模块安装与讲解，asyncio（Python官方提供的实现协程模块）

为真理而斗争是人生最大的乐趣。——布鲁诺

1 GIL锁：全局解释器锁，因为垃圾回收线程不是线程安全的，所有线程必须拿到这把锁，才能执行
2 GIL跟互斥锁的区别？GIL锁不能保证我们自己的数据安全，自己使用互斥锁保证自己的数据安全
3 不同线程数据交互两种方式：
	-共享变量：不同线程修改同一份数据要加锁（互斥锁）
    -通过queue：不需要考虑数据安全问题（线程安全了）
4 死锁现象：
	-1 A线程拿到了A锁，等待B锁，B线程拿到了B锁，等待A锁，相互等待，永远等下去
    -2 A线程拿到了A锁，再去拿A锁
5 递归锁（可重入锁）：当前线程可以多次获得锁，每获得一次，计数器加一，每释放一次，计数器减一，只有计数器为0，其他线程才能获得
6 Event事件：（了解）
	-event.set():发信号
    -event.wait():阻塞等信号，只要收到set信号，就会继续往下执行
7 信号量：（了解），类似于锁，允许多条线程同时修改数据（有一些词，再不同环境下意思不一样）
8 Queue：三个：先进先出，后进先出，优先级   （线程Queue，跟进程的不是一个Queue）
9 池：池子，用来做缓冲
10 线程池：
	from concurrent.futures import ThreadPoolExecutor
    pool=ThreadPoolExecutor(5)
    pool.submit(task,参数1，参数2).add_done_callback(回调函数)
    # task执行完的数据如何给回调函数，回调函数会接收一个f对象，对象中有要的数据（task的return结果），f.result()
11 进程池同理，用法完全一样，只是换一个类
	# 了解
    from multiprocessing import Pool
    p=Pool(3)
        for url in urls:
            p.apply_async(get_page,args=(url,),callback=pasrse_page)
    
12  并发：同一时间段内，多个任务执行（单核cpu可以实现），人跑步，鞋带开了，停下系鞋带，然后继续跑步，5分钟内，它干了两个事
	并行：同一时刻，多个任务执行（单核cpu实现不了，必须多核），人跑步的同时听着歌
    
13 多核多线程比单核多线程更差，IO密集型用多线程，CPU(计算)密集型用多进程

# FastApi，django3.0，sanic，tornado：支持异步，有协程

1 线程池和进程池的shutdown

1 让主线程(进程)等待所有任务执行完成再执行

我们使用shutdown可以做到

2 如何实现呢？

利用进程池或者线程池的shutdown方法

3 shutdown方法的注意点：

• 放到for循环的外面，等待所有任务执行完成，主线程再继续走，如果放在for循环内部就会出现变成串行的问题
• shutdown方法的效果就是：等待所有任务完成，并且把进程（线程）池关闭
• 我们不可以在shutdown方法下面再去提交任务，会报错，应为进程（线程）池已经被关闭了

线程池是shutdown方法代码:

# 主线程等待所有任务执行完成
from concurrent.futures import ThreadPoolExecutor
import time
pool = ThreadPoolExecutor(3)

def task(name):
    print('%s 开始'%name)
    time.sleep(1)
    print('%s 结束'%name)

if __name__ == '__main__':
    for i in range(20):
        pool.submit(task, '屌丝%s' % i)

    pool.shutdown(wait=True)  
    
    #pool.submit(task,'sdddd')
    print('主') # 立马执行，还是20个线程都执行完了，再执行

结果（部分）：

屌丝0 开始
屌丝1 开始
屌丝2 开始
屌丝0 结束
屌丝3 开始
屌丝1 结束
屌丝4 开始
屌丝2 结束
屌丝5 开始
屌丝3 结束
屌丝6 开始

2 定时器

1 用定时器的目的是什么？

应用场景：想要指定多长时间之后执行一个任务

2 传参方式：

• t = Timer(2, task,kwargs={‘name’:‘lqz’})
• t = Timer(2, task,args=(‘lqz’,))
• 第一个位置：填写的是时间（也就是指定多长时间）
• 第二个位置：填写的是需要执行的任务（函数）
• 第三个位置：传参args=（），kwaegs={}

3 Timer的本质是什么？

• Timer的本质是线程。

执行代码：

# 多长时间之后执行一个任务
from threading import Timer

def task(name):
    print('我是大帅比--%s'%name)

if __name__ == '__main__':
    # t = Timer(2, task,args=('lqz',))  # 本质是开两个线程，延迟一秒执行
    t = Timer(2, task,kwargs={'name':'lqz'})  # 本质是开两个线程，延迟一秒执行
    t.start()

结果：

应为有延迟所以大家可以自行查看。

3 协程介绍

1 知识回顾：

我们现在所学习的有三种程分别是：进程，线程，协程

2 协程是用来干嘛的？

• 协程是为了实现单线程下的并发，属于线程下。

3 协程要解决的问题

• 需要协程自身，保存状态+切换，是并发的

4 如何解决保存状态并切换：

• 利用yield关键字：
• yield是什么？
• 生成器，只要函数中有yield关键字，这个函数就是生成器，通过yield可以实现保存状态+切换

实现代码：

5协程是什么？它的作用是什么？

• 协程并不是真是存在的某个东西，而是程序员臆想出来的
• 程序员控制，不让自己的程序遇到io，看上去，是实现并发了

# 通过yield，实现保存状态加切换（自定义的切换，并不是遇到io才切，所有它并不能节约时间）
# 单纯的切换，不但不会提高效率，反而会讲低效率
import time
def func1():
    for i in range(100000000):
        i += 1
        yield

def func2():
    g=func1() # 先执行一下func1
    for i in range(100000000):
        i += 1
        next(g) # 回到func1执行

if __name__ == '__main__':
    ctime = time.time()
    func2()
    print(time.time() - ctime) #14.764776706695557

我们可以把yield关键字删了还有那==next（g）和g=func（）==删了

删了以后运行就是直接串行运行，这样可以看出我们的运行时间会短一半。

6 协程的优缺点有哪些：

• 优点如下：

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

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

• 总结协程特点：

  必须在只有一个单线程里实现并发
  修改共享数据不需加锁
  用户程序里自己保存多个控制流的上下文栈(需要保存状态)

附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））

4 greenlet模块

1 greenlet安装

• pip install greenlet （在正确的python解释器的pip目录下一般是在(E:\Python3.8.3\Scripts)这个是我的在此窗口的地址栏打上cmd直接就可以进入在这个文件位置下的cmd）

2 greenlet模块使用，的注意点：

• 遇到io不会切，需要程序员自己去设置切换的位置。
• 用于实现协程。
• .switch（）来切换前面加上切换的目标函数。

实现代码：

from greenlet import greenlet
import time
def eat():
    print('我吃了一口')
    time.sleep(1)
    # p.switch()
    print('我又吃了一口')
    # p.switch()


def play():
    print('我玩了一会')
    e.switch()
    print('我又玩了一会')


if __name__ == '__main__':
    e = greenlet(eat)
    p = greenlet(play)
    e.switch()

结果：

我吃了一口
我玩了一会
我又吃了一口
我又玩了一会

从结果我们可以看出我们已经有了一些实现了协程的方法了。

5 gevent模块

1 gevent安装

• pip install gevent（在正确的python解释器的pip目录下一般是在(E:\Python3.8.3\Scripts)这个是我的在此窗口的地址栏打上cmd直接就可以进入在这个文件位置下的cmd）

2 gevent模块使用，的注意点：

• gevent基于greenlet写的，实现了遇见io自动切换，也就是说不需要程序员自己去设置切换的位置。

• 用于实现协程。

• join（）来启用前面加上启用的目标函数。

• 其中的==io操作time.sleep（）需要调用模块内的 gevent.sleep() 也就是说其中的需要以这种io time操作才能实现协程之间相互切换的效果。

• 也可以用猴子补丁去实现。

  • from gevent import monkey;monkey.patch_all()
    

实现代码(使用了猴子补丁的情况下)：

# 以后使用,这一句必须写
from gevent import monkey;monkey.patch_all()
import gevent
import time

def eat(name):
    print('%s 吃了一口' % name)
    time.sleep(1)  # io操作，被猴子补丁替换之后，其实本身相当于gevent.sleep()
    print('%s 又吃了一口' % name)


def play(name):
    print('%s 玩了一会' % name)
    time.sleep(2)
    print('%s 又玩了一会' % name)


if __name__ == '__main__':
    ctim = time.time()
    e = gevent.spawn(eat,'lqz')
    p = gevent.spawn(play,'lqz')
    e.join() # 等待e执行完成
    p.join()
    print('主')
    print(time.time() - ctim)  #2.0165154933929443

结果：

有时间延迟，建议自己去查看结果。

6 单线程的套接字并发

作业

# 使用gevent实现单线程下的套接字并发效果

7 asyncio（了解就可以，这个是Python官方提供的。）

# 官方支持协程的库

# import time
# import asyncio
#
# # 把普通函数变成协程函数
# # 3.5以前这么写
# @asyncio.coroutine
# def task():
#     print('开始了')
#     yield from asyncio.sleep(1)  #asyncio.sleep(1)模拟io
#     print('结束了')
#
#
# loop=asyncio.get_event_loop()  # 获取一个时间循环对象#
#
# # 协程函数加括号，并不会真正的去执行，它需要提交给loop，让loop循环着去执行
# # 协程函数列表
#
# ctime=time.time()
# t=[task(),task()]
# loop.run_until_complete(asyncio.wait(t))
# loop.close()
# print(time.time()-ctime)


import time
import asyncio
from threading import current_thread
# 表示我是协程函数,等同于3.5之前的装饰器
async def task():
    print('开始了')
    print(current_thread().name)
    await asyncio.sleep(3)  # await等同于原来的yield from
    print('结束了')

async def task2():
    print('开始了')
    print(current_thread().name)
    await asyncio.sleep(2)
    print('结束了')

loop=asyncio.get_event_loop()

ctime=time.time()
t=[task(),task2()]
loop.run_until_complete(asyncio.wait(t))
loop.close()
print(time.time()-ctime)