devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python并发与并行_python并发和并行

作者：我家小花儿 | 2024-03-01 09:09:18

赞

踩

python并发和并行

python的多线程因为GIL锁的原因是一个伪多线程

  • python2:100字节码或I/O阻塞进行切换
  • python3：I/O阻塞进行切换，移除了100字节码切换

1、并发与并行

并行：多个程序同时运行

并发：伪并行，看起来是同时并行，其实质是利用了多道技术

无论是并行还是并发，在用户眼里看起来都是同时运行的，不管是线程还是进程，都是只是一个任务，真正干活的是CPU，而同一个CPU在同一时刻只能执行一个任务。

2、多进程

  • 进程是操作系统分配资源的最小单元，线程是操作系统调度的最小单元

  • 一个应用程序最少包括一个进程，而一个进程包括1个或多个线程，线程的尺度更小

  • 每个进程在执行过程中都有独立的内存单元，而每一个进程中的多个线程在执行过程中共享内存

2.1 进程之 Process

  1. # -*- coding: utf-8 -*-
  2. # Created by Xue Jian on 3/10/23
  3.  
  4. import time
  5. import os
  6.  
  7.  
  8. def long_time_task():
  9.     print('current_process: {}'.format(os.getpid()))
  10.     time.sleep(2)
  11.     print('result: {}'.format(8 ** 20))
  12.  
  13.  
  14. if __name__ == '__main__':
  15.     print('current parent process: {}'.format(os.getpid()))
  16.     start = time.time()
  17.     for i in range(2):
  18.         long_time_task()
  19.  
  20.     end = time.time()
  21.     print('sec: {}'.format(end - start))

输出结果如下：

总耗时4秒，自始至终只有一个进程在执行。看来电脑计算8的20次方基本不费时。

开启多进程

  1. # -*- coding: utf-8 -*-
  2. # Created by Xue Jian on 3/10/23
  3.  
  4. import time
  5. import os
  6. from multiprocessing import Process
  7.  
  8.  
  9. def long_time_task(i):
  10.     print('子进程: {} - 任务{}'.format(os.getpid(), i))
  11.     time.sleep(2)
  12.     print("结果: {}".format(8 ** 20))
  13.  
  14.  
  15. if __name__ == '__main__':
  16.     print('当前母进程: {}'.format(os.getpid()))
  17.     start = time.time()
  18.     p1 = Process(target=long_time_task, args=(1,))
  19.     p2 = Process(target=long_time_task, args=(2,))
  20.     print('等待所有子进程完成。')
  21.     p1.start()
  22.     p2.start()
  23.     p1.join()
  24.     p2.join()
  25.     end = time.time()
  26.     print("总共用时{}秒".format((end - start)))

输出结果如下所示，耗时变为2秒，时间减了一半，可见并发执行的时间明显比顺序执行要快很多。你还可以看到尽管我们只创建了两个进程，可实际运行中却包含里1个母进程和2个子进程。之所以我们使用join()方法就是为了让母进程阻塞，等待子进程都完成后才打印出总共耗时，否则输出时间只是母进程执行的时间。

知识点：

  • 新创建的进程与进程的切换都是需要消耗资源的，所以平时工作中进程数不能开太大

  • 同时可以运行的进程数，一般受制于CPU的核数

  • 除了使用Process方法，我们还可以使用Pool方法创建多进程

2.2 进程之Pool类

很多时候系统都需要创建多个进程以提高CPU的利用率，当数量较少时，可以手动生成一个个Process实例。

当进程数量很多时，或许可以利用循环，但是这需要程序员手动管理系统中并发进程的数量，有时会很麻烦。这时进程池Pool就可以发挥其功效了。可以通过传递参数限制并发进程的数量，默认值为CPU的核数。

Pool类可以提供指定数量的进程供用户调用，当有新的请求提交到Pool中时，如果进程池还没有满，就会创建一个新的进程来执行请求。如果池满，请求就会告知先等待，直到池中有进程结束，才会创建新的进程来执行这些请求。

下面介绍一下multiprocessing 模块下的Pool类的几个方法：

1.apply_async

函数原型：apply_async(func[, args=()[, kwds={}[, callback=None]]])

其作用是向进程池提交需要执行的函数及参数， 各个进程采用非阻塞（异步）的调用方式，即每个子进程只管运行自己的，不管其它进程是否已经完成。这是默认方式。

2.map()

函数原型：map(func, iterable[, chunksize=None])

Pool类中的map方法，与内置的map函数用法行为基本一致，它会使进程阻塞直到结果返回。 注意：虽然第二个参数是一个迭代器，但在实际使用中，必须在整个队列都就绪后，程序才会运行子进程。

3.map_async()

函数原型：map_async(func, iterable[, chunksize[, callback]])与map用法一致，但是它是非阻塞的。其有关事项见apply_async。

4.close()

关闭进程池（pool），使其不在接受新的任务。

5.terminate()

结束工作进程，不在处理未处理的任务。

6.join()

主进程阻塞等待子进程的退出， join方法要在close或terminate之后使用。

下例是一个简单的multiprocessing.Pool类的实例。

进程池会根据我的CPU的核数进行，本次使用的虚拟机是4核的，这里会创建一个容量为4的进程池，4个进程需要执行5个任务，会有一个在排队等待

  1. from multiprocessing import Pool, cpu_count, Process
  2. import os
  3. import time
  4.  
  5.  
  6. def long_time_task(i):
  7.     print('子进程: {} - 任务{}'.format(os.getpid(), i))
  8.     time.sleep(2)
  9.     print("结果: {}".format(8 ** 20))
  10.  
  11.  
  12. if __name__ == '__main__':
  13.     print("CPU内核数:{}".format(cpu_count()))
  14.     print('当前母进程: {}'.format(os.getpid()))
  15.     start = time.time()
  16.     p = Pool(4)
  17.     for i in range(5):
  18.         p.apply_async(long_time_task, args=(i,))
  19.     print('等待所有子进程完成。')
  20.     p.close()
  21.     p.join()
  22.     end = time.time()
  23.     print("总共用时{}秒".format((end - start)))

2.3 多进程之间的数据共享和通信

通常，进程之间是相互独立的，每个进程都有独立的内存。通过共享内存(nmap模块)，进程之间可以共享对象，使多个进程可以访问同一个变量(地址相同，变量名可能不同)。

多进程共享资源必然会导致进程间相互竞争，所以应该尽最大可能防止使用共享状态。还有一种方式就是使用队列queue来实现不同进程间的通信或数据共享，这一点和多线程编程类似。

下例这段代码中中创建了2个独立进程，一个负责写(pw), 一个负责读(pr), 实现了共享一个队列queue

  1. from multiprocessing import Process, Queue
  2. import os, time, random
  3.  
  4.  
  5. # 写数据进程执行的代码:
  6. def write(q):
  7.     print('Process to write: {}'.format(os.getpid()))
  8.     for value in ['A', 'B', 'C']:
  9.         print('Put %s to queue...' % value)
  10.         q.put(value)
  11.         time.sleep(random.random())
  12.  
  13.  
  14. # 读数据进程执行的代码:
  15. def read(q):
  16.     print('Process to read:{}'.format(os.getpid()))
  17.     while True:
  18.         value = q.get(True)
  19.         print('Get %s from queue.' % value)
  20.  
  21.  
  22. if __name__ == '__main__':
  23.     # 父进程创建Queue，并传给各个子进程：
  24.     q = Queue()
  25.     pw = Process(target=write, args=(q,))
  26.     pr = Process(target=read, args=(q,))
  27.     # 启动子进程pw，写入:
  28.     pw.start()
  29.     # 启动子进程pr，读取:
  30.     pr.start()
  31.     # 等待pw结束:
  32.     pw.join()
  33.     # pr进程里是死循环，无法等待其结束，只能强行终止:
  34.     pr.terminate()

3. 线程

threading.Thread方法可以接收两个参数, 第一个是target，一般指向函数名，第二个是args，需要向函数传递的参数。

对于创建的新线程，调用start()方法即可让其开始。我们还可以使用current_thread().name打印出当前线程的名字。 下例中我们使用多线程技术重构之前的计算代码

  1. import threading
  2. import time
  3.  
  4.  
  5. def long_time_task(i):
  6.     print('当前子线程: {} - 任务{}'.format(threading.current_thread().name, i))
  7.     time.sleep(2)
  8.     print("结果: {}".format(8 ** 20))
  9.  
  10.  
  11. if __name__=='__main__':
  12.     start = time.time()
  13.     print('这是主线程：{}'.format(threading.current_thread().name))
  14.     t1 = threading.Thread(target=long_time_task, args=(1,))
  15.     t2 = threading.Thread(target=long_time_task, args=(2,))
  16.     t1.start()
  17.     t2.start()
  18.  
  19.     end = time.time()
  20.     print("总共用时{}秒".format((end - start)))

当我们设置多线程时，主线程会创建多个子线程，在python中，默认情况下主线程和子线程独立运行互不干涉。

如果希望让主线程等待子线程实现线程的同步，我们需要使用join()方法。

如果我们希望一个主线程结束时不再执行子线程，我们应该怎么办呢? 我们可以使用t.setDaemon(True)，代码如下所示。

  1. import threading
  2. import time
  3.  
  4.  
  5. def long_time_task():
  6.     print('当子线程: {}'.format(threading.current_thread().name))
  7.     time.sleep(2)
  8.     print("结果: {}".format(8 ** 20))
  9.  
  10.  
  11. if __name__ == '__main__':
  12.     start = time.time()
  13.     print('这是主线程：{}'.format(threading.current_thread().name))
  14.     for i in range(5):
  15.         t = threading.Thread(target=long_time_task, args=())
  16.         t.setDaemon(True)
  17.         t.start()
  18.  
  19.     end = time.time()
  20.     print("总共用时{}秒".format((end - start)))

结果如下：

3.1 通过继承Thread类重写run方法创建新进程

除了使用Thread()方法创建新的线程外，我们还可以通过继承Thread类重写run方法创建新的线程，这种方法更灵活。下例中我们自定义的类为MyThread, 随后我们通过该类的实例化创建了2个子线程。

  1. import threading
  2. import time
  3.  
  4.  
  5. def long_time_task(i):
  6.     time.sleep(2)
  7.     return 8 ** 20
  8.  
  9.  
  10. class MyThread(threading.Thread):
  11.     def __init__(self, func, args, name='', ):
  12.         threading.Thread.__init__(self)
  13.         self.func = func
  14.         self.args = args
  15.         self.name = name
  16.         self.result = None
  17.  
  18.     def run(self):
  19.         print('开始子进程{}'.format(self.name))
  20.         self.result = self.func(self.args[0], )
  21.         print("结果: {}".format(self.result))
  22.         print('结束子进程{}'.format(self.name))
  23.  
  24.  
  25. if __name__ == '__main__':
  26.     start = time.time()
  27.     threads = []
  28.     for i in range(1, 3):
  29.         t = MyThread(long_time_task, (i,), str(i))
  30.         threads.append(t)
  31.  
  32.     for t in threads:
  33.         t.start()
  34.     for t in threads:
  35.         t.join()
  36.  
  37.     end = time.time()
  38.     print("总共用时{}秒".format((end - start)))

结果如下：

3.2 不同线程间的数据共享

一个进程中的不同线程之间是共享内存的，这就意味着任何一个变量都可以被任何一个线程修改，因此线程之间共享数据最大的危险在于多个线程同时修改同一个变量，把内容给改乱了。

如果不同线程之间有共享的变量，其中一个方法就是在修改前给加上一把锁lock，确保一次只有一个线程能修改它。

threading.Lock()方法可以轻易实现对一个共享变量的锁定，修改后release，以供其他线程使用。

比如在下例中 余额 balance是一个共享变量，使用lock可以使其不被改变

  1. import threading
  2.  
  3.  
  4. class Account:
  5.     def __init__(self):
  6.         self.balance = 0
  7.  
  8.     def add(self, lock):
  9.         # 获得锁
  10.         # lock.acquire()
  11.         for i in range(0, 100000):
  12.             self.balance += 1
  13.         # 释放锁
  14.         # lock.release()
  15.  
  16.     def delete(self, lock):
  17.         # 获得锁
  18.         # lock.acquire()
  19.         for i in range(0, 100000):
  20.             self.balance -= 1
  21.             # 释放锁
  22.         # lock.release()
  23.  
  24.  
  25. if __name__ == "__main__":
  26.     account = Account()
  27.     lock = threading.Lock()
  28.     # 创建线程
  29.     thread_add = threading.Thread(target=account.add, args=(lock,), name='Add')
  30.     thread_delete = threading.Thread(target=account.delete, args=(lock,), name='Delete')
  31.  
  32.     # 启动线程
  33.     thread_add.start()
  34.     thread_delete.start()
  35.  
  36.     # 等待线程结束
  37.     thread_add.join()
  38.     thread_delete.join()
  39.  
  40.     print('The final balance is: {}'.format(account.balance))

结果如下：

下图进行加锁，就可以避免这个情况

  1. import threading
  2.  
  3.  
  4. class Account:
  5.     def __init__(self):
  6.         self.balance = 0
  7.  
  8.     def add(self, lock):
  9.         # 获得锁
  10.         lock.acquire()
  11.         for i in range(0, 100000):
  12.             self.balance += 1
  13.         # 释放锁
  14.         lock.release()
  15.  
  16.     def delete(self, lock):
  17.         # 获得锁
  18.         lock.acquire()
  19.         for i in range(0, 100000):
  20.             self.balance -= 1
  21.             # 释放锁
  22.         lock.release()
  23.  
  24.  
  25. if __name__ == "__main__":
  26.     account = Account()
  27.     lock = threading.Lock()
  28.     # 创建线程
  29.     thread_add = threading.Thread(target=account.add, args=(lock,), name='Add')
  30.     thread_delete = threading.Thread(target=account.delete, args=(lock,), name='Delete')
  31.  
  32.     # 启动线程
  33.     thread_add.start()
  34.     thread_delete.start()
  35.  
  36.     # 等待线程结束
  37.     thread_add.join()
  38.     thread_delete.join()
  39.  
  40.     print('The final balance is: {}'.format(account.balance))

加锁后输出结果如下：

另一种实现不同线程间数据共享的方法就是使用消息队列queue。不像列表，queue是线程安全的，可以放心使用

使用queue队列通信-经典的生产者和消费者模型

下例创建两个线程，一个负责生产，一个负责消费，所生产的产品存放在queue里，实现了不同线程的沟通

  1. from queue import Queue
  2. import random, threading, time
  3.  
  4.  
  5. # 生产者类
  6. class Producer(threading.Thread):
  7.     def __init__(self, name, queue):
  8.         threading.Thread.__init__(self, name=name)
  9.         self.queue = queue
  10.  
  11.     def run(self):
  12.         for i in range(1, 5):
  13.             print("{} is producing {} to the queue!".format(self.getName(), i))
  14.             self.queue.put(i)
  15.             time.sleep(random.randrange(10) / 5)
  16.         print("%s finished!" % self.getName())
  17.  
  18.  
  19. # 消费者类
  20. class Consumer(threading.Thread):
  21.     def __init__(self, name, queue):
  22.         threading.Thread.__init__(self, name=name)
  23.         self.queue = queue
  24.  
  25.     def run(self):
  26.         for i in range(1, 5):
  27.             val = self.queue.get()
  28.             print("{} is consuming {} in the queue.".format(self.getName(), val))
  29.             time.sleep(random.randrange(10))
  30.         print("%s finished!" % self.getName())
  31.  
  32.  
  33. def main():
  34.     queue = Queue()
  35.     producer = Producer('Producer', queue)
  36.     consumer = Consumer('Consumer', queue)
  37.  
  38.     producer.start()
  39.     consumer.start()
  40.  
  41.     producer.join()
  42.     consumer.join()
  43.     print('All threads finished!')
  44.  
  45.  
  46. if __name__ == '__main__':
  47.     main()

结果如下：

5. 线程池

但从Python3.2开始，标准库为我们提供了concurrent.futures模块，它提供了ThreadPoolExecutor和ProcessPoolExecutor两个类，实现了对threading和multiprocessing的进一步抽象，对编写线程池/进程池提供了直接的支持。

5.1 参数详解

  1. ProcessPoolExecutor(n):n表示池里面存放多少个进程，之后的连接最大就是n的值
  2.  
  3. submit(fn,*args,**kwargs)  异步提交任务
  4.  
  5. map(func, *iterables, timeout=None, chunksize=1) 取代for循环submit的操作
  6.  
  7. shutdown(wait=True) 相当于进程池的pool.close()+pool.join()操作
  8. wait=True，等待池内所有任务执行完毕回收完资源后才继续，--------》默认
  9. wait=False，立即返回，并不会等待池内的任务执行完毕
  10. 但不管wait参数为何值，整个程序都会等到所有任务执行完毕
  11. submit和map必须在shutdown之前
  12.  
  13. result(timeout=None)  #取得结果
  14.  
  15. add_done_callback(fn)  #回调函数

使用submit 来操作线程池/进程池

  1. from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
  2. import time
  3.  
  4.  
  5. # 模拟网络请求的网络延迟
  6. def get_html(times):
  7.     time.sleep(times)
  8.     print("get page {}s finished".format(times))
  9.     return times
  10.  
  11.  
  12. # 创建一个大小为2的线程池
  13. pool = ThreadPoolExecutor(max_workers=2)
  14.  
  15. # 将上个任务提交到线程池，因为线程池的大小是2，所以必须等task1和task2中有一个完成之后才会将第三个任务提交到线程池
  16. task1 = pool.submit(get_html, 3)
  17. task2 = pool.submit(get_html, 2)
  18. task3 = pool.submit(get_html, 4)
  19.  
  20. # 打印该任务是否执行完毕
  21. print(task1.done())
  22. # 只有未被提交的到线程池（在等待提交的队列中）的任务才能够取消
  23. print(task3.cancel())
  24. time.sleep(4)  # 休眠4秒钟之后，线程池中的任务全部执行完毕，可以打印状态
  25. print(task1.done())
  26.  
  27. print(task1.result())  # 该任务的return 返回值  该方法是阻塞的。

 结果如下：

  1. ThreadPoolExecutor构造实例的时候，传入max_workers参数来设置线程池中最多能同时运行的线程数目。

  2. 使用submit函数来提交线程需要执行的任务（函数名和参数）到线程池中，并返回该任务的句柄（类似于文件、画图），注意submit()不是阻塞的，而是立即返回。

  3. 通过submit函数返回的任务句柄，能够使用done()方法判断该任务是否结束。上面的例子可以看出，由于任务有2s的延时，在task1提交后立刻判断，task1还未完成，而在延时4s之后判断，task1就完成了。

  4. 使用cancel()方法可以取消提交的任务，如果任务已经在线程池中运行了，就取消不了。这个例子中，线程池的大小设置为2，任务已经在运行了，所以取消失败。如果改变线程池的大小为1，那么先提交的是task1，task2还在排队等候，这是时候就可以成功取消。

  5. 使用result()方法可以获取任务的返回值。查看内部代码，发现这个方法是阻塞的。

as_completed

上面虽然提供了判断任务是否结束的方法，但是不能在主线程中一直判断啊。有时候我们是得知某个任务结束了，就去获取结果，而不是一直判断每个任务有没有结束。这是就可以使用as_completed方法一次取出所有任务的结果。

  1. import time
  2. from concurrent.futures import ThreadPoolExecutor, as_completed
  3.  
  4.  
  5. # 模拟网络请求的网络延迟
  6. def get_html(times):
  7.     time.sleep(times)
  8.     print("get page {}s finished".format(times))
  9.     return times
  10.  
  11.  
  12. pool = ThreadPoolExecutor(max_workers=2)
  13. urls = [2, 3, 4]
  14. all_task = [pool.submit(get_html, url) for url in urls]
  15.  
  16. for future in as_completed(all_task):
  17.     data = future.result()
  18.     print("in main: get page {}s success".format(data))

结果如下：

as_completed()方法是一个生成器，在没有任务完成的时候，会阻塞，在有某个任务完成的时候，会yield这个任务，就能执行for循环下面的语句，然后继续阻塞住，循环到所有的任务结束。从结果也可以看出，先完成的任务会先通知主线程。

map除了上面的as_completed方法，还可以使用executor.map方法，但是有一点不同。

  1. import time
  2. from concurrent.futures import ThreadPoolExecutor, as_completed
  3.  
  4.  
  5. # 模拟网络请求的网络延迟
  6. def get_html(times):
  7.     time.sleep(times)
  8.     print("get page {}s finished".format(times))
  9.     return times
  10.  
  11.  
  12. pool = ThreadPoolExecutor(max_workers=2)
  13. urls = [2, 3, 4]
  14. for data in pool.map(get_html, urls):
  15.     print("in main: get page {}s success".format(data))

结果如下：

shutdown

shutdown方法的功能类似于 join+close的集合

  1. import time
  2. from concurrent.futures import ThreadPoolExecutor, wait
  3.  
  4. results = []
  5.  
  6.  
  7. def get_html(i):
  8.     time.sleep(2)
  9.     return 2 * i
  10.  
  11.  
  12. def handle(res):
  13.     res = res.result()
  14.     results.append(res)
  15.  
  16.  
  17. pool = ThreadPoolExecutor(max_workers=2)
  18.  
  19. for i in range(4):
  20.     pool.submit(get_html, i).add_done_callback(handle)
  21. pool.shutdown(wait=True)  # 相当于 join + close
  22.  
  23. print('main')
  24. print(results)

结果如下：

wait

wait方法可以让主线程阻塞，直到满足设定的要求。

当设置了wait后，主线程会一直等待子线程执行完毕才能执行

和 shutdown效果类似

  1. from concurrent.futures import ThreadPoolExecutor, wait, ALL_COMPLETED, FIRST_COMPLETED
  2. import time
  3.  
  4.  
  5. # 参数times用来模拟网络请求的时间
  6. def get_html(times):
  7.     time.sleep(times)
  8.     print("get page {}s finished".format(times))
  9.     return times
  10.  
  11.  
  12. executor = ThreadPoolExecutor(max_workers=2)
  13. urls = [3, 2, 4]  # 并不是真的url
  14. all_task = [executor.submit(get_html, (url)) for url in urls]
  15. wait(all_task, return_when=ALL_COMPLETED)
  16. print("main")

结果如下：

6. 进程池

  1. from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
  2. import time,random,os
  3.  
  4. def task(n):
  5.     print('%s is running'% os.getpid())
  6.     time.sleep(random.randint(1,3))
  7.     return n
  8. def handle(res):
  9.     res=res.result()
  10.     print("handle res %s"%res)
  11.  
  12. if __name__ == '__main__':
  13.     #同步调用
  14.     # pool=ProcessPoolExecutor(8)
  15.     #
  16.     # for i in range(13):
  17.     #     pool.submit(task, i).result() #变成同步调用，串行了，等待结果
  18.     # # pool.shutdown(wait=True) #关门等待所有进程完成
  19.     # pool.shutdown(wait=False)#默认wait就等于True
  20.     # # pool.submit(task,3333) #shutdown后不能使用submit命令
  21.     #
  22.     # print('主')
  23.  
  24.     #异步调用
  25.     pool=ProcessPoolExecutor(8)
  26.     for i in range(13):
  27.          obj=pool.submit(task,i)
  28.          obj.add_done_callback(handle) #这里用到了回调函数
  29.     pool.shutdown(wait=True) #关门等待所有进程完成
  30.     print('主')
  31. ##注意，创建进程池必须在if __name__ == '__main__':中，否则会报错
  32. ##其他的用法和创建线程池的一样

回调函数

  1. from concurrent.futures import ThreadPoolExecutor
  2. from urllib import request
  3. from threading import current_thread
  4. import time
  5.  
  6. def get(url):
  7.     print('%s get %s'%(current_thread().getName(),url))
  8.     response=request.urlopen(url)
  9.     time.sleep(2)
  10.     # print(response.read().decode('utf-8'))
  11.     return{'url':url,'content':response.read().decode('utf-8')}
  12.  
  13. def parse(res):
  14.     res=res.result()
  15.     print('parse:[%s] res:[%s]'%(res['url'],len(res['content'])))
  16.  
  17. # get('http://www.baidu.com')
  18. if __name__ == '__main__':
  19.     pool=ThreadPoolExecutor(2)
  20.  
  21.     urls=[
  22.         'https://www.baidu.com',
  23.         'https://www.python.org',
  24.         'https://www.openstack.org',
  25.         'https://www.openstack.org',
  26.         'https://www.openstack.org',
  27.         'https://www.openstack.org',
  28.         'https://www.openstack.org',
  29.         'https://www.openstack.org',
  30.  
  31.     ]
  32.  
  33.     for url in urls:
  34.         pool.submit(get,url).add_done_callback(parse)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/172555
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号