舉例講解Python編程中對線程鎖的使用

更新時間：2016年07月12日 18:44:43 作者：磁針石

Python的threading模塊中提供了多種鎖的相關(guān)方法,Python的多線程不能同時執(zhí)行,因而鎖的使用非常關(guān)鍵,下面我們就來舉例講解Python編程中對線程鎖的使用:

鎖

python的內(nèi)置數(shù)據(jù)結(jié)構(gòu)比如列表和字典等是線程安全的，但是簡單數(shù)據(jù)類型比如整數(shù)和浮點數(shù)則不是線程安全的，要這些簡單數(shù)據(jù)類型的通過操作，就需要使用鎖。

#!/usr/bin/env python3
# coding=utf-8

import threading

shared_resource_with_lock = 0
shared_resource_with_no_lock = 0
COUNT = 100000
shared_resource_lock = threading.Lock()

####LOCK MANAGEMENT##
def increment_with_lock():
  global shared_resource_with_lock
  for i in range(COUNT):
    shared_resource_lock.acquire()
    shared_resource_with_lock += 1
    shared_resource_lock.release()
    
def decrement_with_lock():
  global shared_resource_with_lock
  for i in range(COUNT):
    shared_resource_lock.acquire()
    shared_resource_with_lock -= 1
    shared_resource_lock.release()
    ####NO LOCK MANAGEMENT ##
  
def increment_without_lock():
  global shared_resource_with_no_lock
  for i in range(COUNT):
    shared_resource_with_no_lock += 1
  
def decrement_without_lock():
  global shared_resource_with_no_lock
  for i in range(COUNT):
    shared_resource_with_no_lock -= 1
  
####the Main program
if __name__ == "__main__":
  t1 = threading.Thread(target = increment_with_lock)
  t2 = threading.Thread(target = decrement_with_lock)
  t3 = threading.Thread(target = increment_without_lock)
  t4 = threading.Thread(target = decrement_without_lock)
  t1.start()
  t2.start()
  t3.start()
  t4.start()
  t1.join()
  t2.join()
  t3.join()
  t4.join()
  print ("the value of shared variable with lock management is %s"\
  %shared_resource_with_lock)
  print ("the value of shared variable with race condition is %s"\
  %shared_resource_with_no_lock)

執(zhí)行結(jié)果：

$ ./threading_lock.py

the value of shared variable with lock management is 0
the value of shared variable with race condition is 0

又如：

import random
import threading
import time
logging.basicConfig(level=logging.DEBUG,
          format='(%(threadName)-10s) %(message)s',
          )
          
class Counter(object):
  def __init__(self, start=0):
    self.lock = threading.Lock()
    self.value = start
  def increment(self):
    logging.debug(time.ctime(time.time()))
    logging.debug('Waiting for lock')
    self.lock.acquire()
    try:
      pause = random.randint(1,3)
      logging.debug(time.ctime(time.time()))
      logging.debug('Acquired lock')      
      self.value = self.value + 1
      logging.debug('lock {0} seconds'.format(pause))
      time.sleep(pause)
    finally:
      self.lock.release()
def worker(c):
  for i in range(2):
    pause = random.randint(1,3)
    logging.debug(time.ctime(time.time()))
    logging.debug('Sleeping %0.02f', pause)
    time.sleep(pause)
    c.increment()
  logging.debug('Done')
counter = Counter()
for i in range(2):
  t = threading.Thread(target=worker, args=(counter,))
  t.start()
logging.debug('Waiting for worker threads')
main_thread = threading.currentThread()
for t in threading.enumerate():
  if t is not main_thread:
    t.join()
logging.debug('Counter: %d', counter.value)

執(zhí)行結(jié)果：

$ python threading_lock.py

(Thread-1 ) Tue Sep 15 15:49:18 2015
(Thread-1 ) Sleeping 3.00
(Thread-2 ) Tue Sep 15 15:49:18 2015
(MainThread) Waiting for worker threads
(Thread-2 ) Sleeping 2.00
(Thread-2 ) Tue Sep 15 15:49:20 2015
(Thread-2 ) Waiting for lock
(Thread-2 ) Tue Sep 15 15:49:20 2015
(Thread-2 ) Acquired lock
(Thread-2 ) lock 2 seconds
(Thread-1 ) Tue Sep 15 15:49:21 2015
(Thread-1 ) Waiting for lock
(Thread-2 ) Tue Sep 15 15:49:22 2015
(Thread-1 ) Tue Sep 15 15:49:22 2015
(Thread-2 ) Sleeping 2.00
(Thread-1 ) Acquired lock
(Thread-1 ) lock 1 seconds
(Thread-1 ) Tue Sep 15 15:49:23 2015
(Thread-1 ) Sleeping 2.00
(Thread-2 ) Tue Sep 15 15:49:24 2015
(Thread-2 ) Waiting for lock
(Thread-2 ) Tue Sep 15 15:49:24 2015
(Thread-2 ) Acquired lock
(Thread-2 ) lock 1 seconds
(Thread-1 ) Tue Sep 15 15:49:25 2015
(Thread-1 ) Waiting for lock
(Thread-1 ) Tue Sep 15 15:49:25 2015
(Thread-1 ) Acquired lock
(Thread-1 ) lock 2 seconds
(Thread-2 ) Done
(Thread-1 ) Done
(MainThread) Counter: 4

acquire()中傳入False值，可以檢查是否獲得了鎖。比如：

import logging
import threading
import time
logging.basicConfig(level=logging.DEBUG,
          format='(%(threadName)-10s) %(message)s',
          )
          
def lock_holder(lock):
  logging.debug('Starting')
  while True:
    lock.acquire()
    try:
      logging.debug('Holding')
      time.sleep(0.5)
    finally:
      logging.debug('Not holding')
      lock.release()
    time.sleep(0.5)
  return
          
def worker(lock):
  logging.debug('Starting')
  num_tries = 0
  num_acquires = 0
  while num_acquires < 3:
    time.sleep(0.5)
    logging.debug('Trying to acquire')
    have_it = lock.acquire(0)
    try:
      num_tries += 1
      if have_it:
        logging.debug('Iteration %d: Acquired',
               num_tries)
        num_acquires += 1
      else:
        logging.debug('Iteration %d: Not acquired',
               num_tries)
    finally:
      if have_it:
        lock.release()
  logging.debug('Done after %d iterations', num_tries)
lock = threading.Lock()
holder = threading.Thread(target=lock_holder,
             args=(lock,),
             name='LockHolder')
holder.setDaemon(True)
holder.start()
worker = threading.Thread(target=worker,
             args=(lock,),
             name='Worker')
worker.start()

執(zhí)行結(jié)果：

$ python threading_lock_noblock.py

(LockHolder) Starting
(LockHolder) Holding
(Worker  ) Starting
(LockHolder) Not holding
(Worker  ) Trying to acquire
(Worker  ) Iteration 1: Acquired
(LockHolder) Holding
(Worker  ) Trying to acquire
(Worker  ) Iteration 2: Not acquired
(LockHolder) Not holding
(Worker  ) Trying to acquire
(Worker  ) Iteration 3: Acquired
(LockHolder) Holding
(Worker  ) Trying to acquire
(Worker  ) Iteration 4: Not acquired
(LockHolder) Not holding
(Worker  ) Trying to acquire
(Worker  ) Iteration 5: Acquired
(Worker  ) Done after 5 iterations

線程安全鎖

threading.RLock()

返回可重入鎖對象。重入鎖必須由獲得它的線程釋放。一旦線程獲得了重入鎖，同一線程可不阻塞地再次獲得，獲取之后必須釋放。

通常一個線程只能獲取一次鎖：

import threading

lock = threading.Lock()

print 'First try :', lock.acquire()
print 'Second try:', lock.acquire(0)

執(zhí)行結(jié)果：

$ python threading_lock_reacquire.py

First try : True
Second try: False

使用RLock可以獲取多次鎖：

import threading
lock = threading.RLock()
print 'First try :', lock.acquire()
print 'Second try:', lock.acquire(0)

執(zhí)行結(jié)果：

python threading_rlock.py

First try : True
Second try: 1

再來看一個例子：

#!/usr/bin/env python3
# coding=utf-8
import threading
import time
class Box(object):
  lock = threading.RLock()
  def __init__(self):
    self.total_items = 0
  def execute(self,n):
    Box.lock.acquire()
    self.total_items += n
    Box.lock.release()
  def add(self):
    Box.lock.acquire()
    self.execute(1)
    Box.lock.release()
  def remove(self):
    Box.lock.acquire()
    self.execute(-1)
    Box.lock.release()
    
## These two functions run n in separate
## threads and call the Box's methods    
def adder(box,items):
  while items > 0:
    print ("adding 1 item in the box\n")
    box.add()
    time.sleep(5)
    items -= 1
    
def remover(box,items):
  while items > 0:
    print ("removing 1 item in the box")
    box.remove()
    time.sleep(5)
    items -= 1
    
## the main program build some
## threads and make sure it works
if __name__ == "__main__":
  items = 5
  print ("putting %s items in the box " % items)
  box = Box()
  t1 = threading.Thread(target=adder,args=(box,items))
  t2 = threading.Thread(target=remover,args=(box,items))
  t1.start()
  t2.start()
  t1.join()
  t2.join()
  print ("%s items still remain in the box " % box.total_items)

執(zhí)行結(jié)果：

$ python3 threading_rlock2.py

putting 5 items in the box 
adding 1 item in the box
removing 1 item in the box
adding 1 item in the box
removing 1 item in the box
adding 1 item in the box
removing 1 item in the box
removing 1 item in the box
adding 1 item in the box
removing 1 item in the box
adding 1 item in the box
0 items still remain in the box

您可能感興趣的文章:

Python
鎖

相關(guān)文章

Python網(wǎng)絡(luò)爬蟲之Web網(wǎng)頁基礎(chǔ)
我們在學(xué)習(xí)爬蟲之前，要先了解網(wǎng)頁的組成，只有我們了解其組成嗎，才可以方能百戰(zhàn)百勝，文章中有詳細(xì)的代碼示例，需要的朋友可以參考一下
2023-04-04
解決Python3用PIL的ImageFont輸出中文亂碼的問題
今天小編大家分享一篇解決Python3用PIL的ImageFont輸出中文亂碼的問題，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧
2019-08-08
python3中zip()函數(shù)使用詳解
zip函數(shù)接受任意多個可迭代對象作為參數(shù),將對象中對應(yīng)的元素打包成一個tuple,然后返回一個可迭代的zip對象.這個可迭代對象可以使用循環(huán)的方式列出其元素,若多個可迭代對象的長度不一致,則所返回的列表與長度最短的可迭代對象相同.
2018-06-06
Python PyQt5干貨滿滿小項目輕松實現(xiàn)高效摳圖去背景
PyQt5以一套Python模塊的形式來實現(xiàn)功能。它包含了超過620個類，600個方法和函數(shù)。本篇文章手把手帶你用PyQt5輕松實現(xiàn)圖片扣除背景,大家可以在過程中查缺補(bǔ)漏，提升水平
2021-11-11
python使用opencv按一定間隔截取視頻幀
這篇文章主要為大家詳細(xì)介紹了python使用opencv按一定間隔截取視頻幀，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2018-03-03
Python中and和or如何使用
在本篇文章里小編給各位分享的是一篇關(guān)于Python中and、or用法實例文章，有興趣的朋友們可以參考學(xué)習(xí)下。
2020-05-05
Python進(jìn)階之利用+和*進(jìn)行列表拼接
在我們學(xué)習(xí)python的過程中，有一個非常常見的語法，那就是利用+和*進(jìn)行序列的拼接以及其他操作。今天就帶大家從使用+和*進(jìn)行拼接出發(fā)認(rèn)識一個大家非常容易犯的代碼錯誤。話不多說我們開始吧
2023-04-04
這篇文章主要介紹了Python的面向?qū)ο缶幊?super，super在Pyhon是一個特殊的的類，想具體了解的朋友請參考下面文章內(nèi)容
2021-09-09