python 协程爬虫_Python爬虫进阶教程（二）：线程、协程

简介

线程

线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。线程没有自己的系统资源，只拥有在运行时必不可少的资源。但线程可以与同属与同一进程的其他线程共享进程所拥有的其他资源。

多线程类似同时执行多个不同程序，python的标准库提供了两个模块thread和threading，thread是低级模块，threading是高级模块，对thread进行了封装，大多情况下，我们只使用threading模块即可。

threading模块

此模块在较低级别的thread模块之上构建的更高级别的线程接口，一般通过两种方式实现多线程，第一种方式是把一个函数传入并创建实例，然后调用start方法执行；第二种方式是直接从threading.Thread继承并创建线程类，然后重写init方法和run方法。

第一种方式代码示例：

import time

import random

import threading

'''更多Python学习资料以及源码教程资料，可以在群821460695 免费获取'''

def t_run(urls):

"""线程执行代码"""

# threading.current_thread()返回当前的Thread对象，对应于调用者控制的线程。

# 如果调用者控制的线程不是通过threading模块创建的，则返回一个只有有限功能的虚假线程对象。

print('Current%sis running...' % threading.current_thread().name)

for url in urls:

print(' threading%s----->%s' % (threading.current_thread().name, url))

time.sleep(random.random())

print('%sended.' % threading.current_thread().name)

if __name__ == '__main__':

# 创建两个线程实例

t1 = threading.Thread(target=t_run, name='Thread_1', args=(['url1', 'url2'],))

t2 = threading.Thread(target=t_run, name='Thread_2', args=(['url3', 'url4'],))

# 启动线程

t1.start()

t2.start()

# 等待线程结束

t1.join()

t2.join()

print('%sended.' % threading.current_thread().name)

运行结果如下：

Current Thread_1 is running...

threading Thread_1 -----> url1

Current Thread_2 is running...

threading Thread_2 -----> url3

threading Thread_1 -----> url2

threading Thread_2 -----> url4

Thread_2 ended.

Thread_1 ended.

MainThread ended.

第二种方式用threading.Thread继承创建线程类

import time

import random

import threading

class MyThread(threading.Thread):

"""定义线程类"""

def __init__(self, name, urls):

"""初始化，重写线程"""

threading.Thread.__init__(self, name=name)

self.urls = urls

def run(self):

"""执行函数"""

# 打印当前线程名

print('Current%sis running...' % threading.current_thread().name)

for url in self.urls:

print('Thread%s------>%s' % (threading.current_thread().name, url))

time.sleep(random.random())

print('%sended.' % threading.current_thread().name)

if __name__ == '__main__':

print('%sis running...' % threading.current_thread().name)

t1 = MyThread(name='Thread_1', urls=['url1', 'url2'])

t2 = MyThread(name='Thread_2', urls=['url3', 'url4'])

t1.start()

t2.start()

t1.join()

t2.join()

print('%sended.' % threading.current_thread().name)

结果如下：

MainThread is running...

Current Thread_1 is running...

Thread Thread_1 ------> url1

Current Thread_2 is running...

Thread Thread_2 ------> url3

Thread Thread_1 ------> url2

Thread Thread_2 ------> url4

Thread_1 ended.

Thread_2 ended.

MainThread ended.

线程同步

如果多个线程共同对某个数据进行修改，就有可能会造成不可预料的结果，为了防止这种情况发生，需要对线程进行同步，使用Lock和Rlock可以实现简单线程同步。

Lock 对象

一个可重入锁处于“locked”或者“unlocked”状态中的一种。它创建时处于unlocked状态。它有两个基本方法，acquire()和release()。当状态是unlocked时，acquire()改变该状态为locked并立即返回。当状态被锁定时，acquire()阻塞，直到在另一个线程中对release()的调用将其改为unlocked，然后acquire()执行，release()方法只应在锁定状态下调用；它将状态更改为已解锁并立即返回。如果尝试释放已解锁的锁，将会引发RuntimeError。

Rlock 对象

一个可重入锁必须由获得它的线程释放。一旦线程获得了可重入锁，同一线程可以再次获取它而不阻塞；在所有的release操作完成后，别的线程才能申请Rlock对象，见下面例子：

import threading

# 创建Rlock实例

lock = threading.RLock()

# 定义变量

num = 0

class MyThread(threading.Thread):

"""定义线程类"""

def __init__(self, name):

"""重新定义name"""

threading.Thread.__init__(self, name=name)

def run(self):

"""执行函数"""

# 全局变量num

global num

while True:

# 加锁

lock.acquire()

print('%slocked, Number:%d' % (threading.current_thread().name, num))

if num >= 4:

# 解锁

lock.release()

print('%sreleased, Number:%d' % (threading.current_thread().name, num))

break

num += 1

print('%sreleased, Number:%d' % (threading.current_thread().name, num))

lock.release()

if __name__ == '__main__':

thread1 = MyThread('Thread_1')

thread2 = MyThread('Thread_2')

thread3 = MyThread('Thread_3')

thread1.start()

thread2.start()

thread3.start()

运行结果如下：

Thread_1 locked, Number: 0

Thread_1 released, Number: 1

Thread_1 locked, Number: 1

Thread_1 released, Number: 2

Thread_1 locked, Number: 2

Thread_1 released, Number: 3

Thread_1 locked, Number: 3

Thread_1 released, Number: 4

Thread_1 locked, Number: 4

Thread_1 released, Number: 4

Thread_2 locked, Number: 4

Thread_2 released, Number: 4

Thread_3 locked, Number: 4

Thread_3 released, Number: 4

可以看出Rlock锁只有线程1的num为4时，调用release方法，全部解锁后，线程2才可以调用，线程2开始时num就是4，所以也直接到if判断结束，调用release后，线程3开始执行。

全局解释器锁(GIL)

首先说的一点是GIL并不是Python的特性，它是Python解析器(CPython)引入的一个概念。像其中的JPython就没有GIL。然而因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python，也就把GIL归结为Python语言的缺陷。所以这里要先明确一点：GIL并不是Python的特性，Python完全可以不依赖于GIL。 GIL全称Global Interpreter Lock，是一个互斥锁，它可以防止多个本地线程同时执行Python的某个值，毫无疑问全局锁的存在会对多线程的效率有不小影响。几乎等于Python是个单线程的程序。(这也是大家吐槽python多线程慢的槽点)

协程

协程又称微线程、纤程，就好比同时开启多个任务，但一次只顺序执行一个。等到所执行的任务遭遇阻塞，就切换到下一个任务继续执行，以期节省下阻塞所占用的时间。协程与线程类似，每个协程表示一个执行单元，有自己的本地数据，与其它协程共享全局数据和其它资源。对CPU来说协程就是单线程，不必考虑切换开销。那么python如何实现协程呢？Python对协程的支持是通过generator实现的。在generator中，我们不但可以通过for循环来迭代，还可以不断调用next()函数获取由yield语句返回的下一个值。但是Python的yield不但可以返回一个值，它还可以接收调用者发出的参数。见下面简单生产者消费者示例：

def consumer():

r = ''

while True:

# 这个地方注意，到达这个yield后，就会抛出n的值，暂停等待next或send继续

n = yield r

if not n:

return

print('[CONSUMER] Consuming%s...' % n)

r = '200 OK'

def produce(c):

c.send(None)

n = 0

while n < 5:

n = n + 1

print('[PRODUCER] Porducing%s...' % n)

r = c.send(n)

print('[PRODUCER] Consumer return:%s...' % r)

c.close()

c = consumer()

produce(c)

结果如下：

[PRODUCER] Porducing 1 ...

[CONSUMER] Consuming 1 ...