FixedThreadPool，submit，execute，Callable，Runnable实例

2019独角兽企业重金招聘Python工程师标准>>>

一般使用线程池执行任务都是调用的execute方法，这个方法定义在Executor接口中：

public interface Executor {
    void execute(Runnable command);
}
这个方法是没有返回值的，而且只接受Runnable。

那么像得到线程的返回值怎嘛办呢？

在ExecutorService接口中能找到这个方法：

<T> Future<T> submit(Callable<T> task);//返回的结果是类型T
<T> Future<T> submit(Runnable task, T result);//返回的结果是类型T,之前要把结果的对象传进入
Future<?> submit(Runnable task);//返回结果是字符串"null"
这个方法接收两种参数，Callable和Runnable。返回值是Future。

下面具体看一下这些是什么东西。

Callable和Runnable
先看一下两个接口的定义：

Callable

public interface Callable<V> {
  V call() throws Exception;
}

Runnable

interface Runnable {
  public abstract void run();
}

和明显能看到区别：

Callable能接受一个泛型，然后在call方法中返回一个这个类型的值。而Runnable的run方法没有返回值
Callable的call方法可以抛出异常，而Runnable的run方法不会抛出异常。

以上转自：https://blog.csdn.net/qq_25806863/article/details/71214033 

public class FixedThreadPool {
 
    public static void main(String[] args) {
 
        FixedThreadPool fixedThreadPool1 = new FixedThreadPool();
 
        fixedThreadPool1.testCallable1();
/*    pool-1-thread-1
    pool-1-thread-2
    Tue Nov 06 15:18:28 CST 2018
    task1 has been finished.
    Tue Nov 06 15:18:30 CST 2018
    task2 has been finished.
    Tue Nov 06 15:18:31 CST 2018*/
 
        fixedThreadPool1.testCallable2();
/*        ExecutorService线程[1]
        ExecutorService线程[2]
        Tue Nov 06 15:40:58 CST 2018
        task1 has been finished.
        Tue Nov 06 15:41:00 CST 2018
        task2 has been finished.
        Tue Nov 06 15:41:01 CST 2018*/
 
 
        fixedThreadPool1.testRunnable1();
/*        ExecutorService线程[1]
        ExecutorService线程[2]
        Tue Nov 06 15:59:07 CST 2018
        null
        Tue Nov 06 15:59:09 CST 2018
        null
        Tue Nov 06 15:59:09 CST 2018*/
 
 
        fixedThreadPool1.testRunnable2();
/*        ExecutorService线程[1]
        ExecutorService线程[2]
        Tue Nov 06 16:39:29 CST 2018
        Tue Nov 06 16:39:31 CST 2018
        Tue Nov 06 16:39:31 CST 2018*/
 
 
        fixedThreadPool1.testRunnable3();
/*        ExecutorService线程[1]
        ExecutorService线程[2]
        Tue Nov 06 16:42:16 CST 2018
        RunnableResultTask3 has been finished.
        Tue Nov 06 16:42:18 CST 2018
        RunnableResultTask4 has been finished.
        Tue Nov 06 16:42:18 CST 2018*/
 
 
        fixedThreadPool1.testExecute1();
/*        ExecutorService线程[1]
        ExecutorService线程[2]*/
 
    }
 
 
    public void testCallable1() {
        ExecutorService tpe1 = Executors.newFixedThreadPool(2);
        Future<String> res1 = tpe1.submit(new Task1());
        Future<String> res2 = tpe1.submit(new Task2());
        System.out.println(new Date());
        try {
            System.out.println(res1.get());//等待线程执行完成后才返回结果，期间阻塞
            System.out.println(new Date());
 
            System.out.println(res2.get());//等待线程执行完成后才返回结果，期间阻塞
            System.out.println(new Date());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            tpe1.shutdown();
        }
    }
 
 
    public void testCallable2() {
        ExecutorService tpe2 = Executors.newFixedThreadPool(2, new ThreadFactory() {
            private AtomicInteger count = new AtomicInteger(1);
 
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "ExecutorService线程[" + count.getAndIncrement() + "]");//给线程池中的线程命名
            }
        });
 
        Future<String> res1 = tpe2.submit(new Task1());
        Future<String> res2 = tpe2.submit(new Task2());
        System.out.println(new Date());
        try {
            System.out.println(res1.get());//等待线程执行完成后才返回结果，期间阻塞
            System.out.println(new Date());
 
            System.out.println(res2.get());//等待线程执行完成后才返回结果，期间阻塞
            System.out.println(new Date());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            tpe2.shutdown();
        }
    }
 
 
    //传入Runnable，返回结果为“null”
    public void testRunnable1() {
        ExecutorService tpe3 = Executors.newFixedThreadPool(2, new ThreadFactory() {
            private AtomicInteger count = new AtomicInteger(1);
 
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "ExecutorService线程[" + count.getAndIncrement() + "]");//给线程池中的线程命名
            }
        });
 
        Future res1 = tpe3.submit(new RunnableTask1());
        Future res2 = tpe3.submit(new RunnableTask2());
        System.out.println(new Date());
        try {
            System.out.println(res1.get());//等待线程执行完成后才返回结果，期间阻塞
            System.out.println(new Date());
 
            System.out.println(res2.get());//等待线程执行完成后才返回结果，期间阻塞
            System.out.println(new Date());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            tpe3.shutdown();
        }
    }
 
 
    //传入Runnable，写入String类型的结果，因为String传参再返回时原值才会修改，此处返回空，所以无返回结果
    public void testRunnable2() {
        ExecutorService tpe4 = Executors.newFixedThreadPool(2, new ThreadFactory() {
            private AtomicInteger count = new AtomicInteger(1);
 
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "ExecutorService线程[" + count.getAndIncrement() + "]");//给线程池中的线程命名
            }
        });
 
        String res = new String();
        Future<String> res1 = tpe4.submit(new RunnableResultTask1(res), res);//res1.get()为空
        Future<String> res2 = tpe4.submit(new RunnableResultTask2(res), res);//res2.get()为空
 
        System.out.println(new Date());
        try {
            System.out.println(res1.get());//等待线程执行完成后才返回结果，期间阻塞
            System.out.println(new Date());
 
            System.out.println(res2.get());//等待线程执行完成后才返回结果，期间阻塞
            System.out.println(new Date());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            tpe4.shutdown();
        }
    }
 
 
    //传入Runnable，写入结果然后再返回结果
    public void testRunnable3() {
        ExecutorService tpe4 = Executors.newFixedThreadPool(2, new ThreadFactory() {
            private AtomicInteger count = new AtomicInteger(1);
 
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "ExecutorService线程[" + count.getAndIncrement() + "]");//给线程池中的线程命名
            }
        });
 
        Result result = new Result();//传入的是自定义的类
        Future<Result> res3 = tpe4.submit(new RunnableResultTask3(result), result);
        Future<Result> res4 = tpe4.submit(new RunnableResultTask4(result), result);
 
        System.out.println(new Date());
        try {
 
            System.out.println(res3.get().getRes());//等待线程执行完成后才返回结果，期间阻塞
            System.out.println(new Date());
 
           
            System.out.println(res4.get().getRes());//等待线程执行完成后才返回结果，期间阻塞
            System.out.println(new Date());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            tpe4.shutdown();
        }
    }
 
    public void testExecute1() {
        ExecutorService tpe4 = Executors.newFixedThreadPool(2, new ThreadFactory() {
            private AtomicInteger count = new AtomicInteger(1);
 
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "ExecutorService线程[" + count.getAndIncrement() + "]");//给线程池中的线程命名
            }
        });
 
        tpe4.execute(new RunnableTask1());
        tpe4.execute(new RunnableTask2());
 
        tpe4.shutdown();
    }
 
 
    class Task1 implements Callable<String> {
        @Override
        public String call() throws Exception {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(2000);
            //Integer a = 1/0; //在该线程future.get()之后的线程不会继续执行,之前的会正常执行。与submit的先后顺序无关，与各个线程的执行任务时间长短无关
            String s = "task1 has been finished.";
            return s;
        }
    }
 
    class Task2 implements Callable<String> {
        @Override
        public String call() throws Exception {//有返回值
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(3000);
            String s = "task2 has been finished.";
            return s;
        }
    }
 
 
    class RunnableTask1 implements Runnable {
        @Override
        public void run() {//无返回值
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
                String s = "RunnableTask1 has been finished.";
                //Integer a = 1/0;  //在该线程future.get()之后的线程不会继续执行,之前的会正常执行。与submit的先后顺序无关，与各个线程的执行任务时间长短无关
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
        }
    }
 
 
    class RunnableTask2 implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
                String s = "RunnableTask2 has been finished.";
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 
 
    class RunnableResultTask1 implements Runnable {
        String res1;
 
        public RunnableResultTask1(String res1) {
            this.res1 = res1;
        }
 
        @Override
        public void run() {//无返回值
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
                res1 = "RunnableResultTask1 has been finished.";
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
        }
    }
 
 
    class RunnableResultTask2 implements Runnable {
        String res2;
 
        public RunnableResultTask2(String res2) {
            this.res2 = res2;
        }
 
        @Override
        public void run() {//无返回值
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
                res2 = "RunnableResultTask2 has been finished.";
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
        }
    }
 
 
    class RunnableResultTask3 implements Runnable {
        Result res1;
 
        public RunnableResultTask3(Result res1) {
            this.res1 = res1;
        }
 
        @Override
        public void run() {//无返回值
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
                res1.setRes("RunnableResultTask3 has been finished.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
        }
    }
 
    class RunnableResultTask4 implements Runnable {
        Result res1;
 
        public RunnableResultTask4(Result res1) {
            this.res1 = res1;
        }
 
        @Override
        public void run() {//无返回值
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
                res1.setRes("RunnableResultTask4 has been finished.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
        }
    }
 
    //传入自定义的类
    class Result {
        String res;
 
        public Result() {
        }
 
        public Result(String res) {
            this.res = res;
        }
 
        public String getRes() {
            return res;
        }
 
        public void setRes(String res) {
            this.res = res;
        }
    }
}
--------------------- 
作者：二十六画生的博客 
来源：CSDN 
原文：https://blog.csdn.net/u010002184/article/details/83793218 
版权声明：本文为博主原创文章，转载请附上博文链接！

转载于:https://my.oschina.net/airship/blog/2999861