使用Executor框架创建线程池+自定义线程池+JDK拒绝策略
Executors创建线程池
为了更好的控制多线程，JDK提供了一套线程框架Executor，帮助开发人员有效地进行线程控制。它们都在java.util.concurrent包中，是JDK并发包的核心。其中有一个比较重要的类：Executors，它扮演着线程工厂的角色，我们通过Executors可以创建特定功能的线程池。
Executors创建线程池方法：
newFixedThreadPool()方法，该方法返回一个固定数量的线程池，该方法的线程数始终不变，当有一个任务提交时，若线程池中空闲，则立即执行，若没有，则会被暂时缓存在一个任务队列中，等待有空闲的线程去执行。
newSingleThreadExecutor()方法，创建一个线程的线程池，若空闲则执行，若没有空闲线程则暂缓在任务队列中。
newCachedThreadPool()方法，返回一个可以根据实际情况调整线程个数的线程池，不限制最大线程数量。只要有一个任务来了，就创建一个线程去执行任务。若无任务则不创建线程。并且每一个空闲线程会在60秒后自动回收。
newScheduledThreadPool()方法，该方法返回一个ScheduledExecutorService对象。但该线程池可以指定线程的数量，其中的每一个线程可以实现定时器的作用。
无论创建哪种类型的线程池，最底层还是调用了下面的ThreadPoolExecutor,不同类的线程池传递给ThreadPoolExecutor的参数不同。
自定义线程池
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) 第一个参数：核心线程数，即线程池初始化时就创建的线程个数
第二个参数：线程池中最大线程数
第三个参数：线程池中每一个线程保持活着的空闲时间
第四个参数：时间单位
第五个参数：指定一个阻塞队列，若线程池中线程都忙着的，再有任务过来，则排队等待
第六个参数：线程工厂
第七个参数：拒绝执行的handler,具体拒绝执行的逻辑
自定义线程池中对于队列是什么类型的比较关键：
1.有界队列：在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize,则优先创建线程，若大于corePoolSize,则会将任务加入到队列中，若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，若线程数大于maximumPoolSize，则执行拒绝策略。如：ArrayBlockingQueue
2.无界队列：与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败的情况。当有新任务到来时，系统的线程数小于corePoolSize时，则新建线程执行任务。当达到corePoolSize后，就不会继续增加。若后续仍有新的任务加入，而又没有空闲的线程资源，则任务直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统资源。
自定义线程池使用有界队列的例子
UseThreadPoolExecutor1.java
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy;
public class UseThreadPoolExecutor1 {
public static void main(String[] args) {
/**
* 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
* 若大于corePoolSize，则会将任务加入队列，
* 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
* 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
*
*/
ThreadPoolExecutor pool = new ThreadPoolExecutor(
1, //coreSize
2, //MaxSize
60, //60
TimeUnit.SECONDS,
new ArrayBlockingQueue(3) //指定一种队列 （有界队列）
//new LinkedBlockingQueue()
, new MyRejected()
//, new DiscardOldestPolicy()
);
MyTask mt1 = new MyTask(1, "任务1");
MyTask mt2 = new MyTask(2, "任务2");
MyTask mt3 = new MyTask(3, "任务3");
MyTask mt4 = new MyTask(4, "任务4");
MyTask mt5 = new MyTask(5, "任务5");
MyTask mt6 = new MyTask(6, "任务6");
pool.execute(mt1);
pool.execute(mt2);
pool.execute(mt3);
pool.execute(mt4);
pool.execute(mt5);
pool.execute(mt6);
pool.shutdown();
}
}
MyTask.java
public class MyTask implements Runnable {
private int taskId;
private String taskName;
public MyTask(int taskId, String taskName){
this.taskId = taskId;
this.taskName = taskName;
}
public int getTaskId() {
return taskId;
}
public void setTaskId(int taskId) {
this.taskId = taskId;
}
public String getTaskName() {
return taskName;
}
public void setTaskName(String taskName) {
this.taskName = taskName;
}
@Override
public void run() {
try {
System.out.println("run taskId =" + this.taskId);
Thread.sleep(5*1000);
//System.out.println("end taskId =" + this.taskId);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public String toString(){
return Integer.toString(this.taskId);
}
}
MyRejected.java
import java.net.HttpURLConnection;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
public class MyRejected implements RejectedExecutionHandler{
public MyRejected(){
}
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("自定义处理..");
System.out.println("当前被拒绝任务为：" + r.toString());
}
}在上述代码执行过程中，mt1任务到来时，若该线程池中线程数小于corePoolSize,则优先创建线程去处理该mt1任务，由于corePoolSize=1,所以mt1交给线程池初始化时创建的1个线程进行处理，后续的mt2、mt3、mt4放置到ArrayBlockingQueue队列中排队等待。mt5任务到来时，由于队列已满，且当前线程数小于最大线程数maximumPoolSize的值2,此时线程池创建一个线程来执行mt5。mt6任务到来时，由于队列已满，且当前线程数已经达到了该线程池的最大线程数，则执行拒绝策略。当线程池中存在空闲的线程时，就开始处理队列中排队等待的任务。
Eclipse的控制台输出
自定义线程池使用无界队列的例子
UseThreadPoolExecutor2.java
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class UseThreadPoolExecutor2 implements Runnable{
private static AtomicInteger count = new AtomicInteger(0);
@Override
public void run() {
try {
int temp = count.incrementAndGet();
System.out.println("任务" + temp);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception{
//System.out.println(Runtime.getRuntime().availableProcessors());
BlockingQueue queue =
new LinkedBlockingQueue();
//new ArrayBlockingQueue(10);
ExecutorService executor = new ThreadPoolExecutor(
5, //core
10, //max
120L, //2分
TimeUnit.SECONDS,
queue);
for(int i = 0 ; i < 20; i++){
executor.execute(new UseThreadPoolExecutor2());
}
Thread.sleep(1000);
System.out.println("queue size:" + queue.size()); //10
Thread.sleep(2000);
}
} Eclipse的console输出
JDK拒绝策略
AbortPolicy:直接抛出异常阻止系统正常工作
CallerRunsPolicy:只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务
DiscardOldestPolicy:丢弃最老的一个请求，尝试再次提交当前任务
DiscardPolicy:丢弃无法处理的任务，不给予任何处理
如果需要自定义拒绝策略，可以实现RejectedExecutionHandler接口
MyRejected.java
import java.net.HttpURLConnection;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
public class MyRejected implements RejectedExecutionHandler{
public MyRejected(){
}
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("自定义处理..");
System.out.println("当前被拒绝任务为：" + r.toString());
/*记录拒绝任务的日志信息，稍后系统空闲时再使用定时job进行处理。
使用Apache的HttpClient给任务提交方发送任务被拒绝处理的消息或系统对记录日志的任务进行处理*/
}
}UseThreadPoolExecutor1.java
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy;
public class UseThreadPoolExecutor1 {
public static void main(String[] args) {
/**
* 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
* 若大于corePoolSize，则会将任务加入队列，
* 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
* 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
*
*/
ThreadPoolExecutor pool = new ThreadPoolExecutor(
1, //coreSize
2, //MaxSize
60, //60
TimeUnit.SECONDS,
new ArrayBlockingQueue(3) //指定一种队列 （有界队列）
//new LinkedBlockingQueue()
//, new MyRejected()
, new DiscardOldestPolicy()//拒绝策略
);
MyTask mt1 = new MyTask(1, "任务1");
MyTask mt2 = new MyTask(2, "任务2");
MyTask mt3 = new MyTask(3, "任务3");
MyTask mt4 = new MyTask(4, "任务4");
MyTask mt5 = new MyTask(5, "任务5");
MyTask mt6 = new MyTask(6, "任务6");
pool.execute(mt1);
pool.execute(mt2);
pool.execute(mt3);
pool.execute(mt4);
pool.execute(mt5);
pool.execute(mt6);
pool.shutdown();
}
}
MyTask.java
public class MyTask implements Runnable {
private int taskId;
private String taskName;
public MyTask(int taskId, String taskName){
this.taskId = taskId;
this.taskName = taskName;
}
public int getTaskId() {
return taskId;
}
public void setTaskId(int taskId) {
this.taskId = taskId;
}
public String getTaskName() {
return taskName;
}
public void setTaskName(String taskName) {
this.taskName = taskName;
}
@Override
public void run() {
try {
System.out.println("run taskId =" + this.taskId);
Thread.sleep(5*1000);
//System.out.println("end taskId =" + this.taskId);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public String toString(){
return Integer.toString(this.taskId);
}
}在Eclipse的console输出
