异步框架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();      }    }  }