---恢复内容开始---

python的多线程实际上只有一个线程。

 

 

了让各个线程能够平均利用CPU时间，python会计算当前已执行的微代码数量，达到一定阈值后就强制释放GIL。而这时也会触发一次操作系统的线程调度（当然是否真正进行上下文切换由操作系统自主决定）。

 

GIL全局解释器锁： 保证同一时间只有一个线程得到数据并且只有一个线程执行，但是cpu调度时间到了以后，第一个线程无论是否完成均程等待状态（若未执行完毕，数据放入寄存器中）下一线程得到的依旧是原始的公共数据。

用户级lock:保证同一时间只有一个线程在修改数据。（可以避免几个线程同时对公共原始数据进行修改，提高线程效率）

为公共数据Lock:一个线程修改后，释放，下一进程才可再次进行修改。

 

RLock（递归锁）:在一个大锁中还要再包含子锁

 1 import threading, time
 2 
 3 
 4 def run1():
 5     print("grab the first part data")
 6     lock.acquire()
 7     global num
 8     num += 1
 9     lock.release()
10     return num
11 
12 
13 def run2():
14     print("grab the second part data")
15     lock.acquire()
16     global num2
17     num2 += 1
18     lock.release()
19     return num2
20 
21 
22 def run3():
23     lock.acquire()
24     res = run1()
25     print('--------between run1 and run2-----')
26     res2 = run2()
27     lock.release()
28     print(res, res2)
29 
30 
31 # if __name__ == '__main__':
32 
33 num, num2 = 0, 0
34 lock = threading.RLock()
35 for i in range(10):
36     t = threading.Thread(target=run3)
37     t.start()
38 
39 while threading.active_count() != 1:
40     print(threading.active_count())
41 else:
42     print('----all threads done---')
43     print(num, num2)

线程锁(互斥锁Mutex)

信号量：和单个锁的区别是信号量有多个锁

 1 import threading, time
 2 
 3 # 信号量就是多个锁
 4 def run(n):
 5     semaphore.acquire()#信号量获取
 6     time.sleep(1)
 7     print("run the thread: %s\n" % n)
 8     semaphore.release() # 信号量释放
 9 
10 
11 if __name__ == '__main__':
12 
13     num = 0
14     semaphore = threading.BoundedSemaphore(5)  # 最多允许5个线程同时运行
15     for i in range(20):
16         t = threading.Thread(target=run, args=(i,))
17         t.start()
18 
19 while threading.active_count() != 1:
20     pass  # print threading.active_count()
21 else:
22     print('----all threads done---')
23     print(num)

 

事件Event: