爬虫-6.多线程

创建线程

1、通过函数创建
在theading.Thread()里面传递target参数，该参数为函数名。
如果需要传参，则可以再向theading.Thread()里面传递args=(, )参数。(注意：args后面是元祖)

import threading

def a(d):
    for i in range(d):
        print("target1--%d"%i)

def b():
    for i in range(20):
        print("target2--%d"%i)

if __name__ == '__main__':
    t1 = threading.Thread(target=a, args=(15,))
    t2 = threading.Thread(target=b)
    t1.start()
    t2.start()

2、通过类来创建
写类的时候继承父类threading.Thread ,然后重写run方法

class A(threading.Thread):

    def run(self) -> None:
        for i in range(100):
            print("target1--%d"%i)

if __name__ == '__main__':
    for i in range(2):
        a = A()
        a.start()

补充：
当调用start()方法后才算创建线程和启动线程。

主线程和子线程的执行关系

主线程会等待子线程结束之后在结束

• join() 等待子线程结束之后，主线程继续执行
• setDaemon() 守护线程，不会等待子线程结束

查看线程数量

threading.enumerate()查看当前线程的数量

互斥锁和死锁

互斥锁

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制
某个线程要更改共享数据时，先将其锁定，此时资源的状态为"锁定",其他线程不能改变，只到该线程释放资源，将资源的状态变成"非锁定"，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性

创建锁：lock = threading.Lock()
锁定：lock.acquire()
解锁：lock.release()

死锁

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁

队列Queue

在线程中，访问一些全局变量，加锁是一个经常的过程。如果你是想把一些数据存储到某个队列中，那么Python内置了一个线程安全的模块叫做queue模块。Python中的queue模块中提供了同步的、线程安全的队列类，包括FIFO（先进先出）队列Queue，LIFO（后入先出）队列LifoQueue。这些队列都实现了锁原语（可以理解为原子操作，即要么不做，要么都做完），能够在多线程中直接使用。可以使用队列来实现线程间的同步。

from queue import Queue


# 创建队列：
q = Queue(10)  # 10代表设置队列的长度为10

# put()：将一个数据放到队列中。
for i in ['scsc we', 561864, '我', '8649684']:
    q.put(i)

# get()：从队列中取第一个数据。
print(q.get())  # scsc we
print(q.get())  # 561864
print(q.get())  # 我

# empty()：判断队列是否为空。
print(q.empty())  # False

# full()：判断队列是否满了
print(q.full())  # False

生产者消费者模型

生产者和消费者模式是多线程开发中常见的一种模式。通过生产者和消费者模式，可以让代码达到高内聚低耦合的目标，线程管理更加方便，程序分工更加明确。
生产者的线程专门用来生产一些数据，然后存放到容器中(中间变量)。消费者在从这个中间的容器中取出数据进行消费
Lock版的生产者和消费者

import threading
import random
gMoney = 0
# 定义一个变量 保存生产的次数 默认是0次
gTimes = 0
# 定义一把锁
gLock = threading.Lock()

# 定义生产者
class Producer(threading.Thread):

    def run(self):
        global gMoney
        global gTimes
        gLock.acquire()  # 上锁
        while True:
            # gLock.acquire() # 上锁
            if gTimes >= 10:
                # gLock.release()
                break
            money = random.randint(0,100)
            gMoney += money
            gTimes += 1
            print("%s生产了%d元钱" % (threading.current_thread().name, money))
        gLock.release() # 解锁
# 定义消费者
class Consumer(threading.Thread)
    def run(self):
        global gMoney
        while True:
            gLock.acquire()  # 上锁
            money = random.randint(0, 100)
            if gMoney >= money:
                gMoney -= money
                print("%s消费了%d元钱" % (threading.current_thread().name, money))
            else:
                if gTimes >= 10:
                    gLock.release()
                    break
                print("%s想消费%d元钱，但是余额只有%d"%(threading.current_thread().name,money,gMoney))
            gLock.release()  # 解锁

def main():
    # 开启5个生产者线程
    for x in range(5):
        th = Producer(name="生产者%d号" % x)
        th.start()
    # 开启5个消费者线程
    for x in range(5):
        th = Consumer(name="消费者%d号" % x)
        th.start()

if __name__ == '__main__':
    main()