自定义线程池-自定义有界队列

import  java.util.concurrent.ArrayBlockingQueue;

import  java.util.concurrent.ThreadPoolExecutor;

import  java.util.concurrent.TimeUnit;

 

 

/**

 * 自定义线程池

 */

public   class  MyThreadPool {

public   static   void  main(String[] args) {

/*

 * ThreadPoolExecutor( int  corePoolSize,    核心线程数即初始化时的线程数

         *        int  maximumPoolSize,              最大线程数

         *       long keepAliveTime,               存活时间

         *       TimeUnit unit,                    单位

         *       BlockingQueue<Runnable> workQueue,任务队列

         *       ThreadFactory threadFactory,      线程工厂

         *       RejectedExecutionHandler handler) 拒绝执行的方法 ( 拒绝策略 )

         *  注意事项：

         *   使用有界队列时，如果有新任务

 */

ThreadPoolExecutor pool = new  ThreadPoolExecutor(1,

                2,

                60,

                TimeUnit. SECONDS ,

                 new  ArrayBlockingQueue<Runnable>(3) //指定有界队列

                 //ThreadFactory threadFactory,

                // RejectedExecutionHandler handler)

                );

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

/*

 *  场景 1 ，仅有一个任务

 *  因为初始化就有一个线程，因此立即执行

 */

// pool.execute(mt1);

/*

 *  场景 2 有 2 个任务

 *   mt1会立刻执行， mt2 会被放入队列中

 *  等到 mt1 执行完毕才会执行 mt2 ，干活的都是初始化的那个线程

 *  

 *   2个任务、 3 个任务、 4 个任务 都是这样的，一个线程干活，其他的等待

 */

// pool.execute(mt1);

// pool.execute(mt2);

/*

 * 场景 3    有 5 个任务

 *  mt1 和 mt5 几乎同时执行

 * 然后是 mt2 和 mt3 几乎同时执行

 * 最后是 mt4 执行

 *

 * 原因：初始化的那个线程执行 mt1 ，

 * mt2 mt3 mt4 放入队列 把队列放满了，

 *  mt5无法放入队列 只能在创建一个线程执行 mt5

 */

// pool.execute(mt1);

// pool.execute(mt2);

// pool.execute(mt3);

// pool.execute(mt4);

// pool.execute(mt5);

/*

 * 场景 4  6 个任务

 * mt1和 mt5 几乎同时执行，然后抛异常 mt6 被拒绝执行

 * 然后执行 mt2 和 mt3 几乎同时执行，然后执行 mt4

 */

pool.execute(mt1);

pool.execute(mt2);

pool.execute(mt3);

pool.execute(mt4);

pool.execute(mt5);

pool.execute(mt6);

pool.shutdown();

}

}

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

    }

}