关闭

Linux下消息队列和socket绝对速度比拼

184人阅读 评论(0) 收藏 举报
分类:

http://nanjingjiangbiao-t.iteye.com/blog/1793644

在当今的网络时代,我们常常见到的进程间通信方式都是socket,比如Java的EJB调用,Java和C通信,Web Service服务等。socket是最常用的通讯技术,几乎所有的系统、语言都支持,socket也是面向网络的,通信的两方可以跨越IP网络进行传输。

在本地通信中(同一台机器上的进程间通讯),socket的网络特性却成了累赘,组装解析网络报头、报文确认、CRC校验等都是针对网络的,本地通信没有必要,反而会影响传输效率。本地通信的一些传统技术,如管道、FIFO、消息队列等,没有网络功能的负担,传输速度应该高于socket,那到底高多少以至于值得在应用中替换socket技术呢,今天就来一场小测试,就System V消息队列和socket之间,做一次全面的速度比拼。

比拼场地

本人的笔记本:赛扬1.5G 内存1.5G
系统:Ubuntu8.04 Desktop (Linux 2.6.24-24-generic)
JDK:1.6

第一回合: Java测试

先说明一下,Java并不支持System V消息队列,因此特为Java提供了JNI接口,我们使用lajp_9.09提供C源码编译的so动态连接库,lajp的下载地址和文档:http://code.google.com/p/lajp/

首先上场的是System V消息队列。

发送端程序:

  1. package test;
  2. import lajp.MsgQ;
  3. public class TestSend
  4. {
  5. /** 消息队列KEY */
  6. static final int IPC_KEY = 0×20021230;
  7. static
  8. {
  9. //JNI
  10.  System.loadLibrary("lajpmsgq");
  11. }
  12. public static void main(String[] args)
  13. {
  14. //创建或获得现有的消息队列
  15. int msqid = MsgQ.msgget(IPC_KEY);
  16. //发送字节数组
  17. byte[] msg = new byte[1024];
  18. for (int i = 0; i < 1024 * 5000; i++)
  19. {
  20. //每次发送1204字节到消息队列,9527是消息类型
  21. MsgQ.msgsnd(msqid, 9527, msg, msg.length);
  22. }
  23.  System.out.println("发送结束.");
  24. }
  25. }

接收端程序:

  1. package test;
  2. import lajp.MsgQ;
  3. public class TestRcv
  4. {
  5. /** 消息队列KEY */
  6. static final int IPC_KEY = 0×20021230;
  7. static
  8. {
  9. //JNI
  10.  System.loadLibrary("lajpmsgq");
  11. }
  12. public static void main(String[] args)
  13. {
  14. //创建或获得现有的消息队列
  15. int msqid = MsgQ.msgget(IPC_KEY);
  16. //接收缓冲区
  17. byte[] msg = new byte[1024];
  18. long start = System.currentTimeMillis()//开始时间
  19. for (int i = 0; i < 1024 * 5000; i++)
  20. {
  21. //每次从消息队列中接收消息类型为9527的消息,接收1204字节
  22. MsgQ.msgrcv(msqid, msg, msg.length9527);
  23. }
  24. long end = System.currentTimeMillis()//结束时间
  25.  System.out.println("用时:" + (end – start) + "毫秒");
  26. }
  27. }

程序很简单,需要说明的是三个JNI方法调用:

msgget()方法: System V消息队列的技术要求,含义是通过一个指定的KEY获得消息队列标识符。
msgsnd()方法: 发送。
msgrcv()方法: 接收。

发送方进行了(1024 * 5000)次发送,每次发送1024字节数据,接收方进行了(1024 * 5000)次接收,每次接收1024字节,共计发送接收5G数据。测试时先启动TestSend程序,再启动TestRcv程序,共进行5轮次测试,测试结果如下:

用时:29846毫秒
用时:29591毫秒
用时:29935毫秒
用时:29730毫秒
用时:29468毫秒
平均速度:29714毫秒

用top命令监控测试期间的CPU、内存的使用:

java_msgq

接下来上场的是socket。

发送端程序:

  1. import java.io.IOException;
  2. import java.io.OutputStream;
  3. import java.net.Socket;
  4. public class SocketSend
  5. {
  6. public static void main(String[] args) throws IOException
  7. {
  8. //Socket
  9.  Socket socket = new Socket("127.0.0.1"9527);
  10. //输出流
  11.  OutputStream out = socket.getOutputStream();
  12. //发送字节数组
  13. byte[] msg = new byte[1024];
  14. long start = System.currentTimeMillis()//开始时间
  15. for (int i = 0; i < 1024 * 5000; i++)
  16. {
  17. //发送
  18. out.write(msg);
  19. }
  20. long end = System.currentTimeMillis()//结束时间
  21.  System.out.println("用时:" + (end – start) + "毫秒");
  22. }
  23. }

接收端程序:

  1. import java.io.IOException;
  2. import java.io.InputStream;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  5. public class SocketRecv
  6. {
  7. public static void main(String[] args) throws IOException
  8. {
  9. //侦听9527端口
  10.  ServerSocket serverSocket = new ServerSocket(9527);
  11. //Socket
  12.  Socket socket = serverSocket.accept();
  13. //输入流
  14.  InputStream in = socket.getInputStream();
  15. //接收缓冲区
  16. byte[] msg = new byte[1024];
  17. for (int i = 0; i < 1024 * 5000; i++)
  18. {
  19. //每次接收1204字节
  20. in.read(msg);
  21. }
  22.  System.out.println("接受结束.");
  23. }
  24. }

程序同样很简单,同样发送接收了(1024 * 5000)次,同样5G数据,socket程序必须先启动服务方SocketRecv,然后启动客户方SocketSend,共进行5轮次测试,测试结果如下:

用时:33951毫秒
用时:33448毫秒
用时:33987毫秒
用时:34638毫秒
用时:33957毫秒
平均速度:33996.2毫秒

用top命令监控测试期间的CPU、内存的使用:

java_socket

测试结果让人对消息队列有点失望,性能优势微弱大约只领先了13%,且程序复杂性要大的多(使用了JNI)。不过重新审视测试过程有一个疑问:消息队列程序调用了自定义的JNI接口,而socket是Java内嵌的功能,是否JVM对 socket有特殊的优化呢?

怀着这个疑问,进行第二场纯C程序的测试。

第二回合: C程序测试

首先上场的还是System V消息队列。

发送端程序:

  1. #include <sys/ipc.h>
  2. #include <sys/msg.h>
  3. #include <stdio.h>
  4. #define IPC_KEY 0×20021230 /* 消息队列KEY */
  5. /*消息结构*/
  6. struct message
  7. {
  8. long msg_type; /* 消息标识符 */
  9. char msg_text[1024]/* 消息内容 */
  10. };
  11. int main()
  12. {
  13. /* 创建或获得现有的消息队列 */
  14. int msqid = msgget(IPC_KEY, IPC_CREAT | 0666);
  15. /* 消息结构 */
  16. struct message msgq;
  17. msgq.msg_type = 9527/* 消息类型 */
  18. int i;
  19. for (i = 0; i < 1024 * 5000; i++)
  20. {
  21. /* 接收 */
  22. msgsnd(msqid, &msgq, 10240);
  23. }
  24.  printf("msgq发送结束,共发送%d次\n", i);
  25. return 0;
  26. }

接收端程序:

  1. #include <sys/ipc.h>
  2. #include <sys/msg.h>
  3. #include <stdio.h>
  4. #define IPC_KEY 0×20021230 /* 消息队列KEY */
  5. /*消息结构*/
  6. struct message
  7. {
  8. long msg_type; /* 消息标识符 */
  9. char msg_text[1024]/* 消息内容 */
  10. };
  11. int main()
  12. {
  13. /* 创建或获得现有的消息队列 */
  14. int msqid = msgget(IPC_KEY, IPC_CREAT | 0666);
  15. /* 消息结构 */
  16. struct message msgq;
  17. int i;
  18. for (i = 0; i < 1024 * 5000; i++)
  19. {
  20. /* 接收 */
  21. msgrcv(msqid, &msgq, 102495270);
  22. }
  23.  printf("msgq接收结束,共接收%d次\n", i);
  24. return 0;
  25. }

和第一场一样,发送接收了(1024 * 5000)次,同样5G数据,先启动接收端程序msgrecv,然后以$time msgsend方式启动客户端程序,共进行5轮次测试,time的测试结果如下:

用户 系统 时钟
第一次: 0.992s 7.084s 18.202s
第二次: 0.888s 7.280s 18.815s
第三次: 1.060s 7.656s 19.476s
第四次: 1.048s 7.124s 20.293s
第五次: 1.008s 7.160s 18.655s

用top命令监控测试期间的CPU、内存的使用:

c_msgq

接下来上场的是socket。

发送端程序:

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <netdb.h>
  4. char msg[1024]/* 发送消息 */
  5. int main()
  6. {
  7. char *ip = "127.0.0.1"/* 发送地址 */
  8. int port = 9527/* 发送端口 */
  9. struct hostent *server_host = gethostbyname(ip);
  10. /* 客户端填充 sockaddr 结构 */
  11. struct sockaddr_in client_addr; /* 客户端地址结构 */
  12. bzero(&client_addr, sizeof(client_addr));
  13. client_addr.sin_family = AF_INET; /* AF_INET:IPV4协议 */
  14. client_addr.sin_addr.s_addr = ((struct in_addr *)(server_host->h_addr))->s_addr; /* 服务端地址 */
  15. client_addr.sin_port = htons(port)/* 端口 */
  16. /* 建立socket */
  17. int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  18. /* 连接 */
  19. connect(sockfd, (struct sockaddr *)(&client_addr)sizeof(client_addr));
  20. int i;
  21. for (i = 0; i < 1024 * 5000; i++)
  22. {
  23. /* 发送 */
  24. send(sockfd, msg, 10240);
  25. }
  26.  printf("发送结束,共发送%d次\n", i);
  27. return 0;
  28. }

接收端程序:

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <netdb.h>
  4. char msg[1024]/* 接收缓冲区 */
  5. int main()
  6. {
  7. int listen_port = 9527/* 侦听端口 */
  8. int listenfd = socket(AF_INET, SOCK_STREAM, 0)/* 建立侦听socket */
  9. /* 服务端填充 sockaddr 结构 */
  10. struct sockaddr_in server_addr; /* 服务端地址结构 */
  11. bzero(&server_addr, sizeof(server_addr));
  12. server_addr.sin_family = AF_INET; /* AF_INET:IPV4协议 */
  13. server_addr.sin_addr.s_addr = htonl(INADDR_ANY)/* INADDR_ANY:通配地址,表示内核选择IP地址 */
  14. server_addr.sin_port = htons(listen_port)/* 端口 */
  15. /* 绑定端口 */
  16. bind(listenfd, (struct sockaddr *)(&server_addr)sizeof(server_addr));
  17. /* 侦听 */
  18. listen(listenfd, 5);
  19. int sockfd = accept(listenfd, NULLNULL);
  20. int i;
  21. for (i = 0; i < 1024 * 5000; i++)
  22. {
  23. /* 接收 */
  24. recv(sockfd, msg, 10240);
  25. }
  26.  printf("接收结束,共接收%d次\n", i);
  27. return 0;
  28. }

C语言中,socket程序复杂了不少。测试标准和Java相同,发送接收了(1024 * 5000)次,5G数据,先启动接收端程序,然后以time方式启动发送端,测试结果如下:

用户 系统 时钟
第一次: 0.524s 9.765s 20.666s
第二次: 0.492s 9.825s 20.530s
第三次: 0.468s 9.493s 21.831s
第四次: 0.512s 9.205s 20.059s
第五次: 0.440s 9.605s 21.888s

用top命令监控测试期间的CPU、内存的使用:

c_socket

C语言的socket程序系统用时多一些,消息队列程序用户用时多一些,这和他们的实现方式相关,从时钟比较看,消息队列比socket快10%左右,和Java测试结果相似。比较Java和C,C只领先了三分之一,看来当前的Java效率已经相当高了。

还不能忙于下结论,socket的通信方式一般有两种:长连接和短连接。长连接指发送端和接收端建立连接后,可以保持socket通道进行多次消息传输,在这种场景基本不用计算socket建立和关闭的时间,前面的测试都是基于长连接方式;短连接一般在建立socket通道后,只进行一次通信,然后就关闭 socket通道,这种场景必须考虑socket建立和关闭的时间(socket建立连接需要三次握手,关闭连接要四次通信)。

第三回合: Java测试(短连接)

将第一回合中的Java程序稍作修改,先看socket的:

发送端程序:

  1. import java.io.IOException;
  2. import java.io.OutputStream;
  3. import java.net.Socket;
  4. public class SocketSend2
  5. {
  6. public static void main(String[] args) throws IOException
  7. {
  8. long start = System.currentTimeMillis()//开始时间
  9. //发送字节数组
  10. byte[] msg = new byte[1024];
  11. for (int i = 0; i < 1024 * 1000; i++)
  12. {
  13. //建立Socket连接
  14.  Socket socket = new Socket("127.0.0.1"9527);
  15. //输出流
  16.  OutputStream out = socket.getOutputStream();
  17. //发送
  18. out.write(msg);
  19. //关闭输出流
  20. out.close();
  21. //关闭socket连接
  22. socket.close();
  23. }
  24. long end = System.currentTimeMillis()//结束时间
  25.  System.out.println("用时:" + (end – start) + "毫秒");
  26. }
  27. }

建立socket的语句放在了循环内部,这样每次发送都是新建的连接,025行的关闭语句是必须的,因为socket是系统的有限资源,支持不了这么大规模的申请。

接收端程序:

  1. import java.io.IOException;
  2. import java.io.InputStream;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  5. public class SocketRecv2
  6. {
  7. public static void main(String[] args) throws IOException
  8. {
  9. //侦听9527端口
  10.  ServerSocket serverSocket = new ServerSocket(9527);
  11. //接收缓冲区
  12. byte[] msg = new byte[1024];
  13. for (int i = 0; i < 1024 * 1000; i++)
  14. {
  15. //接到客户端Socket连接请求
  16.  Socket socket = serverSocket.accept();
  17. //输入流
  18.  InputStream in = socket.getInputStream();
  19. //每次接收1204字节
  20. in.read(msg);
  21. //关闭输入流
  22. in.close();
  23. //关闭socket连接
  24. socket.close();
  25. }
  26.  System.out.println("接受结束.");
  27. }
  28. }

接收端也做了相应的改动,发送和接收次数降低到(1024 * 1000)次,测试结果:431280毫秒,不要吃惊,没错是431.280秒,这也是书本上为什么总在强调使用数据库连接池的原因。

消息队列没有像socket那样的连接概念,为了做个参考,将第一回合中的消息队列程序也修改一下:

发送端程序:

  1. package test;
  2. import lajp.MsgQ;
  3. public class TestSend2
  4. {
  5. /** 消息队列KEY */
  6. static final int IPC_KEY = 0×20021230;
  7. static
  8. {
  9. //JNI
  10.  System.loadLibrary("lajpmsgq");
  11. }
  12. public static void main(String[] args)
  13. {
  14. //发送字节数组
  15. byte[] msg = new byte[1024];
  16. for (int i = 0; i < 1024 * 1000; i++)
  17. {
  18. //创建或获得现有的消息队列
  19. int msqid = MsgQ.msgget(IPC_KEY);
  20. //每次发送1204字节
  21. MsgQ.msgsnd(msqid, 9527, msg, msg.length);
  22. }
  23.  System.out.println("发送结束.");
  24. }
  25. }

将024行的msgget()方法放在循环内部,作为和socket比较的“连接”。

接收段程序:

  1. package test;
  2. import lajp.MsgQ;
  3. public class TestRcv2
  4. {
  5. /** 消息队列KEY */
  6. static final int IPC_KEY = 0×20021230;
  7. static
  8. {
  9. //JNI
  10.  System.loadLibrary("lajpmsgq");
  11. }
  12. public static void main(String[] args)
  13. {
  14. long start = System.currentTimeMillis()//开始时间
  15. //接收缓冲区
  16. byte[] msg = new byte[1024];
  17. for (int i = 0; i < 1024 * 1000; i++)
  18. {
  19. //创建或获得现有的消息队列
  20. int msqid = MsgQ.msgget(IPC_KEY);
  21. //每次接收1204字节
  22. MsgQ.msgrcv(msqid, msg, msg.length9527);
  23. }
  24. long end = System.currentTimeMillis()//结束时间
  25.  System.out.println("用时:" + (end – start) + "毫秒");
  26. }
  27. }

测试结果:6617毫秒。

总结:

在能够使用socket长连接的应用中,建议使用socket技术,毕竟很通用熟悉的人也多,而消息队列能够提高的效率有限;在只能使用socket短连接的应用中,特别是并发量大的场景,强烈建议使用消息队列,因为能够极大的提高通信速率。

0
0

猜你在找
【直播】机器学习&数据挖掘7周实训--韦玮
【套餐】系统集成项目管理工程师顺利通关--徐朋
【直播】3小时掌握Docker最佳实战-徐西宁
【套餐】机器学习系列套餐(算法+实战)--唐宇迪
【直播】计算机视觉原理及实战--屈教授
【套餐】微信订阅号+服务号Java版 v2.0--翟东平
【直播】机器学习之矩阵--黄博士
【套餐】微信订阅号+服务号Java版 v2.0--翟东平
【直播】机器学习之凸优化--马博士
【套餐】Javascript 设计模式实战--曾亮
查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:102396次
    • 积分:2666
    • 等级:
    • 排名:第13571名
    • 原创:145篇
    • 转载:198篇
    • 译文:0篇
    • 评论:5条