利用 ACE 来实现 UDP 通讯

TCP和UDP的"保护消息边界" 机制

在socket网络程序中，TCP和UDP分别是面向连接和非面向连接的。因此TCP的socket编程，收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。
       对于UDP，不会使用块的合并优化算法，这样，实际上目前认为，是由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。

保护消息边界和流

那么什么是保护消息边界和流呢?

       保护消息边界，就是指传输协议把数据当作一条独立的消息在网上 传输,接收端只能接收独立的消息.也就是说存在保护消息边界,接收 端一次只能接收发送端发出的一个数据包. 

       而面向流则是指无保护消息保护边界的,如果发送端连续发送数据, 接收端有可能在一次接收动作中,会接收两个或者更多的数据包.

       我们举个例子来说,例如,我们连续发送三个数据包,大小分别是2k, 4k , 8k,这三个数据包,都已经到达了接收端的网络堆栈中,如果使用UDP协议,不管我们使用多大的接收缓冲区去接收数据,我们必须有 三次接收动作,才能够把所有的数据包接收完.而使用TCP协议,我们只要把接收的缓冲区大小设置在14k以上,我们就能够一次把所有的 数据包接收下来.只需要有一次接收动作.这就是因为UDP协议的保护消息边界使得每一个消息都是独立的.而 流传输,却把数据当作一串数据流,他不认为数据是一个一个的消息.

 

      所以有很多人在使用tcp协议通讯的时候,并不清楚tcp是基于流的 传输,当连续发送数据的时候,他们时常会认识tcp会丢包.其实不然, 因为当他们使用的缓冲区足够大时,他们有可能会一次接收到两个甚 至更多的数据包,而很多人往往会忽视这一点,只解析检查了第一个数据包,而已经接收的其他数据包却被忽略了.所以大家如果要作这 类的网络编程的时候,必须要注意这一点.

 

结论：
     根据以上所说，可以这样理解，TCP为了保证可靠传输，尽量减少额外开销（每次发包都要验证），因此采用了流式传输，面向流的传输，相对于面向消息的传输，可以减少发送包的数量。从而减少了额外开销。但是，对于数据传输频繁的程序来讲，使用TCP可能会容易粘包。当然，对接收端的程序来讲，如果机器负荷很重，也会在接收缓冲里粘包。这样，就需要接收端额外拆包，增加了工作量。因此，这个特别适合的是数据要求可靠传输，但是不需要太频繁传输的场合（两次操作间隔100ms，具体是由TCP等待发送间隔决定的，取决于内核中的socket的写法）

     而UDP，由于面向的是消息传输，它把所有接收到的消息都挂接到缓冲区的接受队列中，因此，它对于数据的提取分离就更加方便，但是，它没有粘包机制，因此，当发送数据量较小的时候，就会发生数据包有效载荷较小的情况，也会增加多次发送的系统发送开销（系统调用，写硬件等）和接收开销。因此，应该最好设置一个比较合适的数据包的包长，来进行UDP数据的发送。（UDP最大载荷为1472，因此最好能
每次传输接近这个数的数据量，这特别适合于视频，音频等大块数据的发送，同时，通过减少握手来保证流媒体的实时性）

[cpp]  view plain  copy

 print ?

1. #pragma once  
2.   
3. #include "ace/OS_main.h"  
4. #include "ace/OS_NS_string.h"  
5. #include "ace/OS_NS_unistd.h"  
6. #include "ace/Reactor.h"  
7. #include "ace/SOCK_Dgram.h"  
8. #include "ace/INET_Addr.h"  
9. #include "ace/Process.h"  
10. #include "ace/Log_Msg.h"  
11.   
12. class Dgram_Endpoint : public ACE_Event_Handler  
13. {  
14. public:  
15.     Dgram_Endpoint(const ACE_INET_Addr &local_addr);  
16.     ~Dgram_Endpoint(void);  
17.     virtual ACE_HANDLE get_handle(void) const;  
18.     virtual int handle_input(ACE_HANDLE handle);  
19.     virtual int handle_timeout(const ACE_Time_Value & tv, const void *arg = 0);  
20.     virtual int handle_close(ACE_HANDLE handle, ACE_Reactor_Mask close_mask);  
21.     int send(const char *buf, size_t len, const ACE_INET_Addr &);  
22. private:  
23.     ACE_SOCK_Dgram endpoint_;  
24. };  
25.   
26. #include "Dgram_Endpoint.h"  
27.   
28.   
29. Dgram_Endpoint::Dgram_Endpoint(const ACE_INET_Addr &local_addr): endpoint_(local_addr)  
30. {  
31. }  
32.   
33. Dgram_Endpoint::~Dgram_Endpoint(void)  
34. {  
35. }  
36.   
37.   
38. int Dgram_Endpoint::send(const char *buf, size_t len, const ACE_INET_Addr &addr)  
39. {  
40.     return this->endpoint_.send (buf, len, addr);  
41. }  
42.   
43.   
44. ACE_HANDLE Dgram_Endpoint::get_handle (void) const  
45. {  
46.     return this->endpoint_.get_handle ();  
47. }  
48.   
49. int Dgram_Endpoint::handle_close (ACE_HANDLE handle, ACE_Reactor_Mask)  
50. {  
51.     ACE_UNUSED_ARG (handle);  
52.     this->endpoint_.close ();  
53.     delete this;  
54.     return 0;  
55. }  
56.   
57. int Dgram_Endpoint::handle_input(ACE_HANDLE)  
58. {  
59.     char buf[BUFSIZ];  
60.     memset(buf, 0, BUFSIZ);  
61.     ACE_INET_Addr from_addr;  
62.   
63.     ACE_DEBUG ((LM_DEBUG, "(%P|%t) activity occurred on handle %d!\n", this->endpoint_.get_handle ()));  
64.   
65.     ssize_t n = this->endpoint_.recv (buf, sizeof buf, from_addr);  
66.   
67.     if (n == -1)  
68.     {  
69.         ACE_ERROR ((LM_ERROR, "%p\n", "handle_input"));  
70.     }  
71.     else  
72.     {  
73.         ACE_DEBUG ((LM_DEBUG, "(%P|%t) buf of size %d = %*s\n", n, n, buf));  
74.     }  
75.     return 0;  
76. }  
77.   
78.   
79. int Dgram_Endpoint::handle_timeout (const ACE_Time_Value &, const void *)  
80. {  
81.     ACE_DEBUG ((LM_DEBUG, "(%P|%t) timed out for endpoint\n"));  
82.     return 0;  
83. }  

[cpp]  view plain  copy

 print ?

1. #pragma once  
2.   
3. #include "ace/Synch.h"  
4. #include "ace/Task.h"  
5. #include "Dgram_Endpoint.h"  
6.   
7. class Customer_UI: public ACE_Task<ACE_MT_SYNCH>  
8. {  
9. public:  
10.     Customer_UI(Dgram_Endpoint* dgram, ACE_INET_Addr remoaddr);  
11.     ~Customer_UI(void);  
12. private:  
13.     ACE_thread_t  threads[0x01];      
14.     Dgram_Endpoint* dgramep;  
15.     ACE_INET_Addr remoteaddress;  
16. public:  
17.     virtual int open();  
18.     virtual int svc();  
19. };  
20.   
21. #include "Customer_UI.h"  
22.   
23.   
24. Customer_UI::Customer_UI(Dgram_Endpoint* dgram,  ACE_INET_Addr remoaddr)  
25. {  
26.     this->dgramep = dgram;  
27.     this->remoteaddress = remoaddr;  
28. }  
29.   
30.   
31. Customer_UI::~Customer_UI(void)  
32. {  
33. }  
34.   
35. int Customer_UI::open()  
36. {  
37.     return activate(THR_NEW_LWP, 1, 0, ACE_DEFAULT_THREAD_PRIORITY, -1, this, 0, 0, 0, threads);  
38. }  
39.   
40. int Customer_UI::svc()  
41. {  
42.     if (ACE_Thread::self() == threads[0])  
43.     {     
44.         printf("threadid = %04d has been created\n", threads[0]);  
45.         while(1)  
46.         {  
47.             printf("please input message:\n");  
48.             char buff[BUFSIZ];  
49.             memset(buff, 0, BUFSIZ);  
50.             scanf("%s", buff);  
51.             int length = strlen(buff);  
52.             dgramep->send(buff, length, remoteaddress);  
53.         }  
54.     }  
55.     return 0;  
56. }  

[cpp]  view plain  copy

 print ?

1. // NSVLR.cpp : Defines the entry point for the console application.  
2. //  
3.   
4. #include "stdafx.h"  
5. #include "Dgram_Endpoint.h"  
6. #include "Customer_UI.h"  
7.   
8.   
9. int main(int argc, char* argv[])  
10. {  
11.   
12.     WSADATA wsaData;  
13.     if(WSAStartup(MAKEWORD(2,2),&wsaData) != 0) return 0;     
14.   
15.     u_short localport = 5050;  
16.     const ACE_TCHAR *remotehost = "127.0.0.1";  
17.     u_short remoteport = 6060;  
18.   
19.     ACE_INET_Addr remote_addr(remoteport, remotehost);  
20.     ACE_INET_Addr local_addr(localport);  
21.   
22.     Dgram_Endpoint *endpoint;  
23.   
24.     ACE_NEW_RETURN (endpoint, Dgram_Endpoint(local_addr), -1);  
25.   
26.     if (ACE_Reactor::instance ()->register_handler(endpoint, ACE_Event_Handler::READ_MASK) == -1)  
27.     {  
28.         ACE_ERROR_RETURN ((LM_ERROR, "ACE_Reactor::register_handler"), -1);  
29.     }  
30.   
31.     Customer_UI *ui;  
32.     ACE_NEW_RETURN (ui, Customer_UI(endpoint, remote_addr), -1);  
33.     ui->open();  
34.   
35.     while(true)  
36.     {  
37.         ACE_Reactor::instance()->handle_events();  
38.     }  
39.   
40.     return 0;  
41. }