一. 什么是线程
线程是一条流水线的工作过程, 整个代码的执行过程或者某个任务的执行过程称为线程. 一个进程至少自带一个线程. 进程是资源单位(分配资源), 而线程才是执行单位.
进程VS线程:
1. 同一个进程内的多个线程共享该进程的资源, 不同进程内的线程资源是隔离的
2. 创建线程的"开销"比创建进程要小很多
注意：进程是资源分配的最小单位,线程是CPU调度的最小单位.
线程和进程的关系:
1）地址空间和其它资源（如打开文件）：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。 2）通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。（就类似进程中的锁的作用） 3）调度和切换：线程上下文切换比进程上下文切换要快得多。 4）在多线程操作系统中（现在咱们用的系统基本都是多线程的操作系统），进程不是一个可执行的实体，真正去执行程序的不是进程，是线程，你可以理解进程就是一个线程的容器。
线程的特点:
1）轻型实体 线程中的实体基本上不拥有系统资源，只是有一些必不可少的、能保证独立运行的资源。 线程的实体包括程序、数据和TCB。线程是动态概念，它的动态特性由线程控制块TCB（Thread Control Block）描述。 TCB包括以下信息： （1）线程状态。 （2）当线程不运行时，被保存的现场资源。 （3）一组执行堆栈。 （4）存放每个线程的局部变量主存区。 （5）访问同一个进程中的主存和其它资源。 用于指示被执行指令序列的程序计数器、保留局部变量、少数状态参数和返回地址等的一组寄存器和堆栈。 2）独立调度和分派的基本单位。 在多线程OS中，线程是能独立运行的基本单位，因而也是独立调度和分派的基本单位。由于线程很“轻”，故线程的切换非常迅速且开销小（在同一进程中的）。 3）共享进程资源。 线程在同一进程中的各个线程，都可以共享该进程所拥有的资源，这首先表现在：所有线程都具有相同的进程id，这意味着，线程可以访问该进程的每一个内存资源；此外，还可以访问进程所拥有的已打开文件、定时器、信号量机构等。由于同一个进程内的线程共享内存和文件，所以线程之间互相通信不必调用内核。 4）可并发执行。 在一个进程中的多个线程之间，可以并发执行，甚至允许在一个进程中所有线程都能并发执行；同样，不同进程中的线程也能并发执行，充分利用和发挥了处理机与外围设备并行工作的能力。
内存中的线程:
多个线程共享同一个进程的地址空间中的资源，是对一台计算机上多个进程的模拟，有时也称线程为轻量级的进程。
线程之间是充满"敌意的", 因为要争抢cpu资源. 但是进程内部的线程之间的关系是"合作"的, 一个线程可以访问另一个线程的内存地址
二. Threading 模块
multiprocess模块的完全模仿了threading模块的接口，二者在使用层面，有很大的相似性
1. 线程创建方式
# 第一种 from threading import Thread import time def sayhi(name): time.sleep(2) print('%s say hello' %name) if __name__ == '__main__': t=Thread(target=sayhi,args=('太白',)) t.start() print('主线程') # 第二种 import time from threading import Thread class Sayhi(Thread): #继承Thread def __init__(self,name): super().__init__() #继承父类的构造方法才能封装属性 self.name=name def run(self): #必须这样写, start()才能调用 time.sleep(2) print('%s say hello' % self.name) if __name__ == '__main__': t = Sayhi('太白') t.start() print('主线程')
2. 多线程和多进程
线程的id与所在进程的id是一样
from threading import Thread from multiprocessing import Process import os def work(): print('hello',os.getpid()) if __name__ == '__main__': #part1:在主进程下开启多个线程,每个线程都跟主进程的pid一样 t1=Thread(target=work) t2=Thread(target=work) t1.start() t2.start() print('主线程/主进程pid',os.getpid()) #part2:开多个进程,每个进程都有不同的pid p1=Process(target=work) p2=Process(target=work) p1.start() p2.start() print('主线程/主进程pid',os.getpid())
from threading import Thread from multiprocessing import Process import os import time def work(): print('hello') if __name__ == '__main__': s1 = time.time() #在主进程下开启线程 t=Thread(target=work) t.start() t.join() t1 = time.time() - s1 print('进程的执行时间：',t1) print('主线程/主进程') ''' 打印结果: hello 进程的执行时间： 0.0 主线程/主进程 ''' s2 = time.time() #在主进程下开启子进程 t=Process(target=work) t.start() t.join() t2 = time.time() - s2 print('线程的执行时间：', t2) print('主线程/主进程') ''' 打印结果: hello 线程的执行时间： 0.5216977596282959 主线程/主进程 '''
from threading import Thread from multiprocessing import Process import os def work(): global n #修改全局变量的值 n=0 if __name__ == '__main__': # n=100 # p=Process(target=work) # p.start() # p.join() # print('主',n) #毫无疑问子进程p已经将自己的全局的n改成了0,但改的仅仅是它自己的,查看父进程的n仍然为100 n=1 t=Thread(target=work) t.start() t.join() #必须加join，因为主线程和子线程不一定谁快，一般都是主线程快一些，所有我们要等子线程执行完毕才能看出效果 print('主',n) #查看结果为0,因为同一进程内的线程之间共享进程内的数据 # 通过一个global就实现了全局变量的使用，不需要进程的IPC通信方法
3. Thread其他方法
Thread实例对象的方法 # isAlive(): 返回线程是否活动的。 # getName(): 返回线程名。 # setName(): 设置线程名。 threading模块提供的一些方法： # threading.currentThread(): 返回当前的线程变量。 # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。 # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果
from threading import Thread import threading from multiprocessing import Process import os def work(): import time time.sleep(3) print(threading.current_thread().getName()) if __name__ == '__main__': #在主进程下开启线程 t=Thread(target=work) t.start() print(threading.current_thread())#主线程对象 print(threading.current_thread().getName()) #主线程名称 print(threading.current_thread().ident) #主线程ID print(threading.get_ident()) #主线程ID print(threading.enumerate()) #连同主线程在内有两个运行的线程 print(threading.active_count()) print('主线程/主进程') ''' 打印结果: <_MainThread(MainThread, started 14104)> MainThread 14104 14104 [<_MainThread(MainThread, started 14104)>, <Thread(Thread-1, started 17976)>] 2 主线程/主进程 Thread-1 '''
注意: 多线程共享资源造成数据不安全
在这里我们简单总结一下：
进程是最小的内存分配单位
线程是操作系统调度的最小党委
线程被CPU执行了
进程内至少含有一个线程
进程中可以开启多个线程
开启一个线程所需要的时间要远小于开启一个进程
多个线程内部有自己的数据栈，数据不共享
全局变量在多个线程之间是共享的
4. 守护线程
无论是进程还是线程，都遵循：守护xx会等待主xx运行完毕后被销毁。需要强调的是：运行完毕并非终止运行
#1.对主进程来说，运行完毕指的是主进程代码运行完毕
#2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕
解释:
#1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，
#2 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束，因为进程执行结束是要回收资源的，所有必须确保你里面的非守护子线程全部执行完毕。
from threading import Thread import time def sayhi(name): time.sleep(2) print('%s say hello' %name) if __name__ == '__main__': t=Thread(target=sayhi,args=('taibai',)) t.setDaemon(True) #必须在t.start()之前设置 t.start() print('主线程') print(t.is_alive()) ''' 主线程 True '''
from threading import Thread from multiprocessing import Process import time def func1(): while True: print(666) time.sleep(0.5) def func2(): print('hello') time.sleep(3) if __name__ == '__main__': # t = Thread(target=func1,) # t.daemon = True #主线程结束，守护线程随之结束 # # t.setDaemon(True) #两种方式，和上面设置守护线程是一样的 # t.start() # t2 = Thread(target=func2,) #这个子线程要执行3秒，主线程的代码虽然执行完了，但是一直等着子线程的任务执行完毕，主线程才算完毕，因为通过结果你会发现我主线程虽然代码执行完毕了， # 但是主线程的的守护线程t1还在执行，说明什么，说明我的主线程还没有完毕，只不过是代码执行完了，一直等着子线程t2执行完毕，我主线程的守护线程才停止，说明子线程执行完毕之后，我的主线程才执行完毕 # t2.start() # print('主线程代码执行完啦！') p = Process(target=func1,) p.daemon = True p.start() p2 = Process(target=func2,) p2.start() time.sleep(1) #让主进程等1秒，为了能看到func1的打印效果 print('主进程代码执行完啦！') #通过结果你会发现，如果主进程的代码运行完毕了，那么主进程就结束了，因为主进程的守护进程p随着主进程的代码结束而结束了，守护进程被回收了，这和线程是不一样的，主线程的代码完了并不代表主线程运行完毕了，需要等着所有其他的非守护的子线程执行完毕才算完毕
三. 同步锁(互斥锁)
1. 三个需要注意的点：
#1.线程抢的是GIL锁，GIL锁相当于执行权限，拿到执行权限后才能拿到互斥锁Lock，其他线程也可以抢到GIL，但如果发现Lock仍然没有被释放则阻塞，即便是拿到执行权限GIL也要立刻交出来 #2.join是等待所有，即整体串行，而锁只是锁住修改共享数据的部分，即部分串行，要想保证数据安全的根本原理在于让并发变成串行，join与互斥锁都可以实现，毫无疑问，互斥锁的部分串行效率要更高 #3. 一定要看本小节最后的GIL与互斥锁的经典分析
Python已经有一个GIL来保证同一时间只能有一个线程来执行了，为什么这里还需要lock?
首先我们需要达成共识：锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据
然后，我们可以得出结论：保护不同的数据就应该加不同的锁。
最后，问题就很明朗了，GIL 与Lock是两把锁，保护的数据不一样，前者是解释器级别的（当然保护的就是解释器级别的数据，比如垃圾回收的数据），后者是保护用户自己开发的应用程序的数据，很明显GIL不负责这件事，只能用户自定义加锁处理，即Lock
过程分析：所有线程抢的是GIL锁，或者说所有线程抢的是执行权限
线程1抢到GIL锁，拿到执行权限，开始执行，然后加了一把Lock，还没有执行完毕，即线程1还未释放Lock，有可能线程2抢到GIL锁，开始执行，执行过程中发现Lock还没有被线程1释放，于是线程2进入阻塞，被夺走执行权限，有可能线程1拿到GIL，然后正常执行到释放Lock。。。这就导致了串行运行的效果
既然是串行，那我们执行
t1.start()
t1.join
t2.start()
t2.join()
这也是串行执行啊，为何还要加Lock呢，需知join是等待t1所有的代码执行完，相当于锁住了t1的所有代码，而Lock只是锁住一部分操作共享数据的代码。
因为Python解释器帮你自动定期进行内存回收，你可以理解为python解释器里有一个独立的线程，每过一段时间它起wake up做一次全局轮询看看哪些内存数据是可以被清空的，此时你自己的程序 里的线程和 py解释器自己的线程是并发运行的，假设你的线程删除了一个变量，py解释器的垃圾回收线程在清空这个变量的过程中的clearing时刻，可能一个其它线程正好又重新给这个还没来及得清空的内存空间赋值了，结果就有可能新赋值的数据被删除了，为了解决类似的问题，python解释器简单粗暴的加了锁，即当一个线程运行时，其它人都不能动，这样就解决了上述的问题， 这可以说是Python早期版本的遗留问题。
from threading import Thread,Lock import os,time def work(): global n # lock.acquire() #加锁 temp=n time.sleep(0.1) #一会将下面循环的数据加大并且这里的时间改的更小试试 n=temp-1 # time.sleep(0.02) # n = n - 1 '''如果这样写的话看不出来效果，因为这样写就相当于直接将n的指向改了，就好比从10，经过1次减1之后，n就直接指向了9，速度太快，看不出效果，那么我们怎么办呢，找一个中间变量来接收n，然后对这个中间变量进行修改，然后再赋值给n，多一个给n赋值的过程，那么在这个过程中间，我们加上一点阻塞时间，来看效果，就像读文件修改数据之后再写回文件的过程。那么这个程序就会出现结果为9的情况，首先一个进程的全局变量对于所有线程是共享的，由于我们在程序给中间变量赋值，然后给n再次赋值的过程中我们加了一些I/O时间，遇到I/O就切换，那么每个线程都拿到了10，并对10减1了，然后大家都得到了9，然后再赋值给n，所有n等于了9''' # lock.release() if __name__ == '__main__': lock=Lock() n=100 l=[] # for i in range(10000): #如果这里变成了10000，你在运行一下看看结果 for i in range(100): #如果这里变成了10000，你在运行一下看看结果 p=Thread(target=work) l.append(p) p.start() for p in l: p.join() print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全
上面这个代码示例，如果循环次数变成了10000，在我的电脑上就会出现不同的结果，因为在线程切换的那个time.sleep的时间内，有些线程还没有被切换到，也就是有些线程还没有拿到n的值，所以计算结果就没准了。
锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象，当你需要访问该资源时，调用acquire方法来获取锁对象（如果其它线程已经获得了该锁，则当前线程需等待其被释放），待资源访问完后，再调用release方法释放锁：
1 from threading import Thread,Lock 2 import os,time 3 def work(): 4 global n 5 lock.acquire() #加锁 6 temp=n 7 time.sleep(0.1) 8 n=temp-1 9 lock.release() 10 if __name__ == '__main__': 11 lock=Lock() 12 n=100 13 l=[] 14 for i in range(100): 15 p=Thread(target=work) 16 l.append(p) 17 p.start() 18 for p in l: 19 p.join() 20 21 print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全
上面代码图形解释:
分析:
#1.100个线程去抢GIL锁，即抢执行权限
#2. 肯定有一个线程先抢到GIL（暂且称为线程1），然后开始执行，一旦执行就会拿到lock.acquire()
#3. 极有可能线程1还未运行完毕，就有另外一个线程2抢到GIL，然后开始运行，但线程2发现互斥锁lock还未被线程1释放，于是阻塞，被迫交出执行权限，即释放GIL
#4.直到线程1重新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，然后其他的线程再重复2 3 4的过程
1 #不加锁:并发执行,速度快,数据不安全 2 from threading import current_thread,Thread,Lock 3 import os,time 4 def task(): 5 global n 6 print('%s is running' %current_thread().getName()) 7 temp=n 8 time.sleep(0.5) 9 n=temp-1 10 11 12 if __name__ == '__main__': 13 n=100 14 lock=Lock() 15 threads=[] 16 start_time=time.time() 17 for i in range(100): 18 t=Thread(target=task) 19 threads.append(t) 20 t.start() 21 for t in threads: 22 t.join() 23 24 stop_time=time.time() 25 print('主:%s n:%s' %(stop_time-start_time,n)) 26 27 ''' 28 Thread-1 is running 29 Thread-2 is running 30 ...... 31 Thread-100 is running 32 主:0.5216062068939209 n:99 33 ''' 34 35 36 #不加锁:未加锁部分并发执行,加锁部分串行执行,速度慢,数据安全 37 from threading import current_thread,Thread,Lock 38 import os,time 39 def task(): 40 #未加锁的代码并发运行 41 time.sleep(3) 42 print('%s start to run' %current_thread().getName()) 43 global n 44 #加锁的代码串行运行 45 lock.acquire() 46 temp=n 47 time.sleep(0.5) 48 n=temp-1 49 lock.release() 50 51 if __name__ == '__main__': 52 n=100 53 lock=Lock() 54 threads=[] 55 start_time=time.time() 56 for i in range(100): 57 t=Thread(target=task) 58 threads.append(t) 59 t.start() 60 for t in threads: 61 t.join() 62 stop_time=time.time() 63 print('主:%s n:%s' %(stop_time-start_time,n)) 64 65 ''' 66 Thread-1 is running 67 Thread-2 is running 68 ...... 69 Thread-100 is running 70 主:53.294203758239746 n:0 71 ''' 72 73 #有的同学可能有疑问:既然加锁会让运行变成串行,那么我在start之后立即使用join,就不用加锁了啊,也是串行的效果啊 74 #没错:在start之后立刻使用jion,肯定会将100个任务的执行变成串行,毫无疑问,最终n的结果也肯定是0,是安全的,但问题是 75 #start后立即join:任务内的所有代码都是串行执行的,而加锁,只是加锁的部分即修改共享数据的部分是串行的 76 #单从保证数据安全方面,二者都可以实现,但很明显是加锁的效率更高. 77 from threading import current_thread,Thread,Lock 78 import os,time 79 def task(): 80 time.sleep(3) 81 print('%s start to run' %current_thread().getName()) 82 global n 83 temp=n 84 time.sleep(0.5) 85 n=temp-1 86 87 88 if __name__ == '__main__': 89 n=100 90 lock=Lock() 91 start_time=time.time() 92 for i in range(100): 93 t=Thread(target=task) 94 t.start() 95 t.join() 96 stop_time=time.time() 97 print('主:%s n:%s' %(stop_time-start_time,n)) 98 99 ''' 100 Thread-1 start to run 101 Thread-2 start to run 102 ...... 103 Thread-100 start to run 104 主:350.6937336921692 n:0 #耗时是多么的恐怖
2. 死锁与递归锁
一般情况下进程之间是数据不共享的，不需要加锁，由于线程是对全局的数据共享的，所以对于全局的数据进行操作的时候，要加锁
所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程.
import time from threading import Thread,Lock,RLock def func1(lock_A,lock_B): lock_A.acquire() time.sleep(0.5) print('alex拿到了A锁') lock_B.acquire() print('alex拿到了B锁') lock_B.release() lock_A.release() def func2(lock_A,lock_B): lock_B.acquire() print('taibai拿到了B锁') lock_A.acquire() print('taibai 拿到了A锁') lock_A.release() lock_B.release() if __name__ == '__main__': lock_A = Lock() lock_B = Lock() t1 = Thread(target=func1,args=(lock_A ,lock_B)) t2 = Thread(target=func2,args=(lock_A,lock_B)) t1.start() t2.start() ''' 结果: taibai拿到了B锁 alex拿到了A锁 #程序阻塞 '''
解决方法，递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。
这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：
import time from threading import Thread,Lock,RLock def func1(lock_A,lock_B): lock_A.acquire() time.sleep(0.5) print('alex拿到了A锁') lock_B.acquire() print('alex拿到了B锁') lock_B.release() lock_A.release() def func2(lock_A,lock_B): lock_B.acquire() print('taibai拿到了B锁') lock_A.acquire() print('taibai 拿到了A锁') lock_A.release() lock_B.release() if __name__ == '__main__': # lock_A = RLock() # lock_A = Lock() # lock_B = RLock() # lock_B = Lock() lock_A = lock_B = RLock() #两把锁必须同时定义为递归锁 # lock_A = lock_B = Lock() t1 = Thread(target=func1,args=(lock_A,lock_B)) t2 = Thread(target=func2,args=(lock_A,lock_B)) t1.start() t2.start()
四. 信号量
同进程的一样
Semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。
实例：(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5)：
from threading import Thread,Semaphore import threading import time # def func(): # if sm.acquire(): # print (threading.currentThread().getName() + ' get semaphore') # time.sleep(2) # sm.release() def func(): sm.acquire() print('%s get sm' %threading.current_thread().getName()) time.sleep(3) sm.release() if __name__ == '__main__': sm=Semaphore(5) for i in range(23): t=Thread(target=func) t.start()
信号量和进程池有区别, 线程也有线程池，和信号量也是那点区别
互斥锁与信号量推荐博客：http://url.cn/5DMsS9r
五. 事件
同进程的一样
线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在初始情况下, Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行
事件的基本方法:
event.isSet()：返回event的状态值；
event.wait()：如果 event.isSet()==False将阻塞线程；
event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；
event.clear()：恢复event的状态值为False。
from threading import Thread,Event e = Event() #默认是False, # print(e.isSet()) print('开始等啦') e.set() #将事件对象的状态改为True print(e.isSet()) # e.clear() #将e的状态改为False e.wait() #如果e的状态为False,就在这里阻塞 print('大哥,还没完事儿,你行')