05-爬虫进阶_多线程（02 生产者与消费者模式、线程安全队列）

1-Lock版生产者和消费者模式

生产者和消费者模式是多线程开发中经常见到的一种模式。生产者的线程专门用来生产一些数据，然后存放到一个中间的变量中。消费者再从这个中间的变量中取出转握进行消费，但是因为要使用中间变量，中间变量经常是一些全局交量，因此需要使用锁来保证数据完整性。

Lock版生产者和消费者模式缺点：不停的解锁、加锁比较耗资源。

例如，爬虫：

• 生产者：专门获取url
• 消费者：专门获取并解析响应
•  
•  以下是使用threading.Lock锁实现的生产者与消费者模式的一个例子：

import threading
import random
import time

gMoney = 1000
gLock = threading.Lock()
gTotalTimes = 10  # 总的执行10次
gTimes = 0

class Producer(threading.Thread):
    def run(self):
        global gMoney
        global gTimes
        while True:
            money = random.randint(100,1000)
            gLock.acquire()  # 加上锁
            if gTimes >= gTotalTimes:  # 全局变量10次
                gLock.release()
                break
            gMoney +=money
            print('%s生产了%d元钱，剩余%d元钱' %(threading.current_thread(),money,gMoney))
            gTimes += 1
            gLock.release()  # 释放锁
            time.sleep(0.5)

class Consumer(threading.Thread):
    def run(self):
        global gMoney
        while True:
            money = random.randint(100,1000)
            gLock.acquire()
            if gMoney >= money:
                gMoney -= money
                print('%s消费者消费了%d元钱，剩余%d元钱' %(threading.current_thread(),money,gMoney))
            else:
                if gTimes >= gTotalTimes:
                    gLock.release()
                    break
                print('%s消费者消费了%d元钱，剩余%d元钱，不足' %(threading.current_thread(),money,gMoney))
            gLock.release()
            time.sleep(0.5)

# =============================================================================
# def main():
#     for x in range(gTotalTimes):
#         t = Consumer(name='consumer %d' %x)
#         t.start()
#     for x in range(gTotalTimes):
#         t = Producer(name='producer %d' %x)
#         t.start()
# =============================================================================

def main():
    for x in range(3):
        t = Consumer(name='消费者线程 %d' %x)
        t.start()
    for x in range(5):
        t = Producer(name='生产者线程 %d' %x)
        t.start()

if __name__ == '__main__':
    main()

2-Condition版生产者与消费者模式

 Lock版本的生产者与消费者模式可以正常的运行，但是存在一个不足，在消费者中，总是通过while True死循环并且上锁的方式去判断钱够不够，上锁是一个很耗费CPU资源的行为，因此这种方式不是最好的，还有一种更好的方式便是使用threading.Condition来实现。threading.Conditlon可以在没有数据的时候处于阻塞等待状态。一旦有合适的数据了，还可以使用notity相关的函数来通如其他处于等待状态的线程，这样就可以不用做一些无用的上锁和解锁的操作，可以提高程序的性能。

首先对thresding.Condition相关的函数做个介绍，threading.Condition英似threading.lock，可以在修改全局数据的时候进行上锁，也可以在修改完毕后进行解锁，以下将一些常用的函数做个简单的介绍：
1、acquire：上锁。
2、release：解锁。
3、wait：将当前线程处于等待状态，并且会释放锁。可以被其他线程使用notify和notify_all函数唤醒。被唤醒醒后会继续等待上锁，上锁后继执行下面的代码.
4、notify：通如某个正在等待的线程，默认是第1个等待的线程
5、notify_all：通知所有正在等待的线程.notify和notif_a11不会释放锁。并且需在release之前调用。

Condition版生产者与消费者模式特点：比起Lock版更少耗资源。

# Condition版生产者与消费者模式

import threading
import random
import time

gMoney = 1000
gcondition = threading.Condition()
gTotalTimes = 10  # 总的执行10次
gTimes = 0

class Producer(threading.Thread):
    def run(self):
        global gMoney
        global gTimes
        while True:
            money = random.randint(100,1000)
            gcondition.acquire()  # 加上锁
            if gTimes >= gTotalTimes:  # 全局变量10次
                gcondition.release()
                break
            gMoney +=money
            print('%s生产了%d元钱，剩余%d元钱' %(threading.current_thread(),money,gMoney))
            gTimes += 1
            gcondition.notify_all()
            gcondition.release()  # 释放锁
            time.sleep(0.5)

class Consumer(threading.Thread):
    def run(self):
        global gMoney
        while True:
            money = random.randint(100,1000)
            gcondition.acquire()
            #---------------------------
            while gMoney < money:
                if gTimes >= gTotalTimes:
                    gcondition.release()
                    return
                print('%s消费者消费了%d元钱，剩余%d元钱，不足' %(threading.current_thread(),money,gMoney))
                gcondition.wait()
            gMoney -= money
            print('%s消费者消费了%d元钱，剩余%d元钱' %(threading.current_thread(),money,gMoney))
            #----------------------------
# =============================================================================
#             if gMoney >= money:
#                 gMoney -= money
#                 print('%s消费者消费了%d元钱，剩余%d元钱' %(threading.current_thread(),money,gMoney))
#             else:
#                 if gTimes >= gTotalTimes:
#                     gcondition.release()
#                     break
#                 print('%s消费者消费了%d元钱，剩余%d元钱，不足' %(threading.current_thread(),money,gMoney))
# =============================================================================
            gcondition.release()
            time.sleep(0.5)


def main():
    for x in range(3):
        t = Consumer(name='消费者线程 %d' %x)
        t.start()
    for x in range(5):
        t = Producer(name='生产者线程 %d' %x)
        t.start()

if __name__ == '__main__':
    main()

3-Queue线程安全队列

在线程中，访问一全局变量，加锁是一个经常的过程，如果你是想把一些数据存储到某个队列中，那么Python内置了一个线程安全的模块叫做queue模块。Python中的queue模块中提供了同步的、线程安全的纵列狭，包括FIFO（先进先出）队列Queue，LIFO（后入先出）趴列LfoQueve。这些队列实现了锁原理（可以理解为原子操作，即要么不像，要么都做完），能够在多线程中直接使用，可以使用队列来实现线程间的同步。相关的函数如下：
1、初始化Queue（maxsize）：创建一个先进先出的队列。
2、quize()：返回队列的大小
3、empty()：断队否为空
4、full()：断段队列是否满了
5、get()：从队列中取最后一个数据
6、put()：将一个数据放到队列中

扩展：

• 队列：先进先出
• 栈：后进先出

from queue import Queue
import time
import threading
q = Queue(4)
def set_value(q):
    index = 0
    while True:
        q.put(index)
        index +=1
        time.sleep(3)
    
def get_value(q):
    while True:
        print(q.get())
def main():
    q = Queue(4)
    t1 = threading.Thread(target=set_value,args=[q])
    t2 = threading.Thread(target=get_value,args=[q])
      
    t1.start()
    t2.start()
if __name__ == '__main__':
    main()
# q.qsize()
# q.empty()
# q.full()
# q.get()

 注意：q.put()/p.get()中都有一个参数，block，默认block=True

• q.get(block=True)：表示队列为空时，阻塞在这里
• q.put(block=True)：表示如果队列满了，会一直阻塞在这里，直到不满为止