Python寒假高级培训第四次笔记

1.什么是信号量

semaphore信号量的意思，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。

2.什么是条件变量

条件变量(condition variable)是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待某个条件为真，而将自己挂起；另一个线程使的条件成立，并通知等待的线程继续。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。

3.什么是事件

event，即事件，就是程序上发生的事。例如用户敲击键盘上的某一个键或是点击移动鼠标就是一个事件，而对于这些事件，程序需要做出反应。

4.信号量的使用

实现两个线程的同步。

A程序：创建信号量，初始化信号量中指定下标的值，根据信号量加锁，删除信号量

B程序：得到信号量，解锁

import threading
import time
class Mythread(threading.Thread):
    def __init__(self, num):
        super(Mythread,self).__init__()
        self.num = num

    def run(self):
        if semaphore.acquire():#加锁
            print("线程"+self.num)
            time.sleep(1) #延迟一秒
            semaphore.release()#释放信号量



if __name__ == "__main__":  #主线程
    semaphore = threading.Semaphore(3)#实例化信号量
    all_thread = []
    for i in range(100):
       all_thread.append(Mythread(str(i)))
    for j in all_thread:
        j.start()

5.如何使用条件变量

Condition被称为条件变量，除了提供与Lock类似的acquire和release方法外，还提供了wait和notify方法。线程首先acquire一个条件变量，然后判断一些条件。如果条件不满足则wait；如果条件满足，进行一些处理改变条件后，通过notify方法通知其他线程，其他处于wait状态的线程接到通知后会重新判断条件。不断的重复这一过程，从而解决复杂的同步问题。

import threading
import time

class Producer(threading.Thread):
    def run(self):
        global count
        while True:
            if con.acquire():
                if count > 1000:
                    con.wait()
                else:
                    count = count+100
                    msg = self.name+' produce 100, count=' + str(count)
                    print msg
                    con.notify()
                con.release()
                time.sleep(1)

class Consumer(threading.Thread):
    def run(self):
        global count
        while True:
            if con.acquire():
                if count < 100:
                    con.wait()
                else:
                    count = count-3
                    msg = self.name+' consume 3, count='+str(count)
                    print msg
                    con.notify()
                con.release()
                time.sleep(1)

count = 500
con = threading.Condition()

def test():
    for i in range(2):
        p = Producer()
        p.start()
    for i in range(5):
        c = Consumer()
        c.start()
if __name__ == '__main__':
    test()

6.如何使用事件

Event（事件）：事件处理的机制：全局定义了一个内置标志Flag，如果Flag值为 False，那么当程序执行 event.wait方法时就会阻塞，如果Flag值为True，那么event.wait 方法时便不再阻塞。

Event其实就是一个简化版的 Condition。Event没有锁，无法使线程进入同步阻塞状态。

set(): 将标志设为True，并通知所有处于等待阻塞状态的线程恢复运行状态。

clear(): 将标志设为False。

wait(timeout): 如果标志为True将立即返回，否则阻塞线程至等待阻塞状态，等待其他线程调用set()。

isSet(): 获取内置标志状态，返回True或False。

import threading
import time
class Mythread(threading.Thread):#定义一个名字类
    def __init__(self, num):
        super(Mythread,self).__init__()
        self.num = num

    def run(self):
        if semaphore.acquire():
            print("线程"+self.num)
            time.sleep(1) #延迟一秒
            semaphore.release()#释放信号量



if __name__ == "__main__":  #主线程
    semaphore = threading.Semaphore(3)
    all_thread = []
    for i in range(100):
       all_thread.append(Mythread(str(i)))
    for j in all_thread:
        j.start()



class car(threading.Thread):#定义一个名字类
    def __init__(self, name):
        super(car,self).__init__()
        self.name = name

    def run(self):
        while True:
            if event.is_set():
                print(self.name+"启动")
            else:
                print("car停止")


class set_event(threading.Thread):
    def __init__(self):
        super(set_event, self).__init__()
    def run(self):
        event.set()
        time.sleep(1)
        event.clear()
        time.sleep(1)

if __name__ == "__main__":
    event = threading.Event()
    car_ = car("红旗")
    set_event_ = set_event()

    car_.start()
    set_event_.start()