• 如何使用代理模式来扩展线程池的拒绝策略?
  • 发布于 2个月前
  • 70 热度
    0 评论
  • 王晶
  • 0 粉丝 37 篇博客
  •   
今天学点优雅的。
我们想在任务被拒绝时,扩展一些,比如在任务被拒绝时,发出警报、统计次数等,别急,先看一下源码中拒绝策略是怎么实现的?
 /**
  * Invokes the rejected execution handler for the given command.
  * Package-protected for use by ScheduledThreadPoolExecutor.
  */
 final void reject(Runnable command) {
     handler.rejectedExecution(command, this);
 }
很好,线程池底层设计中,将抛出拒绝策略方法的访问级别设置为 默认访问权限,并添加了 final 关键字,所以我们没法继承和直接调用reject方法

那怎么办,用代理!!!开始跟着我学习!


代理模式
代理模式(Proxy Design Pattern),在不改变原始类代码的情况下,引入代理类对原始类的功能作出增强。
很有干劲,直接来实践:
首先我们来扩展线程池,添加一个拒绝策略次数统计参数,并添加原子自增和查询方法。
 public class SupportThreadPoolExecutor extends ThreadPoolExecutor {
 
     /**
      * 堆代码 duidaima.com
      * 拒绝策略次数统计
      */
     private final AtomicInteger rejectCount = new AtomicInteger();
 
     public SupportThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
         super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
     }
 
     /**
      * 设置 {@link SupportThreadPoolExecutor#rejectCount} 自增
      */
     public void incrementRejectCount() {
         rejectCount.incrementAndGet();
     }
 
     /**
      * 获取拒绝次数
      *
      * @return
      */
     public int getRejectCount() {
         return rejectCount.get();
     }
 }
好了,然后呢,我有点懵,别急,慢慢捋一下,接下来是不是要用到上面的扩展的东西了?就是该使用自己扩展的线程池了!使用之前,是不是得自定义一个拒绝策略?是的,来直接扩展拒绝策略处理器。
public interface SupportRejectedExecutionHandler extends RejectedExecutionHandler {
 
     /**
      * 拒绝策略记录时, 执行某些操作
      *
      * @param executor
      */
     default void beforeReject(ThreadPoolExecutor executor) {
         if (executor instanceof SupportThreadPoolExecutor) {
             SupportThreadPoolExecutor supportExecutor = (SupportThreadPoolExecutor) executor;
             // 发起自增
             supportExecutor.incrementRejectCount();
             // 触发报警...
             System.out.println("线程池触发了任务拒绝...");
         }
     }
 }
很简答,在这个接口中我们新写了一个接口的方法的默认实现(jdk8新特性),在这个里面实现了上面我们的两个要求:次数自增、触发警报
然后,现在我们开始自定义一个拒绝策略:
 public class SupportAbortPolicyRejected extends ThreadPoolExecutor.AbortPolicy implements SupportRejectedExecutionHandler {
 
     @Override
     public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
         beforeReject(e);
         super.rejectedExecution(r, e);
     }
 }
打工打工告成!
开始测试:
@SneakyThrows
 public static void main(String[] args) {
     SupportThreadPoolExecutor executor = new SupportThreadPoolExecutor(
             1,
             1,
             1024,
             TimeUnit.SECONDS,
             new LinkedBlockingQueue(1),
             // 使用自定义拒绝策略
             new SupportAbortPolicyRejected()
     );
 
     // 测试流程
     for (int i = 0; i < 3; i++) {
         try {
             // 无限睡眠, 以此触发拒绝策略.(此处有异常, 为了减少无用代码, 省略...)
             executor.execute(() -> Thread.sleep(Integer.MAX_VALUE));
         } catch (Exception ignored) {
         }
     }
 
     Thread.sleep(50);
     System.out.println(String.format("线程池拒绝策略次数 :: %d", executor.getRejectCount()));
 }
 
 /**
  * 日志打印:
  *
  * 线程池触发了任务拒绝...
  * 线程池拒绝策略次数 :: 1
  */

根据日至打印得知,我们的扩展需求完整的实现了。当线程池执行任务拒绝行为时,首先会调用 SupportRejectedExecutionHandler#beforeReject,然后才是执行真正的拒绝策略行为。


静态代理
很明显,上面的代理思路很简单,就是用扩展类替换了原来要使用的类,在扩展类中扩展了我们想要的东西。但是这种方式优雅吗?很不优雅,静态代理会造成系统设计中类的数量增加、增加了系统复杂度。

怎么解决,动态代理缓缓走来。


动态代理
顾名思义,就是在程序运行时来动态增强类的行为,它取消了对被代理类的扩展限制,遵循开闭原则(对开放扩展,对修改关闭),
如何将动态代理代入到线程池拒绝策略呢?文章采用 JDK 动态代理的例子和大家说明:
回顾一下JDK动态代理怎么用:
先创建一个实现 InvocationHandler 接口的类,实现里面的invoke类
创建一个接口和一个接口实现的类(这个类是用来被扩展的)
然后使用:在代码中,创建这个接口实现的类的实例和实现 InvocationHandler 接口的类的实例
然后使用 Proxy.newProxyInstance 创建动态代理对象,将这两个类放进去,然后直接调用代理对象的实例的方法就完成了代理

好,跟着节奏来
创建核心类 InvocationHandler,这个类主要负责代理拒绝策略执行的,重写里面的invoke方法,看代码:
 @AllArgsConstructor
 public class RejectedExecutionProxyInvocationHandler implements InvocationHandler {
 
     private RejectedExecutionHandler target;
 
     private SupportThreadPoolExecutor executor;
 
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         // 执行拒绝策略前自增拒绝次数 & 发起报警
         executor.incrementRejectCount();
         System.out.println("线程池触发了任务拒绝...");
         return method.invoke(target, args);
     }
 }
创建一个接口和一个接口实现的类(这个类是用来被扩展的),这个用的是线程池的拒绝策略实例abortPolicy
ThreadPoolExecutor.AbortPolicy abortPolicy = new ThreadPoolExecutor.AbortPolicy();
然后创建这两个类的实例,并在代码中测试:
 @SneakyThrows
 public static void main(String[] args) {
     // 删除 SupportThreadPoolExecutor 构造方法中的拒绝策略
     SupportThreadPoolExecutor executor = new SupportThreadPoolExecutor(
             1,
             1,
             1024,
             TimeUnit.SECONDS,
             new LinkedBlockingQueue(1)
     );
 
     ThreadPoolExecutor.AbortPolicy abortPolicy = new ThreadPoolExecutor.AbortPolicy();
     // 创建拒绝策略代理类
     RejectedExecutionHandler rejectedExecutionHandler = (RejectedExecutionHandler) Proxy.newProxyInstance(
             abortPolicy.getClass().getClassLoader(),
             abortPolicy.getClass().getInterfaces(),
             new RejectedExecutionProxyInvocationHandler(abortPolicy, executor)
     );
     // 线程池 set 拒绝策略代理类
     executor.setRejectedExecutionHandler(rejectedExecutionHandler);
      // 堆代码 duidaima.com
     // 测试流程
     for (int i = 0; i < 3; i++) {
         try {
             // 无限睡眠, 以此触发拒绝策略.(此处有异常, 为了减少无用代码, 省略...)
             executor.execute(() -> Thread.sleep(Integer.MAX_VALUE));
         } catch (Exception ex) {
             // ignore
         }
     }
 
     Thread.sleep(50);
     System.out.println(String.format("线程池拒绝策略次数 :: %d", executor.getRejectCount()));
 }
 
 /**
  * 日志打印:
  *
  * 线程池触发了任务拒绝...
  * 线程池拒绝策略次数 :: 1
  */
好的,完成,至此,已经成功了一半多了。
虽然创建动态代理可以解决 类的数量增加;但是,代理类的创建依然需要开发人员操作,这样上面说的静态代理的第二个缺点依然无法解决
我们换一种思路去创建代理拒绝策略类,从外部的创建变更到内部就可以了;这一版选择在线程池的构造方法内部实现代理类:
 public class SupportThreadPoolExecutor extends ThreadPoolExecutor {
 
     // 省略代码...
 
     public SupportThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
         super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
 
         RejectedExecutionHandler rejectedExecutionHandler = (RejectedExecutionHandler) Proxy.newProxyInstance(
                 handler.getClass().getClassLoader(),
                 handler.getClass().getInterfaces(),
                 new RejectedExecutionProxyInvocationHandler(handler, this)
         );
 
         setRejectedExecutionHandler(rejectedExecutionHandler);
     }
 
     // 省略代码...
 }
完结撒花😜😜😜,总的来说不难,捋清楚了很简单,你搞清楚了吗?
用户评论