2. 程式人生 > >Python 線程同步鎖, 信號量

Python 線程同步鎖, 信號量

阿新 • • 發佈：2018-07-29
sleep 圖片 for 初始 image import lock 管理 img

同步鎖

import  time, threading

def addNum():
    global num
    num -= 1

num = 100

thread_list = []
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list:
    t.join()

print(‘final num:‘, num)

運行結果:
final num: 0
import  time, threading

def addNum():
    global num
    #num -= 1
    tmp = num
    time.sleep(0.00001)
    num = tmp - 1

num = 100

thread_list = []
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list:
    t.join()

print(‘final num:‘, num)

運行結果:
final num: 93 
或
final num: 91
或
final num: 94

原因：
第一個程序中，num -= 1 這種寫法，程序執行動作太快(完成這個動作在 cup 切換的時間內)
第二個程序中，把 num -= 1 , 加入了 sleep 時間，100個線程存在沒有執行完就進行了切換，導致全局的 num 沒有正常返回。引用下大神的圖發現總結得非常好：
技術分享圖片
在上面的例子中 使用 join 方法會把整個線程停住，造成了串行，失去了多線程的意義，我們只需要在涉及到計算公共數據的時候串行執行即可。

使用同步鎖處理計算公共的數據

import  time, threading

def addNum():
    global num

    lock.acquire()
    tmp = num
    time.sleep(0.00001)
    num = tmp - 1
    lock.release()


num = 100
lock = threading.Lock()
thread_list = []
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list:
    t.join()

print(‘final num:‘, num)

運算結果:
final num: 0

線程死鎖和遞歸鎖

import  threading, time

class myThread(threading.Thread):
    def doA(self):
        lockA.acquire()
        print(self.name, "gotlockA", time.ctime())
        time.sleep(3)
        lockB.acquire()
        print(self.name, "gotlockB", time.ctime())
        lockB.release()
        lockA.release()

    def doB(self):
        lockB.acquire()
        print(self.name, "gotlockB", time.ctime())
        time.sleep(2)
        lockA.acquire()
        print(self.name, "gotlockA", time.ctime())
        lockA.release()
        lockB.release()

    def run(self):
        self.doA()
        self.doB()

if __name__ == ‘__main__‘:
    lockA = threading.Lock()
    lockB = threading.Lock()
    threads = []
    for i in range(5):
        threads.append(myThread())
    for t in threads:
        t.start()
    for t in threads:
        t.join()

#運行結果:
Thread-1 gotlockA Sat Jul 28 15:09:31 2018
Thread-1 gotlockB Sat Jul 28 15:09:34 2018
Thread-1 gotlockB Sat Jul 28 15:09:34 2018
Thread-2 gotlockA Sat Jul 28 15:09:34 2018

使用遞歸鎖

import  threading, time

class myThread(threading.Thread):
    def doA(self):
        lock.acquire()
        print(self.name, "gotlockA", time.ctime())
        time.sleep(3)
        lock.acquire()
        print(self.name, "gotlockB", time.ctime())
        lock.release()
        lock.release()

    def doB(self):
        lock.acquire()
        print(self.name, "gotlockB", time.ctime())
        time.sleep(2)
        lock.acquire()
        print(self.name, "gotlockA", time.ctime())
        lock.release()
        lock.release()

    def run(self):
        self.doA()
        self.doB()

if __name__ == ‘__main__‘:
    lock = threading.RLock()
    threads = []
    for i in range(5):
        threads.append(myThread())
    for t in threads:
        t.start()
    for t in threads:
        t.join()

運行結果:
Thread-1 gotlockA Sat Jul 28 15:19:35 2018
Thread-1 gotlockB Sat Jul 28 15:19:38 2018
Thread-1 gotlockB Sat Jul 28 15:19:38 2018
Thread-1 gotlockA Sat Jul 28 15:19:40 2018
Thread-3 gotlockA Sat Jul 28 15:19:40 2018
Thread-3 gotlockB Sat Jul 28 15:19:43 2018
Thread-3 gotlockB Sat Jul 28 15:19:43 2018
Thread-3 gotlockA Sat Jul 28 15:19:45 2018
Thread-5 gotlockA Sat Jul 28 15:19:45 2018
Thread-5 gotlockB Sat Jul 28 15:19:48 2018
Thread-5 gotlockB Sat Jul 28 15:19:48 2018
Thread-5 gotlockA Sat Jul 28 15:19:50 2018
Thread-4 gotlockA Sat Jul 28 15:19:50 2018
Thread-4 gotlockB Sat Jul 28 15:19:53 2018
Thread-4 gotlockB Sat Jul 28 15:19:53 2018
Thread-4 gotlockA Sat Jul 28 15:19:55 2018
Thread-2 gotlockA Sat Jul 28 15:19:55 2018
Thread-2 gotlockB Sat Jul 28 15:19:58 2018
Thread-2 gotlockB Sat Jul 28 15:19:58 2018
Thread-2 gotlockA Sat Jul 28 15:20:00 2018

信號量

信號量用來控制線程並發數的，BoundedSemaphore或Semaphore管理一個內置的計數 器，每當調用acquire()時-1，調用release()時+1,計數器不能小於0，當計數器為 0時，acquire()將阻塞線程至同步鎖定狀態，直到其他線程調用release()。(類似於停車位的概念)。
BoundedSemaphore與Semaphore的唯一區別在於前者將在調用release()時檢查計數 器的值是否超過了計數器的初始值，如果超過了將拋出一個異常。

import threading, time

class myThread(threading.Thread):
    def run(self):
        if semaphore.acquire():
            print(self.name)
            time.sleep(5)
            semaphore.release()

if __name__ == "__main__":
    semaphore = threading.Semaphore(5)
    thrs = []
    for i in range(20):
        thrs.append(myThread())
    for t in thrs:
        t.start()

#運行結果:
Thread-1
Thread-2
Thread-3
Thread-4
Thread-5
Thread-6
Thread-7
Thread-9
Thread-10
Thread-8
Thread-11
Thread-13
Thread-14
Thread-12
Thread-15
Thread-18
Thread-16
Thread-17
Thread-19
Thread-20
import threading, time

class myThread(threading.Thread):
    def run(self):
        if semaphore.acquire():
            print(self.name)
            time.sleep(5)
            semaphore.release()

if __name__ == "__main__":
    semaphore = threading.BoundedSemaphore(5)
    thrs = []
    for i in range(20):
        thrs.append(myThread())
    for t in thrs:
        t.start()

#運行結果:
Thread-1
Thread-2
Thread-3
Thread-4
Thread-5
Thread-6
Thread-8
Thread-10
Thread-9
Thread-7
Thread-12
Thread-14
Thread-15
Thread-13
Thread-11
Thread-16
Thread-17
Thread-20
Thread-19
Thread-18

Python 線程同步鎖, 信號量

相關推薦

Python 線程同步鎖, 信號量

sleep 圖片 for 初始 image import lock 管理 img 同步鎖 import time, threading def addNum(): global num num -= 1 num = 100 thread_list =

Python多進程,同步互斥,信號量,鎖補充上一篇文章

python多進程 text stdout 執行 pause mat 1.7 hit splay 進程補充進程間的信號信號量（信號燈）進程的同步互斥Event事件Lock 鎖 進程補充 進程間的信號 信號是唯一的異步通信方法 一個進程向另一個進程發送一個信號來傳遞

python中的線程之semaphore信號量

宕機 strong 釋放 sleep clas 數量 spa params class semaphore是一個內置的計數器 每當調用acquire()時，內置計數器-1 每當調用release()時，內置計數器+1 計數器不能小於0，當計數器為0時，acquire(

C#多線程のSemaphore（信號量，負責協調各個線程）

csharp init true 控制 line 執行方法 start com 執行 Semaphore負責協調線程，可以限制對某一資源訪問的線程數量 這裏對SemaphoreSlim類的用法做一個簡單的例子： namespace WpfApplication6 {

12、第七周-網絡編程 - 線程中的信號量(Semaphore)

eas pytho 下一步 臨界資源 第七周 人才 超時 自己 運行 　　 　　互斥鎖同時只允許一個線程更改數據，而Semaphore是同時允許一定數量的線程更改數據。簡單介紹如下： 　　信號量用在多線程多任務同步的，一個線程完成了某一個動作就通過信號量告訴別的線程，別的線

Python之進程同步控制（鎖信號量事件 ）、進程間通信——隊列和管道

load 很快 容器 數據安全 全部 傳遞 幫我 之前 引入 進程同步(multiprocess.Lock、multiprocess.Semaphore、multiprocess.Event) 鎖 —— multiprocess.Lock 通過剛剛的學習，我們千方百計實現了

有關多線程(同步鎖，遞歸鎖，同步對象，信號量)

self. utf-8 odi odin self 函數名 在線 less 遞歸 上面一個隨筆已經簡單介紹了多線程，比如下面在舉個簡單的例子： 1 #!/usr/bin/env python 2 #-*-coding:utf-8 -*- 3 4 import

並發編程---死鎖||遞歸鎖---信號量---Event事件---定時器

遞歸 spa sleep 事件 lang tin lap 計數器 name 死鎖 互斥鎖：Lock()，互斥鎖只能acquire一次 遞歸鎖: RLock()，可以連續acquire多次，每acquire一次計數器+1，只有計數為0時，才能被搶到acquire # 死

進程數據隔離,守護進程,鎖,信號量和事件

port 系統 先後 天氣 pri *** strong sta fun 主要內容: # Process# 1.進程之間的數據隔離問題# 2.守護進程 # 幾個進程的模型 ---- 進程同步的工具 # 有先後順序 就是同步 # 進程之間 就是異步 # 希望

VC++多線程同步(一) Mutex互斥量

多線程 vc++ 線程同步 互斥量 一 、同步機制的引入目的是為了解決三個主要問題1為了控制線程之間共享資源的同步訪問,保證共享資源的完整性.(比如一個線程正在更新一個數據,而另外一個線程正在讀取該數據,那麽就不知道該數據是新的還是舊的,為了避免這種狀況的發生)2確保線程之間的動作

VC++線程同步(二) Mutex互斥量的例子

c++ 多線程 線程同步 同步對象使用實例 Win32窗口的建立： 我們將要學習的使用,分別是:互斥量,臨界區,事件,信號量.所以我們需要一個窗口,呈現四種四種同步對象狀態.首先創建一個Win32項目,不要選空項目;我們需要四個小窗口,先找到註冊主窗口的代碼

python的學習之旅---信號量 定時器

def 當前 pre 正在 getname from == and span 把線程都創建好，等待執行。 current_thread().getName() 獲取當前線程的線程名 from threading import Thread,Semaphore,curren

用戶模式同步之信號量小解

初始化 any char bsp 信號 include 計數 init return 3.信號燈（重點是記住什麽樣是激發什麽樣稱為未激發）信號燈有兩種狀態，激發和未激發狀態，信號燈內部有個計數器，可以理解信號燈內部有N個燈泡，如果有一個燈泡亮著，表示信號燈處於激發狀態，如果

Qt在多線程中使用信號槽的示例

mov 函數 cout this [] rdb 默認 emit etl 　　之前對線程理解得不深入，所以對Qt的線程機制沒有搞清楚，今天寫一篇文章總結一下，如有錯誤，歡迎指出。 首先需要理解線程是什麽，線程在代碼中的表現其實就是一個函數，只不過這個函數和主

Python線程同步

Python線程同步from random import randint import threading from time import ctime, sleep data = ['a', 'b', 'c', 'd', 'e'

JUC——線程同步鎖（ReentrantLock）

spa his 進入 star zab serial 進行 zed util ReentrantLock簡介 ReentrantLock是一個可重復的互斥鎖，又被稱為獨占鎖，可重入的意思是：ReentrantLock鎖可以被單個線程多次獲取。但是在同一個時間點只能被一個線程

鎖,信號量 ,事件 Event模塊

搶票 time 等待 數量 出現 money nbsp %s tick 1. 鎖 Lock模塊: 保證一段代碼,在同一時刻只能被一個進程執行.　　　　lock = Lock() 　 創造了一把鎖　　　　acquire() 　　 獲取鎖的鑰匙　　　　release(

多線程 -- 同步鎖

release brush wid 共享變量 height rt thread width 圖片 target 多個線程同時操作一個變量 import time import threading def addNum(): #在每個線程中都獲取這個全局變量

傳統線程同步通信技術

說明 描述 必須 ole 線程等待 read rgs 同步鎖 exc 先看一個問題： 有兩個線程，子線程先執行10次，然後主線程執行5次，然後再切換到子線程執行10，再主線程執行5次……如此往返執行50次。 看完這個問題，很明顯要用到線程間的通信了， 先分析一下思路：首

四十一、Linux 線程——線程同步之條件變量

調用 eight attr_ linux 線程阻塞 out span 例子 信號 41.1 概念 41.1.1 條件變量的介紹 互斥鎖的缺點是它只有兩種狀態：鎖定和非鎖定 條件變量通過允許線程阻塞和等待另一個線程發送信號的方法彌補了互斥鎖的不足 條件變量內部是一個等待隊列