使用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方法，