使用Callable接口实现多线程

相比Runnable接口，Callable接口有2个显著的优点：一是可以返回值 二是可以对外声明异常

举例子说明

package cpm.thread.creater;

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 Call {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
      ExecutorService ser= Executors.newFixedThreadPool(2);
      Race race=new Race(1000);
      Race race2=new Race(500);
      Future<Integer> result=ser.submit(race);
      Future<Integer> result2=ser.submit(race2);
      Thread.sleep(2000);
      race.setFlag(false);
      race2.setFlag(false);
      int num=result.get();
      int num2=result2.get();
      System.out.println(num);
      System.out.println(num2);
      ser.shutdown();
    }
 
}

class Race implements Callable<Integer>
{
    private long time;
    private Boolean flag=true;
    private int step;
    
   public Race(long time) {
        super();
        this.time = time;
    }
@Override
       public Integer call() throws Exception {
       while(flag)
       {
           Thread.sleep(time);
           step++;
       }
           return step;
       }
public long getTime() {
    return time;
}
public void setTime(long time) {
    this.time = time;
}
public Boolean getFlag() {
    return flag;
}
public void setFlag(Boolean flag) {
    this.flag = flag;
}
public int getStep() {
    return step;
}
public void setStep(int step) {
    this.step = step;
}    
}

我们给线程类Race实现Callable接口 <>里面是返回值类型，重写call()方法，设置变量time控制线程休眠时间，flag控制线程停止，step作为返回值

mian方法中，我们首先声明了一个线程池，参数为线程个数，     Future<Integer> result=ser.submit(race);代表启动线程，      ser.shutdown();关闭线程池

运行main方法，