# -*- 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
  #定义当前资源只能单线程访问，锁住后完成资源调用一定要释放锁，不然会造成死锁状态，甚至程序崩溃
  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,))
    #开启线程，从此刻起，多线程开始，主线程继续前行
    th.start()
    #调用Thread.join[timeout]将会使主调线程堵塞，直到被调用线程运行结束或超时。参数timeout是一个数值类型，表示超时时间
    th.join()
    print '----- %s is start -----' % th.getName()
    print "over"
#RLock允许在同一线程中被多次acquire，避免单线程出现思索情况
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"
#现在出现复杂的场景，多个线程需要调用多个共同的资源，此时就需要threading.Condition出马,加入简单的说就是A搞完了A的事
# ，就发广播说明自己搞定了,其它人可以进来了，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"
#此时可能会有一点问题，就是线程的同步（并发）问题怎么解决呢？此时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()