VB.net 2010 视频教程 VB.net 2010 视频教程 python基础视频教程
SQL Server 2008 视频教程 c#入门经典教程 Visual Basic从门到精通视频教程
当前位置:
首页 > Python基础教程 >

  • Python3标准库：concurrent.futures管理并发任务池(2)

.format(n))
  • return n / 10
  •  
  • def done(fn):
  • if fn.cancelled():
  • print('{}: canceled'.format(fn.arg))
  • elif fn.done():
  • error = fn.exception()
  • if error:
  • print('{}: error returned: {}'.format(
  • fn.arg, error))
  • else:
  • result = fn.result()
  • print('{}: value returned: {}'.format(
  • fn.arg, result))
  •  
  • if __name__ == '__main__':
  • ex = futures.ThreadPoolExecutor(max_workers=2)
  • print('main: starting')
  • f = ex.submit(task, 5)
  • f.arg = 5
  • f.add_done_callback(done)
  • result = f.result()

    • 不论由于什么原因，只要认为Future“完成”，就会调用这个回调，所以在使用它之前必须检查传入回调的对象的状态。

    1.5 撤销任务

    如果一个Future已经提交但还没启动，那么可以调用它的cancel()方法将其撤销。

    

      

    1. 
from concurrent import futures
      2. 

    2. 
import time
      3. 

    3. 
 
      4. 

    4. 
def task(n):
      5. 

    5. 
print('{}: sleeping'.format(n))
      6. 

    6. 
time.sleep(0.5)
      7. 

    7. 
print('{}: done'.format(n))
      8. 

    8. 
return n / 10
      9. 

    9. 
 
      10. 

    10. 
def done(fn):
      11. 

    11. 
if fn.cancelled():
      12. 

    12. 
print('{}: canceled'.format(fn.arg))
      13. 

    13. 
elif fn.done():
      14. 

    14. 
print('{}: not canceled'.format(fn.arg))
      15. 

    15. 
 
      16. 

    16. 
if __name__ == '__main__':
      17. 

    17. 
ex = futures.ThreadPoolExecutor(max_workers=2)
      18. 

    18. 
print('main: starting')
      19. 

    19. 
tasks = []
      20. 

    20. 
 
      21. 

    21. 
for i in range(10, 0, -1):
      22. 

    22. 
print('main: submitting {}'.format(i))
      23. 

    23. 
f = ex.submit(task, i)
      24. 

    24. 
f.arg = i
      25. 

    25. 
f.add_done_callback(done)
      26. 

    26. 
tasks.append((i, f))
      27. 

    27. 
 
      28. 

    28. 
for i, t in reversed(tasks):
      29. 

    29. 
if not t.cancel():
      30. 

    30. 
print('main: did not cancel {}'.format(i))
      31. 

    31. 
 
      32. 

    32. 
ex.shutdown()
      33. 

    

    

    
cancel()返回一个布尔值，指示任务是否可用撤销。
    

    

    

    

    

    
1.6 任务中的异常
    

    
如果一个任务产生一个未处理的异常，那么它会被保存到这个任务的Future，而且可以通过result()或exception()方法得到。
    

    

    

      

    1. 
from concurrent import futures
      2. 

    2. 
 
      3. 

    3. 
def task(n):
      4. 

    4. 
print('{}: starting'.format(n))
      5. 

    5. 
raise ValueError('the value {} is no good'.format(n))
      6. 

    6. 
 
      7. 

    7. 
ex = futures.ThreadPoolExecutor(max_workers=2)
      8. 

    8. 
print('main: starting')
      9. 

    9. 
f = ex.submit(task, 5)
      10. 

    10. 
 
      11. 

    11. 
error = f.exception()
      12. 

    12. 
print('main: error: {}'.format(error))
      13. 

    13. 
 
      14. 

    14. 
try:
      15. 

    15. 
result = f.result()
      16. 

    16. 
except ValueError as e:
      17. 

    17. 
print('main: saw error "{}" when accessing result'.format(e))
      18. 

    

    

    
如果在一个任务函数中抛出一个未处理的异常后调用了result()，那么会在当前上下文中再次抛出同样的异常。
    

    

    

    

    

    
1.7 上下文管理器
    

    
执行器会与上下文管理器合作，并发的运行任务并等待它们都完成。当上下文管理器退出时，会调用执行器的shutdown()方法。
    

    

    
      



  
    
  
  
    
   
  
    
  
 
 
    
 
 
  
 
 
 
 

    




 



    


    相关教程