鎖 lock，訊號量4

1. 全域性直譯器鎖，保證同一時間只有乙個執行緒在執行，但是由於它是把資料copy成了兩份，所以

只有全域性直譯器鎖的時候，資料加減照樣出錯了。

2.使用者態的鎖，保證同一時間，只有乙個執行緒在真真正正地修改資料。

修改資料之前，先加一把鎖。修改完了以後，釋放鎖。修改資料的時候，把程式變成序列的。

#主線程啟動子執行緒之後，兩者是並行的，相互之間是獨立的。

import threading,time
def run(n):
lock.acquire() #獲取一把鎖
global num   #把num宣告成全域性變數以後，才能夠進行修改。
num+=1
time.sleep(1)
lock.release() #釋放鎖
lock=threading.lock() #生產乙個鎖的例項
num=0 #全域性變數
t_objs=
start_time=time.time()
for i in range(10):
t=threading.thread(target=run,args=("t-%s"%i,))
t.start()
for t in t_objs:
t.join() #所有執行緒都執行完畢
print('----all threads has finished',threading.current_thread(),threading.active_count())
print('num:',num)
print('cost time:',time.time()-start_time)

執行結果：發現確實花費了10s多。

----all threads has finished <_mainthread(mainthread, started 9908)> 1

num: 10
cost time: 10.003000259399414
process finished with exit code 0

3. 遞迴鎖（又叫互斥鎖），因為有多把鎖，找不到出去的鎖，會陷入死迴圈。說白了就是在乙個大鎖中還要再包含子鎖

locks=

程式摘抄自老師的部落格：

import threading,time

def run1():
print("grab the first part data")
lock.acquire()
global num
num +=1
lock.release()
return num
def run2():
print("grab the second part data")
lock.acquire()
global  num2
num2+=1
lock.release()
return num2
def run3():
lock.acquire()
res = run1()
print('--------between run1 and run2-----')
res2 = run2()
lock.release()
print(res,res2)  
if __name__ == '__main__':
num,num2 = 0,0
lock = threading.rlock()
for i in range(10):
t = threading.thread(target=run3)
t.start()
while threading.active_count() != 1:
print(threading.active_count())
else:
print('----all threads done---')
print(num,num2)

4.訊號量semaphore

互斥鎖 同時只允許乙個執行緒更改資料，而semaphore是同時允許一定數量的執行緒更改資料 ，比如廁所有3個坑，那最多隻允許3個人上廁所，後面的人只能等裡面有人出來了才能再進去。最多同時有3個在執行，當有1個執行完了的時候，就會又放1個進去。發現程式是5個5個一組進行執行。

import threading, time

def run(n):
semaphore.acquire()
time.sleep(1)
print("run the thread: %s\n" % n)
semaphore.release()
if __name__ == '__main__':
semaphore = threading.boundedsemaphore(5)  # 生成乙個訊號量的例項，並且定義最多允許5個執行緒同時執行
for i in range(20):
t = threading.thread(target=run, args=(i,))
t.start()
while threading.active_count() != 1:
pass  # print threading.active_count()
else:
print('----all threads done---')

訊號量，互斥鎖

注 摘自 程式設計師的自我修養 相關章節。關鍵字 執行緒同步 原子操作 鎖 二元訊號量 訊號量 互斥量 臨界區 讀寫鎖 條件變數 原子操作 共享資料 全域性變數或堆變數 的自增 操作在多執行緒環境下會出現錯誤是因為這個操作 一條c語句 被編譯為彙編 後不止一條指令，因此在執行的時候可能執行了一半就被...

訊號量 互斥鎖

訊號量與普通整型變數的區別 訊號量 semaphore 是非負整型變數，除了初始化之外，它只能通過兩個標準原子操作 wait semap signal semap 來進行訪問 操作也被成為pv原語 p 於dutch proberen 測試 v 於 dutch verhogen 增加 而普通整型變數則...

自旋鎖，互斥鎖，訊號量

自旋鎖，互斥鎖，訊號量 樂觀鎖和悲觀鎖只是一種理論，是從思想上劃分的。自旋鎖和互斥鎖是應用層確確實實的鎖，用於同步訪問控制 如果一定要劃分，從只有乙個執行緒可以擁有鎖來說，我覺得自旋鎖和互斥鎖應該都屬於悲觀鎖，因為一般的應用不需要支援事物回滾的操作。但是沈詢的直播中說，互斥鎖屬於悲觀鎖 sleep ...