Python基础教程：线程操作(oncurrent模块)详解

迷南。 2023-01-23 14:53 56阅读 0赞

进程是cpu资源分配的最小单元，一个进程中可以有多个线程。

线程是cpu计算的最小单元。

对于Python来说他的进程和线程和其他语言有差异，是有GIL锁。

GIL锁

GIL锁保证一个进程中同一时刻只有一个线程被cpu调度。

GIL锁，全局解释器锁。用于限制一个进程中同一时刻只有一个线程被cpu调度。
扩展:默认GIL锁在执行100个cpu指令(过期时间)。

查看GIL切换的指令个数

  1. import sys
  2. v1 = sys。getcheckinterval()
  3. print(v1)

一、通过threading.Thread类创建线程

1、 创建线程的方式：直接使用Thread

  1. from threading import Thread 
  2. import time 
  4. def sayhi(name):
  5.     time.sleep(2)
  6.     print('%s say hello' %name)
  8. if __name__ == '__main__':
  9.     t=Thread(target=sayhi,args=('nick',))
  10.     t.start()
  11.     print('主线程')

2、 创建线程的方式：继承Thread

  1. ''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
  2. from threading import Thread
  3. import time
  5. class Sayhi(Thread):
  6.     def __init__(self,name):
  7.         super().__init__()
  8.         self.name=name
  10. def run(self):
  11.         time.sleep(2)
  12.         print('%s say hello' % self.name)
  15. if __name__ == '__main__':
  16.     t = Sayhi('nick')
  17.     t.start()
  18.     print('主线程')

二、多线程与多进程

1、 pid的比较

  1. from threading import Thread
  2. from multiprocessing import Process
  3. import os
  5. def work():
  6.     print('hello',os.getpid())
  8. if __name__ == '__main__':
  9.     # part1:在主进程下开启多个线程,每个线程都跟主进程的pid一样
  10.     t1=Thread(target=work)
  11.     t2=Thread(target=work)
  12.     t1.start()
  13.     t2.start()
  14.     print('主线程/主进程pid',os.getpid())
  16.     # part2:开多个进程,每个进程都有不同的pid
  17.     p1=Process(target=work)
  18.     p2=Process(target=work)
  19.     p1.start()
  20.     p2.start()
  21.     print('主线程/主进程pid',os.getpid())

2、 开启效率的较量

  1. from threading import Thread
  2. from multiprocessing import Process
  3. import os
  5. def work():
  6.     print('hello')
  8. if __name__ == '__main__':
  9.     # 在主进程下开启线程
  10.     t=thread(target=work)
  11.     t.start()
  12.     print('主线程/主进程')
  13.     ''' 打印结果: hello 主线程/主进程 '''
  15.     # 在主进程下开启子进程
  16.     t=Process(target=work)
  17.     t.start()
  18.     print('主线程/主进程')
  19.     ''' 打印结果: 主线程/主进程 hello '''

3、 内存数据的共享问题

  1. ''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
  2. from  threading import Thread
  3. from multiprocessing import Process
  4. import os
  5. def work():
  6.     global n
  7.     n=0
  9. if __name__ == '__main__':
  10.     # n=100
  11.     # p=Process(target=work)
  12.     # p.start()
  13.     # p.join()
  14.     # print('主',n) # 毫无疑问子进程p已经将自己的全局的n改成了0,但改的仅仅是它自己的,查看父进程的n仍然为100
  17.     n=1
  18.     t=Thread(target=work)
  19.     t.start()
  20.     t.join()
  21.     print('主',n) # 查看结果为0,因为同一进程内的线程之间共享进程内的数据

三、Thread类的其他方法

Thread实例对象的方法：

  • isAlive()：返回线程是否活动的。
  • getName()：返回线程名。
  • setName()：设置线程名。

threading模块提供的一些方法：

  • threading.currentThread()：返回当前的线程变量。
  • threading.enumerate()：返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  • threading.activeCount()：返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

1、 代码示例

  1. from threading import Thread
  2. import threading
  3. from multiprocessing import Process
  4. import os
  6. def work():
  7.     import time
  8.     time.sleep(3)
  9.     print(threading.current_thread().getName())
  12. if __name__ == '__main__':
  13.     # 在主进程下开启线程
  14.     t=Thread(target=work)
  15.     t.start()
  17.     print(threading.current_thread().getName())
  18.     print(threading.current_thread())
  20.  # 主线程
  21.     print(threading.enumerate())
  23.  # 连同主线程在内有两个运行的线程
  24.     print(threading.active_count())
  25.     print('主线程/主进程')
  27.     ''' 打印结果: MainThread <_MainThread(MainThread, started 140735268892672)> [<_MainThread(MainThread, started 140735268892672)>, <Thread(Thread-1, started 123145307557888)>] 主线程/主进程 Thread-1 '''

2、 join方法

  1. ''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
  2. from threading import Thread
  3. import time
  4. def sayhi(name):
  5.     time.sleep(2)
  6.     print('%s say hello' %name)
  8. if __name__ == '__main__':
  9.     t=Thread(target=sayhi,args=('nick',))
  10.     t.start()
  11.     t.join()
  12.     print('主线程')
  13.     print(t.is_alive())
  15. ''' nick say hello 主线程 False '''

四、多线程实现socket

  1. import multiprocessing
  2. import threading
  4. import socket
  5. s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  6. s.bind(('127.0.0.1',8080))
  7. s.listen(5)
  9. def action(conn):
  10.     while True:
  11.         data=conn.recv(1024)
  12.         print(data)
  13.         conn.send(data.upper())
  15. if __name__ == '__main__':
  17.     while True:
  18.         conn,addr=s.accept()
  20.         p=threading.Thread(target=action,args=(conn,))
  21.         p.start()

五、守护线程

无论是进程还是线程，都遵循：守护xx会等待主xx运行完毕后被销毁。需要强调的是：运行完毕并非终止运行。

  • 对主进程来说，运行完毕指的是主进程代码运行完毕
  • 对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

1、 详细解释

  • 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束。
  • 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

2、守护线程例

  1. from threading import Thread
  2. import time
  5. def foo():
  6.     print(123)
  7.     time.sleep(10)
  8.     print("end123")
  11. def bar():
  12.     print(456)
  13.     time.sleep(10)
  14.     print("end456")
  17. t1 = Thread(target=foo)
  18. t2 = Thread(target=bar)
  20. t1.daemon= True #必须在t.start()之前设置
  22. # t1.setDaemon(True)
  25. t1.start()
  26. t2.start()
  27. print("main-------")
  29. print(t1.is_alive())
  31. # 123
  32. # 456
  33. # main-------
  34. # end456

六、同步锁

1、 多个线程抢占资源的情况

  1. ''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
  2. from threading import Thread
  3. import os,time
  4. def work():
  7. global n temp=n 
  8. time.sleep(0.1) 
  9. n=temp-1 
  11. if __name__ == '__main__':
  12.     n=100
  15.     l=[]
  16.     for i in range(100):
  17.         p=Thread(target=work)
  18.         l.append(p)
  19.         p.start()
  20.     for p in l:
  21.         p.join()
  23.     print(n) #结果可能为99

2、同步锁的引用

对公共数据的操作

  1. import threading
  4. R=threading.Lock()
  5. R.acquire()
  6. ''' 对公共数据的操作 '''
  7. R.release()

3、实例

不加锁:并发执行,速度快,数据不安全

  1. from threading import current_thread,Thread,Lock
  2. import os,time
  3. def task():
  4.     global n
  5.     print('%s is running' %current_thread().getName())
  6.     temp=n
  7.     time.sleep(0.5)
  8.     n=temp-1
  11. if __name__ == '__main__':
  12.     n=100
  13.     lock=Lock()
  14.     threads=[]
  15.     start_time=time.time()
  16.     for i in range(100):
  17.         t=Thread(target=task)
  18.         threads.append(t)
  19.         t.start()
  20.     for t in threads:
  21.         t.join()
  23.     stop_time=time.time()
  24.     print('主:%s n:%s' %(stop_time-start_time,n))
  26. ''' Thread-1 is running Thread-2 is running ...... Thread-100 is running 主:0.5216062068939209 n:99 '''

加锁:未加锁部分并发执行,加锁部分串行执行,速度慢,数据安全

  1. ''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
  2. from threading import current_thread,Thread,Lock
  3. import os,time
  5. def task():
  6.     #未加锁的代码并发运行
  7.     time.sleep(3)
  8.     print('%s start to run' %current_thread().getName())
  9.     global n
  10.     #加锁的代码串行运行
  11.     lock.acquire()
  12.     temp=n
  13.     time.sleep(0.5)
  14.     n=temp-1
  15.     lock.release()
  17. if __name__ == '__main__':
  18.     n=100
  19.     lock=Lock()
  20.     threads=[]
  21.     start_time=time.time()
  22.     for i in range(100):
  23.         t=Thread(target=task)
  24.         threads.append(t)
  25.         t.start()
  26.     for t in threads:
  27.         t.join()
  28.     stop_time=time.time()
  29.     print('主:%s n:%s' %(stop_time-start_time,n))
  31. ''' Thread-1 is running Thread-2 is running ...... Thread-100 is running 主:53.294203758239746 n:0 '''

七、死锁与递归锁

所谓死锁：是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁

1、 死锁

  1. from threading import Lock as Lock
  2. import time
  5. mutexA=Lock()
  6. mutexA.acquire()
  7. mutexA.acquire()
  9. print(123)
  12. mutexA.release()
  13. mutexA.release()

解决方法：递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

2、 递归锁（可重入锁）RLock

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁。

  1. from threading import RLock as Lock
  2. import time
  5. mutexA=Lock()
  6. mutexA.acquire()
  7. mutexA.acquire()
  8. print(123)
  9. mutexA.release()
  10. mutexA.release()

3、典型问题：科学家吃面

递归锁解决死锁问题

  1. ''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
  2. import time
  3. from threading import Thread,RLock
  6. fork_lock = noodle_lock = RLock()
  8. def eat1(name):
  9.     noodle_lock.acquire()
  10.     print('%s 抢到了面条'%name)
  11.     fork_lock.acquire()
  12.     print('%s 抢到了叉子'%name)
  13.     print('%s 吃面'%name)
  14.     fork_lock.release()
  15.     noodle_lock.release()
  17. def eat2(name):
  18.     fork_lock.acquire()
  19.     print('%s 抢到了叉子' % name)
  20.     time.sleep(1)
  21.     noodle_lock.acquire()
  22.     print('%s 抢到了面条' % name)
  23.     print('%s 吃面' % name)
  24.     noodle_lock.release()
  25.     fork_lock.release()
  27. for name in ['哪吒','nick','tank']:
  28.     t1 = Thread(target=eat1,args=(name,))
  29.     t2 = Thread(target=eat2,args=(name,))
  30.     t1.start()
  31.     t2.start()

八、线程队列

queue队列：使用import queue，用法与进程Queue一样

当必须在多个线程之间安全地交换信息时，队列在线程编程中特别有用。

1、先进先出:Queue

通过双向列表实现的

  1. class queue.Queue(maxsize=0)
  3. import queue
  5. q=queue.Queue()
  6. q.put('first')
  7. q.put('second')
  8. q.put('third')
  10. print(q.get())
  11. print(q.get())
  12. print(q.get())
  13. ''' 结果(先进先出): first second third '''

2、后进先出:LifoQueue

通过堆实现

class queue.LifoQueue(maxsize=0)

  1. ''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
  2. import queue
  4. q=queue.LifoQueue()
  5. q.put('first')
  6. q.put('second')
  7. q.put('third')
  9. print(q.get())
  10. print(q.get())
  11. print(q.get())
  12. ''' 结果(后进先出): third second first '''

3、存储数据时可设置优先级的队列:PriorityQueue

PriorityQueue类和LifoQueue类继承Queue类然后重写了_init、_qsize、_put、_get这四个类的私有方法.

通过list来实现的。

  1. class queue.PriorityQueue(maxsize=0)

优先队列的构造函数。maxsize是一个整数，它设置可以放置在队列中的项数的上限。一旦达到此大小，插入将阻塞，直到队列项被使用。如果maxsize小于或等于0，则队列大小为无穷大。

  1. import queue
  3. q=queue.PriorityQueue()
  4. #put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
  5. q.put((20,'a'))
  6. q.put((10,'b'))
  7. q.put((30,'c'))
  9. print(q.get())
  10. print(q.get())
  11. print(q.get())
  12. ''' 结果(数字越小优先级越高,优先级高的优先出队): (10, 'b') (20, 'a') (30, 'c') '''

更多方法说明

  • __init__(self, maxsize=0)：初始化队列长度，maxsize为0的时候长度为无限
  • empty(self) ：返回队列是否为空
  • full(self) ：返回队列是否为满
  • qsize(self) ：返回队列的大小（并不可靠）
  • get(self, block=True, timeout=None) ：从队头获取并删除元素，block为true：timeout为None时候，阻塞当前线程直到队列中有可用元素；timeout为非负时候，等了timeout的时间还没有可用元素时候抛出一个Empty异常；block为false：timeout为None时候，队列为空则抛出Empty异常；timeout为非负时候，等待timeout时候后没有可用元素则抛出Empty异常。
  • get_nowait(self) ：#返回self.get(block=False)
  • put(self, item, block=True, timeout=None)： 在队尾插入一个元素，block为true：timeout为None时候，阻塞当前线程直到队列中有可用位置；timeout为非负时候，等了timeout时间还没有可用位置时候抛出一个Full异常；block为false：timeout为None时候，队列没有位置则抛出Full异常；timeout为非负时候，等待timeout时候后还是没有可用位置则抛出Full异常。
  • put_nowait(self, item) :返回 self.put(item, block=False)
  • join(self) ：阻塞当前线程直到队列的任务全部完成了
  • task_done(self) ：通知队列任务的完成情况，当完成时候唤醒被join阻塞的线程

九、Python标准模块——concurrent.futures

1、介绍

concurrent.futures模块提供了高度封装的异步调用接口:

  • ThreadPoolExecutor：线程池，提供异步调用
  • ProcessPoolExecutor：进程池，提供异步调用

两者都实现了由抽象Executor类定义的相同接口。

ThreadPoolExecutor(线程池)与ProcessPoolExecutor(进程池)都是concurrent.futures模块下的，主线程(或进程)中可以获取某一个线程(进程)执行的状态或者某一个任务执行的状态及返回值。

通过submit返回的是一个future对象，它是一个未来可期的对象，通过它可以获悉线程的状态。

比较：

  • 线程不是越多越好，会涉及cpu上下文的切换（会把上一次的记录保存）。
  • 进程比线程消耗资源，进程相当于一个工厂，工厂里有很多人，里面的人共同享受着福利资源，，一个进程里默认只有一个主线程，比如：开启程序是进程，里面执行的是线程，线程只是一个进程创建多个人同时去工作。
  • 线程里有GIL全局解锁器：不允许cpu调度
  • 计算密度型适用于多进程
  • 线程：线程是计算机中工作的最小单元
  • 进程：默认有主线程 (帮工作)可以多线程共存
  • 协程：一个线程，一个进程做多个任务,使用进程中一个线程去做多个任务，微线程
  • GIL全局解释器锁：保证同一时刻只有一个线程被cpu调度

2、基本方法

  • submit(fn, *args, **kwargs)：异步提交任务
  • map(func, *iterables, timeout=None, chunksize=1)：取代for循环submit的操作
  • shutdown(wait=True)：相当于进程池的pool.close()+pool.join()操作
  • wait=True，等待池内所有任务执行完毕回收完资源后才继续 ，
  • wait=False，立即返回，并不会等待池内的任务执行完毕 ，
  • 但不管wait参数为何值，整个程序都会等到所有任务执行完毕 ，submit和map必须在shutdown之前。
  • result(timeout=None)：取得结果
  • add_done_callback(fn)：回调函数
  • done()：判断某一个线程是否完成
  • cancle()：取消某个任务

3、ProcessPoolExecutor、ThreadPoolExecutor线程池

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

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

通过submit函数返回的任务句柄,能够使用done()方法判断该任务是否结束。

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

对于频繁的cpu操作，由于GIL锁的原因，多个线程只能用一个cpu，这时多进程的执行效率要比多线程高。

  1. ''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
  2. from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
  4. import os,time,random
  5. def task(n):
  6.     print('%s is runing' %os.getpid())
  7.     time.sleep(random.randint(1,3))
  8.     return n**2
  10. if __name__ == '__main__':
  12.     executor=ProcessPoolExecutor(max_workers=3)
  14.     futures=[]
  15.     for i in range(11):
  16.         future=executor.submit(task,i)
  17.         futures.append(future)
  18.     executor.shutdown(True)
  19.     print('+++>')
  20.     for future in futures:
  21.         print(
  22. future.result())

4、过wait()判断线程执行的状态：

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

wait(fs, timeout=None, return_when=ALL_COMPLETED)，wait接受3个参数，

  • s表示执行的task序列；
  • timeout表示等待的最长时间，超过这个时间即使线程未执行完成也将返回；

  • return_when表示wait返回结果的条件，默认为ALL_COMPLETED全部执行完成再返回

    import time
    from concurrent.futures import (

    1. ThreadPoolExecutor, wait

    )

  1. def get_thread_time(times):
  2.     time.sleep(times)
  3.     return times
  6. start = time.time()
  7. executor = ThreadPoolExecutor(max_workers=4)
  8. task_list = [executor.submit(get_thread_time, times) for times in [1, 2, 3, 4]]
  9. i = 1
  10. for task in task_list:
  11.     print("task{}:{}".format(i, task))
  12.     i += 1
  13. print(wait(task_list, timeout=2.5))
  15. # wait在2.5秒后返回线程的状态，result：
  16. # task1:<Future at 0x7ff3c885f208 state=running>
  17. # task2:<Future at 0x7ff3c885fb00 state=running>
  18. # task3:<Future at 0x7ff3c764b2b0 state=running>
  19. # task4:<Future at 0x7ff3c764b9b0 state=running>
  20. # DoneAndNotDoneFutures(
  21. # done={<Future at 0x7ff3c885f208 state=finished returned int>, <Future at 0x7ff3c885fb00 state=finished returned int>},
  22. # not_done={<Future at 0x7ff3c764b2b0 state=running>, <Future at 0x7ff3c764b9b0 state=running>})
  23. #
  24. # 可以看到在timeout 2.5时，task1和task2执行完毕，task3和task4仍在执行中

4、map的用法

map(fn, *iterables, timeout=None)，第一个参数fn是线程执行的函数；第二个参数接受一个可迭代对象；第三个参数timeout跟wait()的timeout一样，但由于map是返回线程执行的结果，如果timeout小于线程执行时间会抛异常TimeoutError。

map的返回是有序的，它会根据第二个参数的顺序返回执行的结果：

  1. from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
  3. import os,time,random
  4. def task(n):
  5.     print('%s is runing' %os.getpid())
  6.     time.sleep(random.randint(1,3))
  7.     return n**2
  9. if __name__ == '__main__':
  11.     executor=ThreadPoolExecutor(max_workers=3)
  13.     # for i in range(11):
  14.     # future=executor.submit(task,i)
  16.     executor.map(task,range(1,12))
  18.  #map取代了for+submit

5、s_completed返回线程执行结果

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

  1. import time
  2. from collections import OrderedDict
  3. from concurrent.futures import (
  4.     ThreadPoolExecutor, as_completed
  5. )
  8. def get_thread_time(times):
  9.     time.sleep(times)
  10.     return times
  13. start = time.time()
  14. executor = ThreadPoolExecutor(max_workers=4)
  15. task_list = [executor.submit(get_thread_time, times) for times in [2, 3, 1, 4]]
  16. task_to_time = OrderedDict(zip(["task1", "task2", "task3", "task4"],[2, 3, 1, 4]))
  17. task_map = OrderedDict(zip(task_list, ["task1", "task2", "task3", "task4"]))
  19. for result in as_completed(task_list):
  20.     task_name = task_map.get(result)
  21.     print("{}:{}".format(task_name,task_to_time.get(task_name)))
  23. # task3: 1
  24. # task1: 2
  25. # task2: 3
  26. # task4: 4

task1、task2、task3、task4的等待时间分别为2s、3s、1s、4s，通过as_completed返回执行完的线程结果，as_completed(fs, timeout=None)接受2个参数，第一个是执行的线程列表，第二个参数timeout与map的timeout一样，当timeout小于线程执行时间会抛异常TimeoutError。

通过执行结果可以看出，as_completed返回的顺序是线程执行结束的顺序，最先执行结束的线程最早返回。

6、回调函数

Future对象也可以像协程一样，当它设置完成结果时，就可以立即进行回调别的函数。add_done_callback(fn)，则表示 Futures 完成后，会调⽤fn函数。

  1. from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
  2. from multiprocessing import Pool
  3. import requests
  4. import json
  5. import os
  7. def get_page(url):
  8.     print('<进程%s> get %s' %(os.getpid(),url))
  9.     respone=requests.get(url)
  10.     if respone.status_code == 200:
  11.         return { 'url':url,'text':respone.text}
  13. def parse_page(res):
  14.     res=res.result()
  15.     print('<进程%s> parse %s' %(os.getpid(),res['url']))
  16.     parse_res='url:<%s> size:[%s]\n' %(res['url'],len(res['text']))
  17.     with open('db.txt','a') as f:
  18.         f.write(parse_res)
  21. if __name__ == '__main__':
  22.     urls=[
  23.         'https://www.baidu.com',
  24.         'https://www.python.org',
  25.         'https://www.openstack.org',
  26.         'https://help.github.com/',
  27.         'http://www.sina.com.cn/'
  28.     ]
  30.     # p=Pool(3)
  31.     # for url in urls:
  32.     # p.apply_async(get_page,args=(url,),callback=pasrse_page)
  33.     # p.close()
  34.     # p.join()
  36.     p=ProcessPoolExecutor(3)
  37.     for url in urls:
  38.         p.submit(get_page,url).add_done_callback(parse_page) #parse_page拿到的是一个future对象obj，需要用obj.result()拿到结果

Python基础太难学？小编创建了一个Python学习交流QQ群：531509025，群里有大量基础入门知识，都是从零开始的，群里还有专业的人给你解答问题。寻找有志同道合的小伙伴，互帮互助,群里还有不错PDF电子书

发表评论

表情：
评论列表 （有 0 条评论，56人围观）

还没有评论，来说两句吧...

相关阅读