前言

在爬虫学习的过程中,一旦爬取的数量过大,很容易带来效率问题,为了能够快速爬取我们想要的内容。为此我们可以使用多线程或者多进程来处理。

多线程和多进程是不一样的!一个是 threading 库,一个是 multiprocessing 库。而多线程 threading 在 Python
里面被称作鸡肋的存在!关于 Python 多线程有这样一句名言——“Python下多线程是鸡肋,推荐使用多进程!”

为什么称 Python 多线程是鸡肋?原因如下:

在大多数环境中,单核CPU情况下,本质上某一时刻只能有一个线程被执行,多核 CPU 则可以支持多个线程同时执行。但是在 Python 中,无论 CPU
有多少核,CPU在同一时间只能执行一个线程。这是由于 GIL 的存在导致的。

GIL 的全称是 Global Interpreter Lock(全局解释器锁),是 Python 设计之初为了数据安全所做的决定。Python
中的某个线程想要执行,必须先拿到 GIL。可以把 GIL 看作是执行任务的“通行证”,并且在一个 Python 进程中,GIL
只有一个。拿不到通行证的线程,就不允许进入 CPU 执行。GIL 只在 CPython 解释器中才有,因为 CPython 调用的是 c
语言的原生线程,不能直接操作 CPU,只能利用 GIL 保证同一时间只能有一个线程拿到数据。在 PyPy 和 JPython 中没有 GIL。

在 Python 多线程下,每个线程的执行方式:

* 拿到公共数据
* 申请GIL
* Python解释器调用操作系统原生线程
* cpu执行运算
* 当该线程执行一段时间消耗完,无论任务是否已经执行完毕,都会释放GIL
* 下一个被CPU调度的线程重复上面的过程

任何Python线程执行前,必须先获得GIL锁,然后,每执行100条字节码,解释器就自动释放GIL锁,让别的线程有机会执行。这个GIL全局锁实际上把所有线程的执行代码都给上了锁,所以,多线程在Python中只能交替执行,即使100个线程跑在100核CPU上,也只能用到1个核。

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

Python 针对不同类型的任务,多线程执行效率是不同的:

* 对于 CPU 密集型任务(各种循环处理、计算等等),由于计算工作多,ticks 计数很快就会达到阈值,然后触发 GIL
的释放与再竞争(多个线程来回切换是需要消耗资源的),所以 Python 下的多线程对 CPU 密集型任务并不友好。
* IO 密集型任务(文件处理、网络通信等涉及数据读写的操作),多线程能够有效提升效率(单线程下有 IO 操作会进行 IO
等待,造成不必要的时间浪费,而开启多线程能在线程 A 等待时,自动切换到线程 B,可以不浪费 CPU 的资源,从而能提升程序执行效率)。所以 Python
的多线程对 IO 密集型任务比较友好。
实际中的建议

Python 中想要充分利用多核 CPU,就用多进程。因为每个进程有各自独立的 GIL,互不干扰,这样就可以真正意义上的并行执行。在 Python
中,多进程的执行效率优于多线程(仅仅针对多核 CPU 而言)。同时建议在 IO 密集型任务中使用多线程,在计算密集型任务中使用多进程。

Python 创建多线程

1.直接利用函数创建多线程

在 Python3 中,Python 提供了一个内置模块 threading.Thread,可以很方便地让我们创建多线程。
threading.Thread()一般接收两个参数:

* target(线程函数名):要放置线程让其后台执行的函数,由我们自已定义,注意不要加();
* args(线程函数的参数):线程函数名所需的参数,以元组的形式传入。若不需要参数,可以不指定。 import time from threading
import Thread # 自定义线程函数。 def main(name="Python"): for i in range(2):
print("hello", name) time.sleep(2) # 创建线程01,不指定参数 thread_01 =
Thread(target=main) # 启动线程01 thread_01.start() # 创建线程02,指定参数,注意逗号 thread_02 =
Thread(target=main, args=("MING",)) # 启动线程02 thread_02.start()
输出结果:
hello Python hello MING hello Python hello MING
2. 使用 Threading 模块构建类对象

使用 Threading 模块创建线程,直接从 threading.Thread 继承,然后重写 init 方法和 run 方法。
import time from threading import Thread class MyThread(Thread): def
__init__(self, name="Python"): # 注意,super().__init__() 一定要写 # 而且要写在最前面,否则会报错。
super().__init__() self.name=name def run(self): for i in range(2):
print("hello", self.name) time.sleep(2) if __name__ == '__main__': #
创建线程01,不指定参数 thread_01 = MyThread() # 创建线程02,指定参数 thread_02 = MyThread("MING")
thread_01.start() thread_02.start()
输出结果:
hello Python hello MING hello MING hello Python
上述是最基本的多线程创建方法,看起来很简单,但在实际的应用中,会复杂许多。

接下来,关于我实际学习中的多线程练习,我会一一记录下来。

多线程练习

在讲述下面的线程同步前,我先用个实例描述一下线程未同步。
import threading import time class myThread(threading.Thread): def
__init__(self, threadID, name, counter): threading.Thread.__init__(self)
self.threadID = threadID self.name = name self.counter = counter def run(self):
print('Starting '+self.name) print_time(self.name, self.counter, 3)
print("Exiting " + self.name) def print_time(threadName, delay, count): while
count: time.sleep(1) print('{0} processing {1}'.format(threadName,
time.ctime(time.time()))) count -= 1 if __name__ == '__main__': threadList =
["Thread-1", "Thread-2"] threads = [] threadID = 1 for tName in threadList:
thread = myThread(threadID, tName, threadID) thread.start()
threads.append(thread) threadID += 1 # for t in threads: # t.join()
print("Exiting Main Thread")
输出结果:
Starting Thread-1Starting Thread-2 Exiting Main Thread Thread-1 processing Sat
May 11 11:06:11 2019 Thread-2 processing Sat May 11 11:06:12 2019 Thread-1
processing Sat May 11 11:06:12 2019 Thread-1 processing Sat May 11 11:06:13
2019 Exiting Thread-1 Thread-2 processing Sat May 11 11:06:14 2019 Thread-2
processing Sat May 11 11:06:16 2019 Exiting Thread-2
由输出结果中可以看出,第二个线程在打印过程中没有回车打印,说明线程间没有同步。
线程同步——Lock

多线程中,所有变量都由所有线程共享,所以,任何一个变量都可以被任何一个线程修改,因此,线程之间共享数据最大的危险在于多个线程同时改一个变量,把内容给改乱了。

使用Thread对象的Lock和Rlock可以实现简单的线程同步,这两个对象都有acquire方法和release方法,对于那些需要每次只允许一个线程操作的数据,可以将其操作放到acquire和release方法之间。
import threading import queue import time exitFlag = 0 class
myThread(threading.Thread): def __init__(self, que):
threading.Thread.__init__(self) self.que = que def run(self): print("Starting "
+ threading.currentThread().name) process_data(self.que) print("Ending " +
threading.currentThread().name) def process_data(que): while not exitFlag:
queueLock.acquire() if not workqueue.empty(): data = que.get()
queueLock.release() print('Current Thread Name %s, data: %s ' %
(threading.currentThread().name, data)) else: queueLock.release()
time.sleep(0.1) if __name__ == '__main__': start_time = time.time() queueLock =
threading.Lock() workqueue = queue.Queue() threads = [] # 填充队列
queueLock.acquire() for i in range(1,10): workqueue.put(i) queueLock.release()
for i in range(4): thread = myThread(workqueue) thread.start()
threads.append(thread) #等待队列清空 while not workqueue.empty(): pass #通知线程退出
exitFlag = 1 for t in threads: t.join() print("Exiting Main Thread") end_time =
time.time() print('耗时{}s'.format((end_time - start_time)))
输出结果:
Starting Thread-1 Current Thread Name Thread-1, data: 1, time: Sat May 11
10:47:25 2019 Starting Thread-2 Current Thread Name Thread-2, data: 2, time:
Sat May 11 10:47:25 2019 Starting Thread-3 Current Thread Name Thread-3, data:
3, time: Sat May 11 10:47:25 2019 Starting Thread-4 Current Thread Name
Thread-4, data: 4, time: Sat May 11 10:47:25 2019 Current Thread Name Thread-1,
data: 5, time: Sat May 11 10:47:25 2019 Current Thread Name Thread-2, data: 6,
time: Sat May 11 10:47:25 2019 Current Thread Name Thread-3, data: 7, time: Sat
May 11 10:47:25 2019 Current Thread Name Thread-4, data: 8, time: Sat May 11
10:47:25 2019 Current Thread Name Thread-2, data: 9, time: Sat May 11 10:47:25
2019 Ending Thread-4 Ending Thread-1 Ending Thread-2 Ending Thread-3 Exiting
Main Thread 耗时0.31415677070617676s
线程同步——Queue

Python 的 Queue 模块中提供了同步的、线程安全的队列类,包括 FIFO(先入先出)队列
Queue,LIFO(后入先出)队列LifoQueue,和优先级队列
PriorityQueue。这些队列都实现了锁原语,能够在多线程中直接使用。可以使用队列来实现线程间的同步。
import threading import time import queue def get_num(workQueue):
print("Starting " + threading.currentThread().name) while True: if
workQueue.empty(): break num = workQueue.get_nowait() print('Current Thread
Name %s, Url: %s ' % (threading.currentThread().name, num)) time.sleep(0.3) #
try: # num = workQueue.get_nowait() # if not num: # break # print('Current
Thread Name %s, Url: %s ' % (threading.currentThread().name, num)) # except: #
break # time.sleep(0.3) print("Ending " + threading.currentThread().name) if
__name__ == '__main__': start_time = time.time() workQueue = queue.Queue() for
i in range(1,10): workQueue.put(i) threads = [] thread_num = 4 #线程数 for i in
range(thread_num): t = threading.Thread(target=get_num, args=(workQueue,))
t.start() threads.append(t) for t in threads: t.join() end_time = time.time()
print('耗时{}s'.format((end_time - start_time)))
输出结果:
Starting Thread-1 Current Thread Name Thread-1, data: 1, time: Sat May 11
10:48:27 2019 Starting Thread-2 Current Thread Name Thread-2, data: 2, time:
Sat May 11 10:48:27 2019 Starting Thread-3 Current Thread Name Thread-3, data:
3, time: Sat May 11 10:48:27 2019 Starting Thread-4 Current Thread Name
Thread-4, data: 4, time: Sat May 11 10:48:27 2019 Current Thread Name Thread-2,
data: 5, time: Sat May 11 10:48:27 2019 Current Thread Name Thread-1, data: 6,
time: Sat May 11 10:48:27 2019 Current Thread Name Thread-4, data: 7, time: Sat
May 11 10:48:27 2019 Current Thread Name Thread-3, data: 8, time: Sat May 11
10:48:27 2019 Current Thread Name Thread-2, data: 9, time: Sat May 11 10:48:28
2019 Ending Thread-1 Ending Thread-4 Ending Thread-3 Ending Thread-2
耗时0.9028356075286865s
因为考虑到爬虫方面的实际应用,所以在程序中使用了 Python 的 Queue 模块,使用队列来实现线程间的同步(关于线程同步在后面会讲到)。在
get_num() 方法中注释的内容是另一种判断队列为空,结束子线程任务的代码实现。

在实际运行中,通过调节线程数可以看到,执行时间会随着线程数的增加而缩短。

技术
©2020 ioDraw All rights reserved
46岁微软:从盖茨缔造帝国到纳德拉复兴第二章 初识C语言常量2021前端高频面试题(一定要看哦!!!)滤波器,窗函数以及切比雪夫逼近法新手快速了解冒泡排序、插入排序的详解pytorch训练过程中GPU利用率低Golang经典面试题初识Mongdb之数据查询篇(三)人类第一架火星直升机正在部署 择机在这颗异域星球首飞python判断两个列表(list)中的值是否相同([1,2,3]和[3,2,1])