通过Callable接口实现多线程

之前通过继承Thread类实现多线程，通过Runnable接口+静态代理实现多线程

但是有一个不足之处是，重写run方法时没有返回值也不能抛出异常

使用Callable接口就可以解决这个问题

Callable接口和Runnable接口的不同之处：

1.Callable规定的方法是call，而Runnable是run

2.call方法可以抛出异常，但是run方法不行

3.Callable对象执行后可以有返回值，运行Callable任务可以得到一个Future对象，通过Future对象可以了解任务执行情况，可以取消任务的执行，而Runnable不可有返回值

多线程的实现有以下4个步骤：

1.创建一个线程，创建Callable的实现类Race，并且重写call方法

ExecutorService ser=Executors.newFixedThreadPool(线程数目);
Race tortoise = new Race();

2.得到Future对象

Future<Integer> result=ser.submit(tortoise);

3.获取返回值

int num=result.get();

4.停止服务

ser.shutdown();

举一个龟兔赛跑的例子，直接上代码吧

public class Call {
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		
		ExecutorService ser=Executors.newFixedThreadPool(2);
		
		Race tortoise=new Race("tortoise",1000);
		Race rabbit = new Race("rabbit",500);
		
		
		//获取值
		Future<Integer> resultR=ser.submit(rabbit);
		Future<Integer> resultT=ser.submit(tortoise);
		
		Thread.sleep(3000);
		rabbit.setFlag(false);
		tortoise.setFlag(false);
		
		int numR=resultR.get();
		int numT=resultT.get();
		
		System.out.println("rabbit  ---"+numR);
		System.out.println("tortoise  ---"+numT);
		
		//停止服务
		ser.shutdown();
	}
}

class Race implements Callable<Integer>{
	
	private int step=0;
	private String name;
	private long time;
	private boolean flag=true;
	
	Race(String name,long time){
		this.name=name;
		this.time=time;
	}

	@Override
	public Integer call() throws Exception {
		while(flag){
			Thread.sleep(time);
			step++;
		}
		return step;
	}
	
	public void setFlag(boolean flag){
		this.flag=flag;
	}
}