【Python】多线程-3

#练习：线程等待 Event e.set() e.wait()

 

from threading import Thread, Lock

import threading

import time

 

def wait_for_event(e):

    #Wait for the event to be set before doing anything

    print 'wait_for_event: starting'

    e.wait() # 等待收到能执行信号，如果一直未收到将一直阻塞

    print 'wait_for_event: e.is_set()->', e.is_set()

 

def wait_for_event_timeout(e, t):

    #Wait t seconds and then timeout

    print 'wait_for_event_timeout: starting'

    e.wait(t)# 等待t秒超时,此时Event的状态仍未未设置

    print 'wait_for_event_timeout: e.is_set()->', e.is_set()

    e.set()# 设置Event的状态

 

if __name__ == '__main__':

    e = threading.Event()

    print "begin, e.is_set()", e.is_set()

    w1 = Thread(name = 'block', target = wait_for_event, args = (e,))

    w1.start()

 

    w2 = Thread(name = 'nonblock', target = wait_for_event_timeout, args = (e, 2))

    w2.start()

    print 'main: waiting before calling Event.set()'

    time.sleep(3)

    # e.set()

    print 'main: event is set'

 

 

#练习：condition 等待notify_all() notify()

import threading as tr

import time

def consumer(cond):

    with cond:

        print("consumer before wait")

        cond.wait() # 等待消费

        print("consumer after wait")

 

def producer(cond):

    with cond:

        print("producer before notifyAll")

        cond.notify_all() # 通知消费者可以消费了

        print("producer after notifyAll")

 

if __name__ == '__main__':   

    condition = tr.Condition()

 

    t1 = tr.Thread(name = "thread-1", target = consumer, args=(condition,))

    t2 = tr.Thread(name = "thread-2", target = consumer, args=(condition,))

    t3 = tr.Thread(name = "thread-3", target = producer, args=(condition,))

 

    t1.start()

    time.sleep(2)

    t2.start()

    time.sleep(2)

    t3.start()

 

 

 

#练习：线程队列 队列是一种数据结构

from threading import Thread

from Queue import Queue  

import random, time

 

# 储钱罐

def create(queue):  

    for i in [100, 50, 20, 10, 5, 1, 0.5]:

      if not queue.full():

        queue.put(i)  # 入队列

        print 'Put %sRMB to queue.' %i

        time.sleep(1)

 

# 取储钱罐中的零钱花

def get(queue):

  while 1:

    if not queue.empty():

      print 'Get %sRMB from queue.' %queue.get()

      time.sleep(2)

    else:

      break 

 

if __name__=="__main__":

    q = Queue() # 创建一个队列实例

    create_t = Thread(target = create, args = (q,))  

    get_t = Thread(target = get, args = (q,))  

    create_t.start() 

    #time.sleep(1) #这里稳妥起见，最好是sleep1秒

    get_t.start()

    create_t.join()

    get_t.join()

 

 

#练习：死锁 互相等，结果谁也等不到谁

 

import threading  

import time

 

#声明全局锁 不用global直接用

lock1 = threading.Lock()  

lock2 = threading.Lock()  

print lock1, lock2

class T1(threading.Thread):  

    def __init__(self, name):  

        threading.Thread.__init__(self)  

        self.t_name = name  

 

    def run(self):  

        lock1.acquire()  

        time.sleep(1)#睡眠的目的是让线程2获得调度，得到第二把锁

        print 'in thread T1',self.t_name

        time.sleep(2) 

        lock2.acquire() #线程1请求第二把锁

        print 'in lock l2 of T1'  

        lock2.release()      

        lock1.release() 

 

class T2(threading.Thread):  

    def __init__(self, name):  

        threading.Thread.__init__(self)  

        self.t_name = name  

 

    def run(self):  

        lock2.acquire()  

        time.sleep(2)#睡眠的目的是让线程1获得调度，得到第一把锁

        print 'in thread T2',self.t_name

        lock1.acquire() #线程2请求第一把锁

        print 'in lock l1 of T2'

        lock1.release() 

        lock2.release() 

 

def test():  

    thread1 = T1('A')  

    thread2 = T2('B')  

    thread1.start()  

    thread2.start()  

 

if __name__== '__main__':  

    test()