python 08

线程通信强化（Event）

方法：
set()
set（）方法将之设置为True。所有等待它成为True的线程都被唤醒。当其为True 时，线程调用wait()是不会阻塞的。

clear()
clear（）方法将之设置为False。随后，调用wait()的线程将阻塞，直到另一个线程调用set()将内部标志重新设置为True。

wait(timeout=None)
阻塞直到内部标志为真。如果内部标志在wait()方法调用时为True，则立即返回。否则，则阻塞，直到另一个线程调用set()将标志设置为True，或发生超时。该方法总是返回True，除非设置了timeout并发生超时。

import threading
import time

def goevent():
    e = threading.Event()  # 事件

    def go():
        for i in range(10):
            e.wait()  # 等待事件，线程卡顿，等待set消息，只调用一次
            e.clear() # 重置线程等待
            print("go",i)

    threading.Thread(target=go).start() # 创建一个线程
    return e


t = goevent()
for i in range(5):
    time.sleep(i)
    t.set()

线程调度
使线程按一定的顺序执行

import threading
import time

def go1():
    with cond:
        for i in range(0, 10, 2):
            time.sleep(1)
            print(threading.current_thread().name, i)
            cond.wait()
            # print("hahah")
            cond.notify()


def go2():
    with cond:
        for i in range(1, 10, 2):
            time.sleep(1)
            print(threading.current_thread().name, i)
            cond.notify()
            cond.wait()


cond = threading.Condition()  # 线程条件变量
threading.Thread(target=go1).start()
threading.Thread(target=go2).start()
'''
逻辑：
首先明确wait（）调用后下面的程序是不会运行的，
首先线程1线绑定cond，打印出0后，线程1进入等待（注意此时线程2并没有绑定），线程2绑定cond，打印出1后
notify给线程1唤醒wait（），（此时才打印出"haha"），同时线程2的wait激活进入等待，同时1打印出2，并唤醒线程2如此循环

'''

生产消费模式
生产者指的是生产数据的任务，消费者指的是处理数据的任务，在并发编程中，生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。

同样，消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

# # 在队列中，有多个生产者将商品放入队列，同时又多个消费者在队列的另一头获取商品，一般
# # 情况下会产生线程冲突，但是python已经将此处理好了，也就是说在将商品放入队列的过程中无需考虑线程冲突
# import threading
# import queue
# import time
# import random
#
#
# # 生产
# class CreatorThread(threading.Thread):
#     def __init__(self, index, myqueue):
#         threading.Thread.__init__(self)
#         self.index = index  # 索引
#         self.myqueue = myqueue  # 队列
#
#     def run(self):
#         while True:
#             time.sleep(3)
#             num = random.randint(1, 1000000)
#             self.myqueue.put("in put 生产者" + str(self.index) + str(num))
#             print("in put 生产者", str(self.index), str(num))
#         # self.myqueue.task_done() # 完成任务
#
#
# # 消费
# class BuyerThread(threading.Thread):
#     def __init__(self, index, myqueue):
#         threading.Thread.__init__(self)
#         self.index = index  # 索引
#         self.myqueue = myqueue  # 队列
#
#     def run(self):
#         while True:
#             time.sleep(1)
#             item = self.myqueue.get()  # 获取数据,拿不到一直等待
#             if item is not None:
#                 print("消费者:" , item,'\n')
#
#
# myqueue = queue.Queue(10)  # 0代表无限，内存有多大装多大，
# for i in range(3):  # 3个生产者同时放入
#     CreatorThread(i, myqueue).start()  # 创建生产者
#
# for j in range(8):# 8个消费者同时获取，最多只能获取到生产者生产的
#     BuyerThread(j, myqueue).start()  # 创建消费者
import threading
import time
import queue

q = queue.Queue(maxsize=10)


def producer(name):  # 生产者
    count = 1
    while True:
        q.put("骨头%s" % count)
        print("生产了骨头", count)
        count += 1
        time.sleep(0.5)


def consumer(name):  # 消费者
    while True:
        print("[%s]取到[%s]并且吃了它..." % (name, q.get()))
        time.sleep(1)


p = threading.Thread(target=producer, args=("Tim",))
c1 = threading.Thread(target=consumer, args=("King",))
c2 = threading.Thread(target=consumer, args=("Wang2",))
c3 = threading.Thread(target=consumer, args=("Wang3",))
c4 = threading.Thread(target=consumer, args=("Wang4",))
c5 = threading.Thread(target=consumer, args=("Wang5",))

p.start()
c1.start()
c2.start()
c3.start()
c4.start()
c5.start()

定时线程
在指定时间运行

import time
import threading
import os

'''
def show():
    os.system("say hello")

mythreading = threading.Timer(3, show).start()  # 延时3秒启动show函数，只启动一次
num = 0
while True:
    print('第', num, "秒")
    time.sleep(1)
    num += 1
        
'''
def show():
    while True:
        time.sleep(3)
        print("say hello")


mythreading = threading.Timer(3, show).start()  # 延时3秒启动show函数，只启动一次，不阻塞主线程
num = 0
while True:
    print('第', num, "秒")
    time.sleep(1)
    num += 1

#mythreading.cancel() # 因为cancel取消了线程的执行，所以fun()函数不会被执行