python中多线程相关
基础知识
进程：进程就是一个程序在一个数据集上的一次动态执行过程
数据集：程序执行过程中需要的资源
进程控制块：完成状态保存的单元
线程：线程是寄托在进程之上，为了提高系统的并发性
线程是进程的实体
进程是一个资源管理单元、线程是最小的执行单元
注意：
- 一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
- 资源分配给进程，同一进程的所有线程共享该进程的所有资源。
- CPU分给线程，即真正在CPU上运行的是线程。
线程切换：遇到i/o操作、优先级等
并发：在同一个时间段里，能够执行多个程序。
并行：多个cpu，在同一时刻能够执行多个程序。
切换：即任务状态的保存，状态的恢复，是并发的条件，注：为了共用数据集，线程进行切换，且线程切换开销远小于进程切换开销
同步：同步指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才能继续执行下去
异步：异步指进程不需要一直等待下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样提高效率
线程的使用场景：
- 把长时间占据内存的程序中的任务放到后台管理
- 同时执行多段程序，以达成更好的用户体验，如用户界面弹出执行另外一段程序等
- 加速程序运行，效率更高
- 在I/O操作时，合理释放资源，如释放内存占用等
线程和进程执行中的区别：进程有程序运行的入口、顺序执行序列、程序运行的出口，但线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。
指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。
- 线程可以被抢占（中断）。
- 在其他线程正在运行时，线程可以暂时搁置（也称为睡眠） -- 这就是线程的退让。
python中的GIL(全局解释器锁)
GIL并不是python的特性，是在实现python解析器(CPython)时所引入的一个概念，是为了实现不同线程对共享资源访问的互斥，才引入了GIL。
在CPython解释器中，同一个进程下开启的多线程，同一时刻只能有一个线程执行，无法利用多核优势
python对于计算密集型的任务开多线程的效率甚至不如串行(没有大量切换)，但对于IO密集型的任务效率还是有显著提升的。
计算密集型：
import time import threading def test(): global count temp = count count = temp + 1 time.sleep(2) count = 0 l = [] for _ in range(100): t = threading.Thread(target=test, args=()) t.start() l.append(t) for t in l: t.join() print(count) # 最终结果一定是100
IO密集型：
import time import threading def test(): global count temp = count time.sleep(0.001) # 模拟大量io操作 count = temp + 1 time.sleep(2) count = 0 l = [] for _ in range(100): t = threading.Thread(target=test, args=()) t.start() l.append(t) for t in l: t.join() print(count) # 输出值不一定
计算密集型每次start结果已经出来了，第二个线程是通过调用第一个线程的count值进行计算。
io密集型，因为中间阻塞了0.001秒，已有start多个线程，所以导致大多数的线程调用count值还是0，仅少数线程完成了count=temp+1的操作，所以最后结果不一定。
python中操作线程
python中使用线程有两种方式：函数或者用类来包装线程对象。
函数：调用thread模块中的start_new_thread()函数来产生新线程。
thread.start_new_thread ( function, args[, kwargs] )
参数说明:
- function - 线程函数。
- args - 传递给线程函数的参数,他必须是个tuple类型。
- kwargs - 可选参数。
线程的结束一般依靠线程函数的自然结束，也可以在线程函数中通过调用thread.exit()，抛出SystemExit exception，达到退出线程的目的。
线程模块
python通过两个标准库对线程操作：thread和threading。其中thread提供了低级别的、原始的线程以及一个简单的锁。
threading模块则提供了很多接口：
- threading.currentThread(): 返回当前的线程变量。
- threading.enumerate(): 返回一个包含正在运行的线程的list。不包括启动前和终止后的线程。
- threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
- Thread类：
- run(): 用以表示线程活动的方法。
- start():启动线程活动。
- join([time]): 等待至线程中止。这阻塞调用线程直至线程的join()方法被调用中止：正常退出或者抛出未处理的异常或者是可选的超时发生。
- isAlive(): 返回线程是否活动的。
- getName(): 返回线程名。
- setName(): 设置线程名。
import treading class myThread(treading.Thread): def __init__(self, threadID, name, counter): # threading.Thread.__init__(self) super(myTread, self).__init__(*args, **kwargs) self.threadID = threadID self.name = name self.counter = counter def run(self): # 线程在创建后会直接执行此方法 print(1) pass # 创建新线程 thread1 = myThread(1, 'Thread-1', 1) thread2 = myThread(2, 'Thread-2', 2) # 开启新线程 thread1.start() thread2.start()
线程同步
如果多个线程共同对某个数据修改，会造成不可预料的结果，为了保证数据的正确性，需对多个线程进行同步，可加锁实现。
使用Tread对象Lock和Rlock可是实现简单的线程同步，这两个对象都有acquire方法和release方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到acquire和release方法之间。
多线程同时运行多个任务，当线程需要共享数据时，可能存在数据不同步的问题，比如一个线程从前往后读取一个序列，一个线程从前往后更改一个序列，最终的结果可能就是前一半输出更改前的，后一半输出更改后的。
解决上述问题通过锁定线程的方式，锁的两个状态锁定和未锁定。当上述负责读取的线程访问共享数据时，必须获得锁定，如果已有别的线程锁定，那就暂停读取线程，即同步阻塞，等别的线程释放锁后再继续读取。这样的结果就是读取所有旧数据或者所有新数据。
import treading class myThread(treading.Thread): def __init__(self, threadID, name, counter): super(myTread, self).__init__(*args, **kwargs) self.threadID = threadID self.name = name self.counter = counter def run(self): # 线程在创建后会直接执行此方法 threadLock.acquire() # 获得锁成功返回True，可选参数timeout不填时将阻塞到获得锁定为止，超时返回False print(1) threadLock.release() # 释放锁 threadLock = threading.Lock() # 把锁内的代码串行化 # 线程列表 threads = [] # 创建新线程 thread1 = myThread(1, 'Thread-1', 1) thread2 = myThread(2, 'Thread-2', 2) # 开启新线程 thread1.start() thread2.start() threads.append(thread1) threads.append(thread2) # 等待所有线程完成 for t in threads: t.join()
python多线程的缺点
在Python中，有一个GIL，即全局解释锁，该锁的存在保证在同一个时间只能有一个线程执行任务，也就是多线程并不是真正的并发，只是交替得执行。假如有10个线程在10核CPU上，当前工作的也只能是一个CPU上的线程。
python多线程的优势
在I/O密集型执行期间大部分是时间都用在I/O上，如数据库I/O，较少时间用在CPU计算上。因此该应用场景可以使用Python多线程，当一个任务阻塞在IO操作上时，我们可以立即切换执行其他线程上执行其他IO操作请求。
即Python多线程在IO密集型任务中还是很有用处的，而对于计算密集型任务，应该使用Python多进程。
锁
互斥锁（同步锁）：用来解决诸如io密集型场景产生的计算错误，即目的是为了保护共享的数据，同一时间只能有一个线程修改共享的数据。
其过程：第一个线程如果申请到锁，会在执行公共数据的过程中持续阻塞后续线程，即后续第二个或其他线程依次来了发现已经上锁，只能等待第一个线程释放锁，当第一个线程将锁释放，后续的线程会进行争抢。
代码类似上述线程同步不再赘述。
死锁：保护不同的数据应该加不同的锁，所以当有多个互斥锁存在时，会导致死锁
import threading import time def test1(): lockA.acquire() print('func test1 ClockA lock') lockB.acquire() print('func test1 ClockB lock') lockB.release() lockA.release() def test2(): lockB.acquire() print('func test2 ClockB lock') time.sleep(2) lockA.acquire() print('func test2 ClockA lock') lockB.release() lockA.release() def run(): test1() test2() lockA=threading.Lock() lockB=threading.Lock() for i in range(10): t=threading.Thread(target=run,args=()) t.start() # 输出结果只有四行，因为产生了死锁阻断了
test2中sleep(2)模拟io或者其他操作，但第一个线程执行到这，因为阻塞，lockA会被第二个进程占用。所以第一个进程无法进行后续操作，只能等待lockA锁的释放，导致死锁。
解锁死锁问题除了合理释放锁之外可以使用下述的递归锁。
递归锁：解决死锁
import threading import time def test1(): rlock.acquire() print('func test1 ClockA lock') rlock.acquire() print('func test1 ClockB lock') rlock.release() rlock.release() def test2(): rlock.acquire() print('func test2 ClockB lock') time.sleep(2) rlock.acquire() print('func test2 ClockA lock') rlock.release() rlock.release() def run(): test1() test2() rlock=threading.RLock() for i in range(10): t=threading.Thread(target=run,args=()) t.start()
RLock本身有一个计数器，如果碰到acquire，那么计数器+1，如果计数器大于0，那么其他线程无法查收，如果碰到release，计数器-1
Semaphore(信号量)：实际上也是一种锁，该锁用于限制线程的并发量
import threading import time sem = threading.Semaphore(5) def test(): sem.acquire() time.sleep(2) print('ok') sem.release() for i in range(100): t = threading.Thread(target=test,args=()) t.start()
上述结果把并发量设置为5，即每sleep两秒，打印5个ok，直至结束
如果不设置则会在两秒后打印出100个ok
