HSF和Dubbo有什么区别
2017-11-25 15:15
344 查看
一、
以下摘录自企业级分布式应用服务EDAS官网段落
RPC服务
提供对Dubbo和HSF两个RPC框架的支持。阿里巴巴第一代RPC框架Dubbo是国内第一款成熟的商用级RPC框架，已于2011年正式对外开源，目前已发展成为国内开源价值最高、用户使用规模最大的开源软件之一。最新一代RPC框架HSF，全称High Speed Framework，也叫"好舒服"，"很舒服"框架，是阿里内部对这一款高性能服务框架的昵称，是一款面向企业级互联网架构量身定制的分布式服务框架。HSF以高性能网络通信框架为基础，提供了诸如服务发布与注册，服务调用，服务路由，服务鉴权，服务限流，服务降级和服务调用链路跟踪等一系列久经考验的功能特性。
来源：企业级分布式应用服务EDAS_企业云计算解决方案
二、
今天没什么事，简单测试下RPC框架性能： HSF完胜dubbo
1.dubbo测试结果:
note:
dubbo测试时有使用ZooKeeper,所以存在不公平性，不一定准确。
同步模型
耗时：16.808 s
平均:0.16808 ms
TPS:5949.547834364588
测试数据：
Java代码
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.305 s
平均:0.06305 ms
TPS:15860.428231562253
测试数据：
Java代码
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.446 s
平均:0.09446 ms
TPS:10586.491636671608
Java代码
//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));
}
以下摘录自企业级分布式应用服务EDAS官网段落
RPC服务
提供对Dubbo和HSF两个RPC框架的支持。阿里巴巴第一代RPC框架Dubbo是国内第一款成熟的商用级RPC框架，已于2011年正式对外开源，目前已发展成为国内开源价值最高、用户使用规模最大的开源软件之一。最新一代RPC框架HSF，全称High Speed Framework，也叫"好舒服"，"很舒服"框架，是阿里内部对这一款高性能服务框架的昵称，是一款面向企业级互联网架构量身定制的分布式服务框架。HSF以高性能网络通信框架为基础，提供了诸如服务发布与注册，服务调用，服务路由，服务鉴权，服务限流，服务降级和服务调用链路跟踪等一系列久经考验的功能特性。
来源：企业级分布式应用服务EDAS_企业云计算解决方案
二、
dubbo和S-HSF测试对比
今天没什么事，简单测试下RPC框架性能： HSF完胜dubbo
1.dubbo测试结果:
note:
dubbo测试时有使用ZooKeeper,所以存在不公平性，不一定准确。
同步模型
耗时：16.808 s
平均:0.16808 ms
TPS:5949.547834364588
测试数据：
Java代码
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.305 s
平均:0.06305 ms
TPS:15860.428231562253
测试数据：
Java代码
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.446 s
平均:0.09446 ms
TPS:10586.491636671608
Java代码
//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));
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- HSF和Dubbo有什么区别
- HSF和Dubbo有什么区别
- HSF和Dubbo有什么区别
- HSF和dubbo的区别
- Dubbo&hsf&Spring-cloud的区别
- static 静态方法 有什么优缺点 PHP中静态方法(static)与非静态方法的使用及区别
- 什么是模块，模块和应用程序的区别，模块的好处
- 对象.和对象[]有什么区别
- 脚本和脚本包有什么区别？
- Java - MyBatis中使用#和$书写占位符有什么区别？
- 机器学习中的目标函数、损失函数、代价函数有什么区别？
- px、dp和sp，这些单位有什么区别？
- 请问在JAVA中Map和HashMap有什么区别?
- javascript:; 和 javascript:void(0); 的区别是什么？
- foo()和@foo()之间有什么区别？
- WEB应用防火墙与数据库应用防火墙有什么区别
- UML中多重度0..*和*有什么区别
- 接口和抽象类有什么区别？
- 接口和抽象类有什么区别