python-线程四（共享与通信）

资源共享：在同一个进程里的线程间，资源是共享的。

　　1）队列共享（只要普通的队列就可以共享）

from threading import Thread
from queue import Queue 
import 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


q = Queue(5)  # 创建一个队列实例
create_t = Thread(target=create, args=(q,))
get_t = Thread(target=get, args=(q,))
create_t.start()
get_t.start()
create_t.join()
get_t.join()

信号传递：在收到信号之前处于阻塞状态

　　1）Event

from threading import Thread, Lock
import threading
import time


def wait_for_event(e):
    print('wait_for_event: starting')
    e.wait()  # 等待收到能执行信号，如果一直未收到将一直阻塞
    print('wait_for_event: e.is_set()->', e.is_set())
    
    
def wait_for_event_timeout(e, t):

    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')

　　2) Condition

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="tjread-3", target=producer, args=(condition,))
    t1.start()
    time.sleep(2)
    t2.start()
    time.sleep(2)
    t3.start()