dubbo和S-HSF测试对比

今天没什么事，简单测试下RPC框架性能：HSF完胜dubbo

1.dubbo测试结果:

note:

dubbo测试时有使用ZooKeeper,所以存在不公平性，不一定准确。

同步模型

耗时：16.808s

平均:0.16808ms

TPS:5949.547834364588

测试数据：

public class TPS_TEST {

    public static void main(String[] args) throws InterruptedException {
    	final ClassPathXmlApplicationContext context = 
    			new ClassPathXmlApplicationContext(
    					new String[] {"file:E:/1-project_test/dubbox-master/dubbo-demo/dubbo-demo-consumer/src/main/resources/META-INF/spring/dubbo-demo-consumer.xml"});
		final HelloService helloService = (HelloService)context.getBean("helloService"); // get service invocation proxy
    	ExecutorService executorServicePool = Executors.newFixedThreadPool(200);
    	final int size = 100000;
    	final CountDownLatch cdl = new CountDownLatch(size);
    	long begin = System.currentTimeMillis();
		for (int i = 0; i < size; i++) {
			executorServicePool.execute(new Runnable() {
				@Override
				public void run() {
					try {
						
						String hello = helloService.hello("aa"); // do invoke!
						//System.out.println( hello ); // cool, how are you~
				        cdl.countDown();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			});
		}
		//executorServicePool.shutdown();
		//executorService.awaitTermination(10, TimeUnit.MINUTES);
		cdl.await();//等待所有任务处理完
        long time = System.currentTimeMillis() - begin;
        System.out.println("耗时：" + (double) time / 1000 + " s");
        System.out.println("平均:" + ((double) time) / size +" ms");
        System.out.println("TPS:" + (double) size / ((double) time / 1000));              
   
    
    }

   
}

2.hsf测试结果：

异步模型：

耗时：6.305s

平均:0.06305ms

TPS:15860.428231562253

测试数据：

public class Client {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		final int size = 100000;
		final CountDownLatch cdl = new CountDownLatch(size);

		// final TestService testService = ServiceProxyFactory.getRoundFactoryInstance(connector).wrapAsyncProxy(
		// TestService.class);
		
		HsfConnector connector = new HsfConnectorImpl();
		connector.connect(new InetSocketAddress("localhost", 8082));
		
		
		final TestService testService = ServiceProxyFactory.getRoundFactoryInstance(connector).wrapAsyncCallbackProxy(
				TestService.class, new AsyncCallback<Object>() {
					public void doCallback(Object data) {
						//System.out.println("received:" + data);
						cdl.countDown();
					};
					@Override
					public void doExceptionCaught(Throwable ex, HsfChannel channel, Object param) {
						System.out.println(ex);
						super.doExceptionCaught(ex, channel, param);
					}
				});
		ExecutorService executorServicePool = Executors.newFixedThreadPool(200);
		long begin = System.currentTimeMillis();
		for (int i = 0; i < size; i++) {
			executorServicePool.execute(new Runnable() {
				@Override
				public void run() {
					try {
						testService.test("aa");
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			});
		}
		//executorServicePool.shutdown();
		//executorService.awaitTermination(10, TimeUnit.MINUTES);
		cdl.await();//等待所有任务处理完
        long time = System.currentTimeMillis() - begin;
        System.out.println("耗时：" + (double) time / 1000 + " s");
        System.out.println("平均:" + ((double) time) / size +" ms");
        System.out.println("TPS:" + (double) size / ((double) time / 1000));
        
	}

}

同步模型：

耗时：9.446s

平均:0.09446ms

TPS:10586.491636671608

//tips:
//模拟HSF的同步模型：在10万个并发线程发送数据时有时候比异步模型还要快，这点有点想不通,估计是我测试的服务是直接return的场景吧。

/**
 * @Title: Client.java
 * @Description: TODO(添加描述)
 * @date 2012-2-23 上午01:01:33
 * @version V1.0
 */
public class Client2 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		 final int size = 100000;  
	     final CountDownLatch cdl = new CountDownLatch(size);   
	     HsfConnector connector = new HsfConnectorImpl();  
	     connector.connect(new InetSocketAddress("10.118.63.12", 10223));  
	          
	          
        /*
         final TestService testService = ServiceProxyFactory.getRoundFactoryInstance(connector).wrapAsyncCallbackProxy(  
                TestService.class, new AsyncCallback<Object>() {  
                    public void doCallback(Object data) {  
                        //System.out.println("received:" + data);  
                        cdl.countDown();  
                    };  
                    @Override  
                    public void doExceptionCaught(Throwable ex, HsfChannel channel, Object param) {  
                        System.out.println(ex);  
                        super.doExceptionCaught(ex, channel, param);  
                    }  
                });  
		 ExecutorService executorServicePool = Executors.newFixedThreadPool(200);  
		        long begin = System.currentTimeMillis();  
		        for (int i = 0; i < size; i++) {  
		            executorServicePool.execute(new Runnable() {  
		                @Override  
		                public void run() {  
		                    try {  
		                        testService.test("aa");  
		                    } catch (Exception e) {  
		                        e.printStackTrace();  
		                    }  
		                }  
		            });  
		        } 
		        
          */
	     
	     final TestService testService = ServiceProxyFactory.getRoundFactoryInstance(connector).wrapSyncProxy(  
	 	        TestService.class); 
	     
        ExecutorService executorServicePool = Executors.newFixedThreadPool(200);  
        long begin = System.currentTimeMillis();  
        for (int i = 0; i < size; i++) {  
            executorServicePool.execute(new Runnable() {  
                @Override  
                public void run() {  
                    try {  
                        String hello = testService.test("aa");  
                        cdl.countDown();  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                }  
            });  
        }  
        //executorServicePool.shutdown();  
        //executorService.awaitTermination(10, TimeUnit.MINUTES);  
        cdl.await();//等待所有任务处理完  
        long time = System.currentTimeMillis() - begin;  
        System.out.println("耗时：" + (double) time / 1000 + " s");  
        System.out.println("平均:" + ((double) time) / size +" ms");  
        System.out.println("TPS:" + (double) size / ((double) time / 1000)); 
	
	}