import atexit

 from random import randrange

 from threading import Thread, Lock, current_thread # or currentThread

 from time import ctime, sleep

 # Use set to record the running thread

 # If we print set directly, it will shows set([a, b, c])

 # So we reload the __str__ function to show it more clean(shows a, b, c as we want)

 class CleanOutputSet(set):

     def __str__(self):

         return ', '.join(x for x in self)

 # randrange(2, 5) will generate a num in range(2, 5)

 # for x in range(randrange(3, 7)) will do "for" loop 3-7 times

 # Below code generate a list which contains 3-6 numbers in range 2-4

 # If not list(), it will return a generator, and it will be null after one time iteration

 loops = list((randrange(2, 5) for x in range(randrange(3, 7))))

 remaining = CleanOutputSet()

 lock = Lock()

 def loop_without_lock(nsec):

     myname = current_thread().name

     remaining.add(myname)

     print('[%s] Start %s' % (ctime(), myname))

     sleep(nsec)

     remaining.remove(myname)

     print('[%s] Completed %s (%d secs)' % (ctime(), myname, nsec))

     # Note: remaining or 'NONE', will return 'NONE' if remaining is Null

     # Null including: None, False, (), [], {}, 0

     print('    (remaining: %s)' % (remaining or 'NONE'))

 def loop_with_lock(nsec):

     myname = current_thread().name

     # When we need to modifiy public resource, acquire lock to block other threads

     # Lock acquire and release can use 'with lock' to simplify

     lock.acquire()

     remaining.add(myname)

     print('[%s] Start %s' % (ctime(), myname))

     # After using resource, release lock for other threads to use

     lock.release()

     sleep(nsec)

     lock.acquire()

     remaining.remove(myname)

     print('[%s] Completed %s (%d secs)' % (ctime(), myname, nsec))

     print('    (remaining: %s)' % (remaining or 'NONE'))

     lock.release()

 def _main():

     print('-----Below threads without lock-----')

     threads = []

     for pause in loops:

         threads.append(Thread(target=loop_without_lock, args=(pause, )))

     for t in threads:

         t.start()

     for t in threads:

         t.join()

     print('-----Below threads with lock-----')

     threads = []

     for pause in loops:

         threads.append(Thread(target=loop_with_lock, args=(pause, )))

     for t in threads:

         t.start()

     for t in threads:

         t.join()

 # This is an exit function, when script exit, this function will be called

 # You can use atexit.register(_atexit) to replace @atexit.register

 # The function name '_atexit' can be change to others

 @atexit.register

 def _atexit():

     print('All DONE at:', ctime())

 if __name__ == '__main__':

     _main()

 from threading import Thread, Lock

 import time

 lock = Lock()

 COUNT = 0

 def gentleCounter():

     name = 'gentleCounter'

     lock.acquire()

     print('%s acquired the lock' % name)

     global COUNT

     COUNT += 1

     print('%s made a count plus, now the COUNT is %d' % (name, COUNT))

     print('%s is taking a rest...' % name)

     time.sleep(3)

     COUNT += 1

     print('%s made a count plus again, now the COUNT is %d' % (name, COUNT))

     lock.release()

     print('%s released the lock' % name)

 def wildCounter():

     time.sleep(1)

     name = 'wildCounter'

     print('%s didn\'t acquire the lock' % name)

     global COUNT

     COUNT += 1

     print('%s made a count plus, now the COUNT is %d' % (name, COUNT))

 Thread(target=gentleCounter).start()

 Thread(target=wildCounter).start()

gentleCounter acquired the lock

gentleCounter made a count plus, now the COUNT is 1

gentleCounter is taking a rest...

wildCounter didn't acquire the lock

wildCounter made a count plus, now the COUNT is 2

gentleCounter made a count plus again, now the COUNT is 3

gentleCounter released the lock  

 from threading import Lock, RLock

 def call():

     print('This is call() function')

     with lock:

         g()

         h()

 def g():

     if not lock.acquire(True, 1):

         print('g() acquires lock failed')

     else:

         print('This is g() function')

         lock.release()

     h()

 def h():

     if not lock.acquire(True, 1):

         print('h() acquires lock failed')

     else:

         print('This is h() function')

         lock.release()

 print('\n-------Using Lock-------')

 lock = Lock()

 call()

 print('\n-------Using RLock-------')

 lock = RLock()

 call()

-------Using Lock-------

This is call() function

g() acquires lock failed

h() acquires lock failed

h() acquires lock failed  

-------Using RLock-------

This is call() function

This is g() function

This is h() function

This is h() function  

 from threading import Thread, Lock, RLock, current_thread

 mutex = Lock()

 reentrant = RLock()

 class MyThread(Thread):

     def __init__(self, lock):

         Thread.__init__(self)

         self.lock = lock

     def run(self):

         self.name = current_thread().name

         print('-------This is %s-------' % self.name)

         if self.lock.acquire():

             print('%s get lock one' % self.name, '\nTrying to get second lock')

             self.lock.acquire()

             print('Got second lock')

             print('Trying to release lock...')

             self.lock.release()

             print('First lock released')

             self.lock.release()

             print('Second lock released')

             print('Lock all released')

         print('--------Exit %s---------' %

               self.name)

 t = MyThread(reentrant)

 t.start()

 t.join()

 t = MyThread(mutex)

 t.start()

 t.join()

-------This is Thread-1-------

Thread-1 get lock one

Trying to get second lock

Got second lock

Trying to release lock...

First lock released

Second lock released

Lock all released

--------Exit Thread-1---------

-------This is Thread-2-------

Thread-2 get lock one

Trying to get second lock  

 from threading import Thread, Lock, RLock, current_thread

 import time

 mutex_1 = Lock()

 mutex_2 = Lock()

 reentrant_1 = RLock()

 reentrant_2 = RLock()

 COUNT = 0

 class MyThread(Thread):

     def __init__(self, lock_1, lock_2):

         Thread.__init__(self)

         self.lock_1 = lock_1

         self.lock_2 = lock_2

     def run(self):

         self.name = current_thread().name

         if self.lock_1.acquire():

             print('%s got its first lock' % self.name)

             global COUNT

             COUNT += 1

             print('%s make COUNT plus one, now COUNT is %d' % (self.name, COUNT))

             time.sleep(2)

             print('%s trying to get another one...' % self.name)

             if self.lock_2.acquire():

                 print('%s got its second lock' % self.name)

                 self.lock_2.release()

                 print('%s release its second lock' % self.name)

             self.lock_1.release()

             print('%s release its first lock' % self.name)

 threads = [MyThread(mutex_1, mutex_2), MyThread(mutex_2, mutex_1)]

 #threads = [MyThread(reentrant_1, reentrant_2), MyThread(reentrant_2, reentrant_1)]

 for t in threads:

     t.start()

 for t in threads:

     t.join()

Thread-1 got its first lock

Thread-1 make COUNT plus one, now COUNT is 1

Thread-1 trying to get another one...

Thread-2 got its first lock

Thread-2 make COUNT plus one, now COUNT is 2

Thread-2 trying to get another one...  

 import atexit

 from random import randrange

 import threading

 from threading import Thread, Lock

 from time import ctime, sleep

 class CleanOutputSet(set):

     def __str__(self):

         return ', '.join(x for x in self)

 # Use generator is much better than list

 # loops = (randrange(1, 7) for x in range(2, 8))

 loops = list(randrange(1, 7) for x in range(2, 8))

 remaining = CleanOutputSet()

 lock = Lock()

 def loop(nsec):

     myname = threading.current_thread().name

     with lock:

         remaining.add(myname)

         print('[{0}] Start {1}'.format(ctime(), myname))

     # loops is generator, after 'for' iteration, remains []

     if len(remaining) == len(loops):

         func_for_trial()

     sleep(nsec)

     with lock:

         remaining.remove(myname)

         print('[{0}] Completed {1} ({2} secs)'.format(ctime(), myname, nsec))

         print('    (remaining: {0})'.format(remaining or 'NONE'))

 def func_for_trial():

     count = threading.active_count()

     active_thread = threading.enumerate()

     print('There are %d active threads, \n%s' % (count, str(active_thread).replace(', ', '\n')))

 def _main():

     threads = []

     for pause in loops:

         threads.append(Thread(target=loop, args=(pause, )))

     for t in threads:

         t.start()

     for t in threads:

         t.join()

 @atexit.register

 def _atexit():

     print('All DONE at:', ctime())

 if __name__ == '__main__':

     _main()

 from atexit import register

 from random import randrange

 from threading import Semaphore, BoundedSemaphore, Lock, Thread

 from time import sleep, ctime

 import threading

 """

 # This Obj reload the __len__ method to return current number of semaphore

 class MySemaphore(BoundedSemaphore):

     def __len__(self):

         return self._value

 candy = MySemaphore(5)

 print(len(candy))

 """

 lock = Lock()

 MAX = 5

 def refill():

     lock.acquire()

     print('Refilling candy...')

     try:

         candyTray.release()

     except ValueError:

         print('Full, skipping')

     else:

         print('OK, current candy num is %d' % candyTray._value)

     lock.release()

 def buy():

     lock.acquire()

     print('Buying candy...')

     if candyTray.acquire(False):

         print('OK, current candy num is %d' % candyTray._value)

     else:

         print('Empty, skipping')

     lock.release()

 def producer(loops):

     for i in range(loops):

         refill()

         sleep(randrange(3))

 def consumer(loops):

     for i in range(loops):

         buy()

         sleep(randrange(3))

 def _main():

     print('Starting at', ctime())

     nloops = randrange(2, 6)

     print('THE CANDY MACHINE (full with %d bars)!' % MAX)

     # Buyer Thread

     buyer = Thread(target=consumer, args=(randrange(nloops, nloops+MAX+2), ))

     buyer.start()

     # Vendor Thread

     vendor = Thread(target=producer, args=(nloops, ))

     vendor.start()

     for t in [buyer, vendor]:

         t.join()

 @register

 def _atexit():

     print('All DONE at:', ctime())

 if __name__ == '__main__':

     print('-------BoundedSemaphore-------')

     candyTray = BoundedSemaphore(MAX)

     _main()

     print('-------Semaphore------')

     candyTray = Semaphore(MAX)

     _main()