精华内容
参与话题
问答
  • 缓冲区

    千次阅读 2016-04-15 15:30:51
    缓冲区像前篇文章讨论的那样被写满和释放,对于每个非布尔原始数据类型都有一个缓冲区类,尽管缓冲区作用于它们存储的原始数据类型,但缓冲区十分倾向于处理字节,非字节缓冲区可以再后台执行从字节或到字节的转换,...

    什么是缓冲区

    一个缓冲区对象是固定数量的数据的容器,其作用是一个存储器,或者分段运输区,在这里数据可被存储并在之后用于检索。缓冲区像前篇文章讨论的那样被写满和释放,对于每个非布尔原始数据类型都有一个缓冲区类,尽管缓冲区作用于它们存储的原始数据类型,但缓冲区十分倾向于处理字节,非字节缓冲区可以再后台执行从字节或到字节的转换,这取决于缓冲区是如何创建的。

    缓冲区的工作与通道紧密联系。通道是I/O传输发生时通过的入口,而缓冲区是这些数据传输的来源或目标。对于离开缓冲区的传输,待传递出去的数据被置于一个缓冲区,被传送到通道;待传回的缓冲区的传输,一个通道将数据放置在所提供的缓冲区中。这种在协同对象之间进行的缓冲区数据传递时高效数据处理的关键。

    Buffer类的家谱

    下图是Buffer的类层次图。在顶部是通用Buffer类,Buffer定义所有缓冲区类型共有的操作,无论是它们所包含的数据类型还是可能具有的特定行为:

    缓冲区基础

    概念上,缓冲区是包在一个对象内的基本数据元素数组。Buffer类相比一个简单数组的优点是它将关于数据的数据内容和信息包含在一个单一的对象中,Buffer类以及它专有的子类定义了一个用于处理数据缓冲区的API。下面来看一下Buffer类所具有的属性和方法:

    1、属性

    所有的缓冲区都具有四个属性来提供关于其所包含的数据元素的信息,它们是:

    属      性 作      用
    capacity 容量,指缓冲区能够容纳的数据元素的最大数量,这一容量在缓冲区创建时被设定,并且永远不能被改变
    limit 上界,指缓冲区的第一个不能被读或写的元素,或者说是,缓冲区中现存元素的计数
    position 位置,指下一个要被读或写的元素的索引,位置会自动由相应的get()和put()函数更新
    mark 标记,指一个备忘位置,调用mark()来设定mark=position,调用reset()来设定postion=mark,标记未设定前是未定义的

    这四个属性总是遵循以下的关系:0 <= mark <= position <= limit <= capacity

    2、方法

    下面看一下如何使用一个缓冲区,Buffer中提供了以下的一些方法:

    方      法 作      用
    Object array() 返回此缓冲区的底层实现数组
    int arrayOffset() 返回此缓冲区的底层实现数组中第一个缓冲区还俗的偏移量
    int capacity() 返回此缓冲区的容量
    Buffer clear() 清除此缓冲区
    Buffer flip() 反转此缓冲区
    boolean hasArray() 告知此缓冲区是否具有可访问的底层实现数组
    boolean hasRemaining() 告知在当前位置和限制之间是否有元素
    boolean isDirect() 告知此缓冲区是否为直接缓冲区
    boolean isReadOnly() 告知此缓冲区是否为只读缓存
    int limit() 返回此缓冲区的上界
    Buffer limit(int newLimit) 设置此缓冲区的上界
    Buffer mark() 在此缓冲区的位置设置标记
    int position() 返回此缓冲区的位置
    Buffer position(int newPosition) 设置此缓冲区的位置
    int remaining() 返回当前位置与上界之间的元素数
    Buffer reset() 将此缓冲区的位置重置为以前标记的位置
    Buffer rewind() 重绕此缓冲区

    关于这个API有一点值得注意的,像clear()这类函数,通常应当返回的是void而不是Buffer引用。这些函数将引用返回到它们在(this)上被引用的对象,这是一个允许级联调用的类设计方法。级联调用允许这种类型的代码:

    buffer.mark();
    buffer.position(5);
    buffer.reset();

    被简写成:

    buffer.mark().position(5).reset();
    

    缓冲区代码实例

    对缓冲区的使用,先看一段代码,然后解释一下:

    复制代码
     1 public class TestMain
     2 {
     3     /**
     4      * 待显示的字符串
     5      */
     6     private static String[] strs = 
     7     {
     8         "A random string value",
     9         "The product of an infinite number of monkeys",
    10         "Hey hey we're the monkees",
    11         "Opening act for the Monkees:Jimi Hendrix",
    12         "Scuse me while I kiss this fly",
    13         "Help Me! Help Me!"
    14     };
    15     
    16     /**
    17      * 标识strs的下标索引
    18      */
    19     private static int index = 0;
    20     
    21     /**
    22      * 向Buffer内放置数据
    23      */
    24     private static boolean fillBuffer(CharBuffer buffer)
    25     {
    26         if (index >= strs.length)
    27             return false;
    28         
    29         String str = strs[index++];
    30         for (int i = 0; i < str.length(); i++)
    31         {
    32             buffer.put(str.charAt(i));
    33         }
    34         
    35         return true;
    36     }
    37     
    38     /**
    39      * 从Buffer内把数据拿出来
    40      */
    41     private static void drainBuffer(CharBuffer buffer)
    42     {
    43         while (buffer.hasRemaining())
    44         {
    45             System.out.print(buffer.get());
    46         }
    47         System.out.println("");
    48     }
    49     
    50     public static void main(String[] args)
    51     {
    52         CharBuffer cb = CharBuffer.allocate(100);
    53         while (fillBuffer(cb))
    54         {
    55             cb.flip();
    56             drainBuffer(cb);
    57             cb.clear();
    58         }
    59     }
    60 }
    复制代码

    逐一解释一下:

    1、第52行,CharBuffer是一个抽象类,它不能被实例化,因此利用allocate方法来实例化,相当于是一个工厂方法。实例化出来的是HeapCharBuffer,默认大小是100。根据上面的Buffer的类家族图谱,可以看到每个Buffer的子类都是使用allocate方法来实例化具体的子类的,且实例化出来的都是Heap*Buffer

    2、第24行~第36行,每次取String数组中的一个,利用put方法放置一个数据进入CharBuffer中

    3、第55行,调用flip方法,这是非常重要的。在缓冲区被写满后,必须将其清空,但是如果现在在通道上直接执行get()方法,那么它将从我们刚刚插入的有用数据之外取出未定义数据;如果此时将位置重新设置为0,就会从正确的位置开始获取数据,但是如何知道何时到达我们所插入数据末端呢?这就是上界属性被引入的目的----上界属性指明了缓冲区有效内容的末端。因此,在读取数据的时候我们需要做两件事情:

    (1)将上界属性limit设置为当前位置    (2)将位置position设置为0

    这两步操作,JDK API给开发者提供了一个filp()方法来完成,flip()方法将一个能够继续添加数据元素的填充状态的缓冲区翻转成一个准备读出元素的释放状态,因此每次准备读出元素前,都必须调用一次filp()方法

    4、第41行~第48行,每次先判断一下是否已经达到缓冲区的上界,若存在则调用get()方法获取到此元素,get()方法会自动移动下标position

    5、第57行,对Buffer的操作完成之后,调用clear()方法将所有属性回归原位,但是clear()方法并不会改变缓冲区中的任何数据

    缓冲区比较

    缓冲区的比较即equals方法,缓冲区的比较并不像我们想像得这么简单,两个缓冲区里面的元素一样就是相等,两个缓冲区相等必须满足以下三个条件:

    1、两个对象类型相同,包含不同数据类型的buffer永远不会像等,而且buffer绝不会等于非buffer对象

    2、两个对象都剩余相同数量的元素,Buffer的容量不需要相同,而且缓冲区中剩余数据的索引也不必相同。但每个缓冲区中剩余元素的数目(从position到limit)必须相同

    3、在每个缓冲区中应被get()函数返回的剩余数据元素序列必须一致

    如果不满足上面三个条件,则返回false。下面两幅图演示了两个缓冲区相等和不相等的场景,首先是两个属性不同的缓冲区也可以相等:

    然后是两个属性相同但是被等为不相等的缓冲区:

    批量移动数据

    缓冲区的设计目的就是为了能够高效地传输数据。一次移动一个数据元素,其实并不高效,如在下面的程序清单中所看到的那样,Buffer API提供了向缓冲区内外批量移动数据元素的函数:

    复制代码
    public abstract class CharBuffer
        extends Buffer
        implements Comparable<CharBuffer>, Appendable, CharSequence, Readable
    {
        ...
        public CharBuffer get(char[] dst){...}
        public CharBuffer get(char[] dst, int offset, int length){...}
        public final CharBuffer put(char[] src){...}
        public CharBuffer put(char[] src, int offset, int length){...}
        public CharBuffer put(CharBuffer src){...}
        public final CharBuffer put(String src){...}
        public CharBuffer put(String src, int start, int end){...}
        ...      
    }
    复制代码

    其实这种批量移动的合成效果和前文的循环在底层实现上是一样的,但是这些方法可能高效得多,因为这种缓冲区实现能够利用本地代码或其他的优化来移动数据。

    字节缓冲区

    字节缓冲区和其他缓冲区类型最明显的不同在于,它们可能成为通道所执行I/O的源头或目标,如果对NIO有了解的朋友们一定知道,通道只接收ByteBuffer作为参数。

    如我们所知道的,操作系统在内存区域进行I/O操作,这些内存区域,就操作系统方面而言,是相连的字节序列。于是,毫无疑问,只有字节缓冲区有资格参与I/O操作。也请回想一下操作系统会直接存取进程----在本例中是JVM进程的内存空间,以传输数据。这也意味着I/O操作的目标内存区域必须是连续的字节序列,在JVM中,字节数组可能不会在内存中连续存储,或者无用存储单元收集可能随时对其进行移动。在Java中,数组是对象,而数据存储在对象中的方式在不同的JVM实现中各有不同。

    出于这一原因,引入了直接缓冲区的概念。直接缓冲区被用于与通道和固有I/O线程交互,它们通过使用固有代码来告知操作系统直接释放或填充内存区域,对用于通道直接或原始存取的内存区域中的字节元素的存储尽了最大的努力。

    直接字节缓冲区通常是I/O操作最好的选择。在设计方面,它们支持JVM可用的最高效I/O机制,非直接字节缓冲区可以被传递给通道,但是这样可能导致性能损耗,通常非直接缓冲不可能成为一个本地I/O操作的目标,如果开发者向一个通道中传递一个非直接ByteBuffer对象用于写入,通道可能会在每次调用中隐含地进行下面的操作:

    1、创建一个临时的直接ByteBuffer对象

    2、将非直接缓冲区的内容复制到临时缓冲中

    3、使用临时缓冲区执行低层次I/O操作

    4、临时缓冲区对象离开作用于,并最终成为被回收的无用数据

    这可能导致缓冲区在每个I/O上复制并产生大量对象,而这种事都是我们极力避免的。

    直接缓冲区是I/O的最佳选择,但可能比创建非直接缓冲区要花费更高的成本。直接缓冲区使用的内存是通过调用本地操作系统的代码分配的,绕过了标准JVM堆栈。建立和销毁直接缓冲区会明显比具有堆栈的缓冲区更极爱破费,这取决于主操作系统以及JVM实现。直接缓冲区的内存区域不受无用存储单元收集支配,因为它们位于标准JVM堆栈之外。

    直接ByteBuffer是通过调用具有所需容量的ByteBuffer.allocateDirect()函数产生的:

    复制代码
    public abstract class ByteBuffer
        extends Buffer
        implements Comparable<ByteBuffer>
    {
        ...
        public static ByteBuffer allocateDirect(int capacity)
        {
            return new DirectByteBuffer(capacity);
        }
        ...
    }
    复制代码
    展开全文
  • 缓冲区溢出以及缓冲区溢出攻击

    千次阅读 2020-08-31 21:35:06
    缓冲区溢出是指当计算机程序向缓冲区内填充的数据位数超过了缓冲区本身的容量。溢出的数据覆盖在合法数据上。理想情况是,程序检查数据长度并且不允许输入超过缓冲区长度的字符串。但是绝大多数程序都会假设数据长度...

    缓冲区溢出是指当计算机程序向缓冲区内填充的数据位数超过了缓冲区本身的容量。溢出的数据覆盖在合法数据上。理想情况是,程序检查数据长度并且不允许输入超过缓冲区长度的字符串。但是绝大多数程序都会假设数据长度总是与所分配的存储空间相匹配,这就为缓冲区溢出埋下隐患。

    展开全文
  • 但是我们自己设定的用户空间缓冲区buf是有大小的,假如小于sockfd通告窗口大小,还是说我们会一般将用户空间的buf大小就写成和通告的窗口大小写成一致,则不存在,一次无法将缓冲区读完的情况发生 以下是tcp回射...
  • 实践发现,当使用socketChannel.close()之后,对于close之前已经写入缓冲区但由于网络原因没有发送成功的数据,在server端网络恢复后,还是能接收到该数据; 求问是否有什么办法能在调用Close之前,将此...
  • 用户进程缓冲区和内核缓冲区

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

    常常听到有程序员会跟你讨论:“我们在读写文件的时候,系统是有缓存的”。但实际上有一部分人把用户进程缓冲区和系统空间的缓冲区的概念混淆了,包括这两种缓冲区的用法和所要解决的问题,还有其它类似的概念。本文就来区分一下不同的缓冲区概念(主要针对类unix平台)。

     

    用户进程和操作系统的关系

     

    首先我用一张图来解释“用户进程和操作系统的关系”

    这是一个计算机系统运行时的简化模型,我们把所有运行在操作系统上的进程成为用户进程,它们都运行在用户空间(可以看到用户空间有很多进程)。把操作系统运行的空间成为系统空间

    为什么将进程分为用户进程和系统进程,首先你一定听说过内核态和用户态(kernel mode和user mode),在内核态可以访问系统资源,比如:

    处理器cpu:cpu控制着一个程序的执行。

    输入输出IO:linux有句话叫“一切都是流”,也就是所有输入输出设备的数据,包括硬盘,内存,终端都可以像流一样操作。

    进程管理:类似对进程的创建,休眠,唤醒,释放之类的调度。比如linux下的fork和windows下的CreateProcess()函数。

    内存:包括内存的申请,释放等管理操作。

    设备:这个就是常常说的外设了,比如鼠标,键盘。

    计时器:计算机能计时是因为晶体振荡器产生的电磁脉冲。那么所有的定时任务都是以它为基础的。

    进程间通信IPC:进程之间是不能够互相访问内存的,所以进程与进程之间的交互需要通信,而通信也是一种资源。

    网络通信:网络通信可以看做是进程见通信的特殊形式。

    而上面所说的这些系统资源,在用户进程中是无法被直接访问的,只能通过操作系统来访问,所以也把操作系统提供的这些功能成为:“系统调用”。

    比如下图,展示一个用户通过shell控制计算机所经过的数据流向:文件读写和终端控制,都是通过内核进行的。

    提供这些限制的基础就是cpu提供的内核态和用户态。比如intel x86 CPU有四种不同的执行级别0-3,linux只使用了其中的0级和3级分别来表示内核态和用户态。

    在用户态,不仅仅是系统资源了,就是别的进程的内存对于你来说,都是“透明的”(并不是没办法访问,否则游戏作弊器怎么实现?)

     

     

     

    用户进程缓冲区

     

    前面提到,用户进程通过系统调用访问系统资源的时候,需要切换到内核态,而这对应一些特殊的堆栈和内存环境,必须在系统调用前建立好。而在系统调用结束后,cpu会从核心模式切回到用户模式,而堆栈又必须恢复成用户进程的上下文。而这种切换就会有大量的耗时。

    你看一些程序在读取文件时,会先申请一块内存数组,称为buffer,然后每次调用read,读取设定字节长度的数据,写入buffer。(用较小的次数填满buffer)。之后的程序都是从buffer中获取数据,当buffer使用完后,在进行下一次调用,填充buffer。

    所以说:用户缓冲区的目的是为了减少系统调用次数,从而降低操作系统在用户态与核心态切换所耗费的时间

     

     

     

    内核缓冲区

     

    除了在进程中设计缓冲区,内核也有自己的缓冲区。

    当一个用户进程要从磁盘读取数据时,内核一般不直接读磁盘,而是将内核缓冲区中的数据复制到进程缓冲区中。

    但若是内核缓冲区中没有数据,内核会把对数据块的请求,加入到请求队列,然后把进程挂起,为其它进程提供服务。

    等到数据已经读取到内核缓冲区时,把内核缓冲区中的数据读取到用户进程中,才会通知进程,当然不同的io模型,在调度和使用内核缓冲区的方式上有所不同,下一小结介绍。

    你可以认为,read是把数据从内核缓冲区复制到进程缓冲区。write是把进程缓冲区复制到内核缓冲区。

    当然,write并不一定导致内核的写动作,比如os可能会把内核缓冲区的数据积累到一定量后,再一次写入。这也就是为什么断电有时会导致数据丢失。

    所以说内核缓冲区,是为了在OS级别,提高磁盘IO效率,优化磁盘写操作。

     

     

    流程

     

    在《Unix网络编程》中的五种io模型,也提到过进程缓冲区和内核缓冲区。因为这个并不是此篇文章的重点,所以这里只对比阻塞模型和非阻塞。

    对比阻塞和非阻塞,在阻塞io中,直到数据从内核缓冲区拷贝到用户缓冲区才通知用户进程调用完成并唤醒,而非阻塞,在轮训得知数据准备好后,数据还是在内核缓冲区中,等你去读取,这也就是说数据准备好,并不代表已经读好可以使用。当然也不代表一定能读。

     

     

    缓冲区和缓存

     

    还有一部分人把缓冲区和缓存混淆,后来我明白这也是因为翻译导致的把两种东西进行混淆。缓冲区的英文是buffer,而缓存的应为是cache。

    CPU缓存(Cache Memory)是位于CPU与内存之间的临时存储器,因为cpu的计算速度要比内存的读写速度快很多,而把这些可能会被重复访问到的数据存储于cpu缓存中,就会提高读取速度。可以说缓存是cpu和内存之间的临时存储器。

    也就是说,buffer是因为减少调用次数,集中调用,提高系统性能。而cache是将读取过的数据保存起来,重新读取时若命中(找到需要的数据)就不要去读硬盘了,若没有命中就读硬盘。

    展开全文
  • Oracle: ORA-06512:字符串缓冲区太小

    万次阅读 2018-11-22 17:55:52
    问题现象:ORA-06512:字符串缓冲区太小 报错截图 解决思路: 出现以上报错后点击"是",plsql会直接定位到以下的程序报错位置; plsql提示的报错位置 由于是查询语句,我现在需要查出在查哪条数据...

    问题现象:ORA-06512:字符串缓冲区太小

    报错截图

    解决思路:

    出现以上报错后点击"是",plsql会直接定位到以下的程序报错位置;

    plsql提示的报错位置

    由于是查询语句,我现在需要查出在查哪条数据时发生的这个报错,便于进行debug,

    一、

    在报错行之前使用

    dbms_output.put_line("v_accoid: " || v_accoid);

    在Output窗口中输出v_accoid,

    二、

    编译后再次运行报错,应该是dbms_output包的缓冲区太小。用自己写的sp_putline()(该函数在我以前的博文有分享出来)替换之。

    三、

    成功查出出错数据

    出错数据

    四、

    Test 该函数之后发现:v_agencyno 变量被定义成了varchar2(10),而该变量的返回结果就达到了12个字节。

    修改v_agencyno的长度为 tageinfo.c_agencyno%type;

    问题完美解决。

    所以在存储过程或函数里定义变量时最好使用【表名.字段名%type】的方式去定义,可以避免以后表字段变大时出现的异常问题。

    展开全文
  • java缓冲区

    万次阅读 2018-11-26 21:38:43
    1 缓冲区的分类 ByteBuffer CharBuffer ShortBuffer IntBuffer LongBuffer FloatBuffer DoubleBuffer 2 ByteBuffer读取数据的操作 容量(capacity):表示Buffer最大数据容量,缓冲区容量不能为负,并且建立后不能...
  • 清空输入缓冲区

    千次阅读 2019-03-24 23:49:49
    所有从键盘输入的数据,,不管是字符还是数字,都是先存储在内存中的一个缓冲区里面,叫做键盘缓冲区,简称“输入缓冲区”或者“输入流”。 #include<stdio.h> int main(void) { int a, b, c; scanf("%d", &...
  • 输入缓冲区与输出缓冲区

    千次阅读 2018-05-17 23:24:34
    本博文通过一段程序来理解输入缓冲区与输出缓冲区。程序如下:/************************************************************************* @Author: wanghao @Created Time : Thu 17 May 2018 06:03:12 AMPDT ...
  • 颜色缓冲区:就是帧缓冲区(图形设备的内存),需要渲染的场景的每一个像素都最终写入该缓冲区,然后由他渲染到屏幕上显示。深度缓冲区:与帧缓冲区对应,用于记录上面每个像素的深度值,通过深度缓冲区,我们可以...
  • printf缓冲区刷新问题

    万次阅读 2020-02-03 22:33:20
    首先,printf缓冲区的问题,平时不大会发现,当时是在使用sleep函数时出现的。先来看一下问题。 #include <stdio.h> int main() { printf("hello\n"); sleep(1); //延迟1秒 printf("world\n"); return 0;...
  • ringbuff | 通用FIFO环形缓冲区实现库

    千次阅读 2020-06-06 10:58:39
    嵌入式开源项目精选专栏 本专栏由Mculover666创建,主要内容为寻找嵌入式领域内的优质开源项目,一是帮助开发者使用开源项目实现更多的功能,二是通过这些开源项目,学习大佬的代码及背后的实现思想,提升自己的代码...
  • STM32进阶之串口环形缓冲区实现

    万次阅读 多人点赞 2018-06-04 10:03:13
    如需转载请说明出处:STM32进阶之串口环形缓冲区实现 队列的概念 在此之前,我们来回顾一下队列的基本概念: 队列 (Queue):是一种先进先出(First In First Out ,简称 FIFO)的线性表,只允许在一端插入(入队),...
  • 当心你的终端输入缓冲区里遗留的炸弹!

    千次阅读 多人点赞 2020-06-13 10:06:41
    来看一个程序: #include <stdio.h> int main (int argc, char ...我这里不谈什么缓冲区溢出,也和各种漏洞无关,我这里说的仅仅是一个操作习惯,或者说编程习惯问题。 问题,输入abc会发生什么? 看看答案: [r
  • 我在构造缓冲区溢出的时候,使fun()函数的返回到main()的地址被自己的函数地址给填充掉,设想的情况是无限执行此函数并输出1,测试结果是只输出了部分1,然后就结束了,为什么? #include using namespace std; void...
  • 环形缓冲区

    万次阅读 2018-10-20 15:11:46
    .... 正在造轮子,同时不停地在找哪里有这个轮子 原因: 当有大量数据的时候,我们不能存储所有的数据,那么计算机处理数据的时候,只能先处理先来的,那么处理完后呢,就会把数据释...
  • tcp缓冲区

    千次阅读 2019-02-08 16:40:39
    每个 socket 被创建后,都会分配两个缓冲区,输入缓冲区和输出缓冲区。 二、缓冲区的意义 write()/send() 并不立即向网络中传输数据,而是先将数据写入缓冲区中,再由TCP协议将数据从缓冲区发送到目标机器。一旦将...
  • TCP/UDP的接收缓冲区和发送缓冲区

    千次阅读 2018-11-23 15:25:30
    每个TCP socket在内核中都有一个发送缓冲区和一个接收缓冲区,TCP的全双工的工作模式以及TCP的流量(拥塞)控制便是依赖于这两个独立的buffer以及buffer的填充状态。 1.1 接收端冲区 接收缓冲区把数据缓存入内核,...
  • 数据缓冲区高速缓冲

    千次阅读 2018-06-12 15:47:08
    因此,内核通过保持一个称为数据缓冲区高速缓冲的内存数据缓冲区池来试图减少对磁盘的存取频率. 当从磁盘中读数据的时候,内核试图先从高速缓冲中读.如果数据已经在该高速缓冲中,则内核可以不必从磁盘上读.如果...
  • 缓冲区刷新问题

    千次阅读 2019-08-18 12:28:14
    缓冲输出流BufferedOutputStream,底层是有一个字节数组当成缓冲区,将数据先存入到缓冲区中,当调用者调用flush方法或者当缓冲区满了之后,数据就会从缓冲区中出来,写入到文件中。 没有调用刷新方法时,数据会...
  • 点击打开链接我们可以用...原因是内核用环形缓冲区存放打印的log信息。那么如何增大缓冲区的大小呢?我们看kernel/printk.c的代码[cpp] view plain copy "font-family: Arial, Helvetica, sans-serif;">/* rec
  • 缓冲区溢出

    千次阅读 2018-08-10 17:30:15
    缓冲区溢出 相关安全文章 概览 描述 风险影响 例子 相关攻击 相关漏洞 相关控制 缓冲区溢出 今天又有点时间,花了大概4个小时不到翻译了这个大概3500字的文章,感觉自己阅读速度真的有待提高。虽说边翻译...
  • 循环缓冲区

    千次阅读 2018-07-26 09:55:46
    这次需要记录之前了解到的参考自linux内核循环队列kfifo的循环缓冲区实现方法。 1、循环缓冲区的实现依靠队列来实现,也就是分配一个数组来存储实际数据。 2、对于一个循环缓冲区来说,我们需要关注的点有: ①...
  • NIO之缓冲区【基础内容】

    千次阅读 2019-04-10 12:30:58
    缓冲区Buffer 1.缓冲区介绍   一个Buffer对象是固定数量的数据的容器。其作用是一个存储器,或者分段运输区,在这里数据可被存储并在之后用于检索。缓冲区可以写满和释放。对于每个非布尔原始数据类型都有一个缓冲...

空空如也

1 2 3 4 5 ... 20
收藏数 69,751
精华内容 27,900
关键字:

缓冲区