异步并行加载使用说明(asyncload)

背景

 最近资讯asyncload使用的同学越来越多，会有些一些经常性的问题，这里我做一下整理和answer，同时介绍一下asyncload的UserGuide 和一些限制等。

 

关于asyncload,又名异步并行加载 ，可参见我之前的文章： (业务层)异步并行加载技术分析和设计

UserGuide篇

几个基本概念：

  1. 线程池 (定义异步处理的线程池模型，包括线程数，队列大小等)
  2. 匹配信息 (定义哪些方法需要实施，包括超时时间等)
  3. 匹配主体 (比如常见的service,dao等，需要进行异步并行加载处理的对象)

声明式: 常规配置(半侵入)

基本步骤：

1.  配置线程池

1.<bean id="asyncLoadExecutor" class="com.agapple.asyncload.AsyncLoadExecutor" init-method="initital" destroy-method="destory">
2.    <property name="poolSize" value="10" />
3.    <property name="acceptCount" value="20" />
4.        <property name="mode" value="CALLSRUN" />
5.</bean>

  • 关于poolSize/acceptCount的建议参数，请参考我的另一篇文章： ThreadPoolExecutor几点使用建议
  • 关于mode参数，目前支持REJECT和CALLSRUN。
    REJECT：当异步提交的任务数超过了acceptCount后，直接返回Reject异常
    CALLSRUN：当异步提交的任务数超过了acceptCount后，由当前提交的线程执行runnable任务。此时的线程模型就变为了poolSize+1线程数，你的提交线程也就成为了其中的一个工作线程。建议使用该参数

2. 匹配信息配置

1.<bean id="asyncLoadConfig" class="com.agapple.asyncload.AsyncLoadConfig">
2.    <property name="defaultTimeout" value="3000" />
3.    <property name="needThreadLocalSupport" value="false" />
4.    <property name="needBarrierSupport" value="false" />
5.    <property name="matches">
6.        <map>
7.            <entry key-ref="asyncLoadMethodMatch" value="2000" />
8.        </map>
9.    </property>
10.</bean>

  • defaultTimeout：指异步提交任务后，等待返回结果的超时时间，可以有效保护系统的健壮性(当外部系统不可用时)。如果不想进行超时控制，可设置为0。默认值为0
  • needThreadLocalSupport：指异步任务提交后，原先的正常业务处理线程A和异步任务的处理线程B，是否共享ThreadLocal变量，使用需慎用，一般不建议开启。默认值为false，不开启
  • needBarrierSupport：指当原先一个业务处理线程，被拆分为N多个异步任务并行处理后，可以通过设置栅栏，在某一代码处要求所有的异步结果均返回后才进行下一步操作。默认值为false，不开启
  • matches：匹配点定义，asyncload自带的匹配方式，如果使用spring拦截器处理可不配置该属性，使用spring pointcut定义匹配点。

        匹配点定义：（pattern定义需要和匹配主体对象相关联

1.<bean id="asyncLoadMethodMatch" class="com.agapple.asyncload.impl.AsyncLoadPerl5RegexpMethodMatcher" >
2.    <property name="patterns">
3.        <list>
4.            <value>(.*)RemoteModel(.*)</value>
5.        </list>
6.    </property>
7.    <property name="excludedPatterns">
8.        <list>
9.            <value>(.*)listRemoteModel(.*)</value>
10.        </list>
11.    </property>
12.    <property name="excludeOveride" value="false" />
13.</bean>
  • patterns：代表满足该正则的匹配
  • excludedPatterns：代表需要被排除的匹配
  • excludeOveride：true/false
    true: 优先执行excluded排除匹配
    false：优先执行满足匹配，在满足匹配通过后，再执行排除匹配     

3. 匹配主体配置

1.<bean id="asyncLoadTestFactoryBean" class="com.agapple.asyncload.impl.spring.AsyncLoadFactoryBean">
2.    <property name="targetClass" value="com.agapple.asyncload.domain.AsyncLoadTestService" /><!-- 指定具体的代理目标class -->
3.    <property name="target">
4.        <ref bean="asyncLoadTestService" />
5.    </property>
6.    <property name="executor" ref="asyncLoadExecutor" />
7.    <property name="config" ref="asyncLoadConfig" />
8.</bean>
  • 类似于spring ProxyFactoryBean配置模式，对应的target即为你需要操作的服务对象。
  • config即为匹配信息定义，步骤2中的定义
  • executor即为线程池定义，步骤1中的定义

4. 使用 AsyncLoadFactoryBeanTest

1.public class AsyncLoadFactoryBeanTest extends BaseAsyncLoadNoRunTest {
2.
3.    @Resource(name = "asyncLoadTestFactoryBean")
4.    private AsyncLoadTestService asyncLoadTestFactoryBean;
5.
6.    @Test
7.    public void testFactoryBean() {
8.       AsyncLoadTestModel model1 = asyncLoadTestFactoryBean.getRemoteModel("first", 1000);
9.        .............
10.    }
11.}

 注意：此时需要引用的bean name为步骤3中定义的主体配置中的名字。

声明式: 集成spring拦截器模式 (更少侵入)

步骤1: 配置线程池
   见上一章节的步骤1定义

 

步骤2:  匹配信息配置
  和上一章节的步骤2定义，基本类似。不过可以不需配置匹配点，可省略asyncLoadMethodMatch定义

 

步骤3：匹配主体配置

  a. 定义拦截器

1.<bean id="asyncLoadInterceptor" class="com.agapple.asyncload.impl.spring.AsyncLoadInterceptor" >
2.    <property name="asyncLoadTemplate" ref="asyncLoadTemplate" />
3.</bean>
  •   注意这里依赖了一个asyncLoadTemplate配置，后面再介绍下对应的配置。

  b. 定义Advisor
     定义一个pointcut 

1.<bean id="asyncLoadPointcut" class="org.springframework.aop.support. Perl5RegexpMethodPointcut">
2.    <property name="pattern">
3.        <value>(.*)RemoteModel(.*)</value>
4.    </property>
5.    <property name="ExcludedPattern">
6.        <value>(.*)listRemoteModel(.*)</value>
7.    </property>
8.</bean>

 组合pointcut和interceptor为一个advisor

1. <bean id="asyncloadAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
2.   <property name="advice" ref="asyncLoadInterceptor"></property>
3.   <property name="pointcut" ref="asyncLoadPointcut"></property>
4.</bean>

   我这里不多罗嗦，主要就是spring的一些定义。

c. 定义主体

1.<span style="white-space: normal; background-color: rgb(255, 255, 255);"><bean id="</span>asyncLoadTestProxy<span style="white-space: normal; background-color: rgb(255, 255, 255);">" class="org.springframework.aop.framework.ProxyFactoryBean"></span>
2.    <property name="proxyTargetClass" value="true" />
3.    <property name="target" ref="asyncLoadTestService" />
4.    <property name="interceptorNames">
5.        <list>
6.            <value>asyncLoadInterceptor</value>
7.        </list>
8.    </property>
9.</bean>

这样就完成了配置，是不是觉得比较easy. 

 

步骤4：使用 (AsyncLoadSpringInteceptorTest)

1.public class AsyncLoadSpringInteceptorTest extends BaseAsyncLoadNoRunTest {
2.
3.    @Resource(name = "asyncLoadTestServiceForInteceptor")
4.    private AsyncLoadTestService asyncLoadTestServiceForInteceptor;
5.
6.    @Test
7.    public void testSpringInteceptor() {
8.        AsyncLoadTestModel model1 = asyncLoadTestServiceForInteceptor.getRemoteModel("first", 1000);
9.        AsyncLoadTestModel model2 = asyncLoadTestServiceForInteceptor.getRemoteModel("two", 1000);
10.        long start = 0, end = 0;
11.        start = System.currentTimeMillis();
12.        System.out.println(model1.getDetail());
13.        end = System.currentTimeMillis();
14.        Assert.assertTrue((end - start) > 500l); // 第一次会阻塞, 响应时间会在1000ms左右
15.
16.        start = System.currentTimeMillis();
17.        System.out.println(model2.getDetail());
18.        end = System.currentTimeMillis();
19.        Assert.assertTrue((end - start) < 500l); // 第二次不会阻塞，第一个已经阻塞了1000ms
20.    }
21.}

可以直接操作原先的主体bean

 

--------------------------------------------------------------------------------分割线--------------------------------------------------------------------------------------------------------------

如果是兼容老系统，减少配置变更，可以考虑使用spring auto-proxy机制，对原先的配置侵入几乎为0

spring: BeanNameAutoProxyCreator  auto-proxy，直接针对现有的bean name实施拦截器切入

1.<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
2.    <property name="optimize" value="false"/>
3.    <property name="proxyTargetClass" value="false" />
4.    <property name="beanNames">
5.        <list>
6.            <value>asyncLoadTestServiceForInteceptor</value>
7.        </list>
8.    </property>
9.    <property name="interceptorNames">
10.        <list>
11.            <value>asyncLoadInterceptor</value>
12.        </list>
13.    </property>
14.</bean>

asyncload :  CompositeAutoProxyCreator ，使用： AsyncLoadSpringCompsiteTest

1.<bean class="com.agapple.asyncload.impl.spring.CompositeAutoProxyCreator">
2.    <property name="optimize" value="false"/>
3.    <property name="proxyTargetClass" value="false" />
4.    <property name="beanNames">
5.        <list>
6.            <value>asyncLoadTestServiceForInteceptor</value>
7.        </list>
8.    </property>
9.    <property name="interceptorNames">
10.        <list>
11.            <value>asyncLoadInterceptor</value>
12.        </list>
13.    </property>
14.</bean>

相比于BeanNameAutoProxyCreator，CompositeAutoProxyCreator会有一种融合机制，假如发现需要操作的bean已经进行了spring aop代理配置后，直接将当前的interceptor加入到原先aop配置定义中，而不会是两次代理封装) 

两次代理封装问题：

 

  • 第一次封装为cglib代理后，生成的对象为final类，无法再次生成cglib代理类。如果无接口，无法再次生成jdk代理

(编程式)模板模式

模板模式： AsyncLoadTemplate

配置： 

1.<bean id="asyncLoadTemplate" class="com.agapple.asyncload.impl.template.AsyncLoadTemplate" >
2.    <property name="executor" ref="asyncLoadExecutor" />
3.    <property name="config" ref="asyncLoadConfig" />
4.</bean>
  •  需要依赖线程池定义 和 匹配信息定义

使用：AsyncLoadTemplateTest

1.public class AsyncLoadTemplateTest extends BaseAsyncLoadNoRunTest {
2.
3.    @Resource(name = "asyncLoadTemplate")
4.    private AsyncLoadTemplate    asyncLoadTemplate;
5.
6.    @Resource(name = "asyncLoadTestService")
7.    private AsyncLoadTestService asyncLoadTestService;
8.
9.    @Test
10.    public void testTemplate() {
11.        AsyncLoadTestModel model2 = asyncLoadTemplate.execute(new AsyncLoadCallback<AsyncLoadTestModel>() {
12.
13.            public AsyncLoadTestModel doAsyncLoad() {
14.                // 总共sleep 2000ms
15.                return asyncLoadTestService.getRemoteModel("ljhtest", 1000);
16.            }
17.        });
18.    }
19.
20.}

  •  接受AsyncLoadCallback进行异步并行业务处理单元封装

使用模板模式的好处： (自由定义异步并行处理单元)

  • 比如针对服务B依赖服务A，两者依赖的间隔时间很多，当将A和B的调用各自做异步并行加载，会发现A的调用几乎都是阻塞式。此时可以选择将A和B的一个完整处理，做为一个异步并行处理的单元。
  • 比如一个方法调用中，可以考虑将部分代码进行异步调用，而不是以方法为一个单元。

(编程式)非spring容器

使用：AsyncLoadProxyTest

1.public class AsyncLoadProxyTest extends BaseAsyncLoadNoRunTest {
2.
3.    @Test
4.    public void testProxy() {
5.    AsyncLoadTestService asyncLoadTestService = xxxxx;  //你原先的业务处理主体
6.
7.        // 初始化config
8.        AsyncLoadConfig config = new AsyncLoadConfig(3 * 1000l);
9.        // 初始化executor
10.        AsyncLoadExecutor executor = new AsyncLoadExecutor(10, 100);
11.        executor.initital();
12.        // 初始化proxy
13.        AsyncLoadEnhanceProxy<AsyncLoadTestService> proxy = new AsyncLoadEnhanceProxy<AsyncLoadTestService>();
14.        proxy.setService(asyncLoadTestService); //传递你原先的业务对象
15.        proxy.setConfig(config);
16.        proxy.setExecutor(executor);
17.
18.        AsyncLoadTestService service = proxy.getProxy(); //获取到异步并行处理包装过的服务对象
19.
20.         // 执行测试
21.        AsyncLoadTestModel model1 = service.getRemoteModel("first", 1000); // 进行业务请求
22.    }
23.}

DevGuide 篇

1. asyncload是否存在一些使用限制？

ans : 存在一定的使用限制和建议

使用限制： 

 

  • 不支持 == null的判断 (原因： asyncload因为需要做异步处理，所以在执行方法调用时，比如xxxService.getRemote()。会预先生成一个假的返回对象，永远不会为null, 所以==null一定返回为false)
    规避： 可以使用AsyncLoadUtils.isNull(xxxModel)进行判断，注意调用此方法，会阻塞直到原先的调用结果返回，然后再依据返回结果进行==null判断
  • 不支持以下几种的方法调用，主要是针对返回结果类型：
    a. void， 没有返回对象。
    b. final类，比如java.lang.String
    c. java.lang.Object，因为asyncload分析是基于当前的class，不能基于运行时对象进行处理。所以针对方法定义中返回为java.lang.Object的不支持
    d. 原生类型， 比如int,long等
    e. array类型，比如int[],long[]等
    f. 非public的类型，比如在一些类的返回结果，返回了一个内部protected类
  • threadlocal使用限制 (原先：引入asyncload后，原先在一个线程中处理的业务会分散到多个线程中，所以ThreadLocal默认无法进行共享处理，虽然asyncload可以有技术做到共享ThreadLocal，但这样会打破原先ThreadLocal的语义，导致出现线程安全问题。严重慎用)
    规避：使用模板模式控制拦截器粒度，尽量将ThreadLocal的操作放在一个异步并行处理单元，或者不进行异步处理。

 

使用建议：

 

  • 应用在I/O只读查询操作上，比如查询数据库，调用远程服务接口，调用cache等。
  • 将请求发起放在前面调用，数据结果处理统一在最后处理。尽量让请求可以走到并行处理
  • 使用spring无嵌入配置(composite配置)

2. asyncload异步并行处理后，如何确保返回结果？提交给ThreadPoolExectuor后的future是如何存储的？

比如有个ProductService中，有个方法ProductModel product.getProductById(Long productId)

ans :  asyncload会在两个层面进行扩展处理(字节码或者拦截器)

 

  • 服务主体层(ProductService)，asyncload会通过常规配置(字节码处理)或者拦截器配置，会改变原先对于getProductById()的方法调用逻辑，这里就会提交到一个线程池中进行处理。 
    1.return asyncLoadTemplate.execute(new AsyncLoadCallback() {
2.
3.            public Object doAsyncLoad() {
4.                try {
5.                    return temp.proceed();
6.                } catch (Throwable e) {
7.                    throw new AsyncLoadException("AsyncLoadInterceptor invoke error!", e);
8.                }
9.            }
10.        }, invocation.getMethod().getReturnType()); // 这里指定了返回目标class
  • 服务返回对象(ProductModel)：asyncload提交任务到线程池之后，会根据原先method.getReturnType()获取到返回结果的类型定义，通过字节码处理技术生成了一个原先retrunType类型的子类，同时覆盖了原先ProductModel中的所有方法，比如getId()方法就会变为：
1.public ProductModelSub extends ProductModel {
2.
3.    public Future future;  //持有线程池返回对象
4.
5.    public Object loadObject() throws Exception {
6.        return loadFuture();
7.    }
8.
9.       private Object loadFuture() throws AsyncLoadException {
10.        try {
11.            // 使用cglib lazyLoader，避免每次调用future
12.            if (timeout <= 0) {// <=0处理，不进行超时控制
13.                return future.get();
14.            } else {
15.                return future.get(timeout, TimeUnit.MILLISECONDS);
16.            }
17.        } catch (TimeoutException e) {
18.            future.cancel(true);
19.            throw new AsyncLoadException(e);
20.        } catch (InterruptedException e) {
21.            throw new AsyncLoadException(e);
22.        } catch (Exception e) {
23.            throw new AsyncLoadException(e);
24.        }
25.    }
26.
27.    public Long getId(){
28.        ProductModel model = loadObject(); //先阻塞等待future返回
29.        return model.getId();
30.    }
31.
32.}
  •  调用productModel.getId()方法就会先调用loadFuture()，阻塞等待future的返回，然后再委托给future的返回对象调用getId方法进行返回

3. asyncload的服务依赖关系链的处理？

ans :

首先依赖关系的定义：如果服务B依赖了服务A的返回结果。(比如这里是ProductModel.getId()的返回结果，将做为服务B ProductDetailService.getProudctDetailByProductId(Long productId))，进行服务B的返回调用参数）

 

出现依赖关系后的处理：其实很简单，当B需要ProductModel.getId()的结果，进行构造自己的参数时，此时服务A的调用就会。也就是转变为了A,B是一个串行调用。

 

 

4. asyncload的线程池配置是否有讲究 ？

ans:  poolSize不宜开的过大，一般建议为20~30，acceptCount建议为poolSize的两倍，model建议为CALLSRUN。

关于poolSize/acceptCount的建议参数，请参考我的另一篇文章： ThreadPoolExecutor几点使用建议

 

 

4. asyncload是否可以提升性能？ 比如tps ，响应时间?

 

ans : 

 

  • 针对响应时间，为你最长依赖关系链的时间之后。所以只要你配置后的依赖关系链有一处做了并行，就可以得到提升。这里需要注意线程池的设置，避免出现大量的异步任务进行等待，导致单个任务的处理时间过长。
  • 针对tps，计算公式 tps =  1000 /  (每个request的响应时间)，只要响应时间减少了，可支持的tps就会上升。注意如果你当前统计的访问tps只有100个，没有出现竞争资源瓶颈，使用asyncload后，当前的tps是不会增加，说白了你每秒就100个request。 (可支持tps会增加，如果当前tps已经存在竞争瓶颈，就会有所增加)

还有一点需要说明，因为使用了异步并行后，原本一个request请求就会被扩大到几倍的并行请求，从而对后端服务的压力瞬间并发就会增加，需要考虑后端服务是否可以顶的住，不过一般来说单纯数据库或者cache访问，自身不会是一个瓶颈。应用asyncload会适当的增加系统资源的消耗，比如CPU(进行线程上下文切换)，Load(同一时间运行的工作线程就会增加)

 

 

可以分享一下我当时一个实施场景的数据：(2o并发的持续高压)

 

 

对比项 主干代码 并行加载实施代码 提升幅度 提升百分比
响应时间 347ms 281ms 66ms 19%
tps 60.7 70.9 10.2 16.8%
cpu使用率 user:44.97%
sys:4.67%		 user:53.12%
sys:5.87%		 user:8.15
sys:1.2		 user:18.1%
sys:25.7%
load 9.39 6.21 3.18 51.2%

最后

 目前asyncload的实施场景已经有好多个，包括阿里巴巴，淘宝，良无限等。至于提升多少性能要结合具体的业务，也就是说你的可提升空间有多少。当然异步并行后，会适当的增加系统资源的消耗。

时间： 2024-10-30 11:24:33

异步并行加载使用说明(asyncload)的相关文章

(业务层)异步并行加载技术分析和设计

背景    前段时间在做应用的性能优化时,分析了下整体请求,profile看到90%的时间更多的是一些外部服务的I/O等待,cpu利用率其实不高,在10%以下. 单次请求的响应时间在50ms左右,所以tps也不会太高,测试环境压力测试过程,受限于环境因素撑死只能到200tps,20并发下.   I/O 目前一般的I/O的访问速度: L1 > L2 > memory -> disk or network   常见的IO:  nas上文件 (共享文件存储) output/xxx (磁盘文件)

(业务层)异步并行加载ChangeLog

继上一篇:  (业务层)异步并行加载技术分析和设计目前已经在google code上新建了一个project,也在逐步的完善和加强并行加载的功能,这里记录一下ChangeLog.   相关代码: https://github.com/agapple/asyncload , 有兴趣的同学可以一起参与,目前正在公司的应用中打算实施,逐步的在完善功能和解决一些兼容性的问题.   Change 1: (HandleMode模式修改) AsyncLoadExecutor(并行加载的执行容器),修改了Han

并行加载实施中遇到的问题

背景   最近着手在一个已有的应用中实施并行加载技术,整理记录一下过程中遇到的问题,方便以后查阅.   关于并行加载可以访问:  (业务层)异步并行加载技术分析和设计   姊妹篇: (业务层)异步并行加载ChangeLog   问题集 1. ThreadLocal不支持  原理分析: 因为并行加载,导致原先的代码快使用了新的独立的线程进行加载.导致原先代码中使用了ThreadLocal失效. 应用分析: 使用的ThreadLocal有几处地方     *  request/response. 需

Oracle 高速批量数据加载工具sql*loader使用说明_oracle

SQL*Loader(SQLLDR)是Oracle的高速批量数据加载工具.这是一个非常有用的工具,可用于多种平面文件格式向Oralce数据库中加载数据.SQLLDR可以在极短的时间内加载数量庞大的数据.它有两种操作模式. 传统路径:(conventional path):SQLLDR会利用SQL插入为我们加载数据. 直接路径(direct path):采用这种模式,SQLLDR不使用SQL:而是直接格式化数据库块. 利用直接路径加载,你能从一个平面文件读数据,并将其直接写至格式化的数据库块,而绕

PHP的autoload自动加载机制使用说明_php技巧

在PHP开发过程中,如果希望从外部引入一个class,通常会使用include和require方法,去把定义这个class的文件包含进来,但是这样可能会使得在引用文件的新脚本中,存在大量的include或require方法调用,如果一时疏忽遗漏则会产生错误,使得代码难以维护. 自PHP5后,引入了__autoload这个拦截器方法,可以自动对class文件进行包含引用,通常我们会这么写: 复制代码 代码如下: function __autoload($className) { include_o

图片预加载并且自动等比例缩放的JS插件

/* **************图片预加载插件****************** ///作者:没剑(2008-06-23) ///http://regedit.cnblogs.com ///说明:在图片加载前显示一个加载标志,当图片下载完毕后显示图片出来 可对图片进行是否自动缩放功能 此插件使用时可让页面先加载,而图片后加载的方式, 解决了平时使用时要在图片显示出来后才能进行缩放时撑大布局的问题 ///参数设置: scaling 是否等比例自动缩放 width 图片最大高 height 图片

采用dlopen、dlsym、dlclose加载动态链接库【总结】

1.前言 为了使程序方便扩展,具备通用性,可以采用插件形式.采用异步事件驱动模型,保证主程序逻辑不变,将各个业务已动态链接库的形式加载进来,这就是所谓的插件.linux提供了加载和处理动态链接库的系统调用,非常方便.本文先从使用上进行总结,涉及到基本的操作方法,关于动态链接库的本质及如何加载进来,需要进一步学习,后续继续补充.如何将程序设计为插件形式,挖掘出主题和业务之间的关系,需要进一步去学习. 2.生产动态链接库 编译参数 gcc -fPIC -shared  例如将如下程序编译为动态链接库

Android通过AsyncTask与ThreadPool（线程池）两种方式异步加载大量数据的分析与对比

   在加载大量数据的时候,经常会用到异步加载,所谓异步加载,就是把耗时的工作放到子线程里执行,当数据加载完毕的时候再到主线程进行UI刷新.在数据量非常大的情况下,我们通常会使用两种技术来进行异步加载,一是通过AsyncTask来实现,另一种方式则是通过ThreadPool来实现,今天我们就通过一个例子来讲解和对比这两种实现方式.     本文原创,如需转载,请注明转载地址http://blog.csdn.net/carrey1989/article/details/12002033     项

jquery 图片预加载 自动等比例缩放插件_jquery

复制代码 代码如下: /* **************图片预加载插件****************** ///作者:没剑(2008-06-23) ///http://regedit.cnblogs.com ///说明:在图片加载前显示一个加载标志,当图片下载完毕后显示图片出来 可对图片进行是否自动缩放功能 此插件使用时可让页面先加载,而图片后加载的方式, 解决了平时使用时要在图片显示出来后才能进行缩放时撑大布局的问题 ///参数设置: scaling 是否等比例自动缩放 width 图片最大