Python爬虫的多线程与多进程的使用场景，以及使用实例代码

本文主要综合三篇文章的内容，分为三个方面理解进程与线程。

 

 

---

前言

python可以实现多线程的方法有

• thread（低版本使用的），threading
• Queue
• multiprocessing

其中threading客户以通过实例方法或者类方法来创建 多线程。

multiprocessing方法可以创建多线程池，用起来比较简洁、方便。

两者的比较

multiprocessing实例化的pool：

Pool可以提供指定数量的线程供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的线程用来执行该请求；但如果池中的线程数已经达到规定最大值，那么该请求就会等待，直到池中有线程结束，才会创建新的线程来它。

threading实例化多线程类：

没有仔细研究过有点，目前姑且认为 multiprocessing更好用，以后更新知识再补充。

一、python多线程 （有点坑）

鸡肋点

名言：

“Python下多线程是鸡肋，推荐使用多进程！”

那当然有同学会问了，为啥？

背景

1、GIL是什么？

GIL的全称是Global Interpreter Lock(全局解释器锁)，来源是python设计之初的考虑，为了数据安全所做的决定。

2、每个CPU在同一时间只能执行一个线程（在单核CPU下的多线程其实都只是并发，不是并行，并发和并行从宏观上来讲都是同时处理多路请求的概念。但并发和并行又有区别，并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔内发生。）

在Python多线程下，每个线程的执行方式：

• 获取GIL
• 执行代码直到sleep或者是python虚拟机将其挂起。
• 释放GIL

可见，某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个python进程中，GIL只有一个。拿不到通行证的线程，就不允许进入CPU执行。

在Python2.x里，GIL的释放逻辑是当前线程遇见IO操作或者ticks计数达到100（ticks可以看作是Python自身的一个计数器，专门做用于GIL，每次释放后归零，这个计数可以通过 sys.setcheckinterval 来调整），进行释放。

而每次释放GIL锁，线程进行锁竞争、切换线程，会消耗资源。并且由于GIL锁存在，python里一个进程永远只能同时执行一个线程(拿到GIL的线程才能执行)，这就是为什么在多核CPU上，python的多线程效率并不高。

那么是不是python的多线程就完全没用了呢？

在这里我们进行分类讨论：

1、CPU密集型代码(各种循环处理、计数等等)，在这种情况下，由于计算工作多，ticks计数很快就会达到阈值，然后触发GIL的释放与再竞争（多个线程来回切换当然是需要消耗资源的），所以python下的多线程对CPU密集型代码并不友好。

2、IO密集型代码(文件处理、网络爬虫等)，多线程能够有效提升效率(单线程下有IO操作会进行IO等待，造成不必要的时间浪费，而开启多线程能在线程A等待时，自动切换到线程B，可以不浪费CPU的资源，从而能提升程序执行效率)。所以python的多线程对IO密集型代码比较友好。

而在python3.x中，GIL不使用ticks计数，改为使用计时器（执行时间达到阈值后，当前线程释放GIL），这样对CPU密集型程序更加友好，但依然没有解决GIL导致的同一时间只能执行一个线程的问题，所以效率依然不尽如人意。

多核性能

多核多线程比单核多线程更差，原因是单核下多线程，每次释放GIL，唤醒的那个线程都能获取到GIL锁，所以能够无缝执行，但多核下，CPU0释放GIL后，其他CPU上的线程都会进行竞争，但GIL可能会马上又被CPU0拿到，导致其他几个CPU上被唤醒后的线程会醒着等待到切换时间后又进入待调度状态，这样会造成线程颠簸(thrashing)，导致效率更低

多进程为什么不会这样？

每个进程有各自独立的GIL，互不干扰，这样就可以真正意义上的并行执行，所以在python中，多进程的执行效率优于多线程(仅仅针对多核CPU而言)。

所以在这里说结论：多核下，想做并行提升效率，比较通用的方法是使用多进程，能够有效提高执行效率。

所以，如果不想浪费时间，可以直接看多进程

用在什么场合？

比如你在爬取一个网站的所有图片时，由于大部分工作都是在下载、存储的I/O操作，因此，在CPU等待的这个过程中，多线程会发挥作用，自动进行下一个任务的下载。

但是在CPU密集型（多计算）的场合，这个python多线程就是个扯淡的玩意，没任何用。

使用实例

使用模块 from multiprocessing.dummy import Pool as ThreadPool

#-*- coding:utf8 -*-
import requests
import re# 导入正则表达式的模块
from multiprocessing.dummy import Pool as ThreadPool
import time
 
#导入下面这几行用中文就不会出错
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
 
 
def changepage(url,total_page):
    """获得所有url的列表"""
    nowPage = int(re.search('pageNum=(\d+)',url).group(1))#re.search只找到第一个符合条件的 .group(1)是只要一个括号里面的
    all_link=[]
    for i in range(nowPage,total_page+1):
         # 替换
         link = re.sub('pageNum=\d+','pageNum=%s'%i,url,re.S)
         all_link.append(link)
    return all_link
 
def geteveryclass(url):
    html = requests.get(url)
    classinfo=[]
    everyclass = re.findall('(deg="0" >.*?)',html.text,re.S)
    for each in everyclass:
        info = getinfo(each)
        classinfo.append(info)
    print classinfo
 
 
def getinfo(eachclass):
    """getinfo用来从每个课程块中提取出我们需要的信息"""
    info = {}
    info['title'] = re.search('class="lessonimg" title="(.*?)>',eachclass,re.S).group(1)
    info['content'] = re.search('display: none;">(.*?)
',eachclass,re.S).group(1)
 
    return info
######################################################################################################################
if __name__ == "__main__":
 
    url = 'http://www.jikexueyuan.com/course/?pageNum=1'
    url_list = changepage(url,5)
    pool = ThreadPool(4)#4核
    time1 = time.time()
    results = pool.map(geteveryclass, url_list)#需要执行的方法和地址列表
    pool.close()
    pool.join()#等待线程都结束后再执行主模块
    time2 = time.time()
    print u'多线程耗时：' + str(time2-time1)
 

二、python多进程 

工作原理：Pool可以提供指定数量的进程供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来它。

这里只说map()函数，至于apply()函数、apply_async()的使用，后面再添加。

进程池的写法与用法和 多线程 时一模一样的。

注意：map()函数传参时，如results = pool.map(get_info, url_list)中，url_list其实是一个list=[1,2,3,4,5,6]，但是map发挥作用后，get_info(url_get)函数接收到的参数url_get其实是分别取1  2  3  4  5，这就是map的作用。

下面拿一个例子说明多进程的使用。这个例子用来动态爬取必应的图片。使用4个进程最快，4个线程次之。单线程速度非常慢，是前两者的约1/3的速度。

当参数为“progress”时，使用多线程；当参数为“threading”时，使用多进程。并且map()函数的作用也体现在其中。

# -*- coding: utf-8 -*-

######################################################
import urllib
import urllib.request
import re
import time
import socket
import random
from multiprocessing.dummy import Pool as ThreadPool
from multiprocessing import cpu_count
import multiprocessing
import time
png_count = 0 #标记爬了多少张图片
def get_url_list():
    #在网页中提取所有的图片链接
    opener = urllib.request.build_opener()
    header = get_header()
    opener.addheaders = [header]
    urllib.request.install_opener(opener)
    #图片链接提取表达式
    pat = '"murl":"(.*?)","turl":"'
    urls = []
    urls_list = []
    for i in range(1, 5):
        url = "https://cn.bing.com/images/async?q=certificate+of+origin&first=" + str(i * 35) + "&count=35&relp=" + str(i * 35) + "&scenario=ImageBasicHover&datsrc=N_I"
        data = opener.open(url, timeout=5).read().decode("utf-8")
        urls = re.compile(pat).findall(data)
        for url_in_urls in urls:
            urls_list.append(url_in_urls)
    return urls_list

def get_header():
    #随机返回一个header
    headerUserAgentList = (
              "Mozilla/5.0 (compatible; WOW64; MSIE 10.0; Windows NT 6.2)",
              "Mozilla/5.0 (Windows NT 6.2; WOW64; rv:21.0) Gecko/20100101 Firefox/21.0",
              "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.94 Safari/537.36",
              "Opera/9.80 (Windows NT 6.1; WOW64; U; en) Presto/2.10.229 Version/11.62",
              "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27",
              )
    header = ('User-Agent',random.choice(headerUserAgentList))
    return header

def get_info(urls_list):

    #将图片下载到本地
    opener = urllib.request.build_opener()
    header = get_header()
    opener.addheaders = [header]
    urllib.request.install_opener(opener)
    print(urls_list)

    try:
        global png_count
        print(png_count)
        file = 'C:/Users/weihua/Desktop/信用证图片/test/' + str(random.randint(0,10000)) + '.png'
        tests = opener.open(urls_list, timeout=10)
        urllib.request.urlretrieve(urls_list, file)
        print('**************第 %s 张图片爬取成功******************'% png_count)
        print("-------成功-------")
        png_count += 1

    except urllib.request.URLError as e:
        if hasattr(e, "code"):
            print(e.code)
        if hasattr(e, "reason"):
            print(e.reason)
            # 若为异常，延时10s执行
            time.sleep(1)
            print("-------下载失败-------")
    except Exception as e:
        print("exception:", str(e))
        # 若为Exception异常，延时1s执行
        time.sleep(1)

    # 防止下载时间过长，需<=60s
    except socket.timeout:
        count = 1
        while count <= 2:
            try:
                urllib.request.urlretrieve(urls[j], file)
                break
            except socket.timeout:
                err_info = 'Reloading for %d time' % count if count == 1 else 'Reloading for %d times' % count
                print(err_info)
                count += 1
        if count > 2:
            print("下载超时")

def method(method):
    #传参选择多进程还是多线程爬取
    url_list = get_url_list()
    if method == "threading":
        pool = ThreadPool(cpu_count())  # 4进程
        time1 = time.time()
        results = pool.map(get_info, url_list)  # 需要执行的方法和执行列表
        pool.close()
        pool.join()  # 等待线程都结束再执行主模块
        time2 = time.time()
    if method == "progress":
        pool = multiprocessing.Pool(processes=cpu_count())
        time1 = time.time()
        # resluts = pool.map(get_info, url_list)
        resluts = pool.map(get_info, url_list)
        pool.close()
        pool.join()
        time2 = time.time()
    return time2 - time1
if __name__ == "__main__":
    print("--------------start-----------")
    socket.setdefaulttimeout(60)
    # time_use = method("threading")
    time_use = method("progress")
    print("多线程耗时："+str(time_use))

下面是我自从测试，多线程与多进程所消耗的时间。 

下载图片这种的I/O超级密集型的任务，多线程的优势也没有多进程大，说明python的多线程真是没什么卵用了啊。