java线程池用法_Java线程池用法分析

前面两篇文章 【Java线程池深入理解(一)】 【Java线程池深入理解(二)】 分别对Java中关于线程池的实现原理做出了解释和讨论，这一节我们来看一下它的具体使用；首先我们讲述简单采用ThreadPoolExecutor实现线程池的操作，再进一步讲述在Java中通过Executors提供四种线程池的原理以及使用！

(一)ThreadPoolExecutor类使用示例

前面我们讨论了关于线程池的实现原理，这里我们来看一下它的具体使用，简单代码如下：package com.cuiyongzhi.threadpool;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

/**

* ClassName: ThreadPoolTest

* @Description: 简单的线程池使用demo

* @author dapengniao

* @date 2016年4月13日 上午11:22:55

*/

public class ThreadPoolTest {

public static void main(String[] args) {

ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 15, 200, TimeUnit.MILLISECONDS,

new ArrayBlockingQueue(5));

for(int i=0;i<20;i++){

MyTask myTask = new MyTask(i);

executor.execute(myTask);

System.out.println("线程池中线程数目："+executor.getPoolSize()+"，队列中等待执行的任务数目："+

executor.getQueue().size()+"，已执行玩别的任务数目："+executor.getCompletedTaskCount());

}

executor.shutdown();

}

}

class MyTask implements Runnable {

private int taskNum;

public MyTask(int num) {

this.taskNum = num;

}

@Override

public void run() {

System.out.println("正在执行task "+taskNum);

try {

Thread.currentThread().sleep(4000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("task "+taskNum+"执行完毕");

}

}

执行过程中大致结果如下：

从执行结果可以看出，当线程池中线程的数目大于5时，便将任务放入任务缓存队列里面，当任务缓存队列满了之后，便创建新的线程。如果上面程序中，将for循环中改成执行21个任务，就会抛出任务拒绝异常了，抛出拒绝异常其实就是前面有讲到的任务拒绝策略！抛出异常如下：

不过在java doc中，并不提倡我们直接使用ThreadPoolExecutor，而是使用Executors类中提供的几个静态方法来创建线程池，下面我们就来讲述如何使用Executors中静态方法创建线程池！

(二)Java中Executors中静态方法创建线程池

Java通过Executors提供四种线程池，分别为：newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

①newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。让我们来看看它的具体实现代码如下：public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

60L, TimeUnit.SECONDS,

new SynchronousQueue());

}

从它的具体实现来看，实际上也是调用了ThreadPoolExecutor，只不过参数都已配置好了；newCachedThreadPool将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，使用的SynchronousQueue，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程！下面我们来看看它在实际中如何使用：ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

for (int i = 0; i 

final int index = i;

try {

Thread.sleep(index * 1000);

}

catch (InterruptedException e) {

e.printStackTrace();

}

cachedThreadPool.execute(new Runnable() {

@Override

public void run() {

System.out.println(index);

}

});

}

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程！

②newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。让我们来看看它的具体实现代码如下：public static ExecutorService newFixedThreadPool(int nThreads) {

return new ThreadPoolExecutor(nThreads, nThreads,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue());

}

从它的具体实现来看，实际上也是调用了ThreadPoolExecutor，只不过参数都已配置好了；newFixedThreadPool创建的线程池corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue！下面我们来看看它在实际中如何使用：ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

for (int i = 0; i 

final int index = i;

fixedThreadPool.execute(new Runnable() {

@Override

public void run() {

try {

System.out.println(index);

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

});

}

③newScheduledThreadPool：创建一个定长线程池，支持定时及周期性任务执行，其实现原理和newFixedThreadPool是一样的，只不过加上了执行周期和延时功能。示例代码如下：//延迟3秒执行

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

scheduledThreadPool.schedule(new Runnable() {

@Override

public void run() {

System.out.println("delay 3 seconds");

}

}, 3, TimeUnit.SECONDS);

//延迟1秒后每3秒执行一次

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

@Override

public void run() {

System.out.println("delay 1 seconds, and excute every 3 seconds");

}

}, 1, 3, TimeUnit.SECONDS);

ScheduledExecutorService比Timer更安全，功能更强大!

④newSingleThreadExecutor：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。让我们来看看它的具体实现代码如下：public static ExecutorService newSingleThreadExecutor() {

return new FinalizableDelegatedExecutorService

(new ThreadPoolExecutor(1, 1,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue()));

}

从它的具体实现来看，实际上也是调用了ThreadPoolExecutor，只不过参数都已配置好了；newSingleThreadExecutor将corePoolSize和maximumPoolSize都设置为1，也使用的LinkedBlockingQueue；下面我们来看看它在实际中如何实现：ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

for (int i = 0; i 

final int index = i;

singleThreadExecutor.execute(new Runnable() {

@Override

public void run() {

try {

System.out.println(index);

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

});

}

这里的结果依次输出，相当于顺序执行各个任务！

总结：在我们应用开发的实际中，如果Executors提供的静态方法能满足要求，就尽量使用它提供的方法，因为自己去手动配置ThreadPoolExecutor的参数有点麻烦，要根据实际任务的类型和数量来进行配置!

----------本文来源于网络学习，感谢你的翻阅，如有疑问可以留言讨论！

除非注明，否则文章均由 崔用志博客 整理发布，欢迎转载。

如果喜欢，可以点此订阅本站