Python攻克之路-信号量

1.信号量(锁)

信号量用来控制线程并发数的,BoundedSemaphore或Semaphore管理一个内置的计数器,每当调用acquire()时-1,调用release()时+1.
计数器不能小于0，当计数器为0时，acquire()将阻塞线程至同步锁定状态，直到其他线程调用release().
BoundedSemaphore和Semaphore的唯一区别在于前者将在调用release()时检查计数器的值是否超过了计数器的初始值,如果超过了将抛出一个异常
作用：数据库连接限制

问题：是否一起进入,一起出？
分析：并不是,内部的计数器可以控制,如果有一个线程完成任务,释放了锁,其他线程就可以进入

[root@node2 semaphore]# cat semaphore.py
#!/usr/local/python3/bin/python3
import threading,time
class MyThread(threading.Thread):
    def run(self):
        if semaphore.acquire():
            print(self.name)
            time.sleep(3)
            semaphore.release()

if __name__=="__main__":
    semaphore=threading.BoundedSemaphore(5)  #创建信号量,5是控制线程数
    thrs=[]
    for i in range(100):
        thrs.append(MyThread()) #同时启动100个线程执行run方法
    for t in thrs:
        t.start()
[root@node2 semaphore]# python3 semaphore.py
Thread-1      #每5个出现一次
...
Thread-100

将for i in range(23)
[root@node2 semaphore]# python3 semaphore.py
Thread-1
....
Thread-20
Thread-21
Thread-22
Thread-23      最后只出3个

　　

2.条件变量同步(锁)

描述：线程之间是可以通信的,某个线程走到一定时候,等待另一个线程的通知后,才继续向下走有一类线程需要满足条件之后才能够继续执行,Python提供了threading.Condition对象条件变量线程的支持,它除了能提供RLock()或Lock()的方法外,还供了wait()、notify()、notifyAll()方法.lock_con=threading.Condition([Lock/Rlock]): 锁是可选选项,不传人锁,对象自动创建一个RLock().
- wait(): 条件不满足时调用,线程会释放锁并进入等待阻塞
- notify(): 条件创造后调用,通知等待池激活一个线程
- notifyAll(): 条件创造后调用,通知等待池激活所有线程

场景：生产者是做包子的人,消费者是吃包子的人,需要生产者与消费者一起行动,得有包子,吃的人才可以吃
分析：生产者和消费者开始行动时,可能两个都有机会取得锁,如果消费者先得到锁,它会先wait,释放锁,让生产者先开始,生产者完成后通知消费者,消费者再次申请锁再开始吃包子,

[root@node2 threading]# cat condition.py
#!/usr/local/python3/bin/python3
import threading,time
from random import randint
class Producer(threading.Thread):
    def run(self):
        global L
        while True:
            val=randint(0,100)           #随机生成数,相当于创建一个包子
            print('Producer',self.name,":Append"+str(val),L)
            if lock_con.acquire():       #请求一把锁
                L.append(val)            #向L中放包子
                lock_con.notify()        #通知消费者可以开始吃包子,相当于满足上一行代码的条件,可以激活消费者的锁
                lock_con.release()
            time.sleep(3)
class Consumer(threading.Thread):
    def run(self):
        global L                          #类似于承包子的东西
        while True:
                lock_con.acquire()        #有可能consumer先获取锁,但是消费者只是吃包子,只能等待包子先做出来
                if len(L)==0:
                    lock_con.wait()       #wait先释放锁,然后一直阻塞,直到有人通知才向下走,但是程序不会从阻塞这里开始走,从lock_con.acquire()开始
                print('consumer',self.name,":Delete"+str(L[0]),L)
                del L[0]
                lock_con.release()
                time.sleep(0.25)

if __name__=="__main__":
    L=[]                                  #空列表
    lock_con=threading.Condition()
    threads=[]
    for i in range(5):                    #启动5个线程来执行生产者的方法,相当于有5个人做包子
        threads.append(Producer())
    threads.append(Consumer())            #消费者对象
    for t in threads:                     #开启了6个线程对象
        t.start()
    for t in threads:
        t.join()

[root@node2 threading]# python3 condition.py 
Producer Thread-1 :Append7 []
Producer Thread-2 :Append85 [7]
Producer Thread-3 :Append33 [7, 85]
Producer Thread-4 :Append1 [7, 85, 33]
Producer Thread-5 :Append2 [7, 85, 33, 1]
consumer Thread-6 :Delete7 [7, 85, 33, 1, 2]
consumer Thread-6 :Delete85 [85, 33, 1, 2]
consumer Thread-6 :Delete33 [33, 1, 2]
consumer Thread-6 :Delete1 [1, 2]
consumer Thread-6 :Delete2 [2]

　　

3.同步条件event
描述：类似于条件,但是它不需要使用锁，内部有一个标志位,如果调用event.wait(),如果判断为False，就会把线程阻塞住，True就继续向下走，通过event.set函数来修改标志位为True，event.clear()修改标志位为False，使用isSet()返回是True还是False
条件同步和条件变量同步差不多，只是少了锁功能，因为条件同步设计于不访问共享资源的条件环境。event=threading.Event():条件环境对象,初始值为False:
- event.isSet(): 返回event的状态值
- event.wait(): 如果event.isSet()==False将阻塞线程
- event.set(): 设置event的状态值为True,所有阻塞池的线程激活进入就绪状态,等待操作系统调度
- event.clear(): 恢复event的状态值为False

场景：老板说晚上加班,工作说累,但是工人要在老板后面反应

[root@node2 threading]# cat ot.py 
#!/usr/local/python3/bin/python3
import threading,time
class Boss(threading.Thread):
    def run(self):
        print("Boss: we gonna ot tonight util 22:00.")  #打印加班
        event.isSet() or event.set()         #event.isSet返回状态值时还是Fasle,event.set()设置为True,这时worker也会相应执行
        time.sleep(5)                        #此时标志位为True
        print("Boss: <22:00>knock off.")
        event.isSet() or event.set()

class Worker(threading.Thread):
    def run(self):
        event.wait()                #默认是false,如果worker先得到资源,要wait,因为这是老板要说的话,老板说了后，才说累
        print("Worker: tired!")
        time.sleep(0.25)
        event.clear()               #相当于工作一段时间后，再把标志位设置为false，当boss去取时为False
        event.wait()
        print("Worker: oh...")

if __name__=="__main__":
    event=threading.Event()   #event取得事件
    threads=[]
    for i in range(5):        #启动5个worker,一个boss
        threads.append(Worker())
    threads.append(Boss())
    for t in threads:
        t.start()
    for t in threads:
        t.join()

[root@node2 threading]# python3 ot.py
Boss: we gonna ot tonight util 22:00.
Worker: tired!
Worker: tired!
Worker: tired!
Worker: tired!

Worker: tired!
Boss: <22:00>knock off.
Worker: oh...
Worker: oh...
Worker: oh...
Worker: oh...
Worker: oh...

　　

4.队列queue***(数据结构)
quue is especially userful in threaded programming when information must be exchaged safely between multiple threads

(1)、queue定义了3种信息列队模式类
Queus([maxsize]): FIFO列队模式(first in first out)，[maxsize]定义列队容量,缺省为0，即无穷大
LifoQueue([maxsize]): LIFO列队模式(last in first out),类似于放糖到瓶子,先放入的只能后出，因为最后放的比较接近瓶盖
PriorityQueue([maxsize]): 优先级列队模式，使用此列队时，项目应该是(priority,data)的形式

(2)、queue队列类的方法
q.put(item[,block,[timeout]]): 将item放入队列,如果block设置为True(默认)时,列队满了，调用者将被阻塞,否则抛出Full异常,timeout设置阻塞超时
q.get([block,[timeout]]): 从列队中取出一个项目
q.qsize()：返回列队的大小
q.full(): 如果列队满了返回True,否则为False
q.empty(): 如果列队为空返回True,否则为False

(3)、创建一个队列

[root@node2 threading]# cat q.py
#!/usr/local/python3/bin/python3
import queue
d=queue.Queue()       #队列对象
d.put('reid')         #插入数据
d.put('betty')
d.put('linux')

print(d.get())        #取数据
print(d.get())
print(d.get())
[root@node2 threading]# python3 q.py  #先进先出
reid
betty
linux

报错：
[root@node2 threading]# python3 queue.py   脚本名与模块冲突
Traceback (most recent call last):
  File "queue.py", line 2, in <module>
    import queue
  File "/root/py/threading/queue.py", line 3, in <module>
    d=queue.Queue()
AttributeError: module 'queue' has no attribute 'Queue'
[root@node2 threading]# mv queue.py q.py   修改脚本名称

(4)、控制队列的量(队列满的情况)

[root@node2 threading]# cat q.py
#!/usr/local/python3/bin/python3
import queue
d=queue.Queue(2)   #2是插入数据的量,如果插入的数量比这个大会造成阻塞，0代表是无限大
d.put('reid')
d.put('betty')
d.put('linux',0)   #加入参数返回队列情况,0通知队列满了，1默认阻塞

print(d.get())
print(d.get())
print(d.get())
[root@node2 threading]# python3 q.py
Traceback (most recent call last):
  File "q.py", line 6, in <module>
    d.put('linux',0)
  File "/usr/local/python3/lib/python3.6/queue.py", line 130, in put
    raise Full
queue.Full         ##显示队列已经满了

(5)、取数据(取的量多于插入的量)

[root@node2 threading]# cat q.py 
#!/usr/local/python3/bin/python3
import queue
d=queue.Queue(3)
d.put('reid')
d.put('betty')
d.put('linux',0)

print(d.get())
print(d.get())
print(d.get())
print(d.get(0))      ##0，没有数据时会返回结果
[root@node2 threading]# python3 q.py
reid
betty
linux
Traceback (most recent call last):
  File "q.py", line 11, in <module>
    print(d.get(0))
  File "/usr/local/python3/lib/python3.6/queue.py", line 161, in get
    raise Empty
queue.Empty          ###等待插入数据

　　

(6)、队列的作用
a. 适用于多线程
分析：如果在单线程情况,阻塞住就没办法,直接使用列表更方便,但是一到多线程就有问题,涉及线程安全,列表的数据,那个线程都可以取,如列表中有1，2，3，4个数,两个线程同时取4这个数,都可以同时取得,这时就无法控制
但是在队列中使用时,多线程去取数不会造成同时取得一个数,因为队列中本身就有一把锁,在数据结构上加了一把锁,因为以后会经常的操作数据,还要不断的加锁
使用列表时,线程不安全

[root@node2 threading]# cat thread-list.py   #模拟队列,先取,再删除
#!/usr/local/python3/bin/python3
import threading,time
li=[1,2,3,4,5]

def pri():
    while li:
        a=li[-1]   #取最后一个数
        print(a)
        time.sleep(1)
        try:
            li.remove(a)
        except:
            print('---',a)

t1=threading.Thread(target=pri,args=())  #两个线程同时去取,可能同时取得同一个数,造成线程不安全
t1.start()
t2=threading.Thread(target=pri,args=())
t2.start()
[root@node2 threading]# python3 thread-list.py
5            ##同时取得两个5
5
4
--- 5
4
3
--- 4
3
2
--- 3
2
1
--- 2
1
--- 1

　　

实例1：三个生产者一个消费者，在有队列的情况下有一把锁 ，三个生产者不会造乱，保证数据安全

[root@node2 threading]# cat qinstance.py
#!/usr/local/python3/bin/python3
import threading,queue
from time import sleep
from random import randint
class Production(threading.Thread):
    def run(self):
        while True:
            r=randint(0,100)
            q.put(r)                  ##生产一个包子，有三个Production对象向里面生产包子，如果没有锁就会有问题，最大限制保证数据安全
            print("produce %s baozi"%r)
            sleep(1)

class Proces(threading.Thread):
    def run(self):
        while True:
            re=q.get()           #消费者一直吃包子
            print("eat %s baozi"%re)

if __name__=="__main__":
    q=queue.Queue(10)
    threads=[Production(),Production(),Production(),Proces()]  #创建4个线程对象，前三个是生产者，最后一个是消费者
    for t in threads:
        t.start()
[root@node2 threading]# python3 qinstance.py
produce 100 baozi
produce 80 baozi
produce 62 baozi
eat 100 baozi
eat 80 baozi
eat 62 baozi

　　

实例2

[root@node2 threading]# cat qinstance1.py
#!/usr/local/python3/bin/python3
import time,random
import queue,threading
q = queue.Queue()
def Producer(name):
    count=0
    while count<20:
        time.sleep(random.randrange(3))
        q.put(count)
        print('Producer %s has produced %s baozi..' %(name,count))
        count +=1

def Consumer(name):
    count=0
    while count<20:
        time.sleep(random.randrange(4))
        if not q.empty():   #不为空时
            data = q.get()
            print(data)
            print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name,data))
        else:
            print("------no baozi anymore ------")
        count +=1

p1 = threading.Thread(target=Producer,args=('A',))
c1 = threading.Thread(target=Consumer,args=('B',))
p1.start()
c1.start()
[root@node2 threading]# python3 qinstance1.py
Producer A has produced 0 baozi..
Producer A has produced 1 baozi..
Producer A has produced 2 baozi..
0
Consumer B has eat 0 baozi...
Producer A has produced 3 baozi..
Producer A has produced 4 baozi..
1
Consumer B has eat 1 baozi...
2
Consumer B has eat 2 baozi...
3
Consumer B has eat 3 baozi...
4
Consumer B has eat 4 baozi...
Producer A has produced 5 baozi..
Producer A has produced 6 baozi..
5
Consumer B has eat 5 baozi...