#并发的多线程效果演示#继承式多线程#守护线程 #互斥锁(用户自己的锁)

  

#并发的多线程效果演示
'''
import threading

def run(n):
    print ('task',n)

t1 =threading.Thread(target=run,args=('t1',))
t2 =threading.Thread(target=run,args=('t2',))

t1.start()
t2.start()
'''

'''
import threading

def run(n):
    print ('task',n)

run('t1')

run('t2')
'''

'''
import threading
import time
def run(n):
    print ('task',n)
    time.sleep(2)

t1 =threading.Thread(target=run,args=('t1',))

t2 =threading.Thread(target=run,args=('t2',))

run('t1')

run('t2')

'''


import threading
import time
def run(n):
    print ('task',n)
    time.sleep(2)

t1 =threading.Thread(target=run,args=('t1',))

t2 =threading.Thread(target=run,args=('t2',))

t1.start()

t2.start()

#继承式多线程
'''
import threading
import time

class MYThread(threading.Thread):
    def __init__(self,n):
        super(MYThread,self).__init__()
        self.n = n
    def run(self):
        print ('runnint task',self.n)

t1 =MYThread('t1')
t2 =MYThread('t2')

t1.start()
t2.start()
'''

'''
import threading
import time

def run(n):
    print ('task',n)
    time.sleep(2)

t1 = threading.Thread(target=run,args=('t1',))
t2 = threading.Thread(target=run,args=('t2',))

t1.start()
t2.start()

'''

'''
import threading
import time

def run(n):
    print ('task',n)
    time.sleep(2)

for i in range(50): 

    t = threading.Thread(target=run,args=('t-%s'% i ,))
    t.start()
 
'''

'''
import threading
import time
#并行所以无法统计总共的时间
def run(n):
    print ('task',n)
    time.sleep(2)
    print ('task done',n)
    
start_time = time.time()
for i in range(50): 

    t = threading.Thread(target=run,args=('t-%s'% i ,))
    t.start()

print ('-------------all threads has finished...')
print ('cost:',time.time() - start_time)

'''
'''
import threading
import time
#设置等待全部子线程结束来测时间
class MYThread(threading.Thread):
    def __init__(self,n,sleep_time):
        super(MYThread,self).__init__()
        self.n = n

        self.sleep_time = sleep_time
    def run(self):
        print ('runnint task',self.n)
        time.sleep(self.sleep_time)
        print ('task done,',self.n)
        
t1 =MYThread('t1',2)
t2 =MYThread('t2',4)

t1.start()
t2.start()

t1.join()#等待
t2.join()

print ('main thread...')

'''


import threading
import time
#设置等待全部子线程结束来测时间
def run(n):
    print ('task',n)
    time.sleep(2)
    print ('task done',n)
  
start_time = time.time()
t_objs = [] #储存线程实例
for i in range(50): 
    t = threading.Thread(target=run,args=('t-%s'% i ,))
    t.start()
    t_objs.append(t)

for t in t_objs:
    t.join()


print ('-------------all threads has finished...')
print ('cost:',time.time() - start_time)

   

#守护线程

#主线程不在等待守护线程结束 就关闭程序

import threading
import time
#设置等待全部子线程结束来测时间
def run(n):
    print ('task',n)
    time.sleep(2)
    print ('task done',n,threading.current_thread())
  
start_time = time.time()

#t_objs = [] #储存线程实例

for i in range(50): 
    t = threading.Thread(target=run,args=('t-%s'% i ,))
    t.setDaemon(True)#把当前先程设置为守护线程
    t.start()
    
    #t_objs.append(t)
#for t in t_objs:
#    t.join()


print ('---all threads has finished...')
print (threading.current_thread(),'当前线程数：',threading.active_count())
print ('cost:',time.time() - start_time)

#互斥锁(用户自己的锁)
#pyton 2.0不加锁上会出错 #pyton 3.0默认加锁，不会出错

import threading
import time

def run(n):
    lock.acquire()
    global num
    num += 1
    #time.sleep(1) #没有释放 等于range(50)   50秒
    lock.release()
    
lock = threading.Lock()
num = 0

t_objs = [] #储存线程实例

for i in range(50): 
    t = threading.Thread(target=run,args=('t-%s'% i ,))
    t.start()
    t_objs.append(t)
    
for t in t_objs:
    t.join()


print ('---all threads has finished...')
print (threading.current_thread(),'当前线程数：',threading.active_count())
print ('num:',num)

   

#递归锁RLock（递归锁）

#说白了就是在一个大锁中还要再包含子锁


'''
locks = {
        door1:key1,
        door2:key2
         }
'''
import threading,time
 
def run1(): #平行房间门
    print("grab the first part data")
    lock.acquire()
    global num
    num += 1
    lock.release()
    return num
def run2(): #平行房间门
    print("grab the second part data")
    lock.acquire()
    global  num2
    num2 += 1
    lock.release()
    return num2
def run3():  #大门
    lock.acquire()
    res = run1()
    print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()
    print(res,res2)
'''
if __name__ == '__main__':
 
    num,num2 = 0,0
    lock = threading.RLock()
    for i in range(10):
        t = threading.Thread(target=run3)
        t.start()

'''
 
num,num2 = 0,0
lock = threading.RLock()
#lock = threading.Lock()
for i in range(10):
    t = threading.Thread(target=run3)
    t.start()

while threading.active_count() != 1:
    print(threading.active_count())
else:
    print('----all threads done---')
    print(num,num2)

#Semaphore(信号量)
'''
互斥锁 同时只允许一个线程更改数据，
而Semaphore是同时允许一定数量的线程更改数据 ，
比如厕所有3个坑，那最多只允许3个人上厕所，
后面的人只能等里面有人出来了才能再进去。
'''

import threading,time
 
def run(n):
    semaphore.acquire()
    time.sleep(1)
    print("run the thread: %s
" %n)
    semaphore.release()
 
if __name__ == '__main__':
 
    #num = 0
    semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行
    for i in range(22):
        t = threading.Thread(target=run,args=(i,))
        t.start()
        
 
while threading.active_count() != 1:
    pass #print threading.active_count()
else:
    print('----all threads done---')
    #print(num)

#Events  事件  全局变量

#通过Event来实现两个或多个线程间的交互，下面是一个红绿灯的例子，
#即起动一个线程做交通指挥灯，生成几个线程做车辆，车辆行驶按红灯停，绿灯行的规则。
'''

redLight = False
while True:
    if counter > 30:
        redLight = True

    if counter > 50:
        redLight = False
        counter = 0

'''
'''
#红绿灯
import threading,time

event = threading.Event()

def lighter():
    count = 0
    
    while True:
        if count > 5 and count < 10 :#改成红灯
            event.clear()#把标志位置清空
            print('1mred light is on--红灯红灯红灯-')
        elif count >10 :   
            event.set()#改成绿灯
            count =0
        else:
            print('1mgeen light is on--绿灯绿灯绿灯-')    
        time.sleep(1)
        count += 1

light = threading.Thread(target=lighter,)

light.start()

'''



#红绿灯#车
import threading,time

event = threading.Event()

def lighter():
    count = 0
    event.set() #先设置成绿灯
    while True:
        if count > 5 and count < 10 :#改成红灯
            event.clear()#把标志位置清空
            print('1mred light is on--红灯红灯红灯-')
        elif count >10 :   
            event.set()#改成绿灯
            count =0
        else:
            print('1mgeen light is on--绿灯绿灯绿灯-')    
        time.sleep(1)
        count += 1


def car(name):
    while True:
        if event.is_set():#代表绿灯
            print ('[%s] running...'%name)
            time.sleep(1)
        else:
            print ('[%s] 看到红灯,等待……')
            event.wait()
            print ('[%s] 绿灯,开始……开车咯' % name)
                    
    
light = threading.Thread(target=lighter,)
light.start()

car1 = threading.Thread(target=car,args=('Tesla',))
car1.start()







'''
import threading,time
import random
def light():
    if not event.isSet():
        event.set() #wait就不阻塞 #绿灯状态
    count = 0
    while True:
        if count < 10:
            print('33[42;1m--green light on---33[0m')
        elif count <13:
            print('33[43;1m--yellow light on---33[0m')
        elif count <20:
            if event.isSet():
                event.clear()
            print('33[41;1m--red light on---33[0m')
        else:
            count = 0
            event.set() #打开绿灯
        time.sleep(1)
        count +=1
def car(n):
    while 1:
        time.sleep(random.randrange(10))
        if  event.isSet(): #绿灯
            print("car [%s] is running.." % n)
        else:
            print("car [%s] is waiting for the red light.." %n)
if __name__ == '__main__':
    event = threading.Event()
    Light = threading.Thread(target=light)
    Light.start()
    for i in range(3):
        t = threading.Thread(target=car,args=(i,))
        t.start()




#这里还有一个event使用的例子，员工进公司门要刷卡， 我们这里设置一个线程是“门”，
        #再设置几个线程为“员工”，员工看到门没打开，就刷卡，刷完卡，
        #门开了，员工就可以通过。


#_*_coding:utf-8_*_
__author__ = 'Alex Li'
import threading
import time
import random

def door():
    door_open_time_counter = 0
    while True:
        if door_swiping_event.is_set():
            print("33[32;1mdoor opening....33[0m")
            door_open_time_counter +=1

        else:
            print("33[31;1mdoor closed...., swipe to open.33[0m")
            door_open_time_counter = 0 #清空计时器
            door_swiping_event.wait()


        if door_open_time_counter > 3:#门开了已经3s了,该关了
            door_swiping_event.clear()

        time.sleep(0.5)


def staff(n):

    print("staff [%s] is comming..." % n )
    while True:
        if door_swiping_event.is_set():
            print("33[34;1mdoor is opened, passing.....33[0m")
            break
        else:
            print("staff [%s] sees door got closed, swipping the card....." % n)
            print(door_swiping_event.set())
            door_swiping_event.set()
            print("after set ",door_swiping_event.set())
        time.sleep(0.5)
door_swiping_event  = threading.Event() #设置事件


door_thread = threading.Thread(target=door)
door_thread.start()



for i in range(5):
    p = threading.Thread(target=staff,args=(i,))
    time.sleep(random.randrange(3))
    p.start()




        
'''