FutureTask并发详解，通俗易懂

最近做项目，使用到了FutureTask和主线程并发，应用到实际中还是挺实用的，特在此总结一下。

有不对之处，忘各位多多指出。

 package com.demo;

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

 public class FutureTaskTest {

     public static void main(String[] args) throws Exception {
         for (int i = 0; i < 10; i++) {
             long currentTimeMillis = System.currentTimeMillis();
             FutureTask<String> future1 = new FutureTask<>(new MyTaskA());
             new Thread(future1).start();// 一定要先开启线程，如果主线程在开启线程前调用，就没了并发的效果，可以自行测试
             Thread.sleep(100);// 主线程耗时100ms
             String r1 = future1.get();
             System.out.println(r1);
             System.err.println(i + "-----" + String.valueOf(System.currentTimeMillis() - currentTimeMillis) + "ms");
         }
     }

     static class MyTaskA implements Callable<String> {
         @Override
         public String call() throws Exception {
             Thread.sleep(50);// 并发线程耗时50ms
             return "testA";
         }
     }

 }

20-26行创建一个任务MyTaskA，实现的是Callable，主要是为了获取返回值(关于如何创建线程，这里就不在赘述)；

11行创建FutureTask；

12行启动线程：此时任务MyTaskA就已经开始执行；

13行主线程执行耗时100ms的任务；

14行FutureTask获取返回值，该方法是会等待任务完成然后获取到返回值。

输出结果如下：

testA
0-----101ms
testA
1-----100ms
testA
2-----100ms
testA
3-----100ms
testA
4-----100ms
testA
5-----100ms
testA
6-----100ms
testA
7-----100ms
testA
8-----100ms
testA
9-----100ms

上面就是一个线程和主线程并发执行，下面再看一个两个线程和主线程并发，其实差别不大

 package com.demo;

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

 public class FutureTaskTest {

     public static void main(String[] args) throws Exception{
         for (int i = 0; i < 10; i++) {
             long currentTimeMillis = System.currentTimeMillis();

             FutureTask<String> futureA = new FutureTask<>(new MyTaskA());
             FutureTask<String> futureB = new FutureTask<>(new MyTaskB());
             new Thread(futureA).start();
             new Thread(futureB).start();

             Thread.sleep(100);
             System.out.println(futureA.get()+"---"+futureB.get());
             System.err.println(i+"-----"+String.valueOf(System.currentTimeMillis()-currentTimeMillis)+"ms");
         }
     }
     static class MyTaskA implements Callable<String>{
         @Override
         public String call() throws Exception {
             Thread.sleep(50);//并发线程耗时50ms
             return "testA";
         }
     }
     static class MyTaskB implements Callable<String>{
         @Override
         public String call() throws Exception {
             Thread.sleep(50);
             return "testB";
         }
     }

 }

执行结果如下

testA---testB
0-----103ms
testA---testB
1-----100ms
testA---testB
2-----100ms
testA---testB
3-----100ms
testA---testB
4-----100ms
testA---testB
5-----101ms
testA---testB
6-----100ms
testA---testB
7-----101ms
testA---testB
8-----100ms
testA---testB
9-----101ms

上面使用Thread启动的FutureTask，咱们也可以用线程池，代码如下

package com.demo;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureTaskTest {

    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 10; i++) {
            long currentTimeMillis = System.currentTimeMillis();
            ExecutorService executorService = Executors.newFixedThreadPool(2);
            Future<String> futureA = executorService.submit(new MyTaskA());
            Future<String> futureB = executorService.submit(new MyTaskB());

            Thread.sleep(100);
            System.out.println(futureA.get() + "---" + futureB.get());
            System.err.println(i + "-----" + String.valueOf(System.currentTimeMillis() - currentTimeMillis) + "ms");
　　　　　　　executorService.shutdown();//注意：用完之后一定要关闭线程池
        }
    }

    static class MyTaskA implements Callable<String> {
        @Override
        public String call() throws Exception {
            Thread.sleep(50);// 并发线程耗时50ms
            return "testA";
        }
    }

    static class MyTaskB implements Callable<String> {
        @Override
        public String call() throws Exception {
            Thread.sleep(50);
            return "testB";
        }
    }

}

输出结果如下

testA---testB
0-----104ms
testA---testB
1-----101ms
testA---testB
2-----101ms
testA---testB
3-----101ms
testA---testB
4-----100ms
testA---testB
5-----102ms
testA---testB
6-----101ms
testA---testB
7-----101ms
testA---testB
8-----101ms
testA---testB
9-----101ms