python学习笔记4

Semaphore(信号量)

信号量是多把锁，同时允许多个线程来更改数据，而互斥锁同时只允许一个线程更改数据。
Python信号量与互斥锁的关系
信号量的一个特殊用法是互斥量。互斥量是初始值为 1 的信号量，可以实现数据、资源的互斥访问。

Python信号量使用语法：

import threading
sem = threading.Semaphore(3)
sem.acquire()
sem.release()

Python多线程信号量使用

使用 threading.Semaphore 信号量控制多线程

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

---

条件变量

Condition被称为条件变量，除了提供与Lock类似的acquire和release方法外，还提供了wait和notify方法。线程首先acquire一个条件变量，然后判断一些条件。如果条件不满足则wait；如果条件满足，进行一些处理改变条件后，通过notify方法通知其他线程，其他处于wait状态的线程接到通知后会重新判断条件。不断的重复这一过程，从而解决复杂的同步问题。
可以认为Condition对象维护了一个锁（Lock/RLock)和一个waiting池。线程通过acquire获得Condition对象，当调用wait方法时，线程会释放Condition内部的锁并进入blocked状态，同时在waiting池中记录这个线程。当调用notify方法时，Condition对象会从waiting池中挑选一个线程，通知其调用acquire方法尝试取到锁。
除了notify方法外，Condition对象还提供了notifyAll方法，可以通知waiting池中的所有线程尝试acquire内部锁。由于上述机制，处于waiting状态的线程只能通过notify方法唤醒，所以notifyAll的作用在于防止有线程永远处于沉默状态。
演示条件变量同步的经典问题是生产者与消费者问题：假设有一群生产者(Producer)和一群消费者（Consumer）通过一个市场来交互产品。生产者的”策略“是如果市场上剩余的产品少于1000个，那么就生产100个产品放到市场上；而消费者的”策略“是如果市场上剩余产品的数量多余100个，那么就消费3个产品。用Condition解决生产者与消费者问题的代码如下：

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

---

Python之Event事件

同进程的一样,线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行。

Event几种方法:

event.isSet(): 返回event的状态值;
event.wait():  如果event.isSet()==False将阻塞线程;
event.set():   设置event的状态值为True,所有阻塞池的线程激活进入就绪状态,等待操作系统调度;
event.clear(): 恢复event的状态值为False.

举例：

from threading import Thread,Event
import time
event=Event()
def light():
    print('红灯正亮着')
    time.sleep(3)
    event.set() #绿灯亮
def car(name):
    print('车%s正在等绿灯' %name)
    event.wait() #等灯绿 此时event为False,直到event.set()将其值设置为True,才会继续运行.
    print('车%s通行' %name)
if __name__ == '__main__':
    # 红绿灯
    t1=Thread(target=light)
    t1.start()
    # 车
    for i in range(10):
        t=Thread(target=car,args=(i,))
        t.start()

---

任务示例

第一个线程中获取当前时间，判断当前时间3秒之后，触发“事件” 对象。在另一个线程中，作为数学考试结束的判断变量，否则一直处于考试中，并打印。

import threading  # 导入线程类
import time  # 导入time类
import datetime  # 导入datetime类
class eventthread(threading.Thread):  # 定义事件监听类继承于Thread类
    def __init__(self):  # 定义构造方法
        super(eventthread, self).__init__()  # 重写Thread类的构造方法
    def run(self):  # 重写Thread类的run方法
        for i in range(3):  # for语句循环3秒
            time1 = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            print(time1)  # 指定格式输出显示当前的时间
            time.sleep(1)  # 暂停1秒
        event.set()  # 设置事件响应
class mythread(threading.Thread):  # 继承于Thread类
    def __init__(self):  # 定义构造方法
        super(mythread, self).__init__()  # 重写Thread类的构造方法
    def run(self):  # 重写run方法
        while True:   # 循环判断事件是否响应
            print("考试中")   # 若事件未响应输出“考试中”的信息
            time.sleep(1)    # 暂停1秒
            if event.is_set():
                print("考试结束！")  # 若事件响应则输出“考试结束”的信息
                break  # 跳出循环
if __name__ == '__main__':  # 创建主线程
    event = threading.Event()  # 初始化对象
    et = eventthread()  # 初始化一个线程对象
    mt = mythread()  # 初始化一个线程对象
    et.start()  # 启动线程
    mt.start()  # 启动线程