Java线程池ExecutorService方法详解

线程在项目中有时候是很重要的一部分，对于那些不需要返回结果只需调用而且执行之间较长的方法，可考虑用线程实现。但是线程的频繁创建和销毁会降低系统的性能，因此多线程情况下最好要考虑线程池技术。

线程池的多种创建方式下一节介绍。

创建线程池方式：

//创建可缓存线程池

没有指定线程的数量，如果第二个线程在第一个线程之后则不去创建新线程。

ExecutorService executor=Executors.newCachedThreadPool();

Executors.newFixedThreadPool(n);最多n个线程

Executors.newSheculedThreadPool();可执行定时任务的线程

Executors.newSingleThreadPool();单线程的线程池。

//线程池的方法

void execute(Runnable runnable)执行一个不需要返回值得线程。

Future<T> submit(Callable callable) 执行有返回值的线程。返回Future对象.

Future<T> submit(Runnable runnable) 执行没有返回值的线程并返回Future对象

Future<T> submit(Runnable runnable,T result)执行没有返回值的线程。如果线程执行成功则返回预设的result.

Set<Future<T>> invokeAll(Set<Callable> set);执行一个集合的有返回值的线程。

Set<Future<T>> invokeAll(Set<Callable> set,Long time,TimeUnit t);在指定的时间内执行集合的方法，如果指定时间内还没有获取结果，那么终止该线程执行。返回的Future对象可通过isDone()方法和isCancel()来判断是执行成功还是被终止了。

代码如下：

package com.example.thread;

import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.*;

public class ExecutorServiceTest {
    private static ExecutorService thread1;

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        thread1 = Executors.newCachedThreadPool();
        ExecutorServiceTest obj = new ExecutorServiceTest();
        obj.submitRunnable();
        obj.submitRunnableAndResult();
        obj.executeRunnable();
        obj.submitCallable();
        Set<Callable<String>> callables = new HashSet<Callable<String>>();
        callables.add(new Callable<String>() {
            public String call() throws Exception {
                return "Task 1";
            }
        });
        callables.add(new Callable<String>() {
            public String call() throws Exception {
                Thread.sleep(1001);
                return Integer.parseInt("2") + "Task";
            }
        });
        callables.add(new Callable<String>() {
            public String call() throws Exception {
                return "Task 3";
            }
        });
        List<Future<String>> list = thread1.invokeAll(callables, 1000, TimeUnit.MILLISECONDS);
        for (Future<String> future : list) {
            System.out.println(future.isCancelled());
        }
    }

    void submitRunnable() {

        Future future1 = thread1.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("submitRunnable()");
            }
        });
    }

    void executeRunnable() {
        thread1.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("submitRunnable()");
            }
        });
    }

    void submitCallable() {
        Future<Integer> future = thread1.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                Thread.sleep(2000);
                return 2;
            }
        });
        try {
            Integer result = future.get();
            System.out.println("submitCallable() ,result=" + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    void submitRunnableAndResult() {
        Future<String> future = thread1.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("submitRunnableAndResult()");
            }
        }, "SUCCESS");
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }

}