20.custom自定义线程池

自定义线程池

    1.若Executors工厂类无法满足需求，可以自己使用工厂类创建线程池，底层都是使用了ThreadPoolExecutor这个类可以自定义。

 

  1. public ThreadPoolExecutor(int corePoolSize(当前核心线程数),
  2.                        int maximunPoolSize(最大线程数),
  3.                        long keepAliveTime(保持活跃时间),
  4.                        TimeUnit utin(时间单位),
  5.                        BlockingQueue<Runnable> workQueue(线程队列容器),
  6.                        ThreadFactory threadFactory(线程工厂),
  7.                        RejectedExecutionHandler rejectedExecutionHandler(拒绝执行的方法，线程队列阻塞到容器等待、例：限制最大执行、));
    2.有界队列【ArrayBlockingQueue】，若有新的任务则立即去执行：若有新的线程需要执行，目标线程池实际数小于"coreRoolSize"，则优先参加线程，若大于，

则会将任务加入队 列中，若队列已经满，则在总线程数不大于maximumPoolSize(最大coreRoolSize数)的前提下。创建一个新的线程，若大于               maximumPoolSize则实行拒绝策略、或其他处理方式。

    3.无界队列【LinkedBlockingQueue】与有界队列对比：除非资源耗尽，否则无界队列在加入任务不存在失败的情况下，当有新的任务到来，系统的线程数小于
       corePoolSize的时候，则新建线程去执行任务队列，，达到maxCorePoolsize后就不会增加了，若后续还有任务到来，而且没有空闲的资源，则把任务进行
        队列中去等待。若创建任务与处理任务的速度差异很大，无界队列保持快速增加等待的任务空间，一直到资源耗尽。
    4.拒绝策略
                    Abortlicy：直接抛出异常、核心系统则不会受到影响。
                    CallerRunspPolicy：该策略直接在调用者现场，运行当前被拒绝的任务、丢弃的任务（我刚刚进行队列就满了，那么就让我插个队执行）。
                    DiscardOldestPolicy：丢弃最老的一个请求(被阻塞在队列中很长时间)，尝试直接运行当前被拒绝的任务。
                    DiscardPolicy：丢弃无法处理的任务，被给与任何的后续处理。
    5.自定义策略
                    
  1. implements RejectedExecutionHandle
案例1：有界队列
  1. package demo8.threadPool;
  3. import java.util.concurrent.*;
  4. public class CustomThreadPool1 {
  7. /*    有界队列ArrayBlockingQueue：
  8.     若有新的线程需要执行，日光线程池实际数小于"coreRoolSize"，则优先参加线程，若大于，则会将任务加入队列中，若队列已经满，则在总线程
  9.     数不大于maximumPoolSize(最大coreRoolSize数)的前提下。创建一个新的线程，若大于maximumPoolSize则实行拒绝策略、或其他处理方式。*/
  12.     public static void main(String[] args) {
  13.         BlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<Runnable>(3);
  14.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1,
  15.                 2,
  16.                 60,
  17.                 TimeUnit.SECONDS,
  18.                 blockingQueue);
  19.         UserTask userTask1 = new UserTask(1, "任务-1");
  20.         UserTask userTask2 = new UserTask(2, "任务-2");
  21.         UserTask userTask3 = new UserTask(3, "任务-3");
  22.         UserTask userTask4 = new UserTask(4, "任务-4");
  23.         UserTask userTask5 = new UserTask(5, "任务-5");
  25.         threadPoolExecutor.execute(userTask1);
  26.         threadPoolExecutor.execute(userTask2);
  27.         threadPoolExecutor.execute(userTask3);
  28.         threadPoolExecutor.execute(userTask4);
  29.         threadPoolExecutor.execute(userTask5);
  30.         try {
  31.             Thread.sleep(1000);
  32.         } catch (InterruptedException e) {
  33.             e.printStackTrace();
  34.         }
  35.         threadPoolExecutor.shutdown();
  36.     }
  38. }
  39. 输出：
  40. pool-1-thread-1	 run taskId：1
pool-1-thread-2	 run taskId：5
pool-1-thread-2	 run taskId：3
pool-1-thread-1	 run taskId：2
pool-1-thread-2	 run taskId：4    这种情况处理完所有的任务
  1. package demo8.threadPool;
  3. /**
  4.  * Created by liudan on 2017/7/23.
  5.  */
  6. public class UserTask implements Runnable {
  8.     private int id;
  9.     private String taskName;
  11.     @Override
  12.     public void run() {
  13.         try {
  14.             Thread.sleep(1000);
  15.             System.err.println(Thread.currentThread().getName()+"\t run taskId："+this.getId());
  16.         } catch (InterruptedException e) {
  17.             e.printStackTrace();
  18.         }
  19.     }
  21.     public UserTask() {
  22.     }
  24.     public UserTask(int id, String taskName) {
  25.         this.id = id;
  26.         this.taskName = taskName;
  27.     }
  29.     public int getId() {
  30.         return id;
  31.     }
  33.     public void setId(int id) {
  34.         this.id = id;
  35.     }
  37.     public String getTaskName() {
  38.         return taskName;
  39.     }
  41.     public void setTaskName(String taskName) {
  42.         this.taskName = taskName;
  43.     }
  45.     @Override
  46.     public String toString() {
  47.         return "UserTask{" +
  48.                 "id=" + id +
  49.                 '}';
  50.     }
  51. }
案例2：拒绝任务，超出暂缓任务对了大小
  1. public static void main(String[] args) {
  2.         BlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<Runnable>(3);
  3.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1,
  4.                 2,
  5.                 60,
  6.                 TimeUnit.SECONDS,
  7.                 blockingQueue);
  8.         UserTask userTask1 = new UserTask(1, "任务-1");
  9.         UserTask userTask2 = new UserTask(2, "任务-2");
  10.         UserTask userTask3 = new UserTask(3, "任务-3");
  11.         UserTask userTask4 = new UserTask(4, "任务-4");
  12.         UserTask userTask5 = new UserTask(5, "任务-5");
  13.         UserTask userTask6 = new UserTask(6, "任务-6");多加一个
  15.         threadPoolExecutor.execute(userTask1);
  16.         threadPoolExecutor.execute(userTask2);
  17.         threadPoolExecutor.execute(userTask3);
  18.         threadPoolExecutor.execute(userTask4);
  19.         threadPoolExecutor.execute(userTask5);
  20.         threadPoolExecutor.execute(userTask6);
  21.         try {
  22.             Thread.sleep(1000);
  23.         } catch (InterruptedException e) {
  24.             e.printStackTrace();
  25.         }
  26.         threadPoolExecutor.shutdown();
  27.     }
  28. 输出：
  29. Exception in thread "main" java.util.concurrent.RejectedExecutionException: 
  30. Task UserTask{id=6} rejected from java.util.concurrent.ThreadPoolExecutor@6f94fa3e
  31. [Running, pool size = 2, active threads = 2, queued tasks = 3, completed tasks = 0]
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
	at demo8.threadPool.CustomThreadPool1.main(CustomThreadPool1.java:35)
pool-1-thread-1	 run taskId：1
pool-1-thread-2	 run taskId：5
pool-1-thread-1	 run taskId：2
pool-1-thread-2	 run taskId：3
pool-1-thread-1	 run taskId：4
案例3：自定义拒绝策略
  1. package demo8.threadPool;
  3. import java.util.concurrent.RejectedExecutionHandler;
  4. import java.util.concurrent.ThreadPoolExecutor;
  5. public class CustomDiscardPolicy implements RejectedExecutionHandler {
  7.     public CustomDiscardPolicy() {
  9.     }
  11.     @Override
  12.     public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
  13.         System.err.println("拒绝任务");
  14.         /**
  15.          * 用日志记录保存下，可做后续的扩展操作
  16.          */
  17.         System.err.println("加入任务log...\t"+r.toString());
  18.     }
  19. }
  1.  public static void main(String[] args) {
  2.         BlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<Runnable>(3);
  3.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1,
  4.                 2,
  5.                 60,
  6.                 TimeUnit.SECONDS,
  7.                 blockingQueue,
  8.                 new CustomDiscardPolicy());//使用自定义拒绝策略
  9.         UserTask userTask1 = new UserTask(1, "任务-1");
  10.         UserTask userTask2 = new UserTask(2, "任务-2");
  11.         UserTask userTask3 = new UserTask(3, "任务-3");
  12.         UserTask userTask4 = new UserTask(4, "任务-4");
  13.         UserTask userTask5 = new UserTask(5, "任务-5");
  14.         UserTask userTask6 = new UserTask(6, "任务-6");
  16.         threadPoolExecutor.execute(userTask1);
  17.         threadPoolExecutor.execute(userTask2);
  18.         threadPoolExecutor.execute(userTask3);
  19.         threadPoolExecutor.execute(userTask4);
  20.         threadPoolExecutor.execute(userTask5);
  21.         threadPoolExecutor.execute(userTask6);
  22.         try {
  23.             Thread.sleep(1000);
  24.         } catch (InterruptedException e) {
  25.             e.printStackTrace();
  26.         }
  27.         threadPoolExecutor.shutdown();
  28.     }
  29. 输出：
  30. 拒绝任务
加入任务log...	UserTask{id=6}
pool-1-thread-1	 run taskId：1
pool-1-thread-2	 run taskId：5
pool-1-thread-1	 run taskId：2
pool-1-thread-2	 run taskId：3
pool-1-thread-1	 run taskId：4
案例4：无界队列LinkedBlockingQueue
  1. package demo8.threadPool;
  3. import java.util.concurrent.*;
  6. public class CustomThreadPool2 {
  9. /*    无界队列LinkedBlockingQueue：
  10.     与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在加入任务队列失败的情况下，当有新的任务到来，系统的线程数小于coreRoolSize
  11.     时候，则新建线程执行任务，当到达coreRoolSize后就不会增加了，若后续还有新的任务加入，而且没有空闲的线程资源，则任务直接进入队列等待
  12.     。若任务创建和处理速度差异很大，无界队列保持快速增长，知道耗尽系统内存。*/
  14.     public static void main(String[] args) throws InterruptedException {
  16.         BlockingQueue<Runnable> blockingQueue = new LinkedBlockingQueue<Runnable>();
  18.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,10,120L, TimeUnit.SECONDS,blockingQueue);
  19.         //ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) Executors.newFixedThreadPool(4);
  20.         for (int i=1;i<=20;i++){
  21.             threadPoolExecutor.execute(new UserTask(i,"任务-"+i));
  22.         }
  23.         Thread.sleep(1000);
  24.         System.err.println("blockingQueue size："+blockingQueue.size());
  25.         Thread.sleep(2000);
  26.     }
  27. }
  28. 输出：
  29. pool-1-thread-1	 run taskId：1
pool-1-thread-2	 run taskId：2
pool-1-thread-3	 run taskId：3
pool-1-thread-4	 run taskId：4
pool-1-thread-5	 run taskId：5
blockingQueue size：10
pool-1-thread-2	 run taskId：7
pool-1-thread-4	 run taskId：9
pool-1-thread-3	 run taskId：8
pool-1-thread-1	 run taskId：6
pool-1-thread-5	 run taskId：10
pool-1-thread-2	 run taskId：11
pool-1-thread-1	 run taskId：14
pool-1-thread-3	 run taskId：13
pool-1-thread-4	 run taskId：12
pool-1-thread-5	 run taskId：15
pool-1-thread-1	 run taskId：17
pool-1-thread-4	 run taskId：19
pool-1-thread-5	 run taskId：20
pool-1-thread-2	 run taskId：16
pool-1-thread-3	 run taskId：18

 




posted @ 2017-08-10 02:02  逍遥叹!!  阅读(323)  评论(0)  编辑  收藏  举报