并发编程

程序、进程、线程的基本概念

  • 程序：由源代码组成的可执行文件
  • 进程：程序运行资源（内存资源）分配的最小单位；一个进程下可以有多个线程，但是至少有一个线程（主线程）；进程之间相互独立，互不影响，资源也不共享

  • 线程：CPU调度的最小单位，必须依赖

    创建多线程的两种方式

    1. # 直接创建不使用多线程
    2. import time
    4. def download():
    5.    print('开始下载')
    6.    time.sleep(2)
    7.    print('下载结束')
    9. if __name__ == '__main__':
    10.    download()

    方法一

    target：指定的是需要执行多线程任务的函数名 args：可以传递元组形式的参数给执行的函数

  1.  # 直接创建多线程
  2.  # 步骤：
  3.  # 1.创建线程
  4.  # 2.启动线程
  6.  import time, threading
  8.  def download(filename):
  9.      print(filename'开始下载')
  10.      time.sleep(2)
  11.      print(filename'下载结束')
  13.  if __name__ == '__main__':
  14.      # 使用循环创建3个线程
  15.      for i in rang(3)：
  16.          # 创建线程
  17.          t = threading.Tread(target=download, args=(i,))
  18.          # 启动线程
  19.          t.start()

方法二

  1.  # 使用类创建多线程（推荐）
  2.  # 步骤：
  3.  # 1.自定义一个类并继承Tread类
  4.  # 2.覆写run()方法
  6.  import time, threading
  8.  class MyThread(threading.Tread):
  9.      # 如果需要传参则需要定义初始化方法
  10.      def __init__(self, filename):
  11.          # 处理父类的init
  12.          #   方法一：
  13.          # threading.Tread.__init__(self)
  14.          #   方法二：
  15.          super().__init__()# super()就相当于threading.Tread
  16.          self.filename = filename
  18.      # 覆写run方法
  19.      def run(self):
  20.          print(self.filename, '开始下载')
  21.          time.sleep(2)
  22.          print(self.filename, '下载结束')
  24.  if __name__ == '__main__':
  25.      # 使用循环创建3个线程
  26.      for i in rang(3)：
  27.          # 实例化对象（创建线程）
  28.          t = MyTread(i)# 传参需要定义初始化方法并处理父类的init
  29.          # 启动线程，会自动执行run()方法
  30.          t.start()

线程名称

主要应用于调错

  1.  import threading
  3.  class MyTread(threading.Tread):
  4.      def run(self):
  5.          # treading.current_thread：查看当前运行的线程
  6.          # 输出结果为：<MyTread(Tread-1, started 4408)
  7.          print('{}正在运行'.format(threading.current_thread()))
  8.          # name属性查看线程的名称，默认为Tread-n
  9.          print('{}正在运行'.format(self.name))
  11.  if __name__ == '__main__':
  12.      # 可以在实例化对象是传入name属性，修改线程名称
  13.      t = MyTread(name = 'file{}'.format('新名称'))
  14.      t.start()

互斥锁

线程之间共享全局变量的安全性问题

  1.  import threading
  3.  # 创建锁
  4.  lock = threading.Lock()
  5.  # 定义初始值，0为数值型，不可变类型
  6.  value = 0
  7.  # 定义加1函数
  8.  def add_value():
  9.      # 在函数中对全局变量中的不可变类型进行修改需要先global
  10.      global value
  11.      # 加锁（哪里有问题在哪里加锁）
  12.      lock.acquire()
  13.      for i in range(100000):
  14.          value += 1
  15.      # 释放锁
  16.      lock.release()
  17.      print(value)# 在不加锁的情况下此时得出的结果会出现问题
  20.  if __name__ == '__main__':
  21.      for i in range(2):
  22.          t = threading.Thread(target=add_value)
  23.          t.start()

注意：加锁之后必须释放锁，不然会形成死锁

生产者和消费者模式

生产者：获取数据
消费者：保存数据

队列

队列在爬虫中的使用：

  1. 将爬取的URL存放到队列中，每次生产者进行爬取时，会从队列中取出URL进行请求
  2. 将生产者爬取到的数据存放到队列中，消费者从队列中取出数据进行保存
  1.  # 导入队列（先进先出）
  2.  from queue import Queue
  4.  # 创建Queue对象
  5.  q = Queue(maxsize=4)# maxsize代表队列中的最大容量
  7.  # put()：向队列中添加元素 
  8.  q.put(1)
  9.  q.put(2)
  10.  q.put(3)
  11.  q.put(4)
  12.  # q.put(5)
  13.  # 注意：如果队列满了，再添加数据，程序不报错，而是进入阻塞状态（等待从队列中取出元素）
  15.  # get()：取出队列中的元素
  16.  print(q.get())
  17.  print(q.get())
  18.  print(q.get())
  19.  print(q.get())
  20.  # print(q.get())
  21.  # 注意：如果队列空了，在获取数据，程序不报错，而是进入阻塞状态（等待箱队列中添加元素）
  23.  # full()：判断队列是否为满，返回布尔值
  25.  # empty()：判断队列是否为空，返回布尔值

线程池

Pool.map创建线程池

爬虫属于I/O（Input/Output，输入/输出）密集型程序所以使用多线程；涉及计算密集型程序需要使用多进程

multiprocessing下的dummy模块下的Pool类，用来实现线程池。这个线程池有一个map()方法，可以让线程池里面的所有线程都“同时”执行一个函数。

  1. from multiprocessing.dummy import Pool
  3. def calc(num):
  4.     return num * num
  6. #     初始化含有3个线程的线程池
  7. pool = Pool(3) 
  8. # 可迭代序列（列表、元组、集合、字典等）
  9. origin_num = [x for x in range(10)]
  10. # map(函数名, 可迭代序列)
  11. result = pool.map(calc, origin_num)
  12. print(f'计算0-9的平方分别为：{result}')
  13. pool.close()
  14. pool.join() # 这里要先关闭再JOIN。进程池中进程执行完后再关闭，如果注释，那么程序直接关闭