举例讲解Python编程中对线程锁的使用

锁

python的内置数据结构比如列表和字典等是线程安全的，但是简单数据类型比如整数和浮点数则不是线程安全的，要这些简单数据类型的通过操作，就需要使用锁。

    #!/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)

执行结果：

    $ ./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)

执行结果：

    $ 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()

执行结果：

    $ 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)

执行结果：

    $ 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)

执行结果：

    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)

执行结果：

    $ 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