Thread对象 的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有acquire方法和release方法

ps:对于那些需要每次只允许一个线程操作的数据，可以将其操作放到acquire和release方法之间。

• 对于Lock对象而言，如果一个线程连续两次进行acquire操作，那么第一次acquire之后没有release，第二次acquire将挂起线程。这会导致Lock对象永远不会release，使得死锁
•  RLock (递归锁) 对象允许一个线程多次进行acquire操作，因为内部通过counter变量维护着线程acquire的次数。简单来说就是锁多小次解多少次

#!coding:utf-8
import threading, time, random

# lock = threading.Lock() #Lock对象
# lock.acquire()
# lock.acquire()  #产生了死琐。
# lock.release()
# lock.release()
#
# ------------------------------------------
# rLock = threading.RLock()  #RLock对象
# rLock.acquire()
# rLock.acquire() #在同一线程内，程序不会堵塞。
# rLock.release()
# rLock.release()


mylock = threading.RLock()
num = 0

class myThread(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self,name=name)

    def run(self):
        global num
        while True:
            mylock.acquire()
            print("%s locked, Number: %d " % (threading.current_thread().name, num))

            if num >= 4:
                mylock.release()
                print("%s released, Number: %d " % (threading.current_thread().name, num))
                break

            print('%s released, Number: %d ' % (threading.current_thread().name, num))
            num += 1

            # print('%s released, Number: %d ' % (threading.current_thread().name, num))
            mylock.release()
            time.sleep(random.random())

if __name__ == '__main__':
    thread1 = myThread('Thread_1')
    thread2 = myThread('Thread_2')

    thread1.start()
    thread2.start()

    thread1.join()
    thread2.join()