洗礼灵魂，修炼python（88）-- 知识拾遗篇 —— 线程（2）/多线程爬虫
线程（下）
7.同步锁
这个例子很经典，实话说，这个例子我是直接照搬前辈的，并不是原创，不过真的也很有意思，请看：
#!usr/bin/env python
#-*- coding:utf-8 -*-
# author:yangva
import threading,time
number = 100
def subnum():
global number
number -= 1
threads = []
for i in range(100):
t = threading.Thread(target=subnum,args=[])
t.start()
threads.append(t)
for i in threads:
i.join()
print(number)
这段代码的意思是，用一百个线程去减1，以此让变量number为100的变为0
结果:
那么我稍微的改下代码看看：
#!usr/bin/env python
#-*- coding:utf-8 -*-
# author:yangva
import threading,time
number = 100
def subnum():
global number
temp = number
time.sleep(0.2)
number = temp -1
threads = []
for i in range(100):
t = threading.Thread(target=subnum,args=[])
t.start()
threads.append(t)
for i in threads:
i.join()
print(number)
并没有很大的改变对吧，只是加了一个临时变量，并且中途停顿了０.２ｓ而已。
而这个结果就不一样了：
这里我先说下，time.sleep(0.2)是我故意加的，就是要体现这个效果，如果你的电脑不加sleep就已经出现这个情况了那么你就不用加了，这咋回事呢？这就是线程共用数据的潜在危险性，因为线程都是抢着CPU资源在运行，只要发现有空隙就各自抢着跑，所以在这停顿的０.２ｓ时间中，就会有新的线程抢到机会开始运行，那么一百个线程就有一百个线程在抢机会运行，抢到的时间都是在temp还没有减1的值，也就是100，所以大部分的线程都抢到了100，然后减1，少部分线程没抢到，抢到已经减了一次的99，这就是为什么会是99的原因。而这个抢占的时间和结果并不是根本的原因，究其根本还是因为电脑的配置问题了，配置越好的话，这种越不容易发生，因为一个线程抢到CPU资源后一直在运行，其他的线程在短暂的时间里得不到机会。
而为什么number -= 1，不借助其他变量的写法就没事呢？因为numebr -= 1其实是两个步骤，减1并重新赋值给number，这个动作太快，所以根本没给其他的线程机会。
图解：
那么这个问题我们怎么解决呢，在以后的开发中绝对会遇到这种情况对吧，这个可以解决呢？根据上面的讲解，有人会想到用join，而前面已经提过了join会使多线程变成串行，失去了多线程的用意。这个到底怎么解决呢，用同步锁
同步锁：当运行开始加锁，防止其他线程索取，当运行结束释放锁，让其他线程继续
#!usr/bin/env python
#-*- coding:utf-8 -*-
# author:yangva
import threading,time
r = threading.Lock() #创建同步锁对象
number = 100
def subnum():
global number
r.acquire() #加锁
temp = number
time.sleep(0.2)
number = temp - 1
r.release() #释放
threads = []
for i in range(100):
t = threading.Thread(target=subnum,args=[])
t.start()
threads.append(t)
for i in threads:
i.join()
print(number)
运行结果：
但是你发现没，这个运行太慢了，每个线程都运行了一次sleep，竟然又变成和串行运行差不多了对吧？不过还是和串行稍微有点不同，只是在有同步锁那里是串行，在其他地方还是多线程的效果
那么有朋友要问了，既然都是锁，已经有了一个GIL，那么还要同步锁来干嘛呢？一句话，GIL是着重于保证线程安全，同步锁是用户级的可控机制，开发中防止这种不确定的潜在隐患
8.死锁现象/可重用锁
前面既然已经用了同步锁，那么相信在以后的开发中，绝对会用到使用多个同步锁的时候，所以这里模拟一下使用两个同步锁，看看会有什么现象发生
#!usr/bin/env python
#-*- coding:utf-8 -*-
# author:yangva
import threading,time
a = threading.Lock() #创建同步锁对象a
b = threading.Lock() #创建同步锁对象b
def demo1():
a.acquire() #加锁
print('threading model test A....')
b.acquire()
time.sleep(0.2)
print('threading model test B....')
b.release()
a.release() #释放
def demo2():
b.acquire() #加锁
print('threading model test B....')
a.acquire()
time.sleep(0.2)
print('threading model test A....')
a.release()
b.release() #释放
threads = []
for i in range(5):
t1 = threading.Thread(target=demo1,args=[])
t2 = threading.Thread(target=demo2,args=[])
t1.start()
t2.start()
threads.append(t1)
threads.append(t2)
for i in threads:
i.join()
运行结果：
这里就一直阻塞住了，因为demo1函数用的锁是外层a锁，内层b锁，demo2函数刚好相反，外层b锁，内层a锁，所以当多线程运行时，两个函数同时在互抢锁，谁也不让谁，这就导致了阻塞，这个阻塞现象又叫死锁现象。
那么为了避免发生这种事，我们可以使用threading模块下的RLOCK来创建重用锁依此来避免这种现象
#!usr/bin/env python
#-*- coding:utf-8 -*-
# author:yangva
import threading,time
r = threading.RLock() #创建重用锁对象
def demo1():
r.acquire() #加锁
print('threading model test A....')
r.acquire()
time.sleep(0.2)
print('threading model test B....')
r.release()
r.release() #释放
def demo2():
r.acquire() #加锁
print('threading model test B....')
r.acquire()
time.sleep(0.2)
print('threading model test A....')
r.release()
r.release() #释放
threads = []
for i in range(5):
t1 = threading.Thread(target=demo1,args=[])
t2 = threading.Thread(target=demo2,args=[])
t1.start()
t2.start()
threads.append(t1)
threads.append(t2)
for i in threads:
i.join()
运行结果:
这个Rlock其实就是Lock+计算器，计算器里的初始值为0，每嵌套一层锁，计算器值加1，每释放一层锁，计算器值减1，和同步锁一样，只有当值为0时才算结束，让其他线程接着抢着运行。而这个Rlock也有一个官方一点的名字，递归锁
那么估计有朋友会问了，为什么会有死锁现象呢？或者你应该问，是什么生产环境导致有死锁现象的，还是那句，为了保护数据同步性，防止多线程操作同一数据时发生冲突。这个说辞很笼统对吧，我说细点。比如前面的购物车系统，虽然我们在操作数据时又重新取了一遍数据来保证数据的真实性，如果多个用户同时登录购物车系统在操作的话，或者不同的操作但会涉及到同一个数据的时候，就会导致数据可能不同步了，那么就可以在内部代码里加一次同步锁，然后再在实际操作处再加一次同步锁，这样就出现多层同步锁，那么也就会出现死锁现象了，而此时这个死锁现象是我们开发中正好需要的。
我想，说了这个例子你应该可以理解为什么lock里还要有lock，很容易导致死锁现象我们还是要用它了，总之如果需要死锁现象就用同步锁，不需要就换成递归锁。
9.信号量/绑定式信号量
信号量也是一个线程锁
1）Semaphore
信号量感觉更有具有多线程的意义。先不急着说，看看例子就懂：
#!usr/bin/env python
#-*- coding:utf-8 -*-
# author:yangva
import threading,time
s = threading.Semaphore(3) #创建值为3的信号量对象
def demo():
s.acquire() #加锁
print('threading model test A....')
time.sleep(2)
s.release() #释放
threads = []
for i in range(10):
t = threading.Thread(target=demo,args=[])
t.start()
threads.append(t)
for i in threads:
i.join()
运行结果：
如果你亲自测试这段代码，你会发现，这个结果是3个一组出的，出了3次3个一组的，最后出了一个一组，3个一组都是并行的，中间停顿2秒。
这里可以给很形象的例子，假如某个地方的停车位只能同时停3辆车，当停车位有空时其他的车才可以停进来。这里的3个停车位就相当于信号量。
2）BoundedSemaphore
既然有信号量为我们完成这些一组一组的操作结果，但敢不敢保证这些线程就不会突然的越出这个设定好的车位呢？比如设定好的3个信号量一组，我们都知道线程是争强着运行，万一就有除了设定的3个线程外的一两个线程抢到了运行权，谁也不让谁，就是要一起运行呢？好比，这里只有3个车位，已经停满了，但有人就是要去挤一挤，出现第4辆或者第5辆车的情况，这个和现实生活中的例子简直太贴切了对吧？
那么我们怎么办？当然这个问题早就有人想好了，所以有了信号量的升级版——绑定式信号量（BoundedSemaphore）。既然是升级版，那么同信号量一样该有的都有的，用法也一样，就是有个功能，在设定好的几个线程一组运行时，如果有其他线程也抢到运行权，那么就会报错。
比如thread_lock = threading.BoundedSemaphore(5)，那么多线程同时运行的线程数就必须在5以内（包括5），不然就报错。换句话，它拥有了实时监督的功能，好比停车位上的保安，如果发现车位满了，就禁止放行车辆，直到有空位了再允许车辆进入停车。
因为这个很简单，就多了个监督功能，其他和semaphore一样的用法，我就不演示了，自己琢磨吧
10.条件变量同步锁
不多说，它也是一个线程锁，本质上是在Rlock基础之上再添加下面的三个方法
condition = threading.Condition([Lock/RLock])，默认里面的参数是Rlock
wait()：条件不满足时调用，释放线程并进入等待阻塞
notify()：条件创造后调用，通知等待池激活一个线程
notifyall()：条件创造后调用，通知等待池激活所有线程
直接上例子
#!usr/bin/env python
#-*- coding:utf-8 -*-
# author:yangva
import threading,time
from random import randint
class producer(threading.Thread):
'''
生产者
'''
def run(self):
global Li
while True:
value = randint(0,100) #创建一百以内随机数
print('生产者',self.name,'Append：'+str(value),Li)
if con.acquire(): #加锁
Li.append(value) #把产品加入产品列表里
con.notify() #通知等待池里的消费者线程激活并运行
con.release() #释放
time.sleep(3) #每3秒做一次产品
class consumer(threading.Thread):
'''
消费者
'''
def run(self):
global Li
while True:
con.acquire() #获取条件变量锁，必须和生产者同一个锁对象，生产者通知后在此处开始运行
if len(Li) == 0: #如果产品列表内没数据，表示消费者先抢到线程运行权
con.wait() #阻塞状态，等待生产者线程通知
print('消费者',self.name,'Delete：'+str(Li [0]),Li)
Li.remove(Li[0]) #删除被消费者用掉的产品
con.release() #释放
time.sleep(0.5) #每0.5秒用掉一个产品
con = threading.Condition() #创建条件变量锁对象
threads = [] #线程列表
Li = [] #产品列表
for i in range(5):
threads.append(producer())
threads.append(consumer())
for i in threads:
i.start()
for i in threads:
i.join()
运行结果：
图片只截取了部分，因为它一直在无线循环着的。这个生产者和消费者的模型很经典，必须理解，每个步骤分别什么意思我都注释了，不再赘述了。
11.event事件
类似于condition，但它并不是一个线程锁，并且没有锁的功能
event = threading.Event()，条件环境对象，初始值为False
event.isSet()：返回event的状态值
event.wait()：如果event.isSet()的值为False将阻塞
event.set()：设置event的状态值为True，所有阻塞池的线程激活并进入就绪状态，等待操作系统调度
event.clear()：恢复event的状态值False
不多说，看一个例子：
#!usr/bin/env python
#-*- coding:utf-8 -*-
# author:yangva
import threading,time
class boss(threading.Thread):
def run(self):
print('boss:今晚加班！')
event.isSet() or event.set() #设置为True
time.sleep(5) #切换到员工线程
print('boss:可以下班了')
event.isSet() or event.set() #又设置为True
class worker(threading.Thread):
def run(self):
event.wait() #等待老板发话，只有值为True再往下走
print('worker:唉～～～，又加班')
time.sleep(1) #开始加班
event.clear() #设置标志为false
event.wait() #等老板发话
print('worker:oh yeah，终于可以回家了')
event = threading.Event()
threads = []
for i in range(5):
threads.append(worker())
threads.append(boss())
for i in threads:
i.start()
for i in threads:
i.join()
运行结果：
其实这个和condition的通信原理是一样的，只是condition用的是notify，event用的set和isset
*12.队列（queue）
本质上，队列是一个数据结构。
1)创建一个“队列”对象
import Queue
q = Queue.Queue(maxsize = 10)
Queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。可通过Queue的构造函数的可选参数maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限。
2)将一个值放入队列中
q.put(obj)
调用队列对象的put()方法在队尾插入一个项目。put()有两个参数，第一个item为必需的，为插入项目的值；第二个block为可选参数，默认为
1。如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。如果block为0，put方法将引发Full异常。
3)将一个值从队列中取出
q.get()
调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block，默认为True。如果队列为空且block为True，get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常。
例：
4)Python Queue模块有三种队列及构造函数:
- Python Queue模块的FIFO队列先进先出 class queue.Queue(maxsize)
- LIFO类似于堆，即先进后出 class queue.LifoQueue(maxsize)
- 还有一种是优先级队列级别越低越先出来 class queue.PriorityQueue(maxsize)
当maxsize值比put的数量少时就会阻塞住，当数据被get后留有空间才能接着put进去，类似于线程的信号量
5)queue中的常用方法(q = Queue.Queue()):
q.qsize()：返回队列的大小
q.empty()：如果队列为空，返回True,反之False
q.full()：如果队列满了，返回True,反之False，q.full与 maxsize 大小对应
q.get([block[, timeout]]) 获取队列，timeout等待时间
q.get_nowait()：相当q.get(False)
q.put_nowait(item)：相当q.put(item, False)
q.task_done()：在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号
q.join()：实际上意味着等到队列为空，再执行别的操作
6）队列有什么好处，与列表区别
队列本身就有一把锁，内部已经维持一把锁，如果你用列表的话，当环境是在多线程下，那么列表数据就一定会有冲突，而队列不会，因为此，队列有个外号——多线程利器
例：
#!usr/bin/env python
#-*- coding:utf-8 -*-
# author:yangva
import threading,time
import queue
from random import randint
class productor(threading.Thread):
def run(self):
while True:
r = randint(0,100)
q.put(r)
print('生产出来 %s 号产品'%r)
time.sleep(1)
class consumer(threading.Thread):
def run(self):
while True:
result =q.get()
print('用掉 %s 号产品'%result)
time.sleep(1)
q = queue.Queue(10)
threads = []
for i in range(3):
threads.append(productor())
threads.append(consumer())
for i in threads:
i.start()
运行结果：
这里根本不用加锁就完成了前面的生产者消费者模型，因为queue里面自带了一把锁。
好的，关于线程的知识点，讲解完。
多线程式爬虫
有的朋友学完线程还不知道线程到底能运用于哪些生活实际，好的，不多说，来，我们爬下堆糖网（https://www.duitang.com/）的校花照片。
import requests
import urllib.parse
import threading,time,os
#设置照片存放路径
os.mkdir('duitangpic')
base_path = os.path.join(os.path.dirname(__file__),'duitangpic')
#设置最大信号量线程锁
thread_lock=threading.BoundedSemaphore(value=10)
#通过url获取数据
def get_page(url):
header={'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'}
page=requests.get(url,headers=header)
page=page.content #content是byte
#转为字符串
page=page.decode('utf-8')
return page
#label 即是搜索关键词
def page_from_duitang(label):
pages=[]
url='https://www.duitang.com/napi/blog/list/by_search/?kw={}&start={}&limit=1000'
label=urllib.parse.quote(label)#将中文转成url(ASCII)编码
for index in range(0,3600,100):
u=url.format(label,index)
#print(u)
page=get_page(u)
pages.append(page)
return pages
def findall_in_page(page,startpart,endpart):
all_strings=[]
end=0
while page.find(startpart,end) !=-1:
start=page.find(startpart,end)+len(startpart)
end=page.find(endpart,start)
string=page[start:end]
all_strings.append(string)
return all_strings
def pic_urls_from_pages(pages):
pic_urls=[]
for page in pages:
urls=findall_in_page(page,'path":"','"')
#print('urls',urls)
pic_urls.extend(urls)
return pic_urls
def download_pics(url,n):
header={'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'}
r=requests.get(url,headers=header)
path=base_path+'/'+str(n)+'.jpg'
with open(path,'wb') as f:
f.write(r.content)
#下载完，解锁
thread_lock.release()
def main(label):
pages=page_from_duitang(label)
pic_urls=pic_urls_from_pages(pages)
n=0
for url in pic_urls:
n+=1
print('正在下载第{}张图片'.format(n))
#上锁
thread_lock.acquire()
t=threading.Thread(target=download_pics,args=(url,n))
t.start()
main('校花')
运行结果：
在与本py文件相同的目录下，有个duitangpic的文件夹，打开看看：
全是美女，而且不出意外又好几千张呢，我这只有一千多张是因为我手动结束了py程序运行，毕竟我这是演示，不需要真的等程序运行完。我大概估计，不出意外应该能爬到3000张左右的照片
怎么样，老铁，得劲不？刺不刺激？感受到多线程的用处了不？而且这还是python下的伪多线程（IO密集型，但并不算是真正意义上的多线程），你用其他的语言来爬更带劲。
