Python爬虫速度很慢？多线程爬虫了解一下，提高10倍速度

你的名字 2022-12-29 12:43 218阅读 0赞

本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理

以下文章来源于Python知识学堂 ，作者： 東不归

![3980c3e11671ff14e0448325922901c8.png][]

**私信回复“资料”，即可免费领取Python实战案例讲解视频**

**Python多线程爬虫讲解视频观看地址**

https://www.bilibili.com/video/BV1L54y1r73F/

# 前言 #

本次推文介绍一下多线程。不过值得注意的是，不能滥用多线程，多线程爬虫请求内容速度过快，可能会导致服务器过载，或者是IP被封禁。为了避免这一问题，我们在使用多线程爬虫的时候需要设置一个delay时间，用于请求同一域名时的最小时间间隔。

# 线程和进程如何工作 #

当程序在运行时，就会创建包含代码和状态的进程。这些进程通过一个或者多个CPU来执行。不过同一时刻每个CPU只会执行一个进程，然后在不同进程之间快速切换，这样就感觉多个程序同时运行。同理，在一个进程中，程序的执行也是在不同线程间进行切换的，每个线程执行程序的不同部分。这就意味着一个线程在等待执行时，进程会切换到其他的线程执行，这样可以避免浪费CPU时间。

![ec499eef14d4a701547b2c22aae3813c.png][]

# Threading线程模块 #

在Python标准库中，使用threading模块来支持多线程。Threading模块对thread进行了封装，绝大数情况，只需要使用threading这个模块。使用起来也非常简单：

t1=threading.Thread(target=run,args=("t1",)) 创建一个线程实例
    # target是要执行的函数名（不是函数），args是函数对应的参数，以元组的形式存在
    t1.start() 启动这个线程实例。

# **普通创建方式** #

线程的创建很简单，如下：

import threading
    import time
    
    def printStr(name):
        print(name+"-python青灯")
        s=0.5
        time.sleep(s)
    print(name+"-python青灯")
    
    t1=threading.Thread(target=printStr,args=("你好！",))
    t2=threading.Thread(target=printStr,args=("欢迎你！",))
    t1.start()
    t2.start()

# **自定义线程** #

本质是继承threading.Thread，重构Thread类中的run方法

import threading
    import time
    
    class testThread(threading.Thread):
        def __init__(self,s):
            super(testThread,self).__init__()
            self.s=s
    
        def run(self):
            print(self.s+"——python")
            time.sleep(0.5)
            print(self.s+"——青灯")
    
    if __name__=='__main__':
        t1=testThread("测试1")
        t2=testThread("测试2")
        t1.start()
        t2.start()

# **守护线程** #

使用setDaemon(True)把子线程都变成主线程的守护线程，因此当主线程结束后，子线程也会随之结束。也就是说，主线程不等待其守护线程执行完成再去关闭。

import threading
    import time
    
    def run(s):
        print(s,"python")
        time.sleep(0.5)
        print(s,"青灯")
    
    if __name__ == "__main__":
        t=threading.Thread(target=run,args=("你好!",))
        t.setDaemon(True)
        t.start()
        print("end")

**结果：**

你好! python

end

当主线程结束后，守护线程不管有没有结束，都自动结束。

# **主线程等待子线程结束** #

使用join方法，让主线程等待子线程执行。如下：

**结果：**

你好! python

你好! 青灯

end

以上是多线程的几种简单的用法，那么threading模块还有做什么呢？请往下看。

# **Lock 锁** #

其实在介绍diskcache缓存的时候也介绍过锁的相关内容，其实不难理解为啥多线程中也会出现锁的概念，当没有保护共享资源时，多个线程在处理同一资源时，可能会出现脏数据，造成不可以预期的结果，即线程不安全。

如下示例出现不可预期的结果：

import threading
    
    price=0
    def changePrice(n):
        global price
        price=price+n
        price=price-n
    
    def runChange(n):
        for i in range(2000000):
            changePrice(n)
    
    if __name__ == "__main__":
        t1=threading.Thread(target=runChange,args=(5,))
        t2=threading.Thread(target=runChange,args=(8,))
        t1.start()
        t2.start()
        t1.join()
        t2.join()
        print(price)

理论上的结果为0，但是每次运行的结果可能都是不一样的。

所以这个时候就需要锁去处理了，如下：

import threading
    import time
    from threading import Lock
    
    price=0
    def changePrice(n):   
        global price
        lock.acquire() #获取锁
        price=price+n
        print("price:"+str(price))
        price=price-n
        lock.release() #释放锁
    
    def runChange(n):
        for i in range(2000000):
            changePrice(n)
    
    if __name__ == "__main__":
        lock=Lock()
        t1=threading.Thread(target=runChange,args=(5,))
        t2=threading.Thread(target=runChange,args=(8,))
        t1.start()
        t2.start()
        t1.join()
        t2.join()
        print(price)

结果值与理论值是一致的。锁的意义在于每次只允许一个线程去修改同一数据，以保证线程安全。

# 信号量 #

BoundedSemaphore类，同时允许一定数量的线程更改数据，如下：

import threading
    import time
    
    def work(n):
        semaphore.acquire()
        print("序号:"+str(n))
        time.sleep(1)
        semaphore.release()
    
    if __name__ == "__main__":
        semaphore=threading.BoundedSemaphore(5)
        for i in range(100):
            t=threading.Thread(target=work,args=(i+1,))
            t.start()
    
    #active_count获取当前正在运行的线程数
    while threading.active_count()!=1:
            pass
        else:
            print("end")

结果为：每5次打印停顿一下，直到结束。

# **GIL全局解释器锁** #

说到多线程，不得不提一下GIL。GIL的全称是Global Interpreter Lock(全局解释器锁)，这是python设计之初，为了数据安全所做的决定。某个线程想要执行，必须先拿到GIL，并且在一个进程中，GIL只有一个。只有拿到GIL的线程，才能进入CPU执行。GIL只在cpython中才有，因为cpython调用的是c语言的原生线程，所以他不能直接操作cpu，只能利用GIL保证同一时间只能有一个线程拿到数据。而在pypy和jpython中是没有GIL的。

# **总结** #

本篇文章介绍了多线程的用法，要根据实际的情况去使用。多线程编程，容易发生冲突，必须用锁加以隔离，又得小心发生死锁。由于Python的设计时有GIL全局锁，导致多线程无法利用多核，使得在多线程并发的情况下并不理想。

[3980c3e11671ff14e0448325922901c8.png]: /images/20221120/51a91aba616044be9cf814ebaf3c50b7.png
[ec499eef14d4a701547b2c22aae3813c.png]: https://img-blog.csdnimg.cn/img_convert/ec499eef14d4a701547b2c22aae3813c.png