随笔- 134 文章- 0 评论- 6 阅读- 16万

FutureTask并发详解，通俗易懂

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

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

 1 package com.demo;
 2 
 3 import java.util.concurrent.Callable;
 4 import java.util.concurrent.FutureTask;
 5 
 6 public class FutureTaskTest {
 7 
 8     public static void main(String[] args) throws Exception {
 9         for (int i = 0; i < 10; i++) {
10             long currentTimeMillis = System.currentTimeMillis();
11             FutureTask<String> future1 = new FutureTask<>(new MyTaskA());
12             new Thread(future1).start();// 一定要先开启线程，如果主线程在开启线程前调用，就没了并发的效果，可以自行测试
13             Thread.sleep(100);// 主线程耗时100ms
14             String r1 = future1.get();
15             System.out.println(r1);
16             System.err.println(i + "-----" + String.valueOf(System.currentTimeMillis() - currentTimeMillis) + "ms");
17         }
18     }
19 
20     static class MyTaskA implements Callable<String> {
21         @Override
22         public String call() throws Exception {
23             Thread.sleep(50);// 并发线程耗时50ms
24             return "testA";
25         }
26     }
27 
28 }

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

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

 1 package com.demo;
 2 
 3 import java.util.concurrent.Callable;
 4 import java.util.concurrent.FutureTask;
 5 
 6 public class FutureTaskTest {
 7     
 8     public static void main(String[] args) throws Exception{
 9         for (int i = 0; i < 10; i++) {
10             long currentTimeMillis = System.currentTimeMillis();
11             
12             FutureTask<String> futureA = new FutureTask<>(new MyTaskA()); 
13             FutureTask<String> futureB = new FutureTask<>(new MyTaskB()); 
14             new Thread(futureA).start();
15             new Thread(futureB).start();
16             
17             Thread.sleep(100);
18             System.out.println(futureA.get()+"---"+futureB.get());
19             System.err.println(i+"-----"+String.valueOf(System.currentTimeMillis()-currentTimeMillis)+"ms");
20         }
21     }
22     static class MyTaskA implements Callable<String>{
23         @Override
24         public String call() throws Exception {
25             Thread.sleep(50);//并发线程耗时50ms
26             return "testA";
27         }
28     }
29     static class MyTaskB implements Callable<String>{
30         @Override
31         public String call() throws Exception {
32             Thread.sleep(50);
33             return "testB";
34         }
35     }
36     
37 
38 }

执行结果如下

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