Future/FutureTask & Callable/Runnable & Executor/ExecutorService/Executors

原创 2017年07月31日 17:03:01

用途:笔记。
各类具体方法参阅JDK API

Callable/Runnable接口

  • Runnable用于实现线程。大多数情况下,如果只想重写 run() 方法,而不重写其他 Thread 方法,那么应使用 Runnable 接口。这很重要,因为除非程序员打算修改或增强类的基本行为,否则不应为该类创建子类。
  • Callable 接口类似于 Runnable,两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果,并且无法抛出经过检查的异常。

Note: Callable需要Override的方法是call(),带返回值,而Runnable是run(),不带返回值。

Future接口/FutureTask实现类

用于异步计算。

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果、设置结果操作。get()方法会阻塞,直到任务返回结果。

Executor顶级接口/ExecutorService次级接口/Executors类

Executor就是Runnable和Callable的调度容器。可以执行Runnable/Callable对象:void execute(Runnable command)

示例

Demo1

  • 有实现Callable的对象,作为FutureTask的初始化参数;
  • 使用Thread启动FutureTask异步子线程;
  • 使用FutureTask的get()返回Callable对象异步执行的返回值;
  • 没Executor屁事儿。
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

@SuppressWarnings("all")
public class FutureTaskDemo {
    public static void main(String[] args) {
        // 初始化一个Callable对象和FutureTask对象
        Callable pAccount = new PrivateAccount();
        FutureTask futureTask = new FutureTask(pAccount);
        // 使用futureTask创建一个线程
        Thread pAccountThread = new Thread(futureTask);
        System.out.println("futureTask线程现在开始启动,启动时间为:" + System.nanoTime());
        pAccountThread.start();
        System.out.println("主线程开始执行其他任务");
        // 从其他账户获取总金额
        int totalMoney = new Random().nextInt(100000);
        System.out.println("现在你在其他账户中的总金额为" + totalMoney);
        System.out.println("等待私有账户总金额统计完毕...");
        // 测试后台的计算线程是否完成,如果未完成则等待
        while (!futureTask.isDone()) {
            try {
                Thread.sleep(500);
                System.out.println("私有账户计算未完成继续等待...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("futureTask线程计算完毕,此时时间为" + System.nanoTime());
        Integer privateAccountMoney = null;
        try {
            privateAccountMoney = (Integer) futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("您现在的总金额为:" + totalMoney + privateAccountMoney.intValue());
    }
}

@SuppressWarnings("all")
class PrivateAccount implements Callable {
    Integer totalMoney;

    @Override
    public Object call() throws Exception {
        Thread.sleep(5000);
        totalMoney = new Integer(new Random().nextInt(10000));
        System.out.println("您当前有" + totalMoney + "在您的私有账户中");
        return totalMoney;
    }

}

Demo2


  • 使用匿名Callable对象作为FutureTask的初始化参数;
  • 不使用Thread,而使用ExecutorService(继承自父类接口Executor)的execute(Runnable)异步启动FutureTask子线程;
  • 使用FutureTask的get()返回Callable对象异步执行的返回值。

区别:引入Executor异步执行FutureTask对象,不再使用Thread异步执行Callable对象。
import java.util.Random;
import java.util.concurrent.*;

@SuppressWarnings("all")
public class FutureTaskDemoAndExecutor {
    public static void main(String[] args) {
        // 初始化一个Callable对象和FutureTask对象
//        Callable pAccount = new PrivateAccount();
        FutureTask futureTask = new FutureTask(new Callable<Integer>() {        // 用不用泛型皆可
            Integer totalMoney;
            @Override
            public Integer call() throws Exception {
                Thread.sleep(5000);
            totalMoney = new Integer(new Random().nextInt(10000));
            System.out.println("您当前有" + totalMoney + "在您的私有账户中");
            return totalMoney;
            }
        });
        // 使用futureTask创建一个线程
//        Thread pAccountThread = new Thread(futureTask);
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        System.out.println("futureTask线程现在开始启动,启动时间为:" + System.nanoTime());
//        pAccountThread.start();
        executorService.execute(futureTask);
        System.out.println("主线程开始执行其他任务");
        // 从其他账户获取总金额
        int totalMoney = new Random().nextInt(100000);
        System.out.println("现在你在其他账户中的总金额为" + totalMoney);
        System.out.println("等待私有账户总金额统计完毕...");
        // 测试后台的计算线程是否完成,如果未完成则等待
        while (!futureTask.isDone()) {
            try {
                Thread.sleep(500);
                System.out.println("私有账户计算未完成继续等待...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("futureTask线程计算完毕,此时时间为" + System.nanoTime());
        Integer privateAccountMoney = null;
        try {
            privateAccountMoney = (Integer) futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("您现在的总金额为:" + totalMoney + privateAccountMoney.intValue());
    }
}

/*
@SuppressWarnings("all")
class PrivateAccount implements Callable {
    Integer totalMoney;

    @Override
    public Object call() throws Exception {
        Thread.sleep(5000);
        totalMoney = new Integer(new Random().nextInt(10000));
        System.out.println("您当前有" + totalMoney + "在您的私有账户中");
        return totalMoney;
    }

}*/

Demo3


  • 使用ExecutorService的submit(Callable<T>)直接异步执行匿名Callable对象
  • Future作为submit(Callable<T>)返回值的接收者;

区别:使用ExecutorService的submit()而不是execute(),省去了FutureTask,但是需要使用Future,调用get()接收匿名Callable对象的返回值。
import java.util.Random;
import java.util.concurrent.*;

@SuppressWarnings("all")
public class FutureTaskDemoAndExecutorSubmit {
    public static void main(String[] args) {
        // 初始化一个Callable对象和FutureTask对象
//        FutureTask futureTask = new FutureTask(new Callable() {
//            Integer totalMoney;
//            @Override
//            public Object call() throws Exception {
//                Thread.sleep(5000);
//                totalMoney = new Integer(new Random().nextInt(10000));
//                System.out.println("您当前有" + totalMoney + "在您的私有账户中");
//                return totalMoney;
//            }
//        });
        // 使用futureTask创建一个线程
//        Thread pAccountThread = new Thread(futureTask);
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        System.out.println("futureTask线程现在开始启动,启动时间为:" + System.nanoTime());
//        executorService.execute(futureTask);
        Future future = executorService.submit(new Callable<Integer>() {        // 用不用泛型皆可
            Integer totalMoney;
            @Override
            public Integer call() throws Exception {
                Thread.sleep(5000);
                totalMoney = new Integer(new Random().nextInt(10000));
                System.out.println("您当前有" + totalMoney + "在您的私有账户中");
                return totalMoney;
            }
        });
        System.out.println("主线程开始执行其他任务");
        // 从其他账户获取总金额
        int totalMoney = new Random().nextInt(100000);
        System.out.println("现在你在其他账户中的总金额为" + totalMoney);
        System.out.println("等待私有账户总金额统计完毕...");
        // 测试后台的计算线程是否完成,如果未完成则等待
//        while (!futureTask.isDone()) {
        while (!future.isDone()) {
            try {
                Thread.sleep(500);
                System.out.println("私有账户计算未完成继续等待...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("futureTask线程计算完毕,此时时间为" + System.nanoTime());
        Integer privateAccountMoney = null;
        try {
//            privateAccountMoney = (Integer) futureTask.get();
            privateAccountMoney = (Integer) future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("您现在的总金额为:" + totalMoney + privateAccountMoney.intValue());
    }
}

匿名Callable泛型可用可不用。

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Java并发编程之Executor,Executors,ExecutorService,Future,Callable

Java并发编程之Executor,Executors,ExecutorService,Future,Callable

Android线程池(九) Runnable、Callable、Executor、Future、FutureTask关系解读

在JAVA中停止线程的方法有多种,有一种是结合ExecutorService和Future的使用,停止在线程池中超时的任务。 这种情况下处理的都是比较耗时的操作,比如请求资源,数据库查询等,当超...

Runnable、Callable、Executor、Future、FutureTask关系解读

在再度温习Java5的并发编程的知识点时发现,首要的就是把Runnable、Callable、Executor、Future等的关系搞明白,遂有了下述小测试程序,通过这个例子上述三者的关系就一目了然了...

Runnable、Callable、Executor、Future、FutureTask关系解读

在再度温习Java5的并发编程的知识点时发现,首要的就是把Runnable、Callable、Executor、Future等的关系搞明白,遂有了下述小测试程序,通过这个例子上述三者的关系就一目了然了...

java多线程Runnable、Callable、Executor、Future、FutureTask关系解读

转自:http://blog.csdn.net/zhangzhaokun/article/details/6615454  在再度温习Java5的并发编程的知识点时发现,首要的就是把Runnab...

Runnable、Callable、Executor、Future、FutureTask关系解读

转载自:http://blog.csdn.net/zhangzhaokun/article/details/6615454  Runnable、Callable、Exec...

Java多线程:Callable、ExecutorService、CountDownLatch、Future和FutureTask

我们知道创建线程的2种方式,一种是直接继承Thread,另外一种就是实现Runnable接口。   这2种方式都有一个缺陷就是:在执行完任务之后无法获取执行结果。   如果需要获取执行结果...

Java中的Runnable、Callable、Future、FutureTask的区别与示例

Java中存在Runnable、Callable、Future、FutureTask这几个与线程相关的类或者接口,在Java中也是比较重要的几个概念,我们通过下面的简单示例来了解一下它们的作用于区别。...

Java中的Runnable、Callable、Future、FutureTask的区别与示例

Java中存在Runnable、Callable、Future、FutureTask这几个与线程相关的类或者接口,在Java中也是比较重要的几个概念,我们通过下面的简单示例来了解一下它们的作用于区别。...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)