java架构《并发线程高级篇二》

　　　　本章主要记录讲解并发线程的线程池。使用Executor框架自定义线程池。

　　　　

　　　　自定义线程池使用Queue队列所表示出来的形式：

　　　　　　

          ArrayBlockingQueue<Runnable>(3);  有界队列：　　　　　　　　

　　　　　　　　/**
　　　　　　　　* 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
　　　　　　　　* 若大于corePoolSize，则会将任务加入队列，
　　　　　　　　* 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
　　　　　　　　* 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
　　　　　　　　*/

 

　　　　　　  LinkedBlockingQueue();  无界队列：

　　　　　　　　/**

　　　　　　　　*当使用无界队列时，MaxSize则无效，只根据corePoolSize大小来创建线程

　　　　　　　　*/

     　　Executor自定义异常：

　　　　　　自定义异常类并实现RejectedExecutionHandler类

　　　　　　　　　

　　　　　　　　代码分解：

　　　　　　　　　　

　　　　　　　　

public class MyRejected implements RejectedExecutionHandler{


　　　　　　　　public MyRejected(){
　　　　　　　　}

　　　　　　　　@Override
　　　　　　　　public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
　　　　　　　　　　System.out.println("自定义处理..");
　　　　　　　　　　System.out.println("当前被拒绝任务为：" + r.toString());
　　　　　　　　}

　　　　　　}

　　　　　　自定义异常代码解析：

　　　　　　　　MyTask类实现 Runnable： 

　　　　　　　　　　

　　　　　　　　　

　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);
　　　　　　　　　　　　}

　　　　　　　　　　}

　　　　　　UseThreadPoolExecutor自定义线程池类：

　　　　　　　　　　

　　　　　　　

　public class UseThreadPoolExecutor{


　　　　　　　　public static void main(String[] args) {
　　　　　　　　　　/**
　　　　　　　　　　* 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
　　　　　　　　　　* 若大于corePoolSize，则会将任务加入队列，
　　　　　　　　　　* 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
　　　　　　　　　　* 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
　　　　　　　　　　* 
　　　　　　　　　　*/    
　　　　　　　　　　ThreadPoolExecutor pool = new ThreadPoolExecutor(
　　　　　　　　　　　　1, //coreSize
　　　　　　　　　　　　2, //MaxSize
　　　　　　　　　　　　60, //60
　　　　　　　　　　　　TimeUnit.SECONDS, 
　　　　　　　　　　　　new ArrayBlockingQueue<Runnable>(3)    //指定一种队列 （有界队列）
　　　　　　　　　　　　//new LinkedBlockingQueue<Runnable>()
　　　　　　　　　　　　, 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();

　　　　　　　　}
　　　　　　}