java并发线程池的使用_Java并发系列：线程池ThreadPoolExecutor基本使用

上一篇说到，线程的创建和销毁耗费的资源是很多的，我们应该使用线程池来代替显式创建线程，复用线程执行我们的任务，本篇我们就来学习一下线程池的基本使用吧~

线程池的创建

既然要使用线程池，那么首先就需要创建线程池了。在JDK1.5以上版本，Java提供了Executors类，它其实可以说是一个工厂类，创建线程池需要比较多的一些参数，而Executors则提供了一批更加语义化的创建线程池的静态方法。

//创建一个线程池，容量大小为Integer.MAX_VALUE，所以是无限大

ExecutorService pool = Executors.newCachedThreadPool();

//创建容量为1的线程池，它的执行是串行的

ExecutorService pool = Executors.newSingleThreadExecutor();

//创建固定容量大小的线程池

ExecutorService pool = Executors.newFixedThreadPool(10);

//周期性任务线程池

ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);

Executors.newCachedThreadPool()，容量为无限大的线程池，它适合任务非常多，高并发的场景。例如EventBus，执行监听Event回调的任务，次数是未知的，就可以使用该策略的线程池。

Executors.newSingleThreadExecutor()，容量为1的线程池，它执行任务是串行的，执行完一个再执行下一个任务。这种策略的线程池一般就是处理串行任务的。

Executors.newFixedThreadPool(10)，固定容量的线程池，如果接收到任务时，线程池容量已到达设置容量大小，就会阻塞。

Executors.newScheduledThreadPool(10)，周期性任务的线程池，可以延时执行或周期执行，可以作为定时器使用。

提交任务到线程池

创建完线程池，接下来就是提交任务到线程池中执行了~执行方法常用有2种，execute()和submit()。

execute(Runnable runnable)，执行一个runnable任务对象，所以它的执行是无返回值的。

submit(Runnable runnable)，也是执行一个runnable任务对象，但是返回Future对象，Future对象可以通过get()方法获取返回值，但实际该重载方法传入null值，所以即使调用get()方法，获取到的也是null值。

submit(Runnable runnable,T result)，和第二个重载方法一样，也是返回Future对象，其实第二个重载方法就是转调该方法，result对象传入null值。

submit(Callable callable)，传入一个Callable对象，我们知道Callable对象是有返回值的，而Runnable是没有返回值的。

invokeAny(Collection extends Callable> tasks)，执行一个Callable任务集合，随机执行其中一个Callable任务，返回任务的结果，如果任务抛出异常，则Callable其他任务则会被取消。

invokeAll(Collection extends Callable> tasks)，执行一个Callable任务集合中的全部任务，返回List>。

示例

execute()，执行无返回值的Runnable。

/**

* 提交Runnable任务

*/

private static void executeByRunnable() {

ExecutorService pool = Executors.newCachedThreadPool();

pool.execute(new Runnable() {

@Override

public void run() {

System.out.println("我在execute()中执行任务");

}

});

}

//输出

我在execute()中执行任务

submit()，执行有返回值的Callable。

/**

* 提交Callable任务

*/

private static void submitByCallable() {

try {

ExecutorService pool = Executors.newCachedThreadPool();

Future future = pool.submit(new Callable() {

@Override

public String call() throws Exception {

return "我是结果";

}

});

String result = future.get();

System.out.println("result: " + result);

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

}

//输出

result: 我是结果

invokeAny()，执行任务集合中任意一个任务。

/**

* 随机执行任务集合中的任意一个任务

*/

private static void runRandomTask() {

try {

ExecutorService pool = Executors.newCachedThreadPool();

ArrayList> taskList = new ArrayList<>();

taskList.add(new Callable() {

@Override

public String call() throws Exception {

return "我是结果1";

}

});

taskList.add(new Callable() {

@Override

public String call() throws Exception {

return "我是结果2";

}

});

taskList.add(new Callable() {

@Override

public String call() throws Exception {

return "我是结果3";

}

});

String result = pool.invokeAny(taskList);

System.out.println("运行结果：" + result);

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

}

//输出

运行结果：我是结果1

invokeAll()，执行任务集合中的所有任务。

/**

* 执行所有任务

*/

private static void runAllTask() {

try {

ExecutorService pool = Executors.newCachedThreadPool();

ArrayList> taskList = new ArrayList<>();

taskList.add(new Callable() {

@Override

public String call() throws Exception {

return "我是结果1";

}

});

taskList.add(new Callable() {

@Override

public String call() throws Exception {

return "我是结果2";

}

});

taskList.add(new Callable() {

@Override

public String call() throws Exception {

return "我是结果3";

}

});

List> futures = pool.invokeAll(taskList);

for (Future future : futures) {

String result = future.get();

System.out.println("获取结果：" + result);

}

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

}

//输出

获取结果：我是结果1

获取结果：我是结果2

获取结果：我是结果3

相对于可以执行周期性任务的ScheduledExecutorService，则还有2个方法，分别是延时执行schedule()，周期性执行scheduleAtFixedRate()。

schedule()，延时执行。

/**

* 延迟执行

*/

private static void runTaskWithDelay(Runnable runnable) {

//延迟3秒后执行

ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);

pool.schedule(runnable, 3, TimeUnit.SECONDS);

}

//调用

runTaskWithDelay(new Runnable() {

@Override

public void run() {

System.out.println("我是线程池中的任务");

System.out.println("我延迟3秒执行了...");

}

});

//输出

我是线程池中的任务

我延迟3秒执行了...

scheduleAtFixedRate()，周期性执行。

/**

* 周期执行任务

*/

private static void runTaskWithCycle(Runnable runnable) {

ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);

//1秒执行一次

pool.scheduleAtFixedRate(runnable, 0, 1, TimeUnit.SECONDS);

}

//调用

runTaskWithCycle(new Runnable() {

@Override

public void run() {

System.out.println("我是周期性的任务");

}

});

//输出

我是周期性的任务

我是周期性的任务

我是周期性的任务

我是周期性的任务

我是周期性的任务

关闭线程池

如果我们需要关闭线程池，有2种方法，shutdown()和shutdownNow()。

shutdown()，并不会马上关闭线程池，而会等待任务都执行完毕后再关闭

/**

* 关闭线程池，会等待任务执行完毕后再关闭

*/

private static void shutdownThreadPool() {

ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);

pool.schedule(new Runnable() {

@Override

public void run() {

System.out.println("我是执行结果...");

}

}, 1, TimeUnit.SECONDS);

pool.shutdown();

}

//输出

我是执行结果...

shutdownNow()则是强制关闭线程池，而不会等待任务执行完毕。

/**

* 马上关闭线程池

*/

private static void shutdownNowThreadPool() {

ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);

pool.schedule(new Runnable() {

@Override

public void run() {

System.out.println("我是执行结果...");

}

}, 1, TimeUnit.SECONDS);

pool.shutdownNow();

}

//没有输出结果，因为任务被取消了

总结

频繁使用线程必须使用线程池，避免线程的频繁创建和销毁带来的资源消耗。本篇，我们讲解了快捷创建线程池的Api。下一篇，我们再讲解线程池具体参数的自定义。