新郑IT教育网


python站群系统

菜鸟网络前端-举例讲解Python编程中对线程锁的使用

摘要:锁菜鸟网络前端的内置数据结构比如列表和字典等是线程安全的,但是简单数据类型比如整数和浮点数则不是线程安全的,要这些简单数据类型的通过操作,就需要使用锁。#!/usr/bin/env 菜鸟网络前端3# coding=utf-8 import threading shared_resource_with_菜鸟网络前端 = 0

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

#!/usr/bin/env 菜鸟网络前端3# coding=utf-8 import threading shared_resource_with_菜鸟网络前端 = 0shared_resource_with_no_菜鸟网络前端 = 0COUNT = shared_resource_菜鸟网络前端 = threading.Lock() ####LOCK MAN**EMENT##def increment_with_菜鸟网络前端():  global shared_resource_with_菜鸟网络前端  for i in range(COUNT):    shared_resource_菜鸟网络前端.acquire()    shared_resource_with_菜鸟网络前端 += 1    shared_resource_菜鸟网络前端.release()     def decrement_with_菜鸟网络前端():  global shared_resource_with_菜鸟网络前端  for i in range(COUNT):    shared_resource_菜鸟网络前端.acquire()    shared_resource_with_菜鸟网络前端 -= 1    shared_resource_菜鸟网络前端.release()    ####NO LOCK MAN**EMENT ##   def increment_without_菜鸟网络前端():  global shared_resource_with_no_菜鸟网络前端  for i in range(COUNT):    shared_resource_with_no_菜鸟网络前端 += 1   def decrement_without_菜鸟网络前端():  global shared_resource_with_no_菜鸟网络前端  for i in range(COUNT):    shared_resource_with_no_菜鸟网络前端 -= 1   ####the Main programif __name__ == "__main__":  t1 = threading.Thread(target = increment_with_菜鸟网络前端)  t2 = threading.Thread(target = decrement_with_菜鸟网络前端)  t3 = threading.Thread(target = increment_without_菜鸟网络前端)  t4 = threading.Thread(target = decrement_without_菜鸟网络前端)  t1.start()  t2.start()  t3.start()  t4.start()  t1.join()  t2.join()  t3.join()  t4.join()  print ("the value of shared variable with 菜鸟网络前端 man**ement is %s"\  %shared_resource_with_菜鸟网络前端)  print ("the value of shared variable with race condition is %s"\  %shared_resource_with_no_菜鸟网络前端)

$ ./threading_菜鸟网络前端.py

the value of shared variable with 菜鸟网络前端 man**ement is 0the value of shared variable with race condition is 0

import randomimport threadingimport timelogging.basicConfig(level=logging.DEBUG,          format='(%(threadName)-10s) %(mess**e)s',          )           class Counter(object):  def __init__(self, start=0):    self.菜鸟网络前端 = threading.Lock()    self.value = start  def increment(self):    logging.debug(time.ctime(time.time()))    logging.debug('Waiting for 菜鸟网络前端')    self.菜鸟网络前端.acquire()    try:      pause = random.randint(1,3)      logging.debug(time.ctime(time.time()))      logging.debug('Acquired 菜鸟网络前端')           self.value = self.value + 1      logging.debug('菜鸟网络前端 {0} seconds'.format(pause))      time.sleep(pause)    finally:      self.菜鸟网络前端.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)

$ 菜鸟网络前端 threading_菜鸟网络前端.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 菜鸟网络前端(Thread-2 ) Tue Sep 15 15:49:20 2015(Thread-2 ) Acquired 菜鸟网络前端(Thread-2 ) 菜鸟网络前端 2 seconds(Thread-1 ) Tue Sep 15 15:49:21 2015(Thread-1 ) Waiting for 菜鸟网络前端(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 菜鸟网络前端(Thread-1 ) 菜鸟网络前端 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 菜鸟网络前端(Thread-2 ) Tue Sep 15 15:49:24 2015(Thread-2 ) Acquired 菜鸟网络前端(Thread-2 ) 菜鸟网络前端 1 seconds(Thread-1 ) Tue Sep 15 15:49:25 2015(Thread-1 ) Waiting for 菜鸟网络前端(Thread-1 ) Tue Sep 15 15:49:25 2015(Thread-1 ) Acquired 菜鸟网络前端(Thread-1 ) 菜鸟网络前端 2 seconds(Thread-2 ) Done(Thread-1 ) Done(MainThread) Counter: 4

acquire()中传入False值,可以检查是否获得了锁。比如:

import loggingimport threadingimport timelogging.basicConfig(level=logging.DEBUG,          format='(%(threadName)-10s) %(mess**e)s',          )           def 菜鸟网络前端_holder(菜鸟网络前端):  logging.debug('Starting')  while True:    菜鸟网络前端.acquire()    try:      logging.debug('Holding')      time.sleep(0.5)    finally:      logging.debug('Not holding')      菜鸟网络前端.release()    time.sleep(0.5)  return           def worker(菜鸟网络前端):  logging.debug('Starting')  num_tries = 0  num_acquires = 0  while num_acquires < 3:    time.sleep(0.5)    logging.debug('Trying to acquire')    have_it = 菜鸟网络前端.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:        菜鸟网络前端.release()  logging.debug('Done after %d iterations', num_tries)菜鸟网络前端 = threading.Lock()holder = threading.Thread(target=菜鸟网络前端_holder,             args=(菜鸟网络前端,),             name='LockHolder')holder.setDaemon(True)holder.start()worker = threading.Thread(target=worker,             args=(菜鸟网络前端,),             name='Worker')worker.start()

$菜鸟网络前端threading_菜鸟网络前端_nob菜鸟网络前端.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 菜鸟网络前端 = threading.Lock() print 'First try :', 菜鸟网络前端.acquire()print 'Second try:', 菜鸟网络前端.acquire(0)

$菜鸟网络前端threading_菜鸟网络前端_reacquire.py

First try : TrueSecond try: False

import threading菜鸟网络前端 = threading.RLock()print 'First try :', 菜鸟网络前端.acquire()print 'Second try:', 菜鸟网络前端.acquire(0)

First try : TrueSecond try: 1

#!/usr/bin/env 菜鸟网络前端3# coding=utf-8import threadingimport timeclass Box(object):  菜鸟网络前端 = threading.RLock()  def __init__(self):    self.total_items = 0  def execute(self,n):    Box.菜鸟网络前端.acquire()    self.total_items += n    Box.菜鸟网络前端.release()  def add(self):    Box.菜鸟网络前端.acquire()    self.execute(1)    Box.菜鸟网络前端.release()  def remove(self):    Box.菜鸟网络前端.acquire()    self.execute(-1)    Box.菜鸟网络前端.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 worksif __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)

putting 5 items in the boxadding 1 item in the boxremoving 1 item in the boxadding 1 item in the boxremoving 1 item in the boxadding 1 item in the boxremoving 1 item in the boxremoving 1 item in the boxadding 1 item in the boxremoving 1 item in the boxadding 1 item in the box0 items still remain in the box

更多关于Python编程中对线程锁的使用请关注PHP中文网()其他文章!