08. 多线程总结

1. 线程简介

1. 线程（Thread）也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。
2. 线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。
3. 一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。

---

2. 为什么要使用线程

1. 同一进程中的线程之间共享内存：线程在程序中是独立的、并发的执行流。与分隔的进程相比，进程中线程之间的隔离程度要小，它们共享内存、文件句柄和其他进程应有的状态。
2. 线程的并发性更高：因为线程的划分尺度小于进程，使得多线程程序的并发性高。进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
3. 线程比进程的性能更好：这是由于同一个进程中的线程共享同一个进程的虚拟空间。线程共享的环境包括进程代码段、进程的公有数据等，利用这些共享的数据，线程之间很容易实现通信。
4. 多线程资源消耗更小：操作系统在创建进程时，必须为该进程分配独立的内存空间，并分配大量的相关资源，但创建线程则简单得多。因此，使用多线程来实现并发比使用多进程的性能要高得多。

---

3. 创建线程的方式

1. thread模块在python3中更名为_thread.而且将要废弃。
2. python3中通过threading模块创建多线程，创建方法有两种：

• 通过实例化threading.Thread对象来创建：threading.Thread(target=xxx, args=(xxx,xxx))
• 通过继承threading.Thread类，并重写run方法来创建：MyThread()

---

4. 守护线程

1. 使用setDaemon(True)把所有的子线程都变成了主线程的守护线程，因此当主进程结束后，子线程也会随之结束。所以当主线程结束后，整个程序就退出了。
2. 把子进程设置为守护线程，必须在start()之前设置。
3. 为了让守护线程执行结束之后，主线程再结束，我们可以使用join方法，让主线程等待子线程执行
4. join()在start()之后。

---

5. 多线程共享全局变量

1. 线程是进程的执行单元，进程是系统分配资源的最小单位，所以在同一个进程中的多线程是共享资源的。

6. 锁

1. 互斥锁

1. 线程之间是进行随机调度，多个线程同时修改同一条数据时可能会出现脏数据。
2. 因此出现了线程锁，即同一时刻允许一个线程执行操作。线程锁用于锁定资源。
3. 由于线程之间是进行随机调度，如果有多个线程同时操作一个对象，如果没有很好地保护该对象，会造成程序结果的不可预期，我们也称此为“线程不安全”。

2. 递归锁

1. RLcok类的用法和Lock类一模一样，但它支持嵌套，在多个锁没有释放的时候一般会使用RLcok类。

7. 信号量（BoundedSemaphore类)

1. 互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，
2. 比如酒店有5个房间，那最多只允许5个人开房，后面的人只能等里面有人出来了才能再进去。

---

8. 事件（Event类）

1. python线程的事件用于主线程控制其他线程的执行，事件是一个简单的线程同步对象，其主要提供以下几个方法：

• clear 将flag设置为“False”
• set 将flag设置为“True”
• is_set 判断是否设置了flag
• wait 会一直监听flag，如果没有检测到flag就一直处于阻塞状态

2. 事件处理的机制：全局定义了一个“Flag”，当flag值为“False”，那么event.wait()就会阻塞，当flag值为“True”，那么event.wait()便不再阻塞。

9. GIL（Global Interpreter Lock）全局解释器锁

1. GIL的全称是Global Interpreter Lock(全局解释器锁).只是cpython解释器导致与python语言无关，用别的解释器无此问题；
2. 在python中，无论有多少核，同时只能执行一个线程。究其原因，这就是由于GIL的存在导致的。
3. cpython解释器为了数据安全所做的决定。某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个python进程中，GIL只有一个。拿不到通行证的线程，就不允许进入CPU执行。
4. Python多线程的工作过程：

• 拿到公共数据
• 申请GIL
• python解释器调用os原生线程
• os操作cpu执行运算
• 当该线程执行时间到后，无论运算是否已经执行完，gil都被要求释放
• 进而由其他进程重复上面的过程
• 等其他进程执行完后，又会切换到之前的线程（从他记录的上下文继续执行），整个过程是每个线程执行自己的运算，当执行时间到就进行切换（context switch）。

5. python针对不同类型的代码执行效率也是不同的:

• CPU密集型代码(各种循环处理、计算等等)，在这种情况下，由于计算工作多，ticks计数很快就会达到阈值，然后触发GIL的释放与再竞争（多个线程来回切换当然是需要消耗资源的），所以python下的多线程对CPU密集型代码并不友好。可以使用多进程。
• IO密集型代码(文件处理、网络爬虫等涉及文件读写的操作)，多线程能够有效提升效率(单线程下有IO操作会进行IO等待，造成不必要的时间浪费，而开启多线程能在线程A等待时，自动切换到线程B，可以不浪费CPU的资源，从而能提升程序执行效率)。所以python的多线程对IO密集型代码比较友好。
• python下想要充分利用多核CPU，就用多进程。因为每个进程有各自独立的GIL，互不干扰，这样就可以真正意义上的并行执行，在python中，多进程的执行效率优于多线程(仅仅针对多核CPU而言)。

6. GIL在python中的版本差异：

• 在python2.x里，GIL的释放逻辑是当前线程遇见IO操作或者ticks计数达到100时进行释放。（ticks可以看作是python自身的一个计数器，专门做用于GIL，每次释放后归零，这个计数可以通过sys.setcheckinterval 来调整）。而每次释放GIL锁，线程进行锁竞争、切换线程，会消耗资源。并且由于GIL锁存在，python里一个进程永远只能同时执行一个线程(拿到GIL的线程才能执行)，这就是为什么在多核CPU上，python的多线程效率并不高。
• 在python3.x中，GIL不使用ticks计数，改为使用计时器（执行时间达到阈值后，当前线程释放GIL），这样对CPU密集型程序更加友好，但依然没有解决GIL导致的同一时间只能执行一个线程的问题，所以效率依然不尽如人意。

10. 线程池

• 线程池在系统启动时即创建大量空闲的线程，程序只要将一个函数提交给线程池，线程池就会启动一个空闲的线程来执行它。当该函数执行结束后，该线程并不会死亡，而是再次返回到线程池中变成空闲状态，等待执行下一个函数。
• 此外，使用线程池可以有效地控制系统中并发线程的数量。当系统中包含有大量的并发线程时，会导致系统性能急剧下降，甚至导致 Python 解释器崩溃，而线程池的最大线程数参数可以控制系统中并发线程的数量不超过此数。
• 官网：https://docs.python.org/dev/library/concurrent.futures.html
• 从Python3.2开始，标准库为我们提供了concurrent.futures模块，它提供了ThreadPoolExecutor和ProcessPoolExecutor两个类，实现了对threading和multiprocessing的进一步抽象（这里主要关注线程池），不仅可以帮我们自动调度线程，还可以做到：
  1. 主线程可以获取某一个线程（或者任务的）的状态，以及返回值。
  2. 当一个线程完成的时候，主线程能够立即知道。
  3. 让多线程和多进程的编码接口一致。

concurrent.futures模块提供了高度封装的异步调用接口
ThreadPoolExecutor：线程池，提供异步调用

属性：max_workers， 线程池容量

1、submit(fn, *args, **kwargs)
异步提交任务

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

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

4、result(timeout=None)
取得结果
5、add_done_callback(fn)
回调函数
6、done()
方法用于判定某个任务是否完成
7、cancel()
cancel方法用于取消某个任务,该任务没有放入线程池中才能取消成功