复习
1.JoinableQueue--可以被join的队列
2.多线程
3线程的使用方法与进程一模一样
3.1守护线程
3.2线程安全问题
3.3解决方案
3.3.1互斥锁mutex
3.3.2递归锁Rlock
3.3.3信号量semaphore
3.3.4死锁问题
详解：
1.JoinableQueue--可以被join的队列
1.1join是等待任务结束
队列怎么叫结束
调用task_done一次则表示有一个数据被处理完成了，当task_done次数等于put的次数就意味着任务处理完成了
1.2这就是join的执行时机
该队列已经明确告知数剧的使用方，所有数据都已经处理完成
1.3在生产者消费者模型中解决了消费者，不知道何时算是任务结束的问题
具体过程:主进程先等待所有的生产者进程生成完毕，再等队列中的数据被全部处理，这就意味着，任务全部结束
2.多线程
2.1使用多线程|多进程目的：
为了 并发执行任务，从而提高效率
2.2什么是线程？
线程是操作系统运算调度的最小单位(CPU最小执行单位)，线程被包含在进程中，一个线程就是一个固定的执行流程（控制流）
2.3线程的特点：
进程是不能被执行的，进程是一个资源单位，其中 包含了程序运行所需的所有资源
线程：才是真正的执行单位，光有进程和程序是无法运行的，必须先创建进程将资源加载到进程中，再启动线程来执行任务
一个进程至少包含一个线程，称之为主线程，主线程是由操作系统来开启的
一个进程可以包含多个线程来提高程序的效率
2.4线程与进程的区别
1.线程创建的开销远小于进程
2.统一进程中的所有线程共享进程内的资源
3.线程之间没有父子关系，是平等的，PID相同
2.5如何选择进程与线程？
要根据具体的任务类型，IO密集（线程） 计算密集（进程）
3.线程的使用方法与进程一模一样
区别：开启线程的位置可以是任意位置
3.1守护线程
守护线程会在所有非守护线程结束时一起结束，当然守护可以提前结束（任务完成的情况下）
3.2线程安全问题
问题：并发操作同一个资源，可能导致数据错乱
解决方案：加互斥锁
3.3解决方案
1.互斥锁mutex--lock
2.递归锁Rlock
同一线程可以多次执行acquire（）
3.信号量semaphore--仅用于控制并发访问
4.死锁问题：
不止一个锁，分别被不同的线程持有，相互等待对方释放，就会导致锁死问题
如何避免死锁问题?
锁不要有多个,一个足够
如果真的发生了死锁问题,必须迫使一方先交出锁
今日内容
1.GIL--全局解释器锁
2.GIL带来的问题
3.为什么需要GIL
4.GIL的加锁解锁时机
5.关于GIL的性能的讨论
6.线程常用方法
7.GIL锁与自定义锁的区别
8.进程池与线程池
9.同步异步
10.异步调用
详解：
1.GIL--全局解释器锁
官方解释:
'''
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple
native threads from executing Python bytecodes at once. This lock is necessary mainly
because CPython’s memory management is not thread-safe. (However, since the GIL
exists, other features have grown to depend on the guarantees that it enforces.)
'''
释义：
在CPython 中，这个全局解释器锁，也称之为GIL，是一个互斥锁,防止多个线程在同一时间执行Python字节码，这个锁是非常重要的，因为CPython的内存管理非线程安全的，很多其他的特性依赖于GIL，所以即使他影响了程序效率也无法将其直接去除
非线程安全：即多个线程访问同一个资源，会有问题
线程安全：即多个线程访问同一个资源，不会有问题
作用：CPython中有一个互斥锁,防止线程同一时间执行python代码
注意：
该锁只存在CPython中，这并不是Python这门语言的问题，而是解释器的问题，除了CPython，还有JPython，pypy解释器
总结：在CPython中，GIL会把线程的并行变成串行，导致效率降低
2.GIL带来的问题
GIL全局解释器锁 本质：是一把互斥锁
前提条件：
1.解释器的作用（py文件中的内容本质都是字符串，只有在被解释器解释时，才具备语法意义）
2.解释器与应用程序代码之间的关系（解释器会将py代码翻译为当前系统支持的指令交给系统执行。）
影响：
1.当进程中仅有一条线程时，GIL锁存在不会有任何影响
2.但是如果进程中有多个线程时，GIL锁就开始发挥作用：
1.开启子线程时，子线程指定一个target表示该子线程要处理的任务即将要执行的代码，
2.代码要执行必须交给解释器，即多个线程之间就要共享解释器，
3.为了避免共享带了的数据竞争问题，于是就给解释器加上了互斥锁。
总结：对应用程序造成什么影响？
由于互斥的特性，程序串行，保证了数据安全，降低了执行效率，GIL将使得程序整体效率降低
为什么Cpython要这么设计?
Cpython诞生于1991年 而多核处理器诞生2004年
当时不需要考虑多核效率问题
现在为什么不拿掉这个锁,因为这期间,很多已经完成的代码都依赖于这个锁,如果直接拿到,这些代码全得该,成本太大了
3.为什么需要GIL?
1.GC:内存管理机制
在使用python进行编程时，程序员无需参与内存管理，因为有Python自带的内存管理机制，简称GC
2.Python内存管理--使用引用计数 了解
垃圾回收机制：
Python中不需要手动管理内存，C，OC
引用计数：
每个数会被加上一个整型的计数器，表示这个数据被引用的次数
a=10 10地址次数计数为1
b=a 计数2
b=1 计数1
a=0 计数0 表示该数据已无人使用，变为垃圾数据
内存管理：
当内存占用达到阈值，GC停止其他线程，启动垃圾清理操作（一串代码。一个线程）
当垃圾回收启动后会将计数为0的数据清除掉，回收内存
分代回收：
自动垃圾回收其实就是说，内部会有一个垃圾回收线程，会在某一时间运行起来，开始清理垃圾
这可能会产生问题：
例如线程1申请了内存，但是还没有使用CPU切换到了GC，GC将数据当成垃圾清理掉了
解决问题：
为了解决问题，CPython就给解释器加了互斥锁,多个线程将不可能同一时间使用解释器，保证了数据的安全性
4.GIL的加锁解锁时机
加锁:
只有一个线程要使用解释器就立马枷锁（即：在调用解释器时立即加锁）
释放:
该线程任务结束
该线程遇到IO
该线程使用解释器过长（超过设定值） 默认100纳秒
5.关于GIL的性能的讨论
5.1GIL:
优点：保证了CPython中的内存管理是线程安全的
缺点：互斥锁的特性使得多线程无法并行，严重降低了运行效率
5.2但我们也不能就此给Python语言全部判负，其原因如下:
1. GIL仅仅在CPython解释器中存在，在其他的解释器中没有，并不是Python这门语言的缺点
2. 在单核处理器下，多线程之间本来就无法真正的并行执行
3. 在多核处理下，运算效率的确是比单核处理器高，但是要知道现代应用程序多数都是基于网络的(qq,微信,爬虫,浏览器等等)，CPU的运行效率是无法决定网络速度的，而网络的速度是远远比不上处理器的运算速度，则意味着每次处理器在执行运算前都需要等待网络IO，这样一来多核优势也就没有那么明显了
5.3GIL给我们造成的影响
多线程不能并行
案例：
1.IO密集型---使用多线程
有一个下载任务 要从网络中下载一个文件 大小1G
和转换任务 使用input 转为大写输出
上述任务并行执行，耗时也不会有太大提升，反而开启多进程会浪费更多资源
这种任务称之为IO密集型，大量的时间都花在IO等待
2.计算机密集型任务（即IO操作较少大部分都是计算任务。）
图像处理，语音处理，大数据分析
总结：**
1.单核下无论是IO密集还是计算密集GIL都不会产生任何影响
2.多核下对于IO密集任务，GIL会有细微的影响，基本可以忽略
3.Cpython中IO密集任务应该采用多线程，计算密集型应该采用多进程
注意：
1.之所以广泛采用CPython解释器，就是因为大量的应用程序都是IO密集型的，
2.还有另一个很重要的原因是CPython可以无缝对接各种C语言实现的库
# 解决方案: `*****`
区分任务类型
1.如果是IO密集使用多线程
2.如果是计算密集使用多进程
6.线程常用方法
# 1.print(active_count())获取存活的线程数量
# 2.print(current_thread().getName())获取线程的名称
# 3.print(enumerate())获取正常运行的所有线程对象
# 4.print(current_thread())获取当前线程对象
7.GIL锁与自定义锁的区别
都是互斥锁
为什么有了GIL还需要自己加锁
GIL是加在解释器上的,只能锁住,解释器内部的资源,但是无法锁住我们自己开启资源,所以当程序中出现了共享自定义的数据时就要自己加锁
8.进程池与线程池******
池就是容器
本质上就是装线程|装进程的容器
池子中存储线程还是进程？
1.如果是IO密集型任务使用线程池， 2.如果是计算密集任务则使用进程池
优点：
1.自动管理线程的开启和销毁
2.自动分配任务给空闲的线程
3.可以限制开启线程的数量，保证系统的稳定
注：信号量中是限制同时并发多少,但是线程已经全都建完了
如何使用？
1.创建池子
pool = ProcessPoolExecutor()
pool=ThreadPoolExecutor
2.submit提交任务
pool.submit(task,"jerry")
3.pool.shutdown()#等待所有任务完毕，销毁所有线程，后关闭线程池
pool.shutdown()
注：关闭后就不能提交新任务了
9.同步 异步
9.1在并发中 经常提及的几个概念
阻塞--非阻塞 程序的状态
程序的运行状态 非阻塞 可能就绪 或者 运行
并发--并行 多任务处理方式
多个任务看起来像是同时运行 ,本质是切换+保存状态
并行真正的同时进行中, 必须具备多核处理器
同步--异步 任务提交执行的方式
同步==阻塞 × 卡住 == 阻塞 ×
异步 == 非阻塞 ×
同步：指的是发起任务后，必须在原地等待，直到任务完成拿到结果
默认情况就是同步
异步：发起任务，不需等待结果，可以继续执行其他代码，异步
异步必须依赖并发或者并行，在python中，通过多线程或多进程
异步的效率明显高于同步
如何使用？
#1. res = pool.submit(task).发起一个异步任务 # 异步调用 res就是一个表示异步任务的对象
# 2.定义一个回调函数 传的参数就是一个完成后任务对象
def finished(arg):
print(arg.result())
print("黑牛买回来了! ")
pass
# 3.res.add_done_callback(finished)给这个异步任务添加了一个回调函数
案例说明：
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time
from concurrent.futures._base import Future
pool = ThreadPoolExecutor() # my cpu_count = 6 so 6 * 5 = 30
def task():
time.sleep(2)
print("执行完成!")
return "一瓶黑牛!"
print("start")
# task()# 同步调用
# 1.发起一个异步任务
res = pool.submit(task) # 异步调用 res就是一个表示异步任务的对象
# 2.定义一个回调函数 传的参数就是一个完成后任务对象
def finished(arg):
print(arg.result())
print("黑牛买回来了! ")
pass
# 3.给这个异步任务添加了一个回调函数
res.add_done_callback(finished)
# pool.shutdown() # 阻塞直到线程池所有任务全部完成 会导致主线卡在原地
# print(res)
# print("执行的结果:",res.result()) # 会导致主线卡在原地
print("over")
10.异步回调
异步指的是任务的提交方式是异步的
10.1 异步任务的问题:
如果这个任务执行完成后会产生返回值,任务发起方该何时去获取结果
解决方案: 异步回调
10.2异步回调
指的就是一个函数,该函数会在任务后自动被调用,并且会传入Future对象 ,
通过Future对象的result()获取执行结果 ,
有了回调函数 就可以在任务完成时 及时处理它
10.3通常异步任务都会绑定一个回调函数,用来处理任务结果
1.在进程池中回调函数是在父进程中执行,原因是 任务是由父进程发起的,所以结果也应该交给父进程
2.在线程池中回调函数就在子线程中执行,原因是 线程之间数据本来是共享的
3.如果你的任务结果需要交给父进程来处理,那建议回调函数,回调函数会自动将数据返回给父进程,不需要自己处理IPC
