异步框架asyn4j的原理

asyn4j基础原理，线程池和反射技术实现的

 

asyn4j核心类AsynServiceImpl

 

启动时调用init方法

 

public void init(){
    if (!run){
      run = true;
      //工作队列
      workQueue = newPriorityBlockingQueue(maxCacheWork);
      //是否存在工作队列满处理类
      if (this.workQueueFullHandler != null) {
        //自定义线程池
        workExecutor = newAsynThreadPoolExecutor(work_thread_num, work_thread_num, 0L,TimeUnit.MILLISECONDS,
          workQueue, new AsynThreadFactory(),new AsynWorkRejectedExecutionHandler(this.workQueueFullHandler),
          executeWorkNum);
      } else {
        workExecutor = newAsynThreadPoolExecutor(work_thread_num, work_thread_num, 0L,TimeUnit.MILLISECONDS,
          workQueue, new AsynThreadFactory(),executeWorkNum);
      }
      //回调函数工作队列
      callBackQueue = newLinkedBlockingQueue();
      //自定义回调函数线程池
      callBackExecutor = newCallBackThreadPoolExecutor(callback_thread_num, callback_thread_num, 0L,
        TimeUnit.MILLISECONDS, callBackQueue,new CallBackThreadFactory(),
        new CallBackRejectedExecutionHandler(),callBackNum);
      //service启动和关闭处理器
      if (this.serviceHandler != null) {
        this.serviceHandler.setServiceStat(0);
       this.serviceHandler.setAsynService(this);
        this.serviceHandler.process();
      }
      //启动工作队列满处理器
      if (this.workQueueFullHandler != null) {
        this.workQueueFullHandler.process();
      }
      //程序关闭后的处理
      Runtime.getRuntime().addShutdownHook(newThread(){
        public void run()
        {
         AsynServiceImpl.this.close(AsynServiceImpl.closeServiceWaitTime);
        }
      });
    }
  }

AsynServiceImpl主要有两个线程池和三个处理器组成

 

工作线程池AsynThreadPoolExecutor

public classAsynThreadPoolExecutor
  extends ThreadPoolExecutor
{
  private AtomicLong executeWorkNum;

回调函数线程池CallbackThreadPoolExecutor

public classCallBackThreadPoolExecutor
  extends ThreadPoolExecutor
{
  private AtomicLong callBackNum;

AsynThreadPoolExecutor的executeWorkNum，统计任务的执行数

AsynThreadPoolExecutor的callBackNum，统计回调函数的执行数

 

ServiceHandler处理器（启动或关闭）

WorkQueueFullHandler处理器（任务数超过maxCacheWork）

ErrorAsynWorkHandler处理器（任务执行异常）

 

 

执行时调用addWork方法

 

  

public void addWork(Object tagerObject, Stringmethod, Object[] params, AsynCallBack asynCallBack, WorkWeight weight, booleancache)
  {
    if ((tagerObject == null) || (method ==null)) {
      throw newIllegalArgumentException("target name is null or  target method name is null");
    }
    Object target = null;
    //如果对象是String
    if(tagerObject.getClass().isAssignableFrom(String.class)){
      addWorkWithSpring(tagerObject.toString(),method, params, asynCallBack, weight);
      return;
    }
    //如果对象是class
    if ((tagerObject instanceof Class)) {
      String classKey =((Class)tagerObject).getSimpleName();
      //是否缓存，一个class缓存一个默认的对象，防止重复创建
         if (cache)
      {
        target = targetCacheMap.get(classKey);
        if (target == null)
        {
          target =newObject((Class)tagerObject);
          targetCacheMap.put(classKey, target);
        }
      }
      else
      {
        target = newObject((Class)tagerObject);
      }
    }
    else
    {
      target = tagerObject;
    }
    if (target == null) {
      throw newIllegalArgumentException("target object is null");
    }
    //封装成异步任务
    AsynWork anycWork = newAsynWorkEntity(target, method, params, asynCallBack, weight);
   
    addAsynWork(anycWork);
  }

public voidaddAsynWork(AsynWork asynWork){
    if (!run) {
      throw new Asyn4jException("asynservice is stop or no start!");
    }
    if (asynWork == null) {
      throw newIllegalArgumentException("asynWork is null");
    }
    try<span style="font-family: Arial, Helvetica, sans-serif;">{</span>

      //通过semaphore来获取许可权限
      if(this.semaphore.tryAcquire(addWorkWaitTime, TimeUnit.MILLISECONDS))
      {
        WorkProcessor workProcessor = newWorkProcessor(asynWork, this);
       
        workExecutor.execute(workProcessor);
        totalWork.incrementAndGet();
      }
      else{
        log.warn("work queue is full,addwork to cache queue");
       this.workQueueFullHandler.addAsynWork(asynWork);
      }
    }
    catch (InterruptedException e)
    {
      log.error(e);
    }
  }

 

通过semaphore来控制最大的访问线程数，maxCacheWork就是semaphore的数量，也是工作队列的数量

这里的目的是控制工作队列的数量不能超过maxCacheWork（也可以通过用上限的queue来代替）

如果超过队列maxCacheWork，就用workQueueFullHandler去处理，处理方式同线程池的拒绝策略处理器（

newAsynWorkRejectedExecutionHandler(this.workQueueFullHandler)）不过线程池的拒绝策略没用到（前提是队列的有上限的队列），

工作任务WorkProcessor（内含AsynWorkEntity）

  public void run() {
    Thread currentThread =Thread.currentThread();
    if (this.asynWork.getThreadName() != null){
      setName(currentThread,this.asynWork.getThreadName());
    }
    AsynCallBack result = null;
    try{
      result = this.asynWork.call();
      if (result != null) {
       ApplicationContext.getCallBackExecutor().execute(result);
      }
    }
    catch (Throwable throwable){
      if(this.applicationContext.getErrorAsynWorkHandler() != null) {
       this.applicationContext.getErrorAsynWorkHandler().addErrorWork(this.asynWork,throwable);
      }
    }
    finally{
     this.applicationContext.getSemaphore().release();
    }
  }

首先修改线程名称，然后调用asynWork的call方法,如果有回调函数，就执行，如果有异常就执行ErrorAsynWorkHandler，最后Semaphore释放一个许可

 

AsynWorkEntity

  public AsynCallBack call()
    throws Exception {
    if (this.target == null) {
      throw new RuntimeException("targetobject is null");
    }
    Class clazz = this.target.getClass();
   
    String methodKey =MethodUtil.getClassMethodKey(clazz, this.params, this.method);
   
    Method targetMethod =(Method)methodCacheMap.get(methodKey);
    if (targetMethod == null){
      targetMethod =MethodUtil.getTargetMethod(clazz, this.params, this.method);
      if (targetMethod != null) {
        methodCacheMap.put(methodKey,targetMethod);
      }
    }
    if (targetMethod == null) {
      throw newIllegalArgumentException("target method is null");
    }
    Object result =targetMethod.invoke(this.target, this.params);
    if (this.anycResult != null) {
      this.anycResult.setInokeResult(result);
    }
    return this.anycResult;
  }

通过反射技术调用用具体方法，也用缓存技术，anycResult就是你定义的回调函数，没有就返回null

 

关闭时调用close方法

 

  publicvoid close(long waitTime){
    if (run){
      run = false;
      try {
        workExecutor.awaitTermination(waitTime,TimeUnit.MILLISECONDS);
       
        callBackExecutor.awaitTermination(0L,TimeUnit.MILLISECONDS);
      }
      catch (InterruptedException e)
      {
        log.error(e);
      }
      //关闭工作线程和回调函数线程
      workExecutor.shutdown();
      callBackExecutor.shutdown();
      //service关闭处理器
      if (this.serviceHandler != null)
      {
       this.serviceHandler.setAsynWorkQueue(workQueue);
        this.serviceHandler.setCallBackQueue(callBackQueue);
        this.serviceHandler.setServiceStat(1);
        this.serviceHandler.process();
      }
    }
  }