juc：Callable

Callable(简单)

1、可以有返回值；
2、可以抛出异常；
3、方法不同，run()/call()

代码测试

传统使用线程方式：

public class CallableTest {
    public static void main(String[] args) {
        for (int i = 1; i < 10; i++) {
            new Thread(new MyThread()).start();
        }
    }
}

class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

使用Callable进行多线程操作：

package demo925;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        myThread thread=new myThread();//怎么启动callable
        FutureTask futureTask = new FutureTask(thread);//适配类

        new Thread(futureTask,"a").start();
        Integer o =(Integer) futureTask.get();//获取callable的返回结果
        System.out.println(o);
    }

    static class myThread implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {
            System.out.println("call");
            return 1024;
        }
    }
}

Calleable 泛型T就是call运行方法的返回值类型；

但是如何使用呢？

Callable怎么放入到Thread里面呢？

对于Thread运行，只能传入Runnable类型的参数；

我们这是Callable 怎么办呢？

看JDK api文档：

在Runnable里面有一个叫做FutureTask的实现类，我们进去看一下。

这样我们就可以先把Callable 放入到FutureTask中，如何再把FutureTask 放入到Thread就可以了。

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        for (int i = 1; i < 10; i++) {
//            new Thread(new Runnable()).start();
//            new Thread(new FutureTask<>( Callable)).start();
            MyThread thread= new MyThread();
            //适配类：FutureTask
            FutureTask<String> futureTask = new FutureTask<>(thread);
            //放入Thread使用
            new Thread(futureTask,String.valueOf(i)).start();
            //获取返回值
            String s = futureTask.get();
            System.out.println("返回值："+ s);
        }
    }
}

class MyThread implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("Call:"+Thread.currentThread().getName());
        return "String"+Thread.currentThread().getName();
    }
}

这样我们就可以使用Callable来进行多线程编程了，并且我们发现可以有返回值，并且可以抛出异常。

Callable(简单)

猜你喜欢