Python多线程，大杂烩

搞任何编程语言肯定都离不开多线程，Python肯定也不例外，虽然Python的多线程并不完美，但还是经常会用到滴，尤其是网络爬虫这些东西，效率很很重要，所以我就屁颠屁颠的来写这篇文章啦！

多线程是为了同步完成多项任务，通过提高资源使用效率来提高系统的效率，线程是在同一时间需要完成多项任务的时候实现的。
多线程就像火车的每一节车厢，而进程则是火车，车厢离开火车是无法跑动的，火车可以有多节车厢，多线程的出现就是为了提高效率，同时使用它也会带来了一些问题。

_thread模块

这是一个被弃用的模块，基本上没人会使用它了

_thread.start_new_thread()
第一个参数是调用的函数，第二个参数是调用函数的参数，需要传入一个序列，一般会用元祖或列表方式传入，一个参数也要用[]或()括起来

import time
import _thread

# 单线程
def worker(n):
    print(f'函数执行于：{time.ctime()}')
    time.sleep(n)
    print(f'函数结束于：{time.ctime()}')


def main1():
    print(f'主函数执行开始于：{time.ctime()}')
    worker(4)
    worker(2)
    print(f'主函数执行结束于：{time.ctime()}')


# _thread 实现多线程(已经弃用的模块，不推荐使用了)
def worker(n):
    print(f'函数执行于：{time.ctime()}')
    time.sleep(n)       # 用延迟模拟执行某任务
    print(f'函数结束于：{time.ctime()}')


def main2():
    print(f'主函数执行开始于：{time.ctime()}')
    _thread.start_new_thread(worker, (4,))
    _thread.start_new_thread(worker, (2,))

    time.sleep(4)     # 加延迟才会打印子函数  而且显示的还不正常
    print(f'主函数执行结束于：{time.ctime()}')

threading模块

threading模块是python中专门提供用来做多线程编程的模块，threading模块中最常用的类是Thread

threading.Thread()
第一个参数是调用的函数，第二个参数是调用函数的参数，需要传入一个序列，一般会用元祖或列表方式传入，一个参数也要用[]或()括起来

import threading
import time

def coding():
    for x in range(3):
        print('%s正在写代码' % x)
        time.sleep(1)

def drawing():
    for x in range(3):
        print('%s正在画图' % x)
        time.sleep(1)

def single_thread():   # 单线程
    coding()
    drawing()

def multi_thread():
    print('多线程开始执行')
    t1 = threading.Thread(target=coding)
    t2 = threading.Thread(target=drawing)

    t1.start()
    t2.start()

    t1.join()  # join()：主线程会等待所有子线程执行完才执行后面的代码
    t2.join()
    print('多线程执行完毕')

if __name__ == '__main__':
    multi_thread()

查看线程数

使用threading.enumerate()函数便可以看到当前线程的数量

查看当前线程的名字

使用threading.current_thread()可以看到当前线程的信息

示例2

import time
import threading

""" threading.Thread() 实例 实现多线程
"""


def worker(n):
    print(f'{threading.current_thread().name} 函数执行于：{time.ctime()}')
    time.sleep(n)       # 用延迟模拟执行某任务
    print(f'{threading.current_thread().name} 函数结束于：{time.ctime()}')


def main():
    print(f'主函数执行开始于：{time.ctime()}')

    threads = []

    t1 = threading.Thread(target=worker, args=(4,))
    threads.append(t1)

    t2 = threading.Thread(target=worker, args=(2,))
    threads.append(t2)

    for t in threads:
        t.start()

    for t in threads:
        t.join()

    print(f'主函数执行结束于：{time.ctime()}')


if __name__ == '__main__':
    main()

继承自threading.Thread类

为了让线程代码更好的封装，可以使用threading模块下的Thread类，继承自这个类，然后实现run方法，线程就会自动运行run方法中的代码

import threading
import time


class CodingThread(threading.Thread):
    # 继承Thread类并将代码直接写在run函数里
    name = '铁牛'
    
    def run(self):
        for x in range(3):
            # print('%s正在写代码' % threading.current_thread())
            print(f'{threading.current_thread()}  {CodingThread.name} 正在写代码')
            time.sleep(1)


class DrawingThread(threading.Thread):
    name = '二蛋'
    
    def run(self):
        for x in range(3):
            # print('%s正在画图' % threading.current_thread())
            print(f'{threading.current_thread()}  {DrawingThread.name} 正在画画')
            time.sleep(1)


def multi_thread():
    t1 = CodingThread()
    t2 = DrawingThread()

    t1.start()
    t2.start()


if __name__ == '__main__':
    multi_thread()

示例2

import time
import threading

""" threading.Thread 派生类 实现多线程
自定义Thread派生类，重写run方法逻辑
"""


lock = threading.Lock()     # 锁


def worker(n):
    # lock.acquire()          # 获取锁
    print(f'{threading.current_thread().name} 函数执行于：{time.ctime()}')
    time.sleep(n)       # 用延迟模拟执行某任务
    print(f'{threading.current_thread().name} 函数结束于：{time.ctime()}')
    # lock.release()          # 释放锁


class MyThread(threading.Thread):
    def __init__(self, func, args):       # 自定义的两个实例属性
        threading.Thread.__init__(self)   # 继承基类Thread所有的参数
        self.func = func
        self.args = args

    def run(self):
        # run是基类Thread类启动线程的函数，现在重写run方法逻辑，把基类Thread的覆盖掉
        self.func(*self.args)    # 重写多线程运行时传入的函数和参数
        # worker(参数1,参数2, ...)


def main():
    print(f'主函数执行开始于：{time.ctime()}')

    threads = []

    for i in range(3):
        # 用for遍历线程数，线程设置3会立马创建6条线程，因为调用了两次，所以：2*3
        # 如果加锁的话会变很慢，相当于是单线程顺序执行的，每次都会等待每条线程执行完，
        # 不会立马创建6条线程，所以锁只有在对共享数据进行操作的场合才去使用。

        # t1 = threading.Thread(target=worker, args=(4,))
        t1 = MyThread(worker, (4,))     # 用自己定义的派生类执行多线程
        threads.append(t1)

        # t2 = threading.Thread(target=worker, args=(1,))
        t2 = MyThread(worker, (1,))    # 用自己定义的派生类执行多线程
        threads.append(t2)

    for t in threads:
        t.start()

    for t in threads:
        t.join()

    print(f'主函数执行结束于：{time.ctime()}')


if __name__ == '__main__':
    main()

多线程共享全局变量的问题

多线程都是在同一个进程中运行的，因此在进程中的全局变量所有线程都是可共享的，这就造成了一个问题，因为线程执行的顺序是无序的，所以有可能会造成数据错误

import threading

tickets = 0

def get_ticket():
    global tickets        # 函数内部调用并修改外面的全局变量需要用global定义
    for x in range(1000000):
        tickets += 1
    print('tickets:%d' % tickets)

def main():
    for x in range(2):   # 遍历两条线程
        t = threading.Thread(target=get_ticket)
        t.start()

if __name__ == '__main__':
    main()
    # 结果正常来讲应该是6，但是因为多线程运行的不确定性，因此最后的结果可能是随机的

锁机制

为了解决共享全局变量的问题，threading提供了一个Lock类，这个类可以在某个线程访问某个变量的时候加锁，其他线程此时就不能进来，直到当前线程处理完后，把锁释放了，其他线程才能进来处理

import threading

VALUE = 0

gLock = threading.Lock()

def add_value():
    global VALUE        # 函数内部调用并修改外面的全局变量需要用global定义
    gLock.acquire()
    for x in range(1000000):
        VALUE += 1       # 锁一般加在多条线程修改全局变量的的地方
    gLock.release()
    print('value：%d' % VALUE)  # 不加锁最后打印的结果是错的

def main():
    for x in range(2):
        t = threading.Thread(target=add_value)
        t.start()

if __name__ == '__main__':
    main()

示例2

import threading
import time
import random


eggs = []

lock = threading.Lock()     # 在外面定义一个锁


def put_egg(n, lst):
    lock.acquire()          # 获取锁
    for i in range(1, n+1):
        time.sleep(random.randint(0, 2))   # 随机延迟0-2秒
        # 模拟每条线程执行的时间不一样，如果不加锁最后打印出的列表会是乱的
        lst.append(i)
        # 列表作为函数的参数，函数内操作列表会改变列表，这里就是要这种效果
        print(eggs)
    lock.release()          # 释放锁


# 采用上下文方式实现锁机制
    # with lock:
    #     for i in range(1, n+1):
    #         lst.append(i)


def main():
    threads = []

    for i in range(3):
        # 用for循环遍历线程次数，因为子线程加了随机延迟，不加的话是一次性打印全部15个(3*5)
        t = threading.Thread(target=put_egg, args=(5, eggs))
        threads.append(t)

    for t in threads:
        t.start()

    for t in threads:
        t.join()

    print(f'已经把所有的鸡蛋按照顺序装进了篮子里！→ {eggs}')


if __name__ == "__main__":
    main()

生产者和消费者模式

生产者和消费者模式是多线程开发中经常见到的一种模式，生产者的线程专门用来生产一些数据，然后存放到一个中间的变量中，消费者再从这个中间的变量中取出数据进行消费，但是因为要使用中间变量，中间变量经常是一些全局变量，因此需要使用锁来保证数据完整性

Lock版本

使用threading.Lock锁实现生产者与消费者模式

import threading
import random
import time

gMoney = 1000               # 总金额初始值为1000
gLock = threading.Lock()    # 锁
gTotalTimes = 20            # 总生产次数
gTimes = 0                  # 起始生产次数(计次)，记录生产者生产的次数，达到总生产次数就不再生产


class Producer(threading.Thread):     # 生产者类(继承Thread)，赚钱
    def run(self):
        global gMoney
        global gTimes
        while True:
            money = random.randint(100, 1000)  # 随机生产100-1000元钱
            gLock.acquire()                    # 创建锁
            if gTimes >= gTotalTimes:          # 如果生产次数已经达到总生产次数
                gLock.release()                # 就先释放掉锁
                break         # 再跳出循环；在锁里面跳出必须要先释放掉锁 要不然会卡死在这里
            gMoney += money                    # 没有达到总生产次数就把生产的钱加入到总金额
            # print('%s当前存入%s元钱，剩余%s元钱' % (threading.current_thread(), money, gMoney))
            print('生产者[%s] 赚了%d元钱，总余额%d元钱'
                  % (threading.current_thread().name, money, gMoney))
            gTimes += 1                        # 生产次数计次
            gLock.release()                    # 释放锁
            time.sleep(0.5)                    # 延迟一段时间再继续生产


class Consumer(threading.Thread):     # 消费者类(继承Thread)，花钱
    def run(self):
        global gMoney
        while True:      # 消费者一般是个死循环，不停的进行消费
            money = random.randint(100, 1000)  # 随机花掉100-1000元钱
            gLock.acquire()
            if gMoney > money:                # 如果总金额>=要花掉的金额
                gMoney -= money               # 就花掉
                # print('%s当前取出%s元钱，剩余%s元钱' % (threading.current_thread(), money, gMoney))
                print('消费者[%s] 消费了%d元钱，总余额%d元钱'
                      % (threading.current_thread().name, money, gMoney))
                time.sleep(0.5)
            else:                           # 如果总金额<要花掉的金额
                # 如果钱不够了，有可能是已经超过了次数，这时候就判断一下
                if gTimes >= gTotalTimes:   # 判断生产者还在不在生产
                    gLock.release()         # 如果生产者已经不生产了就别傻乎乎的等了！先释放锁
                    break      # 再跳出循环；在锁里面跳出必须要先释放掉锁 要不然会卡死在这里
                # print("%s当前想取%s元钱，剩余%s元钱，不足！" % (threading.current_thread(),money,gMoney))
                print('消费者[%s] 准备消费%d元钱，总余额%d元钱，余额不足！'
                      % (threading.current_thread().name, money, gMoney))
                # 如果生产者还在生产，只是余额不足，就打印提示余额不足
            gLock.release()
            time.sleep(0.5)


def main():
    for x in range(6):       # 创建六个消费者
        Consumer(name='消费者线程%d' % x).start()

    for x in range(5):       # 创建五个生产者
        Producer(name='生产者线程%d' % x).start()


if __name__ == '__main__':
    main()

重写Thread类，创建生产者类和消费者类，并用Lock实现生产者和消费者

加一些循环、判断、延迟、变量记录、上锁、释放锁来控制达到生产者和消费者进行生成产和消费

Condition版本

Lock版本的生产者与消费者模式可以正常的运行，但是存在一个不足，在消费者中，总是通过while True死循环并且上锁的方式去判断钱够不够，上锁是一个很耗费CPU资源的行为，因此这种方式不是最好的

还有一种更好的方式便是使用threading.Condition来实现，可以在没有数据的时候让线程处于阻塞等待状态(使用wait方法)，一旦有合适的数据了，还可以使用notify相关的函数来通知其他处于等待状态的线程，这样就可以不用做一些无用的上锁和解锁操作，可以提高程序的性能

threading.Condition类似threading.Lock，可以在修改全局数据的时候进行上锁，在修改完毕后进行解锁

常用的方法

acquire：上锁 类似 threading.Lock的acquire
release：解锁 类似 threading.Lock的release
wait：将当前线程置于阻塞等待状态，并且会释放锁，可以被其他线程使用notify和notify_all函数唤醒，被唤醒后会继续等待上锁，上锁后继续执行下面的代码
notify：通知某个正在等待的线程，默认是第1个等待的线程
notify_all：通知所有正在等待的线程

notify和notify_all不会释放锁，并且需要在release之前调用

import threading
import random
import time

gMoney = 1000
gCondition = threading.Condition()
gTotalTimes = 20
gTimes = 0


class Producer(threading.Thread):
    def run(self):
        global gMoney
        global gTimes
        while True:
            money = random.randint(100, 1000)
            gCondition.acquire()
            if gTimes >= gTotalTimes:
                gCondition.release()
                print('当前生产者总共生产了%s次' % gTimes)
                break
            gMoney += money
            # print('%s当前存入%s元钱，剩余%s元钱' % (threading.current_thread(), money, gMoney))
            print('生产者[%s] 赚了%d元钱，总余额%d元钱'
                  % (threading.current_thread().name, money, gMoney))
            gTimes += 1
            time.sleep(0.5)
            gCondition.notify_all()             # 成功生产后，通知(唤醒)所有等待中的线程
            gCondition.release()
            time.sleep(0.5)


class Consumer(threading.Thread):
    def run(self):
        global gMoney
        while True:
            money = random.randint(100, 1000)
            gCondition.acquire()
            # 这里要给个while循环判断，因为等轮到这个线程的时候，条件有可能又不满足了
            while gMoney < money:               # 用while判断总金额是否<要花掉的金额
                if gTimes >= gTotalTimes:       # <的话再判断生产者还在不在生产
                    gCondition.release()        # 如果生产者已经不生产了就别傻乎乎的等了！先释放锁
                    return                      # 再return
                    # 这里如果用break的话只会跳出这个while循环，外面的会继续执行，所以用return把整个函数返回
                # print('%s准备取%s元钱，剩余%s元钱，不足！'%(threading.current_thread(),money,gMoney))
                print('消费者[%s] 准备消费%d元钱，总余额%d元钱，余额不足！'
                      % (threading.current_thread().name, money, gMoney))
                gCondition.wait()
            ''''如果只是小于并不是不生产了就用.wait()等待(线程挂起)。然后继续一直这样在这个循环里判断，而不是像是要Lock那样还傻乎乎的一直加锁解锁等待！
            
            这里需要用while这样一直判断下去，如果用if就不行了，用if的话只会判断一次，假如过了一会生产者生产了钱 通知了这边的消费者线程来消费，
            但是这个时候有可能刚好来了另外的线程是没有执行过wait()的(来的早不如来得巧)，那么这条刚来的线程可能会抢先在这条排队等待的线程前面执行，
            等到这条.wait()排队的线程苏醒后再来执行的时候，它会不管三七二十一直接执行下面的gMoney -= money，
            但是这个时候有可能gMoney已经 < money了，因为前面那条刚来的线程已经执行了一次了。
            就好像我排队买票的时候在一边玩手机，这个时候售票的通知有票了，但是刚好了来了插队的抢先了，等他或他们买了之后又没票了，那我肯定不愿意啊，跟售票员说：“你今天死也要卖给我一张票”。'''
            gMoney -= money                     # 总金额不<要花掉的金额了就进行消费
            # print('%s当前取出%s元钱，剩余%s元钱' % (threading.current_thread(), money, gMoney))
            print('消费者[%s] 消费了%d元钱，总余额%d元钱'
                  % (threading.current_thread().name, money, gMoney))
            gCondition.release()
            time.sleep(0.5)


def main():
    for x in range(6):       # 创建六个消费者
        Consumer(name='消费者线程%d' % x).start()

    for x in range(4):       # 创建四个生产者
        Producer(name='生产者线程%d' % x).start()


if __name__ == '__main__':
    main()

Queue线程安全队列

在线程中，访问一些全局变量，加锁是一个经常的过程，如果想把一些数据存储到某个队列中，Python内置了一个线程安全的模块叫做queue模块

模块中提供了同步的、线程安全的队列类，包括FIFO（先进先出）队列Queue，LIFO（后入先出）队列LifoQueue，这些队列都实现了锁原语（可以理解为原子操作，即要么不做，要么都一次性做完），能够在多线程中直接使用，可以使用队列来实现线程间的同步

相关的方法

初始化Queue(maxsize)：创建一个先进先出的队列，maxsize英文是最大尺寸的意思
qsize()：返回队列的大小
empty()：判断队列是否为空
full()：判断队列是否满了
get()：从队列中取最后一个数据
put()：将一个数据放到队列中

from queue import Queue
import time
import threading


q = Queue(4)            # 创建一个对象(队列)  指定队列中最多可以放4个元素

q.put(1)                # 向队列中添加一个元素
q.put('1')              # 向队列中再添加一个元素

print(q.qsize())        # 判断队列有中几个元素
print(q.get())          # 从队列中取最后一个元素；先进先出
print(q.qsize())        # 再判断队列有中几个元素

print(q.empty())        # 判断队列是否为空
print(q.full())         # 判断队列是否满了


for i in range(4):      # 通过for循环
    q.put(i)            # 向队列中添加四个元素
    print(q.full())     # 判断队列是否满了

for i in range(4):      # 通过for循环
    print(q.get())      # 从队列中取出最后四个元素；先进先出

q.get(block=True)不指定 block默认为真
[从一个队列中获取值的时候，如果队列中没有值就不再取了：一直阻塞在当前位置，直到有值]

q.put(block=True)不指定 block默认为真
[往一个队列中添加值的时候，如果队列满了就不再添加了：一直阻塞在当前位置，直到有空闲]

使用多线程来操作队列

def set_value(q):
    index = 0
    while True:     # 通过死循环一直向队列中添加元素
        q.put(index)
        index += 1
        time.sleep(3)


def get_value(q):
    while True:     # 通过死循环一直从队列中取最后一个元素
        print(q.get())
        # 每隔三秒才会打印一次，因为上面添加元素的时候是延迟三秒，这个时候才有元素可取
        # 因为block=True，所以上面还没添加它就会执行阻塞，就会乖乖得等三秒，等上面添加了元素再获取


def main():
    q = Queue(4)     # 创建一个对象(队列)  指定队列中最多可以放4个元素
    t1 = threading.Thread(target=set_value, args=[q])
    t2 = threading.Thread(target=get_value, args=[q])

    t1.start()
    t2.start()


if __name__ == '__main__':
    main()

示例2

import threading
import queue
import time
import random

""" LIFO(先进先出) 队列示例
"""


def producer(data_queue):                 # 生产者函数
    for i in range(5):
        time.sleep(0.5)
        item = random.randint(1, 100)     # 准备一个数据项(随机生成1-100范围整数)
        data_queue.put(item)              # 向队列中添加数据项(item)
        print(f'{threading.current_thread().name} 在队列中放入数据项：{item}')


def consumer(data_queue):               # 消费者函数
    while True:
        try:
            item = data_queue.get(timeout=3)  # 取出队列中的最后一个元素(超时延迟3秒，3秒钟得不到就算超时)
            print(f'{threading.current_thread().name} 从队列中移除了 {item}')
        except queue.Empty:             # 如果捕获到异常Empty(说明队列为空)
            break                       # 跳出死循环
        else:
            data_queue.task_done()      # 如果一切正常的话，该取的都取到了，就声明当前队列任务执行完毕


def main():
    threads = []

    q = queue.Queue()    # 创建一个对象(队列)  不指定队列中最多可以放多少个元素

    p = threading.Thread(target=producer, args=(q,))        # 1生产者线程
    p.start()

    for i in range(1):    # 两个消费者
        c = threading.Thread(target=consumer, args=(q,))    # 2消费者线程
        threads.append(c)

    for t in threads:
        t.start()

    for t in threads:
        t.join()        # 主线程等待当前线程执行完毕

	p.join()

    q.join()   # 主线程等待队列执行完毕，队列所有项目处理完毕前阻塞
    # 这个是队列的join方法 跟多线程的用法一样

    print('执行完了')


if __name__ == '__main__':
    main()

单线程下载表情包

import requests
from lxml import etree
from urllib import request
import os
import re


def parse_page(url):
    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) '
               'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36'}
    response = requests.get(url, headers=headers)
    text = response.text
    html = etree.HTML(text)
    imgs = html.xpath('//div[@class="page-content text-center"]//img[@class!="gif"]')
    for img in imgs:
        img_url = img.get('data-original')
        # .get()是获取某个属性的值，得到的是字符串；和 //@属性 作用一样
        alt = img.get('alt')
        alt = re.sub(r'[\?？\.，。！\*]', '', alt)      # 把图片名称里面的符号替换成空白

        suffix = os.path.splitext(img_url)[1]
        # 使用os.path模块通过分割图片url获取图片的后缀，返回的是一个元组(链接, 后缀)，使用[1]取到后缀
        filename = alt + suffix       # 图片+后缀构造图片名称
        request.urlretrieve(img_url, 'C:\\Users\\Administrator\\Desktop\\images1\\' + filename)
        print(filename + ' 下载完成！')


def main():
    for i in range(1, 101):
        url = 'http://www.doutula.com/photo/list/?page='+str(i)
        print('当前正在下载第', str(i), '页所有表情包...')
        parse_page(url)


if __name__ == '__main__':
    main()

使用生产者与消费者模式多线程下载表情包

import requests
from lxml import etree
from urllib import request
import os
import re
from queue import Queue
import threading
import time


class Producer(threading.Thread):       # 生产者 多线程类，解析每张图片url
    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36'}

    def __init__(self,page_queue,img_queue,*args,**kwargs):
        # 重写init函数，*args, **kwargs代表任意参数，所以就继承Thread基类所有的参数了
        super(Producer, self).__init__(*args,**kwargs)
        self.page_queue = page_queue      # 这两个参数是自己用的，不是继承Thread基类的
        self.img_queue = img_queue        # 所以在这里定义一下

    def run(self):
        while True:
            if self.page_queue.empty():
                # 如果每一页url的队列是个空的，说明下面的for循环遍历完了，已经没有数据往里面添加了
                break    # 就跳出死循环，跳出循环后这个run方法就执行完了，这个线程类就会自己结束
            url = self.page_queue.get()     # 从每一页url的队列获取到每个页面的url
            self.parse_page(url)            # 执行parse_page函数并把获取到每个页面的url传入

    def parse_page(self,url):
        response = requests.get(url,headers=self.headers)
        text = response.text
        html = etree.HTML(text)
        imgs = html.xpath('//div[@class="page-content text-center"]//img[@class!="gif"]')
        for img in imgs:
            img_url = img.get('data-original')
            alt = img.get('alt')
            # print(alt)
            alt = re.sub(r'[\?？\.，。！\*]', '', alt)      # 把图片名称里面的符号替换成空白

            suffix = os.path.splitext(img_url)[1]
            # 使用os.path模块通过分割图片链接获取图片的后缀，返回的是一个元组(链接, 后缀)，使用[1]取到后缀
            filename = alt + suffix         # 图片+后缀构造图片名称

            self.img_queue.put((img_url, filename))
            # 把获取到的每张图片url和文件名以元组的方式传入每张图片url的队列

        # imgs = html.xpath("//div[@class='page-content text-center']//a//img")
        # for img in imgs:
            # if img.get('class') == 'gif':
            #     continue
            # img_url = img.xpath(".//@data-original")[0]
            # suffix = os.path.splitext(img_url)[1]
            # alt = img.xpath(".//@alt")[0]
            # alt = re.sub(r'[，。？?,/\\·]','',alt)
            # img_name = alt + suffix
            # self.img_queue.put((img_url,img_name))


class Consumer(threading.Thread):    # 消费者 多线程类，下载图片
    def __init__(self,page_queue,img_queue,*args,**kwargs):
        super(Consumer, self).__init__(*args,**kwargs)
        self.page_queue = page_queue
        self.img_queue = img_queue

    def run(self):
        while True:
        if self.img_queue.empty() and self.page_queue.empty():
                break       # 如果两个队列都是空的，说明已经没有数据了，就跳出循环
            img_url, filename = self.img_queue.get()
            # 因为上面获取到的每张图片url和文件名是以元组的方式传入到队列的的，
            # 所以这里从队列获取的时候直接通过这种解包方式获取到没张图片url和文件名称，相当于:a,b=(1,2)
            request.urlretrieve(img_url, 'C:\\Users\\Administrator\\Desktop\\images\\' + filename)
            time.sleep(1.5)       # 多线程太快了所以加些延迟
            print(filename + ' 下载完成！')

            # if self.img_queue.empty():
            #     if self.page_queue.empty():
            #         return
            # img = self.img_queue.get(block=True)
            # url,filename = img
            # request.urlretrieve(url,'images/'+filename)
            # print(filename+'  下载完成！')


def main():
    page_queue = Queue(100)    # 每一页url的队列，设置最多可以放100个元素
    img_queue = Queue(1000)
    # 每张图片url的队列，这个尽量设置大一些，要不然队列满了会阻塞，这样耗费在等待队列就划不来了

    for x in range(1,101):   # 遍历每一页url
        url = "http://www.doutula.com/photo/list/?page=%d" % x
        page_queue.put(url)  # 将for循环遍历出的每一页url添加到每一页url的队列page_queue

    for x in range(5):       # 创建生产者
        t = Producer(page_queue,img_queue)  # 传入每个页面url的队列和每张图片url的队列
        t.start()

    for x in range(20):      # 创建20个消费者，因为每页的图片很多，一页都几十张所以可以设置多些，所以少创建几个生产者 每次同时生产两个url就够消费者消费很久了
        t = Consumer(page_queue,img_queue)  # 传入每个页面url的队列和每张图片url的队列
        t.start()


if __name__ == '__main__':
    main()

GIL全局解释器锁

Python自带的解释器是CPython，CPython解释器的多线程实际上是一个假的多线程（在多核CPU中，只能利用一核，不能利用多核），同一时刻只有一个线程在执行，为了保证同一时刻只有一个线程在执行，在CPython解释器中有一个东西叫做GIL（Global Intepreter Lock），叫做全局解释器锁，这个解释器锁是有必要的，因为CPython解释器的内存管理不是线程安全的

当然除了CPython解释器，还有其他的解释器，有些解释器是没有GIL锁的

Jython：用Java实现的Python解释器，不存在GIL锁
更多详情请见：https://zh.wikipedia.org/wiki/Jython

IronPython：用.net实现的Python解释器，不存在GIL锁
更多详情请见：https://zh.wikipedia.org/wiki/IronPython

PyPy：用Python实现的Python解释器，存在GIL锁
更多详情请见：https://zh.wikipedia.org/wiki/PyPy

GIL虽然是一个假的多线程，但是在处理一些IO操作（比如文件读写和网络请求）还是可以在很大程度上提高效率的，在IO操作上建议使用多线程提高效率，在一些CPU计算操作上不建议使用多线程，而建议使用多进程

多线程下载百思不得姐段子

import requests
from lxml import etree
import threading
from queue import Queue
import csv


class BSSpider(threading.Thread):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36'
    }

    def __init__(self,page_queue,joke_queue,*args,**kwargs):
        super(BSSpider, self).__init__(*args,**kwargs)
        self.base_domain = 'http://www.budejie.com'
        self.page_queue = page_queue
        self.joke_queue = joke_queue

    def run(self):
        while True:
            if self.page_queue.empty():
                break
            url = self.page_queue.get()
            response = requests.get(url, headers=self.headers)
            text = response.text
            html = etree.HTML(text)
            descs = html.xpath("//div[@class='j-r-list-c-desc']")
            for desc in descs:
                jokes = desc.xpath(".//text()")
                joke = "\n".join(jokes).strip()
                link = self.base_domain+desc.xpath(".//a/@href")[0]
                self.joke_queue.put((joke,link))
            print('='*30+"第%s页下载完成！"%url.split('/')[-1]+"="*30)


class BSWriter(threading.Thread):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36'
    }

    def __init__(self, joke_queue, writer,gLock, *args, **kwargs):
        super(BSWriter, self).__init__(*args, **kwargs)
        self.joke_queue = joke_queue
        self.writer = writer
        self.lock = gLock

    def run(self):
        while True:
            try:
                joke_info = self.joke_queue.get(timeout=40)
                joke,link = joke_info
                self.lock.acquire()                     # 开锁
                self.writer.writerow((joke,link))       # 写入csv文件，以元祖方式写入爬取到的结果
                self.lock.release()                     # 解锁
                print('保存一条')
            except:
                break


def main():
    page_queue = Queue(10)
    joke_queue = Queue(500)
    gLock = threading.Lock()                            # 定义锁
    fp = open('bsbdj.csv', 'a',newline='', encoding='utf-8')
    writer = csv.writer(fp)
    writer.writerow(('content', 'link'))    # 写入csv文件，以元祖方式写入表头
    # 这里先写入表头，然后后面调用线程跑的时候每次写入爬去到的内容

    for x in range(1,11):
        url = 'http://www.budejie.com/text/%d' % x
        page_queue.put(url)

    for x in range(5):
        t = BSSpider(page_queue,joke_queue)
        t.start()

    for x in range(5):
        t = BSWriter(joke_queue,writer,gLock)
        t.start()


if __name__ == '__main__':
    main()

多进程

import multiprocessing
import time

"""多进程示例 (跟多线程写法一样，只是调用的模块不一样)
"""


def fun(n):
    print(f'{multiprocessing.current_process().name} 执行开始于：{time.ctime()}')
    time.sleep(n)
    print(f'{multiprocessing.current_process().name} 执行结束于：{time.ctime()}')


def main():
    print(f'主函数执行开始于：{time.ctime()}')

    processes = []

    p1 = multiprocessing.Process(target=fun, args=(4,))
    processes.append(p1)

    p2 = multiprocessing.Process(target=fun, args=(2,))
    processes.append(p2)

    for p in processes:
        p.start()

    for p in processes:
        p.join()

    print(f'主函数执行结束于：{time.ctime()}')


if __name__ == '__main__':
    main()

线程池 进程池 executor

import time

# 线程池 进程池模块
# import concurrent.futures
from concurrent import futures


numbers = list(range(1, 21))


def count(n):           # 做计算的函数
    for i in range(1000000):        # 随便给个很大的值
        i += i
    return i * n        # 每遍历一次自身相加 再*n


def worker(x):          # 打印上面计算的函数计算结果的函数
    result = count(x)   # 把上面的函数执行的结果给result这个变量
    print(f'数字：{x} 的计算结果是：{result}')    # 再打印result


# 顺序执行 单线程
def sequential_execution():
    start_time = time.process_time()    # 这个方法可以查看程序执行了多少秒
    for i in numbers:
        worker(i)   # 执行打印函数 传入的参数是i，i是遍历列表numbers里面的值
    print(f'顺序执行花费时间：{time.process_time()-start_time} 秒')
    # 程序执行时间减去开始运行时迟钝那零点几秒


# 线程池执行
def threading_execution():
    start_time = time.process_time()
    with futures.ThreadPoolExecutor(max_workers=5) as executor:
        # 用上下文方式调用模块中的线程池方法 max_workers=5是最大线程
        for i in numbers:
            executor.submit(worker, i)      # 用线程池的方法 执行打印函数
    print(f'线程池执行花费时间：{time.process_time()-start_time} 秒')
    # 程序执行时间减去开始运行时迟钝那零点几秒


# 进程池执行
def process_execution():
    start_time = time.perf_counter()
    # print(start_time)
    with futures.ProcessPoolExecutor(max_workers=5) as executor:
        for i in numbers:
            executor.submit(worker, i)
    # print(time.perf_counter())
    print(f'进程池执行花费时间：{time.perf_counter()-start_time} 秒')
    # 程序执行时间减去开始运行时迟钝那零点几秒


if __name__ == '__main__':
    # sequential_execution()    # 单线程
    # threading_execution()     # 多线程 执行慢而且还会打印出错
    process_execution()       # 执行快 打印也不会出错

# 像这种计算型的程序 用进程池调用最快 多进程也不会打印错误

DeprecationWarning: time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8:
use time.perf_counter or time.process_time instead

用time.clock()记录程序运行时间会报这个错误
大概意思是这个被废弃了，推荐用 time.perf_counter or time.process_time 这两个