# -*- coding: utf-8 -*-
import threading
import time
#方式二是方式一的具體，方式一為類構造，方式二為方法實例構造，其實本質都是一樣，都是調用threading.Thread模塊
#方式一
count = 0
class Counter(threading.Thread):
  def __init__(self, lock, threadName):
    #注意：一定要顯式的調用父類的初始化函數,這里可以指定生成的線程名，可以是*args、**kwargs
    #def __init__(self, group=None, target=None, name=None, args=(), kwargs={})，其中group是預留的，將來用于擴展
    super(Counter, self).__init__(name=threadName)
    self.lock = lock
  def run(self):
    global count
    self.lock.acquire()
    for i in range(100):
      count = count + 1
    self.lock.release()
#方式二
lockA = threading.Lock()
lockB = threading.Lock()
rLock = threading.RLock()
condt = threading.Condition()
event = threading.Event()
def add(lockA):
  global count
  #定義當前資源只能單線程訪問，鎖住后完成資源調用一定要釋放鎖，不然會造成死鎖狀態(tài)，甚至程序崩潰
  lockA.acquire()
  for i in range(1000):
    count = count + 1
  #資源調用完畢，釋放鎖
  lockA.release()
def addRunner():
  for i in range(2):
    th = threading.Thread(target=rloc, args=(rLock,))
    #開啟線程，從此刻起，多線程開始，主線程繼續(xù)前行
    th.start()
    #調用Thread.join[timeout]將會使主調線程堵塞，直到被調用線程運行結束或超時。參數timeout是一個數值類型，表示超時時間
    th.join()
    print '----- %s is start -----' % th.getName()
    print "over"
#RLock允許在同一線程中被多次acquire，避免單線程出現(xiàn)思索情況
def rloc(rLock):
  rLock.acquire()
  for i in range(2):
    rLock.acquire()
    print i,
    rLock.release()
  rLock.release()
  print "over!"
def rlocRun():
  for i in range(2):
    th = threading.Thread(target=rloc, args=(rLock,))
    th.start()
    print '----- %s is start -----' % th.getName()
    print "over"
#現(xiàn)在出現(xiàn)復雜的場景，多個線程需要調用多個共同的資源，此時就需要threading.Condition出馬,加入簡單的說就是A搞完了A的事
# ，就發(fā)廣播說明自己搞定了,其它人可以進來了，B同理。
def cond(cond):
  #適合那種主動休眠，被動喚醒的場景
  cond.acquire()
  global count
  for i in range(1000):
    count = count + 1
  #喚醒一個掛起的線程（如果存在掛起的線程）,提醒當前的掛起的線程看看其它的鎖開了沒有，如果開了就搞其他的事。
  #注意：notify()方法不會釋放所占用的瑣。
  cond.notify()
  #wait方法釋放內部所占用的瑣，同時線程被掛起，直至接收到通知被喚醒或超時
  cond.wait(5)
  #相信大家應該看出問題來了，最后一個線程咋辦列，沒人喚醒啊，這個時候應該做過一個判斷
  cond.release()
  print "over!"
def condRun():
  global condt
  for i in range(0, 3):
    th = threading.Thread(target=cond, args=(condt, ))
    th.start()
    print '----- %s is start -----' % th.getName()
  print "over"
#此時可能會有一點問題，就是線程的同步（并發(fā)）問題怎么解決呢？此時threading.Event出馬
def even(n, event):
  while not event.isSet():
    print 'Thread %s is ready' % n
  time.sleep(1)
  #同condition一樣，掛起該線程，等待set開關
  event.wait()
  while event.isSet():
    print 'Thread %s is running' % n
    time.sleep(1)
def evenRun():
  for i in range(0, 2):
    th = threading.Thread(target=even, args=(i, event))
    th.start()
  time.sleep(3)
  print '----- event is set -----'
  event.set()
  time.sleep(3)
  print '----- event is clear -----'
  event.clear()
if __name__ == "__main__":
  Counter(lockA, "thread1").start()
  addRunner()
  rlocRun()
  condRun()
  evenRun()