Android并发编程之白话文详解Future,FutureTask和Callable

原创 2015年11月23日 08:19:17

从最简单的说起Thread和Runnable

说到并发编程,就一定是多个线程并发执行任务。那么并发编程的基础是什么呢?没错那就是Thread了。一个Thread可以执行一个Runnable类型的对象。那么Runnable是什么呢?其实Runnable是一个接口,他只定义了一个方法run(),这个run()方法里就是我们要执行的任务,并且是要被Thread调用的。因此,一个Runnable就可以理解为一个要被执行的任务,而Thread就是一个执行任务的工人!
接下来我们用一个例子来实践一下,我们有一个任务(Runnable),这个任务就是来计算1+2+3+…+10,然后我们叫来一个工人(Thread)来执行这个任务。

public class ThreadDemo {
    public static void main(String[] args) {
        Thread worker = new Thread(new CountRunnable());
        worker.start();
    }
    public static class CountRunnable implements Runnable{
        private int sum;
        @Override
        public void run() {
            for(int i=1 ; i<11 ; i++){
                sum = sum+i;
            }
            System.out.println("sum="+sum);
        }

    }
}

这里写图片描述
这里我们调用了Thread的start()方法,相当于通知我们的工人去干活,然后工人Thread去调用任务Runnable的run()方法去干活。
这里写图片描述

如果我们觉得一个工人不够用,那么我们可以多叫来几个工人,让他们一起来工作,这就是并发编程了!

public class ThreadDemo {
    public static void main(String[] args) throws Exception{
        List<Thread> threads = new ArrayList<Thread>();
        for(int i=1 ; i<101 ; i++){
            Thread thread = new Thread(new CountRunnable(),"Thread"+i);
            threads.add(thread);
            thread.start();
        }
        for(Thread t : threads){
            t.join();
        }
        System.out.println("所有线程执行完毕!");

    }
    public static class CountRunnable implements Runnable{
        private int sum;
        @Override
        public void run() {
            for(int i=1 ; i<11 ; i++){
                sum = sum+i;
            }
            System.out.println(Thread.currentThread().getName()+"执行完毕 sum="+sum);
        }

    }
}

这里写图片描述
我们看到,每个sum都等于55,不是听说多线程并发执行会带来线程不安全的问题吗?其实这里我们是给每个工人分配一个只属于自己的任务,每个工人干自己的活,所以并不会影响到其他的人

Thread thread = new Thread(new CountRunnable(),"Thread"+i);

那么什么情况下会出现线程并发的问题的?我们要做的就是把一个任务同时分配给100名工人,那么就会出现线程不安全的问题

public class ThreadDemo {
    public static void main(String[] args) throws Exception{
        List<Thread> threads = new ArrayList<Thread>();
        //注意这里,我们在外面new出一个任务来,让100个线程都来执行这个任务
        CountRunnable work = new CountRunnable();
        for(int i=1 ; i<101; i++){
            Thread thread = new Thread(work,"Thread"+i);
            threads.add(thread);
        }
        for(Thread t : threads){
            t.start();
        }
        for(Thread t : threads){
            t.join();
        }
        System.out.println("所有线程执行完毕");

    }
    public static class CountRunnable implements Runnable{
        private int sum;
        @Override
        public void run() {
            for(int i=1 ; i<11 ; i++){
                try {
                    //在这里我们让每个工人每进行一次加法运算后就休息1ms,这样会使得结果明显
                    TimeUnit.MILLISECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                sum = sum+i;
            }
            System.out.println(Thread.currentThread().getName()+"执行完毕 sum="+sum);
        }

    }
}

这里写图片描述
我们看到的结果简直不堪入目,正确结果应该是5500对吧,这时因为我们有100名工人去干一件任务,他们都操作的是同一个变量,因此多线程修改共享变量会出现问题,至于原理是什么,大家可以参考我的另一篇文章Java并发编程之图文解析volatile关键字来了解一下Java的内存模型(JMM)。

这篇文章的题目不是叫Future,FutureTask和Callable吗?我怎么连他们的影子都还没有见到?大家先别着急,还是和我一起慢慢深入,这样才能真正理解他们存在的道理。

最简单的方法出现了问题,线程池来解决

现在我们可以叫来这100名工人来为我们干活了,可是这样有个问题,这100名工人不是说找就找的,首先你得去发招聘启事,接着再去面试,再去培训等等,非常的费时费力,所以我们应该找到一个外包公司,比如我们需要100名工人,我们直接就到外包公司去借100名工人,直接来干活,这样就省了不少的力气了,这个外包公司就是线程池了。关于线程池的介绍,有一篇写的非常详细的博客Android性能优化之使用线程池处理异步任务,既然已经有人把它的理论总结的很清晰透彻了,我就不再重复去介绍一遍了,如果大家有对线程池的基础还不了解的话,推荐看看这篇文章。下面我就来说说线程池的使用,慢慢引出Future和Callable。

我们在使用线程池的时候,可以把一个任务(Runnable)交给线程池,调用线程池的execute(runnable)来执行

public class ExecutorDemo {
    public static void main(String[] args) {
        ExecutorService es = Executors.newSingleThreadExecutor();
        CountRunnable work = new CountRunnable();
        es.execute(work);
        es.shutdown();
        System.out.println("任务结束"+es.isShutdown());
    }
    public static class CountRunnable implements Runnable{
        private int sum;
        @Override
        public void run() {
            for(int i=1 ; i<11 ; i++){
                sum+=i;
            }
            System.out.println("sum="+sum);
        }
    }
}

这里写图片描述

不知道大家有没有发现一个问题,我们执行Runnable任务,他的run()方法是没有返回值的,那如果我们想要执行完一个任务,并且能够拿到一个返回值结果,那么应该怎么做呢?

Future登场

当当当!没错!主角就要登场了!首先介绍Future

public interface Future<V> {


    boolean cancel(boolean mayInterruptIfRunning);


    boolean isCancelled();


    boolean isDone();


    V get() throws InterruptedException, ExecutionException;


    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future是一个接口,他提供给了我们方法来检测当前的任务是否已经结束,还可以等待任务结束并且拿到一个结果,通过调用Future的get()方法可以当任务结束后返回一个结果值,如果工作没有结束,则会阻塞当前线程,直到任务执行完毕,我们可以通过调用cancel()方法来停止一个任务,如果任务已经停止,则cancel()方法会返回true;如果任务已经完成或者已经停止了或者这个任务无法停止,则cancel()会返回一个false。当一个任务被成功停止后,他无法再次执行。isDone()和isCancel()方法可以判断当前工作是否完成和是否取消。

简单介绍一番,我们发现原来那些工人,只会去执行工作,做完工作之后也不给我们反馈信息,并且我们也不知道他们何时能完工,更不能打断他们的工作,这种工人的弊端就显现出来了。

现在我们有了更高级的工人,这些工人只能是从外包公司来借(利用线程池),当这些工人干完活之后,他们会给我们返回运行的结果,而且我们还可以暂停他们的工作。

我们看到线程池还有一个方法可以执行一个任务,那就是submit()方法

 public Future<?> submit(Runnable task) {
            return e.submit(task);
        }

我们看到他会返回一个Future对象,这个Future对象的泛型里还用的是一个问号“?”,问号就是说我们不知道要返回的对象是什么类型,那么就返回一个null好了,因为我们执行的是一个Runnable对象,Runnable是没有返回值的,所以这里用一个问号,说明没有返回值,那么就返回一个null好了。

public class ExecutorDemo {
    public static void main(String[] args) {
        ExecutorService es = Executors.newSingleThreadExecutor();
        CountRunnable work = new CountRunnable();
        Future<?> future = es.submit(work);
        System.out.println("任务开始于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        for(int i=0 ; i<10 ; i++){
            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println("主线程"+Thread.currentThread().getName()+"仍然可以执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Object object = future.get();
            System.out.println("任务结束于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"  result="+object);
        } catch (Exception e) {
            e.printStackTrace();
        }
        es.shutdown();

        System.out.println("关闭线程池"+es.isShutdown());
    }
    public static class CountRunnable implements Runnable{
        private int sum;
        @Override
        public void run() {
            for(int i=1 ; i<11 ; i++){
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                    sum+=i;
                    System.out.println("工作线程"+Thread.currentThread().getName()+"正在执行  sum="+sum);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }
}

这里写图片描述
我们看到Future有一个get()方法,这个方法是一个阻塞方法,我们调用submit()执行一个任务的时候,会执行Runnable中的run()方法,当run()方法没有执行完的时候,这个工人就会歇着了,直到run()方法执行结束后,工人就会立即将结果取回并且交给我们。我们看到返回的result=null。那既然返回null的话还有什么意义呢??别着急,那就要用到Callable接口了

Callable登场

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

我们看到Callable接口和Runnable接口很像,也是只有一个方法,不过这个call()方法是有返回值的,这个返回值是一个泛型,也就是说我们可以根据我们的需求来指定我们要返回的result的类型

public class CallableDemo {
    public static void main(String[] args) throws Exception{
        ExecutorService es = Executors.newSingleThreadExecutor();
        Future<Number> future = es.submit(new CountCallable());
        System.out.println("任务开始于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        Number number = future.get();
        System.out.println("任务结束于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        if(future.isDone()){
            System.out.println("任务执行完毕  result="+number.num);
            es.shutdown();
        }

    }
    public static class CountCallable implements Callable<Number>{

        @Override
        public Number call() throws Exception {
            Number number = new Number();
            TimeUnit.SECONDS.sleep(2);
            number.setNum(10);
            return number;
        }

    }
    static class Number{
        private int num;
        private int getNum(){
            return num;
        }
        private void setNum(int num){
            this.num = num;
        }
    }
}

我们创建我们的任务(Callable)的时候,传入了一个Number类的泛型,那么在call()方法中就会返回这个Number类型的对象,最后在Future的get()方法中就会返回我们的Number类型的结果。
这里写图片描述

然而Future不仅仅可以获得一个结果,他还可以被取消,我们通过调用future的cancel()方法,可以取消一个Future的执行

public class CallableDemo {
    public static void main(String[] args) throws Exception{
        ExecutorService es = Executors.newSingleThreadExecutor();
        Future<Number> future = es.submit(new CountCallable());
        System.out.println("任务开始于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        future.cancel(true);
        if (future.isCancelled()) {
            System.out.println("任务被取消于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            es.shutdownNow();
        }else{
            Number number = future.get();
            System.out.println("任务结束于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            if(future.isDone()){
                System.out.println("任务执行完毕  result="+number.num);
                es.shutdown();
            }
        }
    }

    public static class CountCallable implements Callable<Number>{

        @Override
        public Number call() throws Exception {
            Number number = new Number();
            TimeUnit.SECONDS.sleep(5);
            number.setNum(10);
            return number;
        }

    }
    static class Number{
        private int num;
        private int getNum(){
            return num;
        }
        private void setNum(int num){
            this.num = num;
        }
    }
}

这里写图片描述

FutureTask登场

说完了Future和Callable,我们再来说最后一个FutureTask,Future是一个接口,他的唯一实现类就是FutureTask,其实FutureTask的一个很好地特点是他有一个回调函数done()方法,当一个任务执行结束后,会回调这个done()方法,我们可以在done()方法中调用FutureTask的get()方法来获得计算的结果。为什么我们要在done()方法中去调用get()方法呢? 这是有原因的,我在Android开发中,如果我在主线程去调用futureTask.get()方法时,会阻塞我的UI线程,如果在done()方法里调用get(),则不会阻塞我们的UI线程。

public class FutureTask<V> implements RunnableFuture<V> {
}

我们来看看FutureTask实现了RunnableFuture接口

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

Runnable接口又实现了Runnable和Future接口,所以说FutureTask可以交给Executor执行,也可以由调用线程直接执行FutureTask.run()方法。FutureTask的run()方法中又会调用Callable的call()方法

public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

所以一个FutureTask实际上执行的是一个Callable类型实例的call()方法,call()方法才是我们的最终任务。其实Android中的AsyncTask内部也是使用的FutureTask,我们写一个小的例子来模仿AsyncTask的可以停止的功能

public class MainActivity extends AppCompatActivity {
    FutureTask<Number> futureTask;
    CountCallable countCallable;
    ExecutorService es;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        countCallable = new CountCallable();
        futureTask = new FutureTask<Number>(countCallable){
            @Override
            protected void done() {
                try {
                    Number number = futureTask.get();
                    Log.i("zhangqi", "任务结束于" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date()) + "  result=" + number.getNum());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                } catch (CancellationException e) {
                    Log.i("zhangqi", "任务被取消于" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date()));
                }
            }
        };
        es = Executors.newFixedThreadPool(2);
        es.execute(futureTask);
        Log.i("zhangqi", "任务被开始于" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date()));

    }



    public void cancel(View view) {
        futureTask.cancel(true);
    }

    public static class CountCallable implements Callable<Number> {

        @Override
        public Number call() throws Exception {
            Number number = new Number();
            Log.i("zhangqi","运行在"+Thread.currentThread().getName());
            Thread.sleep(5000);
            number.setNum(10);
            return number;
        }

    }

    static class Number {
        private int num;

        private int getNum() {
            return num;
        }

        private void setNum(int num) {
            this.num = num;
        }
    }

}

我们写了一个CountCallable类,在call()方法里是我们要执行的任务,最终我们的任务要返回一个Number类型的对象,我们在call()方法中首先会让线程睡眠5秒钟,然后new出一个Number对象并且给他赋值为10.

接着我们new一个FutureTask并且把我们的CountCallable对象传入进去,FutureTask的泛型就是我们要返回的结果的类型,并且我们要重写FutureTask的done()方法,这个方法会在任务结束后自动执行,在done()方法中我们调用get()方法获得运行的结果
这里写图片描述
这里写图片描述

现在我们执行cancel方法,来结束这个FutureTask任务
这里写图片描述
这里写图片描述
在任务执行2秒的时候,我点击了cancel按钮,执行了FutureTask的cancel方法,当我们执行了cancel()方法后,FutureTask的get()方法会抛出CancellationException异常,我们捕捉这个异常,然后在这里来处理一些后事 =-=!

相信大家都已经理解了为什么Java要提供给我们Future,FutureTask和Callable了,他们其实是并发编程中更高级的应用,我们应该理解他们并且正确的使用它们。

版权声明:欢迎转载,转载请注明出处http://blog.csdn.net/nugongahou110

相关文章推荐

Android并发二三事之Callable,Future,FutureTask

Android并发二三事之Callable,Future,FutureTask 标签: android并发FutureTaskFuture 2016-11-04 12:03 148人阅读 ...

Android并发编程之图文解析volatile关键字

相信很多人对于volatile关键字既熟悉又陌生,熟悉是对这个名字很熟悉,陌生是对他的原理和用法很陌生,最近几天通过查阅大量资料和书,终于对volatile有了一定的理解,写此博客一来做了记录,二来使...

android之Futuretask、Timer、AsyncTask的使用及原理解析

之前用写过这么一篇文章,但是写的很简单(那时候想的只是给自己做个笔记),但是后来想想还是有必要写的详细些,所以就把这前那篇删了,重写整理除了这篇文章。 还是先给出参考的博文地址: Java 并...

ScheduledExecutorService定时周期执行指定的任务

一:简单说明 ScheduleExecutorService接口中有四个重要的方法,其中scheduleAtFixedRate和scheduleWithFixedDelay在实现定时程序时比较方便。...

Java程序执行超时——Future接口介绍

在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分,在java.uti...
  • dww410
  • dww410
  • 2011-07-14 13:29
  • 6385

Android ScheduledFuture介绍

ScheduledFuture java.util.concurrent 接口 ScheduledFuture 类型参数:     V - 此 Future 返回的结果类型。 所有超级接口:...

Android性能优化之使用线程池处理异步任务

说到线程,我想大家都不陌生,因为在开发时候或多或少都会用到线程,而通常创建线程有两种方式: 1、继承Thread类 2、实现Runnable接口 虽说这两种方式都可以创建出一个线程,不过它们...

FutureTask的用法及两种常用的使用场景

FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask,直接调用其run方法或者放入线程池执行,之后可以在外部通过Fu...

Java进阶之FutureTask的用法及解析

1 FutureTask概念FutureTask一个可取消的异步计算,FutureTask 实现了Future的基本方法,提空 start cancel 操作,可以查询计算是否已经完成,并且可以获取计...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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