码迷，mamicode.com
首页 > Web开发 > 详细

三种网络数据传输方式比较(byte stream,protobuf,json)

时间：2015-10-23 16:17:34      阅读：738      评论：0      收藏：0      [点我收藏+]

标签：

 三种网络数据传输方式比较(byte stream,protobuf,json) 2014-08-27 10:39:04

分类： LINUX

原文地址：三种网络数据传输方式比较(byte stream,protobuf,json) 作者：yuyunliuhen

 

    针对于tinynet进行了三种数据传输方式的测试，包括最初的byte stream,protobuf,以及比较流行json方式。跟之前的几次测试一样，模型为echo模型，都是以epoll为例，每个连接每秒发送10个包，每个数据包约100bytes,数据包括包头以及数据，包头12bytes,包括长度以及其他8bytes信息，客户端连接为每秒5个，此次测试总计连接10000个.
    之前的测试报告:
    工程源代码：
    服务器是多线程模型，主线程负责接收处理网络数据，并添加的输入缓冲区中；读线程从输入缓冲中读取数据并进行处理，将处理的数据添加的输出缓冲区中；写线程将输出缓冲区的数据发送到指定的客户端连接。由于数据处理只是在读线程处理，所以只需要变更读线程的处理代码就可以了。( 默认读写线程的sleep时间为500ms)
    下面分别为服务器端读线程byte stream,protobuf,json三种方式的部分代码：

点击(此处)折叠或打开

  1. // byte stream
  2. void Server_Impl::_read_thread()
  3. {
  4.     static const int __head_size = 12;
  5.     char __read_buf[max_buffer_size_] = {};
  6.     while (true)
  7.     {
  8.         lock_.acquire_lock();
  9. #ifdef __DEBUG
  10.         struct timeval __start_timeval;
  11.         gettimeofday(&__start_timeval, NULL);
  12.         long __start_time = __start_timeval.tv_usec;
  13. #endif //__DEBUG
  14.         for (std::vector<Buffer*>::iterator __it = connects_copy.begin(); __it != connects_copy.end(); ++__it)
  15.         {
  16.             if(*__it)
  17.             {
  18.                 Buffer::ring_buffer* __input = (*__it)->input_;
  19.                 Buffer::ring_buffer* __output = (*__it)->output_;
  20.                 if (!__input || !__output)
  21.                 {
  22.                     continue;
  23.                 }
  24. #ifdef __DEBUG
  25.                 if(0 == (*__it)->fd_ % 1000)
  26.                 {
  27.                     printf("fd =%d,rpos = %d, wpos = %d\n",(*__it)->fd_,__input->rpos(),__input->wpos());
  28.                 }
  29. #endif //__DEBUG
  30.                 while (!__input->read_finish())
  31.                 {
  32.                     int __packet_length = 0;
  33.                     int __log_level = 0;
  34.                     int __frame_number = 0;
  35.                     unsigned char __packet_head[__head_size] = {};
  36.                     int __head = 0;
  37.                     unsigned int __guid = 0;
  38.                     if(!__input->pre_read((unsigned char*)&__packet_head,__head_size))
  39.                     {
  40.                         //    not enough data for read
  41.                         break;
  42.                     }
  43.                     memcpy(&__packet_length,__packet_head,4);
  44. #if 0
  45.                     memcpy(&__head,__packet_head + 4,4);
  46.                     memcpy(&__guid,__packet_head + 8,4);
  47. #endif
  48.                     if(!__packet_length)
  49.                     {
  50.                         printf("__packet_length error\n");
  51.                         break;
  52.                     }
  53. #if 0
  54.                     __log_level = (__head) & 0x000000ff;
  55.                     __frame_number = (__head >> 8);
  56. #endif
  57.                     memset(__read_buf,0,max_buffer_size_);
  58.                     if(__input->read((unsigned char*)__read_buf,__packet_length + __head_size))
  59.                     {
  60.                         __output->append((unsigned char*)__read_buf,__packet_length + __head_size);
  61.                     }
  62.                     else
  63.                     {
  64.                         break;
  65.                     }
  66.                 }
  67.             }
  68.         }
  69. #ifdef __DEBUG
  70.         struct timeval __end_timeval;
  71.         gettimeofday(&__end_timeval, NULL);
  72.         long __end_time = __end_timeval.tv_usec;
  73.         long __time_read = __end_time - __start_time;
  74.         printf("start time = %ld, end time = %ld,server impl time read = %ld\n",__start_time,__end_time,__time_read);
  75. #endif //__DEBUG
  76.         lock_.release_lock();
  77. #ifdef __LINUX
  78.         usleep(max_sleep_time_);
  79. #endif // __LINUX
  80.     }
  81. }
  83. // protobuf
  84. void Server_Impl::_read_thread()
  85. {
  86.     transfer::Packet __packet_protobuf;
  87.     std::string      __string_packet;
  88.     static const int __head_size = 4;
  89.     while (true)
  90.     {
  91.         lock_.acquire_lock();
  92. #ifdef __DEBUG
  93.         struct timeval __start_timeval;
  94.         gettimeofday(&__start_timeval, NULL);
  95.         long __start_time = __start_timeval.tv_usec;
  96. #endif //__DEBUG
  97.         for (std::vector<Buffer*>::iterator __it = connects_copy.begin(); __it != connects_copy.end(); ++__it)
  98.         {
  99.             if(*__it)
  100.             {
  101.                 Buffer::ring_buffer* __input = (*__it)->input_;
  102.                 Buffer::ring_buffer* __output = (*__it)->output_;
  103.                 if (!__input || !__output)
  104.                 {
  105.                     continue;
  106.                 }
  107. #ifdef __DEBUG
  108.                 if(0 == (*__it)->fd_ % 1000)
  109.                 {
  110.                     printf("fd =%d,rpos = %d, wpos = %d\n",(*__it)->fd_,__input->rpos(),__input->wpos());
  111.                 }
  112. #endif //__DEBUG
  113.                 while (!__input->read_finish())
  114.                 {
  115.                     int __packet_length = 0;
  116.                     int __log_level = 0;
  117.                     int __frame_number = 0;
  118.                     unsigned char __packet_head[__head_size] = {};
  119.                     int __head = 0;
  120.                     unsigned int __guid = 0;
  121.                     if(!__input->pre_read(__packet_head,__head_size))
  122.                     {
  123.                         //    not enough data for read
  124.                         break;
  125.                     }
  126.                     __packet_length = (int)*__packet_head;
  127.                     if(!__packet_length)
  128.                     {
  129.                         printf("__packet_length error\n");
  130.                         break;
  131.                     }
  132. #if 0
  133.                     //    easy_bool read(easy_uint8* des,size_t len)
  134.                     char __read_buf[max_buffer_size_] = {};
  135.                     if(__input->read((unsigned char*)__read_buf,__packet_length + __head_size))
  136.                     {
  137.                         __string_packet = __read_buf + __head_size;
  138.                         __packet_protobuf.ParseFromString(__string_packet);
  139.                         __output->append((unsigned char*)__read_buf,__packet_length + __head_size);
  140. #else
  141.                     //    easy_bool read(std::string& des,size_t len)
  142.                     __packet_protobuf.Clear();
  143.                     __string_packet.clear();
  144.                     if(__input->read(__string_packet,__packet_length + __head_size))
  145.                     {
  146.                         __packet_protobuf.ParseFromString(__string_packet.c_str() + __head_size);
  147.                         __output->append((unsigned char*)__string_packet.c_str(),__packet_length + __head_size);
  148. #endif
  149. #ifdef __DEBUG
  150.                         printf("__packet_protobuf.head = %d\n",__packet_protobuf.head());
  151.                         printf("__packet_protobuf.guid = %d\n",__packet_protobuf.guid());
  152.                         printf("__packet_protobuf.content = %s\n",__packet_protobuf.content().c_str());
  153. #endif //__DEBUG
  154.                     }
  155.                     else
  156.                     {
  157.                         break;
  158.                     }
  159.                 }
  160.             }
  161.         }
  162. #ifdef __DEBUG
  163.         struct timeval __end_timeval;
  164.         gettimeofday(&__end_timeval, NULL);
  165.         long __end_time = __end_timeval.tv_usec;
  166.         long __time_read = __end_time - __start_time;
  167.         printf("start time = %ld, end time = %ld,server protobuf impl time read = %ld\n",__start_time,__end_time,__time_read);
  168. #endif //__DEBUG
  169.         lock_.release_lock();
  170. #ifdef __LINUX
  171.         usleep(max_sleep_time_);
  172. #endif // __LINUX
  173.     }
  174. }
  176. // json
  177. void Server_Impl::_read_thread()
  178. {
  179.     static const int __head_size = 4;
  180.     while (true)
  181.     {
  182.         lock_.acquire_lock();
  183. #ifdef __DEBUG
  184.         struct timeval __start_timeval;
  185.         gettimeofday(&__start_timeval, NULL);
  186.         long __start_time = __start_timeval.tv_usec;
  187. #endif //__DEBUG
  188.         for (std::vector<Buffer*>::iterator __it = connects_copy.begin(); __it != connects_copy.end(); ++__it)
  189.         {
  190.             if(*__it)
  191.             {
  192.                 Buffer::ring_buffer* __input = (*__it)->input_;
  193.                 Buffer::ring_buffer* __output = (*__it)->output_;
  194.                 if (!__input || !__output)
  195.                 {
  196.                     continue;
  197.                 }
  198. #ifdef __DEBUG
  199.                 if(0 == (*__it)->fd_ % 1000)
  200.                 {
  201.                     printf("fd =%d,rpos = %d, wpos = %d\n",(*__it)->fd_,__input->rpos(),__input->wpos());
  202.                 }
  203. #endif //__DEBUG
  204.                 while (!__input->read_finish())
  205.                 {
  206.                     int __packet_length = 0;
  207.                     int __log_level = 0;
  208.                     int __frame_number = 0;
  209.                     unsigned char __packet_head[__head_size] = {};
  210.                     int __head = 0;
  211.                     unsigned int __guid = 0;
  212.                     if(!__input->pre_read(__packet_head,__head_size))
  213.                     {
  214.                         //    not enough data for read
  215.                         break;
  216.                     }
  217.                     __packet_length = (int)*__packet_head;
  218.                     if(!__packet_length)
  219.                     {
  220.                         printf("__packet_length error\n");
  221.                         break;
  222.                     }
  224.                     char __read_buf[max_buffer_size_] = {};
  225.                     if(__input->read((unsigned char*)__read_buf,__packet_length + __head_size))
  226.                     {
  227.                         json_error_t* __json_error = NULL;
  228.                         json_t* __json_loads = json_loads(__read_buf + __head_size,JSON_DECODE_ANY,__json_error);
  229.                         __output->append((unsigned char*)__read_buf,__packet_length + __head_size);
  230. #ifdef __DEBUG
  231.                         json_t* __json_loads_head = json_object_get(__json_loads,"head");
  232.                         json_t* __json_loads_guid = json_object_get(__json_loads,"guid");
  233.                         json_t* __json_loads_content = json_object_get(__json_loads,"content");
  234.                         printf("json.head = %d\n",json_integer_value(__json_loads_head));
  235.                         printf("json.guid = %d\n",json_integer_value(__json_loads_guid));
  236.                         printf("json.content = %s\n",json_string_value(__json_loads_content));
  237. #endif //__DEBUG
  238.                         json_decref(__json_loads);
  239.                     }
  240.                     else
  241.                     {
  242.                         break;
  243.                     }
  244.                 }
  245.             }
  246.         }
  247. #ifdef __DEBUG
  248.         struct timeval __end_timeval;
  249.         gettimeofday(&__end_timeval, NULL);
  250.         long __end_time = __end_timeval.tv_usec;
  251.         long __time_read = __end_time - __start_time;
  252.         printf("start time = %ld, end time = %ld,server json impl time read = %ld\n",__start_time,__end_time,__time_read);
  253. #endif //__DEBUG
  254.         lock_.release_lock();
  255. #ifdef __LINUX
  256.         usleep(max_sleep_time_);
  257. #endif // __LINUX
  258.     }
  259. }
nmon监控部分结果:
    sys summ
    byte stream
    技术分享
    protobuf
    技术分享
    json
    技术分享
    cpu summ
 
    byte stream
    技术分享
    protobuf
    技术分享
    json
    技术分享
    memory
    byte stream
    技术分享
    protobuf
    技术分享
    json
    技术分享
    net
    byte stream
    技术分享
    protobuf
    技术分享
    json
    技术分享
    netpackets
    byte stream
    技术分享
    protobuf
    技术分享
    json
    技术分享
    我们主要通过cpu,内存，网络流量，网络发包数量来分析：
    (1)    就cpu消耗来说，使用byte stream所消耗的cpu要比使用protobuf,json要小的多，主要是因为后者需要额外的创建对象，序列化，还原的开销;
    (2)    内存变化都不太大，基本保持稳定；
    (3)    就网络流量来说，byte stream使用流量比较小，也比较恒定，平均流量在5M左右，而protobuf,json方式平均值都在20M左右，而且前者每秒处理的数据包约为30000个，而后两者在150000~200000之间。这看起来比较奇怪，客户端都是每秒发送10个包，阻塞，服务器读写线程sleep的时间都是500ms,那么正常来说，如果按服务器的处理来看，每秒处理约2个数据包，客户端时间间隔再小，也是如此，这还是都能完全处理的情况下，那么，byte stream的结果应该更加接近事实。但是后两者与前者为何相差这么大呢？
    带着疑问，进行了下面的测试，服务器相关代码只是更改了读线程部分，所以我在线程的每次tick前后加上时间戳，记录一次tick所花费的时间，并记录输入缓冲区读写的位置，因为连接数比较多，日志太多，而且刷屏太快，容易影响测试结果，仅仅采样fd为1000的倍数，下面是结果的截图：
    byte stream
    技术分享
    protobuf
    技术分享
    json
    技术分享
    由上述结果可知：byte stream每次tick时间为10+毫秒，而且输入缓冲区的r/w pos基本是一致的，也就是说数据每次都处理完毕；而protobuf每次tick时间为100+毫秒，r/w pos的位置差在600~700bytes左右； 使用json方式，每次tick时间多达数百毫秒，且r/w pos的位置差在2000~3000bytes之间。从这组数据基本可以确定，在传输效率上来说：byte stream > protobuf > json,其差距差不多在几倍到一个数量级之间。
    为了进一步验证，又做了一组测试，对一个模拟的数据包分别按三种方式进行打包，解包操作，执行10000次，查看执行的总时间：

点击(此处)折叠或打开

  1. /****************************************************************************
  2.  Copyright (c) 2013-2014 King Lee
  4.  Permission is hereby granted, free of charge, to any person obtaining a copy
  5.  of this software and associated documentation files (the "Software"), to deal
  6.  in the Software without restriction, including without limitation the rights
  7.  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  8.  copies of the Software, and to permit persons to whom the Software is
  9.  furnished to do so, subject to the following conditions:
  11.  The above copyright notice and this permission notice shall be included in
  12.  all copies or substantial portions of the Software.
  14.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15.  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16.  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17.  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18.  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19.  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20.  THE SOFTWARE.
  21.    general:
  22.     $export LD_LIBRARY_PATH=$LD_LIBRARY_PATH../easy/dep/protobuf/src/.libs:../easy/dep/jansson/src/.libs
  23.         $../easy/dep/protobuf/src/.libs/protoc -I./ --cpp_out=. transfer.proto
  24.     
  25.     compiler:
  26.         $g++ -g -o byte_stream_vs_protobuf_vs_json transfer.pb.h transfer.pb.cc byte_stream_vs_protobuf_vs_json.cc -I../easy/dep/protobuf/src/ -I../easy/dep/jansson/src/ -L../easy/dep/protobuf/src/.libs -L../easy/dep/jansson/src/.libs -lprotobuf -ljansson
  27.  ****************************************************************************/
  28. #include <stdlib.h>            //    exit
  29. #include <stdio.h>
  30. #include <stdarg.h>
  31. #include <string>
  32. #include <sys/time.h>
  33. #include <string.h>
  34. #include "transfer.pb.h"
  35. #include <jansson.h>
  36. static std::string __random_string[] = 
  37. {
  38.     "[0x000085e4][T]AdvertisingIndentitifer: ‘‘, IdentifierForVendor: ‘‘, DeviceName: ‘PC‘, ModelName: ‘x86‘, SystemName: ‘‘, SystemVersion: ‘‘, HardwareID: ‘74d435046509‘",
  39.     "nice to meet you!",
  40.     "It is the tears of the earth that keep here smiles in bloom.",
  41.     "The mighty desert is burning for the love of a blade of grass who shakes her head and laughs and flies away.",
  42.     "If you shed tears when you miss the sun, you also miss the stars.",
  43.     "Her wishful face haunts my dreams like the rain at night.",
  44.     "Once we dreamt that we were strangers.We wake up to find that we were dear to each other.",
  45.     "Sorrow is hushed into peace in my heart like the evening among the silent trees.",
  46.     "Some unseen fingers, like an idle breeze, are playing upon my heart the music of the ripples.",
  47.     "Listen, my heart, to the whispers of the world with which it makes love to you.",
  48.     "Do not seat your love upon a precipice because it is high.",
  49.     "I sit at my window this morning where the world like a passer-by stops for a moment, nods to me and goes.",
  50.     "There little thoughts are the rustle of leaves; they have their whisper of joy in my mind.",
  51.     "What you are you do not see, what you see is your shadow.",
  52.     "My wishes are fools, they shout across thy song, my Master.Let me but listen.",
  53.     "They throw their shadows before them who carry their lantern on their back.",
  54.     "That I exist is a perpetual surprise which is life.",
  55.     "We, the rustling leaves, have a voice that answers the storms,but who are you so silent?I am a mere flower.",
  56.     "Do not blame your food because you have no appetite.",
  57.     "Success is not final, failure is not fatal: it is the courage to continue that counts.",
  58.     "I cannot tell why this heart languishes in silence.It is for small needs it never asks, or knows or remembers.",
  59.     "The bird wishes it were a cloud.The cloud wishes it were a bird."
  60. };
  62. static const int __loop_count = 10000;
  63. static int __buf_size = 256;
  64. void byte_stream_test()
  65. {
  66.     int __guid = 15;
  67.     int __head = 567;
  68.     int __length2 = 0;
  69.     int __head2 = 0;
  70.     int __guid2 = 0;
  71.     char __buf[__buf_size];
  72.     int __packet_head_size = 12;
  73.     int __random_index = 0;
  74.     unsigned char __packet_head[__packet_head_size];
  75.     int __length = __random_string[__random_index].size();
  76.     
  77.     struct timeval __start_timeval;
  78.     gettimeofday(&__start_timeval, NULL);
  79.     long __start_time = __start_timeval.tv_usec;
  80.     for(int __i = 0; __i < __loop_count; ++__i)
  81.     {
  82.         memset(__buf,0,__buf_size);
  83.         memset(__packet_head,0,__packet_head_size);
  84.         //    pack
  85.         memcpy(__buf,(void*)&__length,4);
  86.         memcpy(__buf + 4,(void*)&__head,4);
  87.         memcpy(__buf + 8,(void*)&__guid,4);
  88.         strcpy(__buf + __packet_head_size,__random_string[__random_index].c_str());
  89.         //    unpack
  90.         memcpy(&__length2,(void*)__packet_head,4);
  91.         memcpy(&__head2,(void*)(__packet_head + 4),4);
  92.         memcpy(&__guid2,(void*)(__packet_head + 8),4);
  93.     }
  94.     struct timeval __end_timeval;
  95.     gettimeofday(&__end_timeval, NULL);
  96.     long __end_time = __end_timeval.tv_usec;
  97.     long __time_total = __end_time - __start_time;
  98.     printf("start time = %ld, end time = %ld,byte stream total time = %ld\n",__start_time,__end_time,__time_total);
  99. }
  101. void protobuf_test()
  102. {
  103.     transfer::Packet __packet_protobuf;
  104.     std::string __string_packet;
  105.     int __guid = 15;
  106.     int __head = 567;
  107.     int __length2 = 0;
  108.     int __head2 = 0;
  109.     int __guid2 = 0;
  110.     char __buf[__buf_size];
  111.     int __packet_head_size = 4;
  112.     int __random_index = 0;
  113.     unsigned char __packet_head[__packet_head_size];
  114.     
  115.     struct timeval __start_timeval;
  116.     gettimeofday(&__start_timeval, NULL);
  117.     long __start_time = __start_timeval.tv_usec;
  118.     for(int __i = 0; __i < __loop_count; ++__i)
  119.     {
  120.         memset(__buf,0,__buf_size);
  121.         //    pack
  122.         __packet_protobuf.Clear();
  123.         __string_packet.clear();
  124.         __packet_protobuf.set_head(__head);
  125.         __packet_protobuf.set_guid(__guid);
  126.         __packet_protobuf.set_content(__random_string[__random_index]);
  127.         __packet_protobuf.SerializeToString(&__string_packet);
  128.         int __length = __string_packet.length();
  129.         memcpy(__buf,(void*)&__length,4);
  131.         //    unpack
  132.         __packet_protobuf.Clear();
  133.         __packet_protobuf.ParseFromString(__string_packet);
  134.         __head2 = __packet_protobuf.head();
  135.         __guid2 = __packet_protobuf.guid();
  136.     }
  137.     struct timeval __end_timeval;
  138.     gettimeofday(&__end_timeval, NULL);
  139.     long __end_time = __end_timeval.tv_usec;
  140.     long __time_total = __end_time - __start_time;
  141.     printf("start time = %ld, end time = %ld,protobuf total time = %ld\n",__start_time,__end_time,__time_total);    
  142. }
  144. void json_test()
  145. {
  146.     int __guid = 15;
  147.     int __head = 567;
  148.     int __length2 = 0;
  149.     int __head2 = 0;
  150.     int __guid2 = 0;
  151.     char __buf[__buf_size];
  152.     int __random_index = 0;
  153.     
  154.     struct timeval __start_timeval;
  155.     gettimeofday(&__start_timeval, NULL);
  156.     long __start_time = __start_timeval.tv_usec;
  157.     for(int __i = 0; __i < __loop_count; ++__i)
  158.     {
  159.         //    pack
  160.         json_t* __json_msg = json_object();
  161.         json_t* __json_head = json_integer(__head);
  162.         json_t* __json_guid = json_integer(__guid);
  163.         json_t* __json_content = json_string(__random_string[__random_index].c_str());
  164.         json_object_set(__json_msg, "head", __json_head);
  165.         json_object_set(__json_msg, "guid", __json_guid);
  166.         json_object_set(__json_msg, "content", __json_content);
  167.         char* __json_dumps_string = json_dumps(__json_msg,0);
  168.         int __length = strlen(__json_dumps_string);
  169.         json_decref(__json_head);
  170.         json_decref(__json_guid);
  171.         json_decref(__json_content);
  172.         json_decref(__json_msg);
  173.         
  174.         //    unpack
  175.         json_error_t* __json_error = NULL;
  176.         json_t* __json_loads = json_loads(__json_dumps_string,JSON_DECODE_ANY,__json_error);
  177.         json_t* __json_loads_head = json_object_get(__json_loads,"head");
  178.         json_t* __json_loads_guid = json_object_get(__json_loads,"guid");
  179.         __head2 = json_integer_value(__json_loads_head);
  180.         __guid2 = json_integer_value(__json_loads_guid);
  181.         json_decref(__json_loads);
  182.         free(__json_dumps_string);
  183.     }
  184.     struct timeval __end_timeval;
  185.     gettimeofday(&__end_timeval, NULL);
  186.     long __end_time = __end_timeval.tv_usec;
  187.     long __time_total = __end_time - __start_time;
  188.     printf("start time = %ld, end time = %ld,json total time = %ld\n",__start_time,__end_time,__time_total);
  189. }
  191. int main(int __arg_num, char** __args)
  192. {
  193.     byte_stream_test();
  194.     protobuf_test();
  195.     json_test();
  196. }

   技术分享
    其结果与上面的推断基本一致.
    其他疑问：使用protobuf,json的方式，读线程的每个tick时间较长，意味着处理的数据可能更少，但是为什么带宽和处理数据包更多了，且接近于满值。目前想到的可能性是使用byte stream的方式服务器基本能及时处理客户端的请求，大部分时间都在sleep了，因此cpu使用量也比较低。(也额外做过测试，将服务器线程的sleep时间更改为10毫秒，这样带宽，以及数据包数量也与后两者相近了，是不是原因就如此呢？)

三种网络数据传输方式比较(byte stream,protobuf,json)

标签：

原文地址：http://www.cnblogs.com/4Dream/p/4904568.html
踩
(0)
赞
(1)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！