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()方法。
    

    
	
    
      



  
    
  
  
    
   
  
    
  
 
 
    
 
 
  
 
 
 
 

    




 



    


    相关教程