Go如何優(yōu)雅的使用字節(jié)池示例詳解
背景
在某些場景下，我們可能會大量的使用字節(jié)數組，比如IO操作、編解碼，如果不進行優(yōu)化，大量的申請和釋放字節(jié)數組會造成一定的性能損耗，因此有必要復用字節(jié)數組。
為何需要字節(jié)池
在 Go 語言編程中，在從 io.Reader 中讀取數據時，我們都要創(chuàng)建一個字節(jié)切片 []byte 去存儲，在高頻調用或并發(fā)比較高的場景中，需要頻繁的進行內存申請和釋放，增大了 GC 的壓力，所以這時候需要采用 “字節(jié)池” 來優(yōu)化。
最簡單的方式
對于Go語言來說，我們第一個想到的就是使用sync.Pool來做字節(jié)數組的對象池，比如這樣：
package bufferpool
import "sync"
type BytePool struct {
p sync.Pool
}
func NewBytePool(size, cap int) *BytePool {
if size > cap {
panic("size must be less then cap")
}
p := &BytePool{}
p.p.New = func() any {
return make([]byte, size, cap)
}
return p
}
// 獲取字節(jié)數組
func (p *BytePool) Get() []byte {
return p.p.Get().([]byte)
}
// 歸還字節(jié)數組
func (p *BytePool) Put(b []byte) {
// 重置已用大小
b = b[:0]
p.p.Put(b)
}我們簡單的封裝了sync.Pool，sync.Pool.New根據指定的初始大小申請新的字節(jié)數組，在Put的時候重置字節(jié)數組的已用空間（這樣下次才能從頭開始使用）。
測試
我們進行一個簡單性能測試，也就是不斷的申請字節(jié)數組，然后寫入長度為1024的字節(jié)數組塊，共64塊，也就是64KB，測試樣例共3個：
不預先申請空間
這個樣例我們不預先申請字節(jié)數組空間，因此在append的過程中會不斷的申請新的更大的空間，然后轉移字節(jié)數組內容。
func BenchmarkByte(b *testing.B) {
for n := 0; n < b.N; n++ {
// 從長度為0的字節(jié)數組開始
var b []byte
for i := 0; i < blocks; i++ {
b = append(b, block...)
}
}
}預先申請空間
由于這個測試的總大小的預先知道的，因此我們可以先提前申請空間，這樣就不用在append過程中不斷的申請新的更大空間，然后轉移字節(jié)數組內容了。
func BenchmarkMake(b *testing.B) {
for n := 0; n < b.N; n++ {
// 預先保留需要的空間
b := make([]byte, 0, blocks*blockSize)
for i := 0; i < blocks; i++ {
b = append(b, block...)
}
}
}字節(jié)數組池
這里我們每次先從字節(jié)池拿一個字節(jié)數組Get()，使用完之后歸還字節(jié)池Put()。
func BenchmarkBytePool(b *testing.B) {
pool := NewBytePool(0, blocks*blockSize)
for n := 0; n < b.N; n++ {
// 拿字節(jié)數組
b := pool.Get()
for i := 0; i < blocks; i++ {
b = append(b, block...)
}
// 歸還
pool.Put(b)
}
}測試結果
可以看到我們簡單的字節(jié)池就可以帶來很大的性能提升！
BenchmarkByte-16 32470 38136 ns/op BenchmarkMake-16 605449 1962 ns/op BenchmarkBytePool-16 1000000 1162 ns/op
更優(yōu)雅的方式
在實際的編程中，我們在使用字節(jié)數組時，很多時候都需要以一個流的形式去讀寫，同時也可能很難提前計算出需要的大小，因此bytes.Buffer可能更加適合實際的編程。
package bufferpool
import (
"bytes"
"sync"
)
type BufferPool struct {
p sync.Pool
}
func NewBufferPool(size, cap int) *BufferPool {
if size > cap {
panic("size must be less then cap")
}
p := &BufferPool{}
p.p.New = func() any {
var b []byte
if cap > 0 {
b = make([]byte, size, cap)
}
return bytes.NewBuffer(b)
}
return p
}
// 獲取字節(jié)數組
func (p *BufferPool) Get() *bytes.Buffer {
return p.p.Get().(*bytes.Buffer)
}
// 歸還字節(jié)數組
func (p *BufferPool) Put(b *bytes.Buffer) {
// 重置已用大小
b.Reset()
p.p.Put(b)
}測試
測試條件與上面相同。
直接使用Buffer
作為對比實驗我們直接使用Buffer。
func BenchmarkBuffer(b *testing.B) {
for n := 0; n < b.N; n++ {
b := bytes.NewBuffer(make([]byte, 0, blocks*blockSize))
for i := 0; i < blocks; i++ {
b.Write(block)
}
}
}bytes.Buffer池
func BenchmarkBufferPool(b *testing.B) {
pool := NewBufferPool(0, blocks*blockSize)
for n := 0; n < b.N; n++ {
b := pool.Get()
for i := 0; i < blocks; i++ {
b.Write(block)
}
pool.Put(b)
}
}測試結果
可以看到使用bytes.Buffer池比字節(jié)數組池性能差了一點，主要是因為bytes.Buffer比較復雜，但是bytes.Buffer的功能比字節(jié)數組強大很多。
BenchmarkByte-16 31748 38131 ns/op BenchmarkMake-16 605847 1964 ns/op BenchmarkBytePool-16 1000000 1162 ns/op BenchmarkBuffer-16 589336 2030 ns/op BenchmarkBufferPool-16 962132 1235 ns/op
限制池大小
有時候我們不想對象池無限大，因此我們需要限制對象池的大小，對于Go語言來說，我們可以使用channel+select，也就是申請一個固定長度緩沖區(qū)的channel，配合select的default分支。
- Put：channel不滿則put，否則default分支丟棄這個對象。
- Get：channel不空則get，否則default分支申請新對象。
這里我們直接使用minio的實現(xiàn)： github.com/minio/minio…
package bufferpool
type ByteFixPool struct {
cache chan []byte
size int
cap int
}
// cacheSize: 字節(jié)池緩存長度
// size: 字節(jié)數組長度
// cap: 字節(jié)數組容量
func NewByteFixPool(cacheSize, size, cap int) *ByteFixPool {
if size > cap {
panic("size must be less then cap")
}
return &ByteFixPool{
cache: make(chan []byte, cacheSize),
size: size,
cap: cap,
}
}
func (p *ByteFixPool) Get() []byte {
select {
// 從channel讀
case b := <-p.cache:
return b
// 如果channel空則申請一個新的字節(jié)數組
default:
return make([]byte, p.size, p.cap)
}
}
func (p *ByteFixPool) Put(b []byte) {
// 重置已用大小
b = b[:0]
select {
// 放入channel
case p.cache <- b:
// channel滿了則丟棄字節(jié)數組
default:
}
}測試
固定大小字節(jié)池
這里使用固定大小字節(jié)池，同時預先分配空間。
func BenchmarkByteFixPool(b *testing.B) {
pool := NewByteFixPool(16, 0, blocks*blockSize)
for n := 0; n < b.N; n++ {
b := pool.Get()
for i := 0; i < blocks; i++ {
b = append(b, block...)
}
pool.Put(b)
}
}測試結果
可以看到使用channel+select的性能甚至更好一點，而且還能限制字節(jié)池大小，當然相比于sync.Pool的實現(xiàn)，它在字節(jié)池channel里面的空間是沒辦法自動回收的。
BenchmarkByte-16 31748 38131 ns/op BenchmarkMake-16 605847 1964 ns/op BenchmarkBytePool-16 1000000 1162 ns/op BenchmarkBuffer-16 589336 2030 ns/op BenchmarkBufferPool-16 962132 1235 ns/op BenchmarkByteFixPool-16 1000000 1130 ns/op
總結
對于字節(jié)池來說。
字節(jié)對象可以是：
[]byte：字節(jié)數組bytes.Buffer：功能更加強大的字節(jié)數組- 其他：比如一組
bytes.Buffer
實現(xiàn)方式可以是：
sync.Pool：根據GC期間對象是否使用回收對象channel+select：限制字節(jié)池長度- 其他：比如限制對象池使用空間
當然，最通用的實現(xiàn)是sync.Pool+bytes.Buffer，因為sync.Pool能夠自動回收字節(jié)對象，bytes.Buffer又能提供強大的功能。
上面介紹的幾種都是比較常用的，而且實現(xiàn)也非常簡單的字節(jié)池，如果在業(yè)務中有更加復雜的需求，也可以根據需求實現(xiàn)一個字節(jié)池。
總結
到此這篇關于Go如何優(yōu)雅的使用字節(jié)池的文章就介紹到這了,更多相關Go優(yōu)雅使用字節(jié)池內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
本文主要介紹了golang實現(xiàn)協(xié)程池的方法示例,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧2025-02-02
這篇文章主要為大家介紹了Go1.18新特性使用Generics泛型進行流式處理詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-06-06
使用Singleflight實現(xiàn)Golang代碼優(yōu)化
有許多方法可以優(yōu)化代碼以提高效率,減少運行進程就是其中之一,本文我們就來學習一下如何通過使用一個Go包Singleflight來減少重復進程,從而優(yōu)化Go代碼吧2023-09-09
我們都知道go語言中內存管理工作都是由Go在底層完成的，這樣我們可以不用過多的關注底層的內存問題。本文主要總結一下?Golang內存逃逸分析，需要的朋友可以參考以下內容，希望對大家有幫助2022-09-09
在日常工作中每一名開發(fā)者,不管是前端還是后端,都經常使用 JSON,下面這篇文章主要給大家介紹了關于golang解析json數據的4種方法,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下2023-06-06
數組相必大家都很熟悉，各大語言也都有數組的身影。Go 語言也提供了數組類型的數據結構。本文就來通過一些簡單的示例帶大家了解一下Go語言中數組的使用，希望對大家有所幫助2022-12-12
在Go語言中,uint類型的無符號整數在達到其最大值時會發(fā)生回繞,為了避免溢出,應確保不超出最大值,使用條件語句檢查接近溢出點,選擇合適的數據類型,進行適當的錯誤處理,或者使用數學庫處理大整數2024-12-12
這篇文章主要介紹了Go語言函數基本用法,結合實例形式分析了Go語言函數的格式、定義、使用方法與相關注意事項,需要的朋友可以參考下2016-07-07
雪花算法是twitter開源的由64位整數組成的分布式ID,本文主要介紹了Go基于雪花算法生成隨機id,具有一定的參考價值,感興趣的可以了解一下2024-05-05
這篇文章主要介紹了Golang中很好用的viper配置模塊用法，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-12-12