Thread和Rnnable接口都不允许声明检查类型异常,也不能定义返回值。
  public void run()方法契约意味着必须捕获并处理检查型异常。即使小心地保存了异常信息以便以后检查,但也不能保证这个类的所有使用者都读取异常信息。
  Callable与Runnable的区别在于:

  • Callable规定的方法是call(),而Runnable是run();
  • Callable的任务执行可返回值,而Runnable的任务不能有返回值;
  • call()方法可抛出异常,而run()不能抛出异常;
  • 运行Callable任务可拿到Futrue对象.

  Future对象是Callable任务返回的结果,Callable产生结果,future拿到结果。
  Future接口提供方法来检测任务是否被执行完,等待任务执行完获得结果。也可以设置任务执行的超时时间,这个设置超时的方法就是实现Java程序执行超时的关键。所以,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableTest1 {
    public static void main(String[] args) {
        //与线程池配合使用
        CallableDemo cd = new CallableDemo();
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> result = executor.submit(cd);
        int i = 0;
        try {
            i = result.get();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(i);
    }
}

class CallableDemo implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // TODO Auto-generated method stub
        return new Random().nextInt(1000);
    }

}

Future##

  在Future接口中声明了5个方法:

  • isCancelled方法表示任务是否被取消,如果正常被取消,则返回true;
  • isDone方法表示任务已经完成,若完成,返回true;
  • get方法获取执行结果,这个方法会产生阻塞,会一直等到任务执行完毕才返回;
  • get(long timeout, TimeUnit unit)用来获取执行结构,如果在指定时间内,还没获取到结果,就直接返回null。

 Ԉ也就是说Future提供了三个功能:

  1. 判断任务是否完成;
  2. 中断任务;
  3. 获取执行结果。

  Future只是一个接口,所以无法直接创建对象,因此有了实现类FutureTask。

import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class FutureTaskRunnable {
	public static void main(String[] args) {
		ExecutorService executor = Executors.newSingleThreadExecutor();
		
		Future<String> result = executor.submit(new Runnable() {
			public void run() {
				// TODO Auto-generated method stub
				int i = new Random().nextInt(100);
				System.out.println(i);
			}
			
		},"任务完成");
		
		FutureTask<String> future2 = new FutureTask<String>(new Runnable() {
			public void run() {
				// TODO Auto-generated method stub
				int i = new Random().nextInt(100);
				System.out.println(i);
			}
			
		}, "任务完成");
		
		
		//FutureTask实现了Runnable接口,所以可以直接调用execute()方法执行。
		//executor.execute(future2);
		executor.submit(future2);
		String str = "str";
		try {
			str = future2.get();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(str);
	}
}