queue队列lock、condition加锁，解锁，阻塞机制，生产者与消费者关系

queue队列lock、condition加锁，解锁，阻塞机制，生产者与消费者关系 

 

queue队列lock、condition加锁，解锁，阻塞机制，生产者与消费者关系

1、队列的属性

from queue import Queue

"""
    初始化Queue(maxsize)：创建一个先进先出的队列。
    qsize()：返回队列的大小。
    empty()：判断队列是否为空。
    full()：判断队列是否满了。
    get()：从队列中取最后一个数据。
    put()：将一个数据放到队列中。
"""
q=Queue(4)

for i in range(4):
    q.put(i)
print(q.full())

print(q.qsize())
print(q.empty())

for i in range(4):
    print(q.get())

"""
    True
    4
    False
    0
    1
    2
    3
"""



2、队列与线程的结合使用

from queue import Queue
import time
import threading

def add_value(q):
    index=0
    while True:
        q.put(index)
        index+=1
        time.sleep(1)

def get_value(q):
    while True:
        print(q.get())

def main():
    q=Queue(4)
    t1 = threading.Thread(target=add_value, args=[q])
    t2 = threading.Thread(target=get_value, args=[q])
    t1.start()
    t2.start()

if __name__ == '__main__':
    main()


3、使用lock上锁，解锁机制，这样会避免在程序运行时插队，但会增加CPU运行速度。

import threading

VALUE=0

glock=threading.Lock()

def add_value():
    global VALUE
    glock.acquire()#上锁
    for i in range(1000000):
        VALUE+=1
    glock.release()#开锁
    print('valeu:%d'%VALUE)

def main():
    for i in range(2):
        t1=threading.Thread(target=add_value)
        t1.start()


if __name__ == '__main__':
    main()



4、lock生产者与消费者模式，不足：每次运行时都会上锁，解锁，增加CPU的运行功率

import threading
import random
import time

Money=100
gLock=threading.Lock()
gTime=0
gTimeCount=10

class Production(threading.Thread):
    def run(self):
        global Money
        global gTime

        while True:
            money=random.randint(100,1000)
            gLock.acquire()
            Money+=money

            if gTime>=gTimeCount:
                gLock.release()
                break
            print('%s生产了%d块钱,剩余%d块钱'%(threading.current_thread(),money,Money))
            gTime+=1
            time.sleep(1)
            gLock.release()


class Customer(threading.Thread):
    def run(self):
        global Money
        global gTime

        while True:
            money = random.randint(100, 1000)
            gLock.acquire()

            if Money>=money:
                Money-=money
                time.sleep(1)
                print('%s消费了%d块钱,剩余%d块钱' % (threading.current_thread(), money, Money))

            else:
                if gTime>=gTimeCount:
                    gLock.release()
                    break
                print('%s消费了%d块钱,剩余%d块钱,不足' % (threading.current_thread(), money, Money))
            gLock.release()

def main():
    for x in range(5):
        t=Production(name='线程%d生产'%(x))
        t.start()

    for x in range(3):
        t=Customer(name='线程%d消费'%(x))
        t.start()

if __name__ == '__main__':
    main()


5、condition生产者与消费者模式

队列进行时，如果运行到条件判断时，使用condition.wait()开始阻塞，如果条件允许，使用condition.notify_all（）解开阻塞，继续运行。

使用堆和栈原理。

import threading
import random
import time

Money=100
gcondition=threading.Condition()
gTime=0
gTimeCount=10

class Production(threading.Thread):
    def run(self):
        global Money
        global gTime

        while True:
            money=random.randint(100,1000)
            gcondition.acquire()
            Money+=money

            if gTime>=gTimeCount:
                gcondition.release()
                break
            print('%s生产了%d块钱,剩余%d块钱'%(threading.current_thread(),money,Money))
            gTime+=1
            time.sleep(1)
            gcondition.notify_all()#通知阻塞
            gcondition.release()


class Customer(threading.Thread):
    def run(self):
        global Money
        global gTime

        while True:
            money = random.randint(100, 1000)
            gcondition.acquire()
            # 这里要给个while循环判断，因为等轮到这个线程的时候
            # 条件有可能又不满足了
            while Money<=money:
                if gTime>=gTimeCount:
                    gcondition.release()
                    return
                print('%s消费了%d块钱,剩余%d块钱' % (threading.current_thread(), money, Money))
                gcondition.wait()  # 阻塞等待
            Money -= money
            print('%s消费了%d块钱,剩余%d块钱' % (threading.current_thread(), money, Money))
            time.sleep(1)
            gcondition.release()

def main():
    for x in range(5):
        t=Production(name='线程%d生产'%(x))
        t.start()

    for x in range(3):
        t=Customer(name='线程%d消费'%(x))
        t.start()

if __name__ == '__main__':
    main()