精华内容
下载资源
问答
  • socket读写缓冲区.

    2020-11-21 08:36:40
    关于socket的发送缓冲区网上有诸多的讨论,这里个人小结一下,希望对以后有些帮助。首先,看下面一段代码, //设定socket参数 #define dfUdpRcvCacheSize 2561024 //256//接收缓冲区大小(字节) int optval,optlen ...

    关于socket的发送缓冲区网上有诸多的讨论,这里个人小结一下,希望对以后有些帮助。首先,看下面一段代码,
    //设定socket参数
    #define dfUdpRcvCacheSize 2561024 //256//接收缓冲区大小(字节)
    int optval,optlen = sizeof(int);
    optval=dfUdpRcvCacheSize; //设置读缓冲区
    err=setsockopt(iSock,SOL_SOCKET,SO_RCVBUF,(char
    )&optval,optlen);
    optval=dfUdpSndCacheSize; //设置读缓冲区
    err=setsockopt(iSock,SOL_SOCKET,SO_SNDBUF,(char*)&optval,optlen);
    上面的代码无需解释,很多人应该都知道是在win32下面用来设置SOCKET接收发送缓冲区的,先不讨论上面的代码有没问题。既然提供了这样的API可以对缓冲区进行设置,那么究竟对缓冲区的设置是否有一个最大值的限制呢?先来看下网上各大技术论坛对该问题的讨论:
    ”只要是IP包就是65535字节, 也就是64K

    这是由IP数据报的结构决定的

    IP首部有个表示IP数据报总长度的16位字节, 其最大值表示为FFFF

    因此最大值为65535

    此数值不是纯粹的数据净负荷,而是包含了IP首部信息

    而IP首部是20字节, UDP首部是8字节

    因此UDP数据部分是65535-20-8=65507 ”
    显然,该段评论的论据本身是没错的,本人也专门翻了TCP/IP详解第一卷第3章的IP协议,看到了IP首部表示数据包总长度的字段是16个字节,最长表示65535,当然还要去掉首部。论据本身是对的,但该论据并不能证明我最开始提出的论点,因为我们的论点是socket发送以及读取缓冲区设置的最大长度,显然,这并不等于1个IP数据包的最大长度,甚至可以说其实两者毫无关系。原因在此,何谓发送缓冲区,其实无非是大并发量时期,socket本身都会在本身维护一个缓冲池,然后分段(注意:此次的分段,很明显,大家都知道这才是不能超过1个IP包的最大长度)往目的地址发送数据。 说到这里,应该明白不少了吧:) ,遗憾的是,本人最终还是没有查到win32对于socket接收缓冲区大小的最大限制,而在实际大并发量通讯的项目中,目前我是设置了256k,暂时没发现任何问题。
    既然说到了IP包的最大长度,那么随带提一下,一切理论都要结合实践。在公网网络通信中,无论你如何七十二变,你最终都要经过中国复杂而又混乱的互联网络,那么在实际的UDP通讯中,是否每次都可以组成一个最大的IP包往外仍呢,答案自然是否定的,抛开MTU最大传输单元本身不说,通常为1.5K左右,也就是说传输层要发送的数据超过了1.5K那么IP层会自动进行数据分片,至于怎样分片以及组包,对于传输层UDP/TCP都是透明的),问题是目前实际公网的路由器,对于大于1k左右的UDP包,都会自动做丢弃处理(经过测试是这样的),所以,通常我们自己必须做的切割包大小为1k,就是超过这个大小的包都必须先在源地址进行切割,再分传送出去)OK,今天先总结到此,里面应该还有很多错误或者遗漏的地方,等有时间再过来修改。

    展开全文
  • linux下查看系统socket读写缓冲区

    千次阅读 2018-12-23 12:22:03
    一:linux下查看系统socket读写缓冲区大小配置: http://blog.csdn.net/herecles/article/details/8146017   1. tcp 收发缓冲区默认值 [root@ www.linuxidc.com]# cat /proc/sys/net/ipv4/tcp_rmem   4096 ...

    一:linux下查看系统socket读写缓冲区大小配置:

    http://blog.csdn.net/herecles/article/details/8146017

     

    1. tcp 收发缓冲区默认值


    [root@ www.linuxidc.com]# cat /proc/sys/net/ipv4/tcp_rmem  


    4096    87380   4161536


    87380  :tcp接收缓冲区的默认值


    [root@ www.linuxidc.com]# cat /proc/sys/net/ipv4/tcp_wmem 


    4096    16384   4161536


    16384  : tcp 发送缓冲区的默认值


    2. tcp 或udp收发缓冲区最大值


    [root@ www.linuxidc.com]# cat /proc/sys/net/core/rmem_max 


    131071


    131071:tcp 或 udp 接收缓冲区最大可设置值的一半。


    也就是说调用 setsockopt(s, SOL_SOCKET, SO_RCVBUF, &rcv_size, &optlen);  时rcv_size 如果超过 131071,那么


    getsockopt(s, SOL_SOCKET, SO_RCVBUF, &rcv_size, &optlen); 去到的值就等于 131071 * 2 = 262142


    [root@ www.linuxidc.com]# cat /proc/sys/net/core/wmem_max  


    131071


    131071:tcp 或 udp 发送缓冲区最大可设置值得一半。


    跟上面同一个道理


    3. udp收发缓冲区默认值


    [root@ www.linuxidc.com]# cat /proc/sys/net/core/rmem_default   


    111616:udp接收缓冲区的默认值


    [root@ www.linuxidc.com]# cat /proc/sys/net/core/wmem_default 


    111616


    111616:udp发送缓冲区的默认值


    4. tcp 或udp收发缓冲区最小值


    tcp 或udp接收缓冲区的最小值为 256 bytes,由内核的宏决定;


    tcp 或udp发送缓冲区的最小值为 2048 bytes,由内核的宏决定

     

    二:socket编程设置读写缓冲区大小:

    http://blog.csdn.net/maopig/article/details/6982457

    系统提供的socket缓冲区大小为8K,你可以将之设置为64K,尤其在传输实时视频时。 

    socket发送数据时候先把数据发送到socket缓冲区中,之后接受函数再从缓冲区中取数据,如果发送端特别快的时候,缓冲区很快就被填满(socket默认的是1024×8=8192字节),这时候我们应该根据情况设置缓冲区的大小,可以通过setsockopt函数实现

     #include <stdio.h> 
    #include <stdlib.h> 
    #include <unistd.h> 
    #include <string.h> 
    #include <errno.h> 
    #include <sys/types.h> 
    #include <sys/socket.h> 
    #include <assert.h> 
     
    int main(int argc,char **argv) 

        int err = -1;        /* 返回值 */ 
        int s = -1;            /* socket描述符 */ 
        int snd_size = 0;   /* 发送缓冲区大小 */ 
        int rcv_size = 0;    /* 接收缓冲区大小 */ 
        socklen_t optlen;    /* 选项值长度 */ 
     
        /* 
         * 建立一个TCP套接字 
         */ 
        s = socket(PF_INET,SOCK_STREAM,0); 
        if( s == -1){ 
            printf("建立套接字错误\n"); 
            return -1;     
        } 
         
        /* 
         * 先读取缓冲区设置的情况 
         * 获得原始发送缓冲区大小 
         */ 
        optlen = sizeof(snd_size); 
        err = getsockopt(s, SOL_SOCKET, SO_SNDBUF,&snd_size, &optlen); 
        if(err<0){ 
            printf("获取发送缓冲区大小错误\n"); 
        }   
        /* 
         * 打印原始缓冲区设置情况 
         */ 
     
        /* 
         * 获得原始接收缓冲区大小 
         */ 
        optlen = sizeof(rcv_size); 
        err = getsockopt(s, SOL_SOCKET, SO_RCVBUF, &rcv_size, &optlen); 
        if(err<0){ 
            printf("获取接收缓冲区大小错误\n"); 
        } 
         
       printf(" 发送缓冲区原始大小为: %d 字节\n",snd_size); 
       printf(" 接收缓冲区原始大小为: %d 字节\n",rcv_size); 
     
        /* 
         * 设置发送缓冲区大小 
         */ 
        snd_size = 10*1024;    /* 发送缓冲区大小为8K */ 
        optlen = sizeof(snd_size); 
        err = setsockopt(s, SOL_SOCKET, SO_SNDBUF, &snd_size, optlen); 
        if(err<0){ 
            printf("设置发送缓冲区大小错误\n"); 
        } 
     
        /* 
         * 设置接收缓冲区大小 
         */ 
        rcv_size = 10*1024;    /* 接收缓冲区大小为8K */ 
        optlen = sizeof(rcv_size); 
        err = setsockopt(s,SOL_SOCKET,SO_RCVBUF, (char *)&rcv_size, optlen); 
        if(err<0){ 
            printf("设置接收缓冲区大小错误\n"); 
        } 
     
        /* 
         * 检查上述缓冲区设置的情况 
         * 获得修改后发送缓冲区大小 
         */ 
        optlen = sizeof(snd_size); 
        err = getsockopt(s, SOL_SOCKET, SO_SNDBUF,&snd_size, &optlen); 
        if(err<0){ 
            printf("获取发送缓冲区大小错误\n"); 
        }   
     
        /* 
         * 获得修改后接收缓冲区大小 
         */ 
        optlen = sizeof(rcv_size); 
        err = getsockopt(s, SOL_SOCKET, SO_RCVBUF,(char *)&rcv_size, &optlen); 
        if(err<0){ 
            printf("获取接收缓冲区大小错误\n"); 
        } 
     
        /* 
         * 打印结果 
         */ 
        printf(" 发送缓冲区大小为: %d 字节\n",snd_size); 
        printf(" 接收缓冲区大小为: %d 字节\n",rcv_size); 
     
        close(s); 
        return 0; 

    运行后的结果:

    发送缓冲区原始大小为: 16384 字节

     接收缓冲区原始大小为: 87380 字节
     发送缓冲区大小为: 20480 字节
     接收缓冲区大小为: 20480 字节
    从结果 看出ubuntu系统默认的发送缓冲区大小:16384字节,接收缓冲区87380字节

    但是有个问题我设置的接收和发送缓冲区大小为:10*1024=10240字节,但是实际用getoptsock得到却是20480字节加了一倍。改成其他大小也是都是加倍。

    这是由linux内核的算法决定的。

    展开全文
  • 关于socket读写缓冲区小结

    千次阅读 2011-11-08 13:15:10
    关于socket的发送缓冲区网上有诸多的讨论,这里个人小结一下,希望对以后有些帮助。首先,看下面一段代码, //设定socket参数 #define dfUdpRcvCacheSize 256*1024 //256//接收缓冲区大小(字节)  int optval...
     
    

    关于socket的发送缓冲区网上有诸多的讨论,这里个人小结一下,希望对以后有些帮助。首先,看下面一段代码,

    //设定socket参数

    #define dfUdpRcvCacheSize  256*1024 //256//接收缓冲区大小(字节)
     int optval,optlen = sizeof(int);
     optval=dfUdpRcvCacheSize; //设置读缓冲区  
     err=setsockopt(iSock,SOL_SOCKET,SO_RCVBUF,(char*)&optval,optlen);
     optval=dfUdpSndCacheSize; //设置读缓冲区
     err=setsockopt(iSock,SOL_SOCKET,SO_SNDBUF,(char*)&optval,optlen);

    上面的代码无需解释,很多人应该都知道是在win32下面用来设置SOCKET接收发送缓冲区的,先不讨论上面的代码有没问题。既然提供了这样的API可以对缓冲区进行设置,那么究竟对缓冲区的设置是否有一个最大值的限制呢?先来看下网上各大技术论坛对该问题的讨论:

    ”只要是IP包就是65535字节,   也就是64K   
        
      这是由IP数据报的结构决定的   
        
      IP首部有个表示IP数据报总长度的16位字节,   其最大值表示为FFFF   
        
      因此最大值为65535   
        
      此数值不是纯粹的数据净负荷,而是包含了IP首部信息   
        
      而IP首部是20字节,   UDP首部是8字节   
        
      因此UDP数据部分是65535-20-8=65507   ”

    显然,该段评论的论据本身是没错的,本人也专门翻了TCP/IP详解第一卷第3章的IP协议,看到了IP首部表示数据包总长度的字段是16个字节,最长表示65535,当然还要去掉首部。论据本身是对的,但该论据并不能证明我最开始提出的论点,因为我们的论点是socket发送以及读取缓冲区设置的最大长度,显然,这并不等于1个IP数据包的最大长度,甚至可以说其实两者毫无关系。原因在此,何谓发送缓冲区,其实无非是大并发量时期,socket本身都会在本身维护一个缓冲池,然后分段(注意:此次的分段,很明显,大家都知道这才是不能超过1个IP包的最大长度)往目的地址发送数据。  说到这里,应该明白不少了吧:) ,遗憾的是,本人最终还是没有查到win32对于socket接收缓冲区大小的最大限制,而在实际大并发量通讯的项目中,目前我是设置了256k,暂时没发现任何问题。

    既然说到了IP包的最大长度,那么随带提一下,一切理论都要结合实践。在公网网络通信中,无论你如何七十二变,你最终都要经过中国复杂而又混乱的互联网络,那么在实际的UDP通讯中,是否每次都可以组成一个最大的IP包往外仍呢,答案自然是否定的,抛开MTU最大传输单元本身不说,通常为1.5K左右,也就是说传输层要发送的数据超过了1.5K那么IP层会自动进行数据分片,至于怎样分片以及组包,对于传输层UDP/TCP都是透明的),问题是目前实际公网的路由器,对于大于1k左右的UDP包,都会自动做丢弃处理(经过测试是这样的),所以,通常我们自己必须做的切割包大小为1k,就是超过这个大小的包都必须先在源地址进行切割,再分传送出去)OK,今天先总结到此,里面应该还有很多错误或者遗漏的地方,等有时间再过来修改。

    展开全文
  • 转自:...缓冲区提供了两种方法来读写缓冲区中的数据:get、put方法和array方法。而get、put方法可以有三种读写数据的方式:按顺序读写单个

    转自:http://www.blogjava.net/nokiaguy/archive/2009/08/archive/2009/nokiaguy/archive/2009/10/09/297494.html

    对于缓冲区来说,最重要的操作就是读写操作。缓冲区提供了两种方法来读写缓冲区中的数据:getput方法和array方法。而getput方法可以有三种读写数据的方式:按顺序读写单个数据、在指定位置读写单个数据和读写数据块。除了上述的几种读写数据的方法外,CharBuffer类还提供了用于专门写字符串的putappend方法。在本文及后面的文章中将分别介绍这些读写缓冲区的方法。

    虽然使用allocate方法创建的缓冲区并不是一次性地分配内存空间,但我们可以从用户地角度将一个缓冲区想象成一个长度为capacity的数组。当缓冲区创建后,和数组一样,缓冲区的大小(capacity值)将无法改变,也无法访问缓冲区外的数据。如下面的代码创建了一个大小为6的字节缓冲区。

    ByteBuffer byteBuffer = ByteBuffer.allocate(6);

    对于byteBuffer来说,只能访问属于这个缓冲区的六个字节的数据,如果超过了这个范围,将抛出一个BufferOverflowException异常,这是一个运行时错误,因为这个错误只能在程序运行时被发现。

    既然缓冲区和数组类似,那么缓冲区也应该象数组一样可以标识当前的位置。缓冲区的position方法为我们提供了这个功能。position方法有两种重载形式,它们的定义如下:

    public  final  int position()
    public  final Buffer position( int newPosition)

    第一个重载形式用来获取缓冲区的当前位置。在创建缓冲区后,position的初始值是0,也就是缓冲区第一个元素的位置。当从缓冲区读取一个元素后,position的值加1。我们从这一点可以看出,position方法返回的位置就是当前可以读取的元素的位置。position的取值范围从0capacity – 1。如果position的值等于capacity,说明缓冲区当前已经没有数据可读了。

    position方法的第二个重载形式可以设置缓冲区的当前位置。参数newPosition的取值范围是0 <= newPosition < capacity。如果newPosition的值超出这个范围,position方法就会抛出一个IllegalArgumentException异常。

    在大多数情况下不需要直接控制缓冲区的位置。缓冲区类提供的用于读写数据的方法可以自动地设置缓冲区的当前位置。在缓冲区类中,getput方法用于读写缓冲区中的数据。getput方法的定义如下:

    ByteBuffer类的getput方法:

    public  abstract  byte get()            
    public  abstract ByteBuffer put( byte b) 

    IntBuffer类的getput方法:

    public  abstract  int get()            
    public  abstract IntBuffer put( int i) 

    其他五个缓冲区类中的getput方法定义和上面的定义类似,只是get方法返回相应的数据类型,而put方法的参数是相应的数据类型,并且返回值的类型是相应的缓冲区类。

    每当put方法向缓冲区写入一个数据后,缓冲区的当前位置都会加1。如果缓冲区的当前位置已经等于capacity,调用put方法就会抛出一个java.nio.BufferOverflowException异常。在缓冲区未初赋值的区域将被0填充。使用get方法可以得到缓冲区当前位置的数据,并使缓冲区的当前位置加1。和put方法一样,在缓冲区当前位置等于capacity时使用get方法也会抛出java.nio.BufferOverflowException异常。缓冲区的初始状态如图1所示。

    图1  缓冲区的初始状态

    从图1可以看出,在缓冲区创建之初,当前的位置和缓冲区中的数据都为0。当使用如下语句向缓冲区中写入数据后,缓冲区当前状态如图2所示。

     

    byteBuffer.put(( byte)2);
    byteBuffer.put(( byte)-1);

    图2  缓冲区的当前状态

     

    当缓冲区的当前位置如图3所示时,使用putget方法将会抛出上述的BufferOverflowException异常。

    图3  当前位置处于缓冲区尾

    如果要使用get方法得到缓冲区中的指定数据,必须将缓冲区的当前位置移动到指定的位置,我们可以使用position方法将当前位置移到缓冲区的任何位置。如下面的代码将图3所示的缓冲区的当前位置设为2,并用get方法获得位置2的数据:

    byteBuffer.position(2);
    System.out.println(byteBuffer.get());

    上面的代码将输出3。缓冲区的当前位置为除了使用position方法,也可以使用rewind方法将缓冲区的当前位置设为0rewind方法的定义如下:

    public  final Buffer rewind()

    在图2所示的缓冲区状态下调用rewind方法,就会得到如图4的缓冲区状态。

    图4  调用rewind方法后的缓冲区状态

    接下来让我们执行如下语句:

    System.out.println(byteBuffer.get());

    缓冲区的状态将如图5所示。

    图5  调用get方法后的缓冲区状态

    缓冲区除了positioncapacity外,还提供了一个标识来限制缓冲区可访问的范围。这个标识就是limitlimitposition一样,在缓冲区类中也提供了两个重载方法。用于获得和设置limit的值。limit方法的定义如下:


    public  final  int limit()
    public  final Buffer limit( int newLimit) 

    在初始状态下,缓冲区的limitcapacity值相同。但limitcapacity的区别是limit可以通过limit方法进行设置,而capacity在创建缓冲区时就已经指定了,并且不能改变。(在上面所讲的position方法的newPosition参数的取值范围时曾说是0 <= newPosition < capacity,其实严格地说,应是0 <= newPosition < limitlimit的其他性质和capacity一样。如在图5所示的缓冲区状态中将limit的值设为2,就变成了图6所示的状态。

    图6  将limit设为2的缓冲区状态

    在这时position的值等于limit,就不能访问缓冲区的当前数据,也就是说不能使用getput方法。否则将抛出BufferOverflowException异常。由于使用allocate创建的缓冲区并不是一次性地分配内存空间,因此,可以将缓冲区的capacity设为很大的值,如10M。缓冲区过大可能在某些环境中会使系统性能降低(如在PDA或智能插秧机中),因此,可以使用limit方法根据具体的情况来限定缓冲区的大小。当然,limit还可以表示缓冲区中实际的数据量,这将在后面讲解。下面的代码演示了如何使用limit方法来枚举缓冲区中的数据:

    while(byteBuffer.position() < byteBuffer.limit())
        System.out.println(byteBuffer.get());

    我们还可以用fliphasRemaining方法来重写上面的代码。flip方法将limit设为缓冲区的当前位置。当limit等于position时,hasRemaining方法返回false,而则返回true fliphasRemaining方法的定义如下:


    public  final Buffer flip()
    public  final  boolean hasRemaining() 

        下面的代码演示了如何使用hasRemaining方法来枚举缓冲区中的数据:

    while(byteBuffer.hasRemaining())
        System.out.println(byteBuffer.get());

    如果从缓冲区的第一个位置依次使用put方法向缓冲区写数据,当写完数据后,再使用flip方法。这样limit的值就等于缓冲区中实际的数据量了。在网络中传递数据时,可以使用这种方法来设置数据的结束位置。

    为了回顾上面所讲内容,下面的代码总结了创建缓冲区、读写缓冲区中的数据、设置缓冲区的limitposition的方法。

       package net;
      
       import java.nio.*;
      
       public  class GetPutData
      {
           public  static  void main(String[] args)
          {
               //  创建缓冲区的四种方式
              IntBuffer intBuffer = IntBuffer.allocate(10);
              ByteBuffer byteBuffer = ByteBuffer.allocateDirect(10);
              CharBuffer charBuffer = CharBuffer.wrap("abcdefg");
              DoubleBuffer doubleBuffer = DoubleBuffer.wrap( new  double[] { 1.1, 2.2 });
              
               //  向缓冲区中写入数据
              intBuffer.put(1000);
              intBuffer.put(2000);
              
              System.out.println("intBuffer的当前位置:" + intBuffer.position());
              
              intBuffer.position(1);   //  将缓冲区的当前位置设为1
              System.out.println(intBuffer.get());   //  输出缓冲区的当前数据
              
              intBuffer.rewind();   //  将缓冲区的当前位置设为0
              System.out.println(intBuffer.get());   //  输出缓冲区的当前数据
              
              byteBuffer.put(( byte)20);
              byteBuffer.put(( byte)33);
              byteBuffer.flip();    //  将limit设为position,在这里是2
              byteBuffer.rewind(); 
               while(byteBuffer.hasRemaining())   //  枚举byteBuffer中的数据
                  System.out.print(byteBuffer.get() + " ");
              
               while(charBuffer.hasRemaining())   //  枚举charBuffer中的数据
                  System.out.print(charBuffer.get() + " ");
      
               //  枚举doubleBuffer中的数据
               while(doubleBuffer.position() < doubleBuffer.limit())
                  System.out.print(doubleBuffer.get() + " ");
      
          }
      }

    运行结果:   

    intBuffer的当前位置:2
    2000
    1000
    20 33 a b c d e f g 1.1 2.2

    注意:如果必须使用缓冲区的大小来读取缓冲区的数据,尽量不要使用capacity,而要使用limit。如尽量不要写成如下的代码:

    while(byteBuffer.position() < byteBuffer.capacity())
        System.out.println(byteBuffer.get());

    这是因为当limit比capacity小时,上面的代码将会抛出一个BufferUnderflowException异常。


    展开全文
  • 小结:关于socket读写缓冲区

    万次阅读 2007-09-19 17:32:00
    关于socket的发送缓冲区网上有诸多的讨论,这里个人小结一下,希望对以后有些帮助。首先,看下面一段代码,//设定socket参数#define dfUdpRcvCacheSize 256*1024 //256//接收缓冲区大小(字节) int optval,...
  • 在tcp的通信过程中,内核其实为tcp维护着一个缓冲区 当调用write/send时,会向内核缓冲区中写入数据,内核和tcp协议栈负责将缓冲区中的数据发送到指定,port>的目标位置。 当有数据到达内核的tcp缓冲区中,如果开启...
  • tcp缓冲区

    千次阅读 2019-02-08 16:40:39
    write()/send() 并不立即向网络中传输数据,而是先将数据写入缓冲区中,再由TCP协议将数据从缓冲区发送到目标机器。一旦将数据写入到缓冲区,函数就可以成功返回,不管它们有没有到达目标机器,也不管它们何时被发送...
  • 环形缓冲区

    千次阅读 2017-12-14 17:19:13
    我们再处理网络数据包时,可能会将接受到的网络数据包放入缓冲区去做进一步的处理,这里我自己根据自己的需要用C++编写了一个环形缓冲区,实际上是用数组来进行模拟。 首先头文件“RingBuffer.h”如下: #pragma ...
  • 用户进程缓冲区和内核缓冲区

    千次阅读 2019-04-29 16:20:46
    但实际上有一部分人把用户进程缓冲区和系统空间的缓冲区的概念混淆了,包括这两种缓冲区的用法和所要解决的问题,还有其它类似的概念。本文就来区分一下不同的缓冲区概念(主要针对类unix平台)。 用户进程和操作...
  • 一文搞懂用户缓冲区与内核缓冲区

    千次阅读 2020-09-21 09:58:46
    但实际上有一部分人把用户进程缓存区和系统空间缓存区的概念混淆了,包括这两种缓冲区的用法和所要解决的问题,还有其它类似的概念。本文就来区分一下不同的缓冲区概念(主要针对类unix平台)。  用户进程和操作...
  • 网络层数据缓冲区大小的设置

    千次阅读 2014-07-24 16:08:42
    在send(), recv()的时候,返回的是实际发送出去的字节(同步)或发送到socket缓冲区的字节 (异步);系统默认的状态发送和接收一次为8688字节(约为8.5K);在实际的过程中发送数据 和接收数据量比较大,可以设置socket...
  • 1.读写缓冲的设计可以直接使用stl 中的vector模板,为了更加方便,我们继承vector类,添加像string一样方便的append函数,让后声明只能指针: typedef unsigned char uint8_t; class byte_buffer:public vector { ...
  • 这个是根据自己的项目来设计的缓冲区,应用方面可能比较窄,只适用相关操作。  先说一下相关的背景,我这里的结构是这样的:本地一个线程专门负责采集数据recordsound,本地同样有一个线程专门负责播放数据...
  • 我们在使用TCP/IP编程的时候除了socket有收发数据缓冲区之外,通常我们还要自己定一个数据的收发缓冲区: 1,为什么系统已经有收发缓冲区了,我们还要自定义收发缓冲区呢?  a.假设应用程序需要发送40kB数据,但是...
  • 一般说IO操作,指的是文件IO,如果指的是网络IO,都会直接说网络IO 文件IO常用操作 文件操作无非就是读和写 open 打开 read 读取 write 写入 close 关闭 readline 行读取 readlines 多行读取 seek 文件指针操作 tell ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 93,538
精华内容 37,415
关键字:

网络读写缓冲区