龙浩的blog http://www.longtask.com/blog 用技术创造价值，用艺术塑造自我！ Fri, 20 Apr 2012 10:26:33 +0000 http://wordpress.org/?v=2.8.4 en hourly 1 Jetty8.0.4的ClassLoader的体系结构 http://www.longtask.com/blog/?p=755 http://www.longtask.com/blog/?p=755#comments Fri, 20 Apr 2012 10:19:31 +0000 longhao http://www.longtask.com/blog/?p=755 More >]]>     1：JDK的ClassLoader基础

Bootstrap ClassLoader/启动类加载器 

主要负责jdk_home/lib目录下的核心 api 或 -Xbootclasspath 选项指定的jar包装入工作。

Extension ClassLoader/扩展类加载器 

主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作。

System ClassLoader/系统类加载器 

主要负责java -classpath/-Djava.class.path所指的目录下的类与jar包装入工作。

User Custom ClassLoader/用户自定义类加载器(java.lang.ClassLoader的子类) 

在程序运行期间, 通过java.lang.ClassLoader的子类动态加载class文件, 体现java动态实时类装入特性。

 

自User Custom向Bootstrap的检查类是否已经加载；自Bootstrap向User Custom的尝试加载类

 //检查类是否被装载过
      Class c = findLoadedClass(name);
      //指定类未被装载过，自顶部向下的尝试加载类
      if (c == null) {
          try {
            //如果父类加载器不为空，指定为父类加载器加载

            if (parent != null) {

                c = parent.loadClass(name, false);
            } else {
                //在父类加载器为空的情况下，指定为系统启动类加载（native），不存在则返回null
                c = findBootstrapClassOrNull(name);
            }
          } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }
            if (c == null) {
              // If still not found, then invoke findClass in order
              // to find the class.
              c = findClass(name); //通过自己的findClass来加载类
          }
      }
      if (resolve) {
          resolveClass(c);//用来做类链接操作
      }

     JVM在加载类时默认采用的是双亲委派机制。通俗的讲，就是某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。关于虚拟机默认的双亲委派机制，我们可以从系统类加载器和标准扩展类加载器为例作简单分析。

 

     2：Jetty的classloader

2.1：Jetty的classloader架构

    web容器的classloader比普通java应用略为复杂。

    每个web上下文（web应用和war文件）的普通配置是有自身的classloader，系统的classloader是它的父类。这是普通的java classloader的层次，但是servlet规范提出了负责的层次要求：

1. 在WEB-INF/lib和WEB-INF/classes中包含的类的加载优先级高于父classloader中的类。这和普通的java2的classloader加载动作相反。

2. 像java.lang.String这样的系统类不会被WEB-INF/lib或者WEB-INF/classes中的类替代。不幸的是，servlet规范并没有清楚的规定哪些类是系统类，也没有清楚的指出javax类应该作为系统类

3. Server实现类应该对web应用和其他classloader不可见。不幸的是，servelt规范并没有规定什么是server class ，也没有清楚的指出像xerces parser 这样的common libraries应该作为实现类。

2.2：如何配置classloading

    jetty提供配置来控制以上三个选项。org.mortbay.jetty.webapp.WebAppContext.setParentLoaderPriority(boolean) 来控制所有类是否双亲委派的方式加载，这个配置解决了web应用加载的类在web应用和系统classpath同时存在的情况。

    org.mortbay.jetty.webapp.WebAppContext.setSystemClasses(String[])和org.mortbay.jetty.webapp.WebAppContext.setServerClasses(String[])用来控制那些能够被web应用看到或者覆写的类。

* SystemClasses 不能被webapp 上下文 classloaders覆写. 默认的是： 

{"java.","javax.servlet.","javax.xml.","org.mortbay.","org.xml.","org.w3c.", "org.apache.commons.logging.","org.eclipse.jetty.continuation.","org.eclipse.jetty.jndi.","org.eclipse.jetty.plus.jaas.","org.eclipse.jetty.websocket.WebSocket", "org.eclipse.jetty.websocket.WebSocketFactory", "org.eclipse.jetty.servlet.DefaultServlet"}

* ServerClasses (on the container classpath) 不能被webapp 上下文 classloaders看到但是可以被webapp覆写. 默认配置是: 

{"-org.eclipse.jetty.continuation.","-org.eclipse.jetty.jndi.", "-org.eclipse.jetty.plus.jaas.", "-org.eclipse.jetty.websocket.WebSocket","-org.eclipse.jetty.websocket.WebSocketFactory","-org.eclipse.jetty.servlet.DefaultServlet", "-org.eclipse.jetty.servlet.listener.", "org.eclipse.jetty."};

    [这段不知道如何翻译]Absolute classname can be passed, names ending with . are treated as packages names and names starting with – are treated as negative matches and must be listed before any enclosing packages.

      具体的类名可以不写，名称以.结尾代表是package名称，名称以"-"开头被认为是负面符号， and must be listed before any enclosing packages.

2.3：给jetty添加额外的classpaths

    在启动时，jetty会自动加载$jetty.home/lib下所有的jars，随之加载在start.jar中的文件start.config中明确配置的子目录（例如：$jetty.home/lib/management，$jetty.home/lib/naming/ 等）中的jars。所以，给jetty添加拓展的jars，需要在$jetty.home/lib/ext中创建一个任何你想的深度的文件层次。当然，你可以在自己创建start.config来定义默认加载动作来代替系统动作，否则，你需要使用以下方法：  

2.4：使用 jetty.class.path 系统属性

    如果你想添加一个类目录或者jar到jetty，但是你不想把东西放到$jetty.home/lib/ext/中，或者你不想自己创建start.config文件，你可以简单的使用系统属性-Djetty.class.path，示例：

    java -Djetty.class.path="../my/classes:../my/jars/special.jar:../my/jars/other.jar" -jar start.jar

2.5：在WebAppContext中使用extraClasspath()方法

    如果你因为某种原因不想把jars或者classes放到 $jetty.home/lib ,同事也不想放到WEB-INF/lib 或者 WEB-INF/classes中，你可以把它添加到 $JETTY_HOME/contexts/mycontext.xml 文件中

    <Configure class="org.mortbay.jetty.webapp.WebAppContext">

      …

      <Set name="extraClasspath">../my/classes:../my/jars/special.jar:../my/jars/other.jar</Set>

      …

2.6：使用惯用的WebAppClassLoader

   最后，没有其他替代方案满足你的需求，你可以在自己的webapp中定制classloader，建议你的classloader是    org.mortbay.jetty.webapp.WebAppClassLoader的子类，但这不是必须的。你可以像如下的方式配置自己的webapp的classloader：

     MyCleverClassLoader myCleverClassLoader = new MyCleverClassLoader();

     …

     WebAppContext webapp = new WebAppContext();

     …

     webapp.setClassLoader(myCleverClassLoader);

 

     参考资料：

]]> http://www.longtask.com/blog/?feed=rss2&p=755 0 Google Guava V11 中的Cache操作 http://www.longtask.com/blog/?p=753 http://www.longtask.com/blog/?p=753#comments Thu, 05 Apr 2012 07:46:03 +0000 longhao http://www.longtask.com/blog/?p=753 More >]]> Google Guava cache的主要功能点：

    * 你需要给现有系统加速；
    * 有些key需要不知一次的查询获取；
    * 从策略上讲，你的应用需要从策略上把所有的value从cache中清理出来 — 你试图减少重复的工作；[注：weakKey , weakValue]
    * cache仅仅存储在内存中，没有在文件中或者其他的server上面，如果不满足你的需求，可以考虑Memcached

API的两种调用方式

1：普通的调用方式，通过key得到value的时间较短

 /**
       * 不需要延迟处理(泛型的方式封装)
       * @return
       */
      public static <K , V> LoadingCache<K , V> cached(CacheLoader<K , V> cacheLoader) {
            LoadingCache<K , V> cache = CacheBuilder.newBuilder()
                        .maximumSize(10000)
                        .weakKeys()
                        .softValues()
                        .refreshAfterWrite(120, TimeUnit.SECONDS)
                        .expireAfterWrite(10, TimeUnit.MINUTES)
                        // .removalListener(RemovalListeners.asynchronous(listener,executor))
                        // .removalListener(MY_LISTENER)
                        .build(cacheLoader);
            return cache;
      }
      /**
       * 通过key获取value
       * 调用方式 commonCache.get(key) ; return String
       * @param key
       * @return
       * @throws Exception
       */
      public static LoadingCache<String , String> commonCache(final String key) throws Exception{
            return cached(new CacheLoader<String , String>(){
                  @Override
                  public String load(String key) throws Exception {
                        return null;
                  }
            });
      }

2：延迟加载的处理方式，通过key得到value的时间较长

/**
       * 对需要延迟处理的可以采用这个机制；(泛型的方式封装)
       * @param <K>
       * @param <V>
       * @param key
       * @param callable
       * @return V
       * @throws Exception
       */
      public static <K,V> Cache<K , V> callableCached(Callable<V> callable) throws Exception {
            Cache<K, V> cache = CacheBuilder.newBuilder()
                        .maximumSize(10000)
                        .expireAfterWrite(10, TimeUnit.MINUTES)
                        // .removalListener(RemovalListeners.asynchronous(listener,executor))
                        // .removalListener(MY_LISTENER)
                        // .weakKeys()
                        // .weakValues()
                        .build();
            return cache;
      }
      /**
       * 通过callable的方式获取value；
       * 调用方式 callableCache.get(key) ; return String
       * @param key
       * @return
       * @throws Exception
       */
      public static Cache<String , String> callableCache(final String key) throws Exception{
            return callableCached(new Callable<String>(){
                  @Override
                  public String call() throws Exception {
                        return null;
                  }
            });
      }

     回收的参数设置

    1. 大小的设置：CacheBuilder.maximumSize(long)  CacheBuilder.weigher(Weigher)  CacheBuilder.maxumumWeigher(long)
    2. 时间：expireAfterAccess(long, TimeUnit) expireAfterWrite(long, TimeUnit)
    3. 引用：CacheBuilder.weakKeys() CacheBuilder.weakValues()  CacheBuilder.softValues()
    4. 明确的删除：invalidate(key)  invalidateAll(keys)  invalidateAll()
    5. 删除监听器：CacheBuilder.removalListener(RemovalListener)

     refresh机制

    1. LoadingCache.refresh(K)  在生成新的value的时候，旧的value依然会被使用。
    2. CacheLoader.reload(K, V) 生成新的value过程中允许使用旧的value
    3. CacheBuilder.refreshAfterWrite(long, TimeUnit) 自动刷新cache

     未来要实现的功能

    1. 更多统计信息，通过Cache.stats()来获取统计类CacheStats，例如缓存命中率，缓存获取实践统计等
    2. asMap，把缓存动作一个ConcurrentMap

参考资料 ：http://code.google.com/p/guava-libraries/wiki/CachesExplained#Inserted_Directly  

]]> http://www.longtask.com/blog/?feed=rss2&p=753 0 Linux kernel 性能压力下的优化实践(V0.1) http://www.longtask.com/blog/?p=750 http://www.longtask.com/blog/?p=750#comments Sun, 01 Apr 2012 05:32:41 +0000 longhao http://www.longtask.com/blog/?p=750 More >]]>      做benchmark测试的过程中，总是会涉及到linux操作系统底层的设置导致无法充分利用机器的性能，在调试的过程中，不少资料没能和linux kernel版本对应上导致一些参数的设置错误。根据现有服务器的硬件条件和软件版本做相关优化，把一些实践的心得分享出来。

      Kernel version ： 2.6.32-71.el6.x86_64

      Cpu：Intel(R) Xeon(R) CPU    E5606  @ 2.13GHz

      Memory：8G

      Release notes ： v0.1  2012-03-31  句柄数  ， 网络参数

     问题1：句柄数的问题

    使用webbench在Linux下做varlish访问压力测试的时候，遇到Socket/File: Can’t open so many files的问题，原因是linux下所有的东西都是文件，包括socket接口，对于大量的网络连接，不仅仅消耗socket文件描述符，对于进程本身还打开相当多的文件，Linux的默认句柄数是1024。

解决方式：

修改/etc/security/limits.conf
     你的用户名  soft nofile 65535      ##ulimit -Sn
     你的用户名 hard nofile 65535      ##ulimit -Hn
unlimt -n 查看

参考资料：

  1. 通过ulimit改善系统性能

     问题2：网络参数

      使用ab或者webbench做压力测试，如果并发数开到1000的时候，无法完成测试。到晚上查看资料发现是linux网络参数设置。

解决方式：

[longhao@longhao etc]# vi /etc/sysctl.conf
在kernel2.6之前的添加项：
net.ipv4.netfilter.ip_conntrack_max = 655360
net.ipv4.netfilter.ip_conntrack_tcp_timeout_established = 180

kernel2.6之后的添加项：
net.nf_conntrack_max = 655360  # net.nf_conntrack_max = 655360 也可以
net.netfilter.nf_conntrack_tcp_timeout_established = 1200

[longhao@longhao etc]# sysctl -p /etc/sysctl.conf

如果报错：error: "net.nf_conntrack_max" is an unknown key 则需要使用modprobe载入ip_conntrack模块，lsmod查看模块已载入。
[longhao@longhao etc]# modprobe  ip_conntrack

后续说明：
     –CONNTRACK_MAX 允许的最大跟踪连接条目，是在内核内存中netfilter可以同时处理的“任务”（连接跟踪条目）
     –HASHSIZE 存储跟踪连接条目列表的哈西表的大小

CONNTRACK_MAX和HASHSIZE的默认值
      一般来说，CONNTRACK_MAX和HASHSIZE都会设置在“合理”使用的值上，依据可使用的RAM的大小来计算这个值。

CONNTRACK_MAX的默认值
     在i386架构上，CONNTRACK_MAX = RAMSIZE (以bytes记) / 16384 =RAMSIZE (以MegaBytes记) * 64，因此，一个32位的带512M内存的PC在默认情况下能够处理512*1024^2/16384 = 512*64 = 32768个并发的netfilter连接。
     但是真正的公式是：CONNTRACK_MAX = RAMSIZE (in bytes) / 16384 / (x / 32) 这里x是指针的bit数，（例如，32或者64bit）

请注意：
     －默认的CONNTRACK_MAX值不会低于128
     －对于带有超过1G内存的系统，CONNTRACK_MAX的默认值会被限制在65536（但是可以手工设置成更大的值）

HASHSIZE的默认值
     通常，CONNTRACK_MAX = HASHSIZE * 8。这意味着每个链接的列表平均包含8个conntrack的条目（在优化的情况并且CONNTRACK_MAX达到的情况下），每个链接的列表就是一个哈西表条目（一个桶）。
     在i386架构上，HASHSIZE = CONNTRACK_MAX / 8 =RAMSIZE (以bytes记) / 131072 = RAMSIZE (以MegaBytes记) * 8。举例来说，一个32位、带512M内存的PC可以存储512*1024^2/128/1024 =512*8 = 4096 个桶（链接表）
     但是真正的公式是：HASHSIZE = CONNTRACK_MAX / 8 = RAMSIZE (以bytes记) / 131072 / (x / 32)这里x是指针的bit数，（例如，32或者64bit）

请注意：
     －默认HASHSIZE的值不会小于16
     －对于带有超过1G内存的系统，HASHSIZE的默认值会被限制在8192（但是可以手工设置成更大的值）

参考资料：

  1. Conntrack tuning
  2. kernel nf_conntrack: table full, dropping packet 解决办法
  3. 不要盲目增加ip_conntrack_max-理解Linux内核内存

]]> http://www.longtask.com/blog/?feed=rss2&p=750 0 DelayQueue在容错时的使用 http://www.longtask.com/blog/?p=748 http://www.longtask.com/blog/?p=748#comments Wed, 14 Mar 2012 05:08:59 +0000 longhao http://www.longtask.com/blog/?p=748 More >]]>      1：异步容错的处理需求

     遇到错误消息后，把消息写入到表中同时写入到queue中，把这个错误的内容异步通知到其他系统中去。同步的时间间隔以2的N次方递增，设计的前提是尽量减小数据库的压力。

     2：设计

      java.util.concurrent.DelayQueue中的对象必须实现java.util.concurrent.Delayed的接口，Delayed 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部 是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部，并且 poll 将返回 null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于等于 0 的值时，将发生到期。即使无法使用 take 或 poll 移除未到期的元素，也不会将这些元素作为正常元素对待。例如，size 方法同时返回到期和未到期元素的计数。此队列不允许使用 null 元素。 

    队列中的对象设计：

public class DelayDomain implements Delayed{

      /**

       * 处理机制：按照发送次数2的N次方秒递增。

       * @param payInternalNotify

       */

      public DelayDomain(int sendtime , String url){

            this.sendTime = (new Date()).getTime() +  (long)Math.pow(2, sendtime) * TIME_UNIT;

            this.url = url;

      }      

      @Override

      public int compareTo(Delayed obj) {

            DelayDomain delayDomain = (DelayDomain)obj;

            long timeout = sendTime – delayDomain.sendTime;

        return timeout > 0 ? 1 : timeout < 0 ? -1 : 0;

      }

      @Override

      public long getDelay(TimeUnit unit) {

            return sendTime – System.currentTimeMillis(); 

      }

      

      private static final int TIME_UNIT = 1000 ; //按照秒来递增

      private long sendTime ;

      private String url ;

      public String getUrl() {

            return url;

      }     

}

     Queue的代码：

     public class SendQueue {

      public static void put(DelayDomain DelayDomain)

            throws InterruptedException{

            QUEUE.put(DelayDomain);

      }

      public static DelayDomain take()throws InterruptedException{

            return QUEUE.take();

      }     

      /**

       * 添加错误消息到队列中,

       * @param payInternalNotify

       */

      public static void addSendUrl(int sendTime , String url)

            throws InterruptedException{

            DelayDomain DelayDomain = new DelayDomain(sendTime , url);

            put(DelayDomain);

      }  

      private SendQueue(){};

      //服务队列

      private static final BlockingQueue<DelayDomain> QUEUE =  new DelayQueue<DelayDomain>();

   }

     测试代码：

     public class DelayMain {

      public static void main(String[] args) throws Exception{

            System.out.println("Start time @ " + getNow());

            SendQueue.addSendUrl(2 , "www.baidu.com");

            SendQueue.addSendUrl(1 , "www.google.com");

            SendQueue.addSendUrl(3 , "www.hao123.com");

            while(true){

                  DelayDomain domain = SendQueue.take();

                  System.out.println(domain.getUrl() + " @ " + getNow());

            }

      }      

      private static String getNow(){

            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");

            return sdf.format(new Date());

      }

   }

     输出结果：

     Start time : 11:20:21

     www.google.com @ 11:20:23

     www.baidu.com @ 11:20:25

     www.hao123.com @ 11:20:29

    我们看到google在2秒后出队列，百度的4秒，hao123的8秒。放到队列中会自动按照时间顺序来排序，只有时间到了才会被take出队列，否则一直等待。

 

     3：设计缺点

    修改数据库状态不能自动同步了。需要通过脚本来执行一些过期的内容，或者通过接口方式处罚容错。

]]> http://www.longtask.com/blog/?feed=rss2&p=748 0 Spring的RMI , Http Invoker, Hessian测试结果 http://www.longtask.com/blog/?p=742 http://www.longtask.com/blog/?p=742#comments Tue, 06 Mar 2012 12:12:23 +0000 longhao http://www.longtask.com/blog/?p=742 More >]]>      RMI配置说明：

1：对象序列化：

public class Account implements Serializable{

    private String name;

    public String getName(){

        return name;

    }

    public void setName(String name) {

      this.name = name;

    }

}

2：远程接口定义：

public interface RemoteCallExample extends Remote {

      public String show() throws RemoteException;

}

3：远程接口实现：

public class RemoteCallExampleImpl implements RemoteCallExample {

      @Override

      public String show() throws RemoteException{

            return "remote test";

      }

}

4：Spring服务器端配置（使用RmiServiceExporter来）：

在WEB-INF目录下面新建remoting-servlet.xml文件，添加相关的配置。

<bean name="remoteCallExample" class="com.hqb360.pay.service.impl.RemoteCallExampleImpl" />

<bean class="org.springframework.remoting.rmi.RmiServiceExporter">

          <!– does not necessarily have to be the same name as the bean to be exported –>

          <property name="serviceName" value="remoteCallExample"/>

          <property name="service" ref="remoteCallExample"/>

          <property name="serviceInterface" value="com.hqb360.pay.service.RemoteCallExample"/>

          <!– defaults to 1099 –>

          <property name="registryPort" value="1199"/>

</bean>

5：服务器端类

public class RemoteCallRMI{

      public String show() throws RemoteException{

            return remoteCallExample.show();

      }    

      private RemoteCallExample remoteCallExample;

      public RemoteCallExample getRemoteCallExample() {

            return remoteCallExample;

      }

      public void setRemoteCallExample(RemoteCallExample remoteCallExample) {

            this.remoteCallExample = remoteCallExample;

      }

}

6：服务器端配置

<bean name="remoteCallRMI" class="com.hqb360.pay.service.impl.RemoteCallRMI" >

            <property name="remoteCallExample" ref="remoteCall" />

</bean>

<bean id="remoteCall" class="org.springframework.remoting.rmi.RmiProxyFactoryBean">

          <property name="serviceUrl" value="rmi://192.168.100.10:1199/remoteCallExample"/>

          <property name="serviceInterface" value="com.hqb360.pay.service.RemoteCallExample"/>

</bean>

     一些RMI问题说明：

1. RMI在启动配置中需要添加：-Djava.rmi.server.hostname=192.168.100.10

2. 需要制定相关的具体IP，把读取配置文件放到系统启动的时候处理。

Spring3.0后默认的HandlerMapping是DefaultAnnotationHandlerMapping，不是以前的BeanNameUrlHandlerMapping，所以配置Hessian和HttpInvoker的时候需要重新定义一下HandlerMapping.

在按照spring手册配置的时候需要添加定义（Spring文档有遗漏的地方）：

<!–Hessian 启动BeanNameMapping 映射功能,以httpRequest作为处理Adapter–>

    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">

        <property name="defaultHandler" ref="httpRequestHandlerAdapter" />

    </bean>

    <!– Hessian 方式以Http进行传递 –>

    <bean id="httpRequestHandlerAdapter" class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter" />

     测试结果

测试性能：RMI > Hessian > Http Invoker

数据图表如下：

RMI

RMI并发测试（线程池大小：5，线程数：5）

[TestRunner] Starting executor timeOut:1000000ms workers:5 threadPoolSize:5

0 [5,880ms, 100%]

0 [5,881ms, 100%]

0 [5,977ms, 100%]

0 [5,978ms, 100%]

0 [5,989ms, 100%]

RemoteTestNG finishing: 8318 ms

RMI并发测试（线程池大小：5，线程数：10）

[TestRunner] Starting executor timeOut:1000000ms workers:10 threadPoolSize:5

0 [5,843ms, 100%]

0 [5,856ms, 100%]

0 [5,864ms, 100%]

0 [5,967ms, 100%]

0 [5,970ms, 100%]

0 [5,795ms, 100%]

0 [5,810ms, 100%]

0 [5,812ms, 100%]

0 [5,891ms, 100%]

0 [5,935ms, 100%]

RemoteTestNG finishing: 14194 ms

Httpinvoker

并发测试（线程池大小：5，线程数：5）

[TestRunner] Starting executor timeOut:100000ms workers:5 threadPoolSize:5

0 [24,350ms, 100%]

0 [25,384ms, 100%]

0 [27,601ms, 100%]

0 [27,700ms, 100%]

0 [29,443ms, 100%]

RemoteTestNG finishing: 31737 ms

并发测试（线程池大小：5，线程数：10）

[TestRunner] Starting executor timeOut:1000000ms workers:10 threadPoolSize:5

0 [26,519ms, 100%]

0 [26,637ms, 100%]

0 [28,365ms, 100%]

0 [29,744ms, 100%]

0 [29,821ms, 100%]

0 [28,433ms, 100%]

0 [29,914ms, 100%]

0 [31,795ms, 100%]

0 [28,959ms, 100%]

0 [29,407ms, 100%]

RemoteTestNG finishing: 61477 ms

hessian测试结果

并发测试（线程池大小：5，线程数：5）

[TestRunner] Starting executor timeOut:100000ms workers:5 threadPoolSize:5

0 [13,343ms, 100%]

0 [13,957ms, 100%]

0 [14,544ms, 100%]

0 [14,612ms, 100%]

0 [14,822ms, 100%]

RemoteTestNG finishing: 17133 ms

并发测试（线程池大小：5，线程数：10）

[TestRunner] Starting executor timeOut:100000ms workers:10 threadPoolSize:5

0 [13,407ms, 100%]

0 [14,058ms, 100%]

0 [14,271ms, 100%]

0 [14,293ms, 100%]

0 [18,198ms, 100%]

0 [14,496ms, 100%]

0 [15,128ms, 100%]

0 [16,478ms, 100%]

0 [17,680ms, 100%]

0 [17,317ms, 100%]

RemoteTestNG finishing: 37844 ms

 

需要测试代码的联系：longtask@gmail.com

]]> http://www.longtask.com/blog/?feed=rss2&p=742 1 并发编程实践PPT http://www.longtask.com/blog/?p=740 http://www.longtask.com/blog/?p=740#comments Thu, 01 Mar 2012 05:40:40 +0000 longhao http://www.longtask.com/blog/?p=740     一年多前写的ppt，拿出了和大家分享。自己也顺便回忆一下里面的内容

Java并发编程培训

View more presentations from longhao.
]]> http://www.longtask.com/blog/?feed=rss2&p=740 1