Go on erpan's note

磁盘IO类型

Tue, 18 Apr 2023 21:55:06 +0800

仅作为个人笔记，不保证完全的准确性和正确性，请自行甄别

顺序写

文件IO中的“顺序写”通常指的是对文件进行连续写入操作的过程，即从文件的一个位置开始，依次向后写入数据，即追加。可以提高写入效率，尤其是在传统的机械硬盘（HDD）上，因为不需要频繁地在不同的位置之间切换，减少了寻道时间和旋转延迟。

需要注意的是，“顺序写”并不直接等同于物理磁盘上的连续空间写入。虽然理想情况下，操作系统和文件系统会尽量将文件的数据块分配到物理上连续的存储空间中，以提高读写性能，但实际上由于多种因素（如文件系统的碎片、先前删除文件留下的空洞、以及其他文件的存在等），很难保证文件的所有部分都能被分配到完全连续的物理空间中。因此，通常说的“顺序写”，更多是指逻辑上的连续写入，即按照文件内部的偏移量顺序写入数据，而不是指物理磁盘上的连续写入。

即，“顺序写”主要关注的是逻辑层面的连续性，而物理层面的连续性则是文件系统和操作系统尽力优化的结果。

示例

顺序写：

package main

import (
  "fmt"
  "os"
)

func main() {
  fileName := "t.bin"
  fileSize := 1 << 30 // 1GB  1073741824
  // fileSize := 1073741825 // 测试不按照块的倍数写

  // 创建并截断文件（直接分配空间）
  file, err := os.Create(fileName)
  if err != nil {
    fmt.Println("Error creating file:", err)
    return
  }
  defer file.Close()

  fInfo, err := file.Stat()
  if err != nil {
    fmt.Println("Error getting file size:", err)
  }
  fmt.Println("create: ", fInfo.Size())

  err = file.Truncate(int64(fileSize))
  if err != nil {
    fmt.Println("Error truncating file:", err)
    return
  }
  fInfo, _ = file.Stat()
  fmt.Println("truncate: ", fInfo.Size())

  randomBlock := make([]byte, 0x1<<10<<2) // 4kB
  for i := 0; i < len(randomBlock); i++ {
    randomBlock[i] = 0x0
  }

  bytesWritten := 0
  for i := 0; i < fileSize; i += len(randomBlock) {
    n, err := file.Write(randomBlock)
    if err != nil {
      fmt.Println("Error writing to file:", err)
    }
    fmt.Println(n)
    bytesWritten += n
  }
  file.Sync()
  fmt.Println("written: ", bytesWritten)
  fInfo, err = file.Stat()
  if err != nil {
    fmt.Println("Error getting file size:", err)
  }
  fmt.Println("finally: ", fInfo.Size())

  // 文件指针在末尾
  n, err := file.Read(randomBlock)
  fmt.Println("read nums: ", n)
  fmt.Println("err: ", err)
}

输出：

Go 装饰器模式与洋葱模型

Thu, 18 Aug 2022 22:53:06 +0800

简要理解设计思路和用法

golang context包用法理解

Tue, 15 Feb 2022 20:13:06 +0800

简要理解其用法

client-go RingGrowingBuffer 环形缓冲区

Mon, 11 Oct 2021 22:27:36 +0800

在client-go源码中，processorListener对象里面定义了一个RingBuffer用于缓存所有尚未分发的事件通知，在此记录下这个RingBuffer。

RingBuffer一般用于数据的缓存机制，例如tcp协议里面数据包的缓冲就利用到了RingBuffer。

client-go中的这个buffer是非线程安全、可增长、无边界的先进先出环形缓冲区。环是一个逻辑上的概念，有了环，此段内存空间就可以重复利用，不用频繁重新申请内存，本质上数据还是存在数组里面的，这个数组的大小可以按需进行倍数扩容，扩容后需要重新分配内存空间并拷贝未消费的数据到新数组来。因为它是数组，内存是预先分配的，数组是内存上连续的一段空间，它有一个容易预测的访问模式，因此对CPU高速缓存友好，垃圾回收（GC）在这种情况下也不用做什么。

在实现上，可以理解为两个指针：a) 读指针、b)写指针。在一段buffer上，读指针控制下一次该读数据的位置，写指针控制下一次该写数据的位置。在数组里面我们可以直接用数组下标。要遵循FIFO原则，读指针不能超过写指针，两指针重叠了要么buffer写满了，要么buffer为空。

参考这里的一张图

目前我们只需要考虑：

存储啥数据类型
数据如何存放
何时空间满了需要扩容
不能丢失未消费数据

k8s中的源码：

// 源码路径k8s.io/utils/buffer/ring_growing.go

package buffer

// 非线程安全、可增长的环形缓冲区
type RingGrowing struct {
    data     []interface{} // 存任意数据的数组
    n        int // 缓冲区大小
    beg      int // 第一个可用的元素位置索引
    readable int // 未消费的元素数量
}

// 初始化一个RingBuffer
func NewRingGrowing(initialSize int) *RingGrowing {
    return &RingGrowing{
        data: make([]interface{}, initialSize),
        n:    initialSize,
    }
}

// 取出未消费元素中的第一个元素
func (r *RingGrowing) ReadOne() (data interface{}, ok bool) {
    if r.readable == 0 {
        return nil, false
    }
    r.readable--
    element := r.data[r.beg]
    r.data[r.beg] = nil // Remove reference to the object to help GC
    if r.beg == r.n-1 {
        // 这种情况就是读到数组最后一个元素了，下次读就得从列表的头部开始，以免越界
        r.beg = 0
    } else {
        r.beg++
    }
    return element, true
}

// 在buffer尾部添加一个元素，buffer满了就扩容
func (r *RingGrowing) WriteOne(data interface{}) {
    // 满了的情况
    if r.readable == r.n {
        newN := r.n * 2
        // 新开辟一个两倍大小的数组
        newData := make([]interface{}, newN)
        to := r.beg + r.readable
        if to <= r.n {
            copy(newData, r.data[r.beg:to])
        } else {
            // 未消费的元素在数组两端的情况
            copied := copy(newData, r.data[r.beg:])
            copy(newData[copied:], r.data[:(to%r.n)])
        }
        r.beg = 0
        r.data = newData
        r.n = newN
    }
    r.data[(r.readable+r.beg)%r.n] = data
    r.readable++
}

client-go中的这个buffer是非线程安全、可增长、无边界的先进先出环形缓冲区，因此，在此client-go ringBuffer基础上可以继续考虑下面几个问题：