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();
}
}
}
---------------------
作者：clbhii
来源：CSDN
原文：https://blog.csdn.net/clbhii/article/details/47778279
版权声明：本文为博主原创文章，转载请附上博文链接！
