lovebsd
lovebsd

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

作者：diaoyf  |  文章来源：http://programmerdigest.cn

在当今的网络时代，我们常常见到的进程间通信方式都是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.  
  3. import lajp.MsgQ;
  4.  
  5. public class TestSend
  6. {
  7.     /** 消息队列KEY */
  8.     static final int IPC_KEY = 0×20021230;
  9.  
  10.     static
  11.     {
  12.         //JNI
  13.         System. loadLibrary ( "lajpmsgq" );
  14.     }
  15.  
  16.     public static void main ( String [ ] args )
  17.     {
  18.         //创建或获得现有的消息队列
  19.         int msqid = MsgQ. msgget (IPC_KEY );
  20.         //发送字节数组
  21.         byte [ ] msg = new byte [ 1024 ];
  22.      
  23.         for ( int i = 0; i < 1024 * 5000; i++ )
  24.         {
  25.             //每次发送1204字节到消息队列，9527是消息类型
  26.             MsgQ. msgsnd (msqid, 9527, msg, msg. length );
  27.         }
  28.  
  29.         System. out. println ( "发送结束." );
  30.     }
  31. }

 

接收端程序：

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

 

程序很简单，需要说明的是三个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.    
  5. public class SocketSend
  6. {
  7.     public static void main ( String [ ] args ) throws IOException
  8.     {
  9.         //Socket
  10.         Socket socket = new Socket ( "127.0.0.1", 9527 );
  11.         //输出流
  12.         OutputStream out = socket. getOutputStream ( );
  13.         //发送字节数组
  14.         byte [ ] msg = new byte [ 1024 ];
  15.    
  16.         long start = System. currentTimeMillis ( ); //开始时间
  17.        
  18.         for ( int i = 0; i < 1024 * 5000; i++ )
  19.         {
  20.             //发送
  21.             out. write (msg );
  22.         }
  23.    
  24.         long end = System. currentTimeMillis ( ); //结束时间
  25.         System. out. println ( "用时:" + (end – start ) + "毫秒" );
  26.     }
  27. }

 

接收端程序：

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

 

程序同样很简单，同样发送接收了(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.    
  5. #define IPC_KEY 0×20021230  /* 消息队列KEY */
  6.    
  7. /*消息结构*/
  8. struct message
  9. {
  10.     long msg_type;             /* 消息标识符 */
  11.     char msg_text [ 1024 ];     /* 消息内容 */
  12. };
  13.    
  14. int main ( )
  15. {
  16.     /* 创建或获得现有的消息队列 */
  17.     int msqid = msgget (IPC_KEY, IPC_CREAT | 0666 );
  18.     /* 消息结构 */
  19.     struct message msgq;
  20.     msgq. msg_type = 9527; /* 消息类型 */
  21.        
  22.     int i;
  23.     for (i = 0; i < 1024 * 5000; i++ )
  24.     {  
  25.         /* 接收 */
  26.         msgsnd (msqid, &msgq, 1024, 0 );
  27.     }
  28.    
  29.     printf ( "msgq发送结束，共发送%d次\n", i );
  30.     return 0;
  31. }

 

接收端程序：

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

 

和第一场一样，发送接收了(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.  
  5. char msg [ 1024 ]; /* 发送消息 */
  6.    
  7. int main ( )
  8. {
  9.     char *ip = "127.0.0.1";     /* 发送地址 */
  10.     int port = 9527;             /* 发送端口 */
  11.    
  12.     struct hostent *server_host = gethostbyname (ip );
  13.    
  14.     /* 客户端填充 sockaddr 结构 */
  15.     struct sockaddr_in client_addr;             /* 客户端地址结构 */
  16.     bzero (&client_addr, sizeof (client_addr ) );
  17.     client_addr. sin_family = AF_INET;             /* AF_INET:IPV4协议 */
  18.     client_addr. sin_addr. s_addr = ( ( struct in_addr * ) (server_host->h_addr ) )->s_addr; /* 服务端地址 */
  19.     client_addr. sin_port = htons (port );         /* 端口 */
  20.        
  21.     /* 建立socket */
  22.     int sockfd = socket (AF_INET, SOCK_STREAM, 0 );
  23.     /* 连接 */
  24.     connect (sockfd, ( struct sockaddr * ) (&client_addr ), sizeof (client_addr ) );
  25.            
  26.     int i;
  27.     for (i = 0; i < 1024 * 5000; i++ )
  28.     {  
  29.         /* 发送 */
  30.         send (sockfd, msg, 1024, 0 );
  31.     }
  32.    
  33.     printf ( "发送结束，共发送%d次\n", i );  
  34.     return 0;
  35. }

 

接收端程序：

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

 

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

 

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

接收端程序：

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

 

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

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

发送端程序：

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

 

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

接收段程序：

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

 

测试结果：6617毫秒。

总结：

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

你可能感兴趣的:(socket,测试,消息列队)

  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 将cmd中命令输出保存为txt文本文件 落难Coder Windowscmdwindow
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 398顺境，逆境 戴骁勇
    2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
  • 使用Apify加载Twitter消息以进行微调的完整指南 nseejrukjhad twittereasyui前端python
    #使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
  • GitHub上克隆项目 bigbig猩猩 github
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
  • Kafka 消息丢失如何处理？ 架构文摘JGWZ 学习
    今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南） 诚芯微科技 社交电子
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1） 算法大师 华为od面试python算法前端
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
  • 【六】阿伟开始搭建Kafka学习环境 能源恒观 中间件学习kafkaspring
    阿伟开始搭建Kafka学习环境概述上一篇文章阿伟学习了Kafka的核心概念，并且把市面上流行的消息中间件特性进行了梳理和对比，方便大家在学习过程中进行对比学习，最后梳理了一些Kafka使用中经常遇到的Kafka难题以及解决思路，经过上一篇的学习我相信大家对Kafka有了初步的认识，本篇将继续学习Kafka。一、安装和配置学习一项技术首先要搭建一套服务，而Kafka的运行主要需要部署jdk、zook
  • 网络编程基础 记得开心一点啊 网络
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
  • 2021-09-13一切向好发展 昀妡
    今天，一位学员在群里发了一条求助信息。问题是：一个学生小男孩3年级了，学习态度不端正不认真，也不和老师家长沟通，怎么办？我正好看到了这条消息，便加了她的微信。我问她是否方便电话沟通。在征求学员的同意后，我和她电话沟通了10分钟，给了她一些建议。通过这件事，我看到了自己积极主动的一面。之前，我总说自己消极被动，但其实，问题的根源在于目标不清晰。如果知道方向，还是会突破心理障碍往前走。比如，陌生感召。
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 第1步win10宿主机与虚拟机通过NAT共享上网互通 学习3人组 大数据大数据
    VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
  • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
  • 《前夫如龙》王昊江琼（独家小说）精彩TXT阅读 海边书楼
    《前夫如龙》王昊江琼（独家小说）精彩TXT阅读主角：王昊江琼简介：离婚那天，她视他如泥土。谁曾想，消息一出，天下震动！可关注微信公众号【风车文楼】去回个书号【203】，即可免费阅读【前夫如龙】全文！江芸并未听出华少龙声音里的冷漠，依旧一脸笑容道：“是啊，那个废物哪儿配得上我姐？这些年，我姐对他仁至义尽了。以后，华少爷可以多跟我姐接触接触，只有华少爷这样的人，才配得上我姐啊！”江琼低着头，微微有些娇
  • Python神器！WEB自动化测试集成工具 DrissionPage 亚丁号 python开发语言
    一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
  • esp32开发快速入门 8 : MQTT 的快速入门，基于esp32实现MQTT通信 z755924843 ESP32开发快速入门服务器网络运维
    MQTT介绍简介MQTT（MessageQueuingTelemetryTransport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的"轻量级"通讯协议，该协议构建于TCP/IP协议上，由IBM在1999年发布。MQTT最大优点在于，可以以极少的代码和有限的带宽，为连接远程设备提供实时可靠的消息服务。作为一种低开销、低带宽占用的即时通讯协议，使其在物联
  • 06选课支付模块之基于消息队列发送支付通知消息 echo 云清 学成在线javarabbitmq消息队列支付通知学成在线
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
  • 在RabbitMQ中四种常见的消息路由模式 Xwzzz_ rabbitmq分布式
    1.Fanout模式Fanout模式的交换机是扇出交换机（FanoutExchange），它会将消息广播给所有绑定到它的队列，而不考虑消息的内容或路由键。工作原理：生产者发送消息到FanoutExchange。FanoutExchange会将消息广播给所有绑定到它的队列，所有绑定的队列都会收到这条消息。消费者监听绑定的队列，处理收到的消息。特点：没有路由键：消息不需要路由键，所有绑定的队列都会接收
  • 笋丁网页自动回复机器人V3.0.0免授权版源码 希希分享 软希网58soho_cn源码资源笋丁网页自动回复机器人
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
  • 圣诞节后的人气又回来了？好丽友、特斯拉们的生意却不好做| 每周热点汇总 饭Sir看天下
    新的一年来了大家好，今天是2022年12月26日，星期一，农历十二月初四。这个月，相信我们很多人都遇到了身体不适的情况，饭Sir上周也因为发烧不得不停更了一周，这几天才刚刚恢复，好在这一切最后都能过去。疫情之外，一些好消息也逐渐到来，例如北京等多座大城市在年底的圣诞节期间又恢复了生机，一些迹象也在预示着久违的热闹春节要回来了。但另一方面，明年不确定的经济形势又带来一些不利的消息，不禁让人有些担心。
  • 【Python搞定车载自动化测试】——Python实现车载以太网DoIP刷写（含Python源码） 疯狂的机器人 Python搞定车载自动化pythonDoIPUDSISO142291SO13400Bootloadertcp/ip
    系列文章目录【Python搞定车载自动化测试】系列文章目录汇总文章目录系列文章目录前言一、环境搭建1.软件环境2.硬件环境二、目录结构三、源码展示1.DoIP诊断基础函数方法2.DoIP诊断业务函数方法3.27服务安全解锁4.DoIP自动化刷写四、测试日志1.测试日志五、完整源码链接前言随着智能电动汽车行业的发展，汽车=智能终端+四个轮子，各家车企都推出了各自的OTA升级方案，本章节主要介绍如何使
  • 如果没有结婚，是不是还能好好活着。 橡皮树
    昨天，小区发生了一起命案。原因暂时不明。一种说法是，女人生的孩子不是男人的，所以男人一气之下把正在做月子的女人给杀死了。另一种说法是，女人与婆婆发生了口角，男人回到家，听到母亲的控诉，找女人算账，然后活活将其打死了。听到这个消息，不寒而栗。警方已将男子抓获。只是在想，这个女人如果没有结婚的话，是不是还能好好的活在这个世上。
  • Python 课程10-单元测试 可愛小吉 Python教學python单元测试开发语言TDDunittest
    前言在现代软件开发中，单元测试已成为一种必不可少的实践。通过测试，我们可以确保每个功能模块在开发和修改过程中按预期工作，从而减少软件缺陷，提高代码质量。而测试驱动开发（TDD）则进一步将测试作为开发的核心部分，先编写测试，再编写代码，以测试为指导开发出更稳定、更可靠的代码。Python提供了强大的unittest模块，它是Python标准库的一部分，专门用于编写和执行单元测试。与其他测试框架相比，
  • RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmqrabbitmqjava
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
  • 【自动化测试】UI自动化的分类、如何选择合适的自动化测试工具以及其中appium的设计理念、引擎和引擎如何工作 Lossya ui自动化测试工具自动化测试appium
    引言UI自动化测试主要针对软件的用户界面进行测试，以确保用户界面元素的交互和功能符合预期文章目录引言一、UI自动化的分类1.1基于代码的自动化测试1.2基于录制/回放的自动化测试1.3基于框架的自动化测试1.4按测试对象分类1.5按测试层次分类1.6按测试执行方式分类1.7按测试目的分类二、如何选择合适的自动化测试工具2.1项目需求分析2.2工具特性评估2.3成本考虑2.4团队技能2.5试用和评估
  • 三人行（六十三） 清风不等明月
    书接上文：虽然大家都认为要进密室看看，但是罗道长还是提醒各位不要轻举妄动。让灵儿这两天也不用在盯着孟琦了，罗道长想从侧面打探一下密室的消息，看看有没有办法把孟琦调走一段时间，这样就有机会进入密室查看了。机会很快就来了，因为月底孟琦要在议事堂商议各堂口的事项。所以有一天的时间他的卧室都是空的。这一天很快就到了，各堂口的负责人都聚集在议事堂，今天孟琦是主角，他当然也是不能缺席的。他们商议的无非是各堂口
  • 微信小程序开发注意事项 jun778895 微信小程序小程序
    微信小程序开发是一个融合了前端开发、用户体验设计、后端服务（可选）以及微信小程序平台特性的综合性项目。这里，我将详细介绍一个典型的小程序开发项目的全过程，包括项目规划、设计、开发、测试及部署上线等各个环节，并尽量使内容达到或超过2000字的要求。一、项目规划1.1项目背景与目标假设我们要开发一个名为“智慧校园助手”的微信小程序，旨在为学生提供一站式校园生活服务，包括课程表查询、图书馆座位预约、食堂
  • java数字签名三种方式 知了ing javajdk
    以下3钟数字签名都是基于jdk7的 1，RSA String password="test"; // 1.初始化密钥 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(51
  • Hibernate学习笔记 caoyong Hibernate
    1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 2>、搭建Hibernate的开发环境      a>、添加jar包:      aa>、hibernatte开发包中/lib/required/所
  • 设计模式之装饰器模式Decorator（结构型） 漂泊一剑客 Decorator
    1. 概述        若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。      
  • 读取磁盘文件txt，并输入String 一炮送你回车库 String
    public static void main(String[] args) throws IOException {    String fileContent = readFileContent("d:/aaa.txt");    System.out.println(fileContent);   
  • js三级联动下拉框 3213213333332132 三级联动
    //三级联动 省/直辖市<select id="province"></select> 市/省直辖<select id="city"></select> 县/区 <select id="area"></select>
  • erlang之parse_transform编译选项的应用 616050468 parse_transform游戏服务器属性同步abstract_code
             最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
  • JAVA JSON的解析 darkranger java
    // { // “Total”：“条数”， // Code: 1, // // “PaymentItems”:[ // { // “PaymentItemID”:”支款单ID”, // “PaymentCode”:”支款单编号”, // “PaymentTime”:”支款日期”, // ”ContractNo”:”合同号”， //
  • POJ-1273-Drainage Ditches aijuans ACM_POJ
    POJ-1273-Drainage Ditches http://poj.org/problem?id=1273 基本的最大流，按LRJ的白书写的 #include<iostream> #include<cstring> #include<queue> using namespace std; #define INF 0x7fffffff int ma
  • 工作流Activiti5表的命名及含义 atongyeye 工作流Activiti
    activiti5 - http://activiti.org/designer/update在线插件安装 activiti5一共23张表 Activiti的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。 ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。 A
  • android的广播机制和广播的简单使用 百合不是茶 android广播机制广播的注册
          Android广播机制简介 在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
  • Spring事务传播行为详解 bijian1013 javaspring事务传播行为
            在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。         Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
  • eidtplus operate 征客丶 eidtplus
    开启列模式: Alt+C 鼠标选择   OR   Alt+鼠标左键拖动 列模式替换或复制内容(多行): 右键-->格式-->填充所选内容-->选择相应操作 OR Ctrl+Shift+V(复制多行数据,必须行数一致) -------------------------------------------------------
  • 【Kafka一】Kafka入门 bit1129 kafka
    这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧   下载Kafka http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 2.10表示Scala的版本，而0.8.1.1表示Kafka
  • Spring 事务实现机制 BlueSkator spring代理事务
    Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口
  • bootstrap源码学习与示例：bootstrap-dropdown（转帖） BreakingBad bootstrapdropdown
    bootstrap-dropdown组件是个烂东西，我读后的整体感觉。 一个下拉开菜单的设计： <ul class="nav pull-right"> <li id="fat-menu" class="dropdown">
  • 读《研磨设计模式》-代码笔记-中介者模式-Mediator bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /* * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 * * 在我看来，Mediator模式是把多个对象（
  • 常用代码记录 chenjunt3 UIExcelJ#
      1、单据设置某行或某字段不能修改 //i是行号,"cash"是字段名称 getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false); //取得单据表体所有项用以上语句做循环就能设置整行了 getBillC
  • 搜索引擎与工作流引擎 comsci 算法工作搜索引擎网络应用
          最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想)   -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
  • oracle Health Monitor daizj oracleHealth Monitor
    About Health Monitor Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. About Health Monitor Checks Health M
  • JSON字符串转换为对象 dieslrae javajson
        作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.   
  • C语言学习八结构体，综合应用，学生管理系统 dcj3sjt126com C语言
    实现功能的代码： # include <stdio.h> # include <malloc.h> struct Student { int age; float score; char name[100]; }; int main(void) { int len; struct Student * pArr; int i,
  • vagrant学习笔记 dcj3sjt126com vagrant
    想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant   1. vagrant virtualbox 下载安装 https://www.vagrantup.com/downloads.html https://www.virtualbox.org/wiki/Downloads   查看安装在命令行输入vagrant     2.
  • 14.性能优化-优化-软件配置优化 frank1234 软件配置性能优化
    1.Tomcat线程池 修改tomcat的server.xml文件： <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
  • 一个不错的shell 脚本教程 入门级 HarborChung linuxshell
    一个不错的shell 脚本教程 入门级 建立一个脚本 　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。 　　如同其他语言一样
  • Spring4新特性——核心容器的其他改进 jinnianshilongnian spring动态代理spring4依赖注入
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • Linux设置tomcat开机启动 liuxingguome tomcatlinux开机自启动
    执行命令sudo gedit /etc/init.d/tomcat6 然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 #!/bin/bash # # /etc/rc.d/init.d/tomcat # init script for tomcat precesses
  • 第13章 Ajax进阶（下） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • Troubleshooting Crystal Reports off BW blueoxygen BO
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE   Quite useful, especially this part: SAP BW connectivity For t
  • Java开发熟手该当心的11个错误 tomcat_oracle javajvm多线程单元测试
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
  • 正则表达式大全 yang852220741 html编程正则表达式
    今天向大家分享正则表达式大全，它可以大提高你的工作效率 正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。 一、校验数字的表达式 数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他