python多线程爬虫学习

 下面是我多线程爬虫学习时的测试代码,每一段代码前的注释代表接下来一段的代码的功能,共四部分,第一部分多线程基础,第二部分使用子类创建多线程,第三部分使用互斥锁管理多线程，第四部分使用队列实现进程间通信

# # #-*-coding:utf-8-*-
# # import threading#多线程模块
# # #Thread(group=None,target=None,name='Thread-N',args,kwargs)
# # import time


# # def process():#函数,打印当前线程的名字
# #     for i in range(0,3):
# #         time.sleep(1)
# #         print("thread name is %s"%threading.current_thread().name)
# # if __name__=='__main__':
# #     print("……主线程开始……")
# #     #创建四个线程,存入列表
# #     threads=[threading.Thread(target=process)for i in range(4)]
# #     for i in threads:
# #         i.start()#开启进程
# #     for i in threads:
# #         i.join()#等待子线程结束join()函数在多线程中的作用是等待线程执行完毕。当一个线程调用了join()函数后，
# #                     #它会阻塞当前线程，直到被调用的线程执行完毕后才会继续执行。
# #                     #这个函数通常用于确保在主线程退出前所有的子线程都已经执行完毕，从而避免出现资源未释放等问题。
# #     print("……主线程结束……")

# # #使用子类创造线程
# # import threading
# # import time


# # class SubThread(threading.Thread):
    
# #     def run(self):
# #         for i in range(4):
# #             time.sleep(2)
# #             msg="子进程"+self.name+'执行,i='+str(i)
# #             print(msg)

# # if __name__=="__main__":       
# #     print("主线程开始……")
# #     t1=SubThread()
# #     t2=SubThread()
# #     t1.start()
# #     t2.start()
# #     t1.join()
# #     t2.join()
# #     print("主线程结束……")


# #使用互斥锁管理通信Lock类
# #acquire([blocking]):当将blocking设置为False,当获取锁定时返回Ture,反之返回False方法
# #release()方法:释放一个锁定,当锁定处于未锁定状态或从与原本调用acquire方法不同的线程调用此方法,则出现错误
# #使用多线程的互斥锁实现多人订购电影票的功能
# from threading import Lock
# from threading import Thread
# import time

# n=100
# #创建一个所有线程共用的函数,在该函数中,可以使用锁对象的acquire方法和release方法进行限制全局变量的访问,
# #可以看作为只有release后其他线程才能对该函数进行访问
# def task():
#     global n
#     mutex.acquire()
#     temp=n
#     time.sleep(0.1)
#     n=temp-1
#     print("购买成功,还剩%s张票"%n)
#     mutex.release()


# if __name__=="__main__":
#     mutex=Lock()
#     t_li=[]
#     for t in range(10):
#         #将所有线程都指向有互斥锁存在的该函数
#         t=Thread(target=task())
#         t_li.append(t)
#         t.start()
#     for i in t_li:
#         #阻塞主线程
#         i.join()


#使用队列在进程间通信(队列几乎相当于一个互斥锁)
#生产者-消费者模式

import threading
import time
import random
from queue import Queue

#生产者类
class Producer(threading.Thread):
    #类属性初始化
    def __init__(self,name,queue):
        threading.Thread.__init__(self,name=name)
        self.data=queue
    
    def run(self):
        for i in range(5):
            print("生产者%s将产品%d加入队列!"%(self.getName(),i))
            self.data.put(i)
            time.sleep(random.random())
        print("生产者%s完成!"%self.getName())

#消费者类
class Consumer(threading.Thread):

    def __init__(self,name,queue):
        threading.Thread.__init__(self,name=name)
        self.data=queue
    
    def run(self):
        for val in range(5):
            print("消费者%s将产品%d取出队列!"%(self.getName(),val))
            self.data.get(val)
            time.sleep(random.random())
        print("消费者%s完成!"%self.getName())

if __name__=='__main__':
    
    print("主线程开始……")
    queue=Queue()
    producer=Producer("Producer",queue)
    consumer=Consumer("Consumer",queue)
    producer.start()
    consumer.start()
    producer.join()
    consumer.join()
    print("主线程结束……")

代码基于vscode调试,测试暂无问题,若出现错误，请在评论区指正，希望大家一起进步！！