0
点赞
收藏
分享

微信扫一扫

java5线程Callable与Future的应用

斗米 2023-07-26 阅读 57
javaSystemi++Windows Server服务器


Callable和Future

   

    A、call方法可以有返回值
    B、call方法可以申明抛出异常
 
    Callable接口是JDK5后新增的接口，而且不是Runnable的子接口，所以Callable对象不能直接作为Thread的target。而且call方法还有一个返回值，
    call方法不能直接调用，它作为线程的执行体被调用。那么如何接收call方法的返回值？
    JDK1.5提供了Future接口来代表Callable接口里的call方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现Future接口，
    并实现了Runnable接口—可以作为Thread的target。
 
    Future接口里定义了如下几个公共方法控制他关联的Callable任务：
   
    A、boolean cancel(Boolean mayInterruptlfRunning):试图取消该Future里关联的Callable任务
    B、V get()：返回Callable任务里的call方法的返回值，调用该方法将导致线程阻塞，必须等到子线程结束才得到返回值
    C、V get(long timeout, TimeUnit unit)：返回Callable任务里的call方法的返回值，该方法让程序最多阻塞timeout和unit指定的时间。
        如果经过指定时间后Callable任务依然没有返回值，将会抛出TimeoutException。
    D、boolean isCancelled：如果在Callable任务正常完成前被取消，则返回true。
    E、boolean isDone：如果Callable任务已经完成，则返回true
 
    创建、并启动有返回值的线程的步骤如下：
   
    一、创建Callable接口的实现类，并实现call方法，该call方法的返回值，并作为线程的执行体。
    二、创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call方法的返回值
    三、使用FutureTask对象作为Thread对象的target创建、并启动新线程
   




1、Executor框架使用Runnable作为其任务的基本表达形式。Runnable相当有限，不能返回一个值，也不能抛出受检查的异常，对于复杂费时的计算更加无法处理


2、因此产生了Callable和Future这种任务，对任务进行全面管理

3、

1）Callable在主进入点-call处等待返回值，并为可能抛出的异常预先做了准备。

2）Executors包含了一些工具方法将其他类型的任务封装成一个Callable，比如Runnable和java.security.PrivilegedAction。Runnable和Callable描述的是抽象的计算型任务。

3）这些任务很有限，有明确的开始和结束，但是对于非常费时的任务比较麻烦，对于已经提交但尚未开始的任务可以取消，但是对于已经开始的任务，只有它们响应中断，才可以取消。

4、

1）Future描述了任务的生命周期，并提供了相关的方法来获得任务的结果、取消任务以及检验任务已经完成还是被取消。

2）Future意味着任务完成后永远停留在完成状态上，就像ExecutorService的生命周期。使用get方法完成任务和异常处理。


3）ExecutorService中的所有submit方法都返回一个Future，可以将一个Runnable或一个Callable提交给executor,然后得到一个Future。也可以显式地为给定的Runnable或Callable实例化一个FutureTask。




[java]
 package com.itm.thread; 
  
 import java.util.Random; 
 import java.util.concurrent.Callable; 
 import java.util.concurrent.CompletionService; 
 import java.util.concurrent.ExecutionException; 
 import java.util.concurrent.ExecutorCompletionService; 
 import java.util.concurrent.ExecutorService; 
 import java.util.concurrent.Executors; 
 import java.util.concurrent.Future; 
  
 import javax.annotation.processing.Completion; 
  
 public class CallableAndFuture { 
  
      
     public static void main(String[] args) { 
         ExecutorService threadPool = Executors.newSingleThreadExecutor(); 
         Future future =  
         threadPool.submit( 
                 new Callable(){ 
                         public String call() throws Exception { 
                             Thread.sleep(2000); 
                             return "hello"; 
                         }; 
                 } 
         ); 
         System.out.println("等待结果"); 
         try { 
             System.out.println("拿到结果  : " + future.get()); 
         } catch (InterruptedException e) { 
             e.printStackTrace(); 
         } catch (ExecutionException e) { 
             e.printStackTrace(); 
         } 
          
          
         ExecutorService threadPool2 = Executors.newFixedThreadPool(10); 
         CompletionService completionService = new ExecutorCompletionService(threadPool2); 
          
         // 提交十个任务。  
         for(int i=1;i<=10;i++){ 
                 final int seq = i; 
                 completionService.submit(new Callable() { 
                     @Override 
                     public Integer call() throws Exception { 
                         Thread.sleep(new Random().nextInt(5000)); 
                         return seq; 
                     } 
                 }); 
         } 
         // 拿到  提交任务的结果  。。。  
         for(int i=0;i<10;i++){ 
             try { 
                 System.out.println( 
                 completionService.take().get()); 
             } catch (InterruptedException e) { 
                 // TODO Auto-generated catch block  
                 e.printStackTrace(); 
             } catch (ExecutionException e) { 
                 // TODO Auto-generated catch block  
                 e.printStackTrace(); 
             } 
         } 
     } 
      
  
 }


package com.itm.thread;
import java.util.Random;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletionService;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorCompletionService;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;import javax.annotation.processing.Completion;
public class CallableAndFuture {
  public static void main(String[] args) {
   ExecutorService threadPool = Executors.newSingleThreadExecutor();
   Future future =
   threadPool.submit(
     new Callable(){
       public String call() throws Exception {
        Thread.sleep(2000);
        return "hello";
       };
     }
   );
   System.out.println("等待结果");
   try {
    System.out.println("拿到结果  : " + future.get());
   } catch (InterruptedException e) {
    e.printStackTrace();
   } catch (ExecutionException e) {
    e.printStackTrace();
   }


  
  

ExecutorService threadPool2 = Executors.newFixedThreadPool(10);
   CompletionService completionService = new ExecutorCompletionService(threadPool2);
   
   // 提交十个任务。
   for(int i=1;i<=10;i++){
     final int seq = i;
     completionService.submit(new Callable() {
      @Override
      public Integer call() throws Exception {
       Thread.sleep(new Random().nextInt(5000));
       return seq;
      }
     });
   }
   // 拿到  提交任务的结果  。。。
   for(int i=0;i<10;i++){
    try {
     System.out.println(
     completionService.take().get());
    } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    } catch (ExecutionException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
   }
  }
  }


 




也可以借鉴一下：

[java]
 import java.util.concurrent.Callable; 
 import java.util.concurrent.ExecutorService; 
 import java.util.concurrent.Executors; 
 import java.util.concurrent.Future; 
   
  
 public class CallableAndFuture { 
         
        public static class MyCallableClass implements Callable{ 
               private int flag = 0; 
               public MyCallableClass(int flag){ 
                      this.flag = flag; 
               } 
               public String call() throws Exception{ 
                      if(this.flag == 0){ 
                             return "flag = 0";//如果flag的值为0,则立即返回  
                      } 
                      if(this.flag == 1){ 
                             //如果flag的值为1,做一个无限循环  
                             try{ 
                                    while(true){ 
                                           System.out.println("looping..."); 
                                           Thread.sleep(2000); 
                                    } 
                             }catch(InterruptedException e){ 
                                    System.out.println("Interrupted"); 
                             } 
                             return "false"; 
                      }else{ 
                             throw new Exception("Bad flag value!");//flag不为1或0,则抛出异常  
                      } 
               } 
        } 
        public static void main(String... args){ 
               //定义3个Callable类型的任务  
               MyCallableClass task1 = new MyCallableClass(0); 
               MyCallableClass task2 = new MyCallableClass(1); 
               MyCallableClass task3 = new MyCallableClass(2); 
               
               //创建一个执行任务的服务  
               ExecutorService es = Executors.newFixedThreadPool(3); 
               try{ 
                      //提交并执行任务,任务启动时返回了一个Future对象  
                      //如果想得到任务执行的结果或者是异常可对这个Future对象进行操作  
                      Future future1 = es.submit(task1); 
                      //获得第一个任务的结果,如果调用get方法,当前线程会等待任务执行完毕后才往下执行  
                      System.out.println("task1: " + future1.get()); 
                      
                      Future future2 = es.submit(task2); 
                      //等待5秒后,再停止第二个任务,因为第二个任务进行的是无限循环  
                      Thread.sleep(5000); 
                      System.out.println("task2 cancel: " + future2.cancel(true)); 
                      
                      //获取第三个任务的输出,因为执行第三个任务会引起异常  
                      //所以下面的语句将引起异常的输出  
                      Future future3 = es.submit(task3); 
                      System.out.println("task3: " + future3.get()); 
               }catch(Exception e){ 
                      System.out.println(e.toString()); 
               } 
               es.shutdown();//立即停止任务执行服务  
        } 
 } 
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
  

 public class CallableAndFuture {
       
        public static class MyCallableClass implements Callable{
               private int flag = 0;
               public MyCallableClass(int flag){
                      this.flag = flag;
               }
               public String call() throws Exception{
                      if(this.flag == 0){
                             return "flag = 0";//如果flag的值为0,则立即返回
                      }
                      if(this.flag == 1){
                             //如果flag的值为1,做一个无限循环
                             try{
                                    while(true){
                                           System.out.println("looping...");
                                           Thread.sleep(2000);
                                    }
                             }catch(InterruptedException e){
                                    System.out.println("Interrupted");
                             }
                             return "false";
                      }else{
                             throw new Exception("Bad flag value!");//flag不为1或0,则抛出异常
                      }
               }
        }
        public static void main(String... args){
               //定义3个Callable类型的任务
               MyCallableClass task1 = new MyCallableClass(0);
               MyCallableClass task2 = new MyCallableClass(1);
               MyCallableClass task3 = new MyCallableClass(2);
             
               //创建一个执行任务的服务
               ExecutorService es = Executors.newFixedThreadPool(3);
               try{
                      //提交并执行任务,任务启动时返回了一个Future对象
                      //如果想得到任务执行的结果或者是异常可对这个Future对象进行操作
                      Future future1 = es.submit(task1);
                      //获得第一个任务的结果,如果调用get方法,当前线程会等待任务执行完毕后才往下执行
                      System.out.println("task1: " + future1.get());
                    
                      Future future2 = es.submit(task2);
                      //等待5秒后,再停止第二个任务,因为第二个任务进行的是无限循环
                      Thread.sleep(5000);
                      System.out.println("task2 cancel: " + future2.cancel(true));
                    
                      //获取第三个任务的输出,因为执行第三个任务会引起异常
                      //所以下面的语句将引起异常的输出
                      Future future3 = es.submit(task3);
                      System.out.println("task3: " + future3.get());
               }catch(Exception e){
                      System.out.println(e.toString());
               }
               es.shutdown();//立即停止任务执行服务
        }
 }

举报

相关推荐

java多线程--Callable、Future

java返回结果子线程

Java多线程 Callable和Future

java

Java线程篇(七)：Callable和Future

线程安全javaSystem返回结果虚拟化云计算

Callable、Future 和 FutureTask 简单应用

日记本

java5

eclipse

Future和Callable

JavaFutureCallable线程池抛出异常Html/CSS前端开发

Callable和Future

java返回结果i++数据虚拟化云计算

并发编程-Callable与Future模式

J2SE-并发编程RxJavaJava服务器端编程编程语言爱好者JavaJava 核心技术

Java并发JUC——Future和Callable

Java并发编程个人学习并发（个人收集）

Java(86):通过Callable接口+Future接口实现多线程

java开发语言后端
0 条评论