go - sync.Pool 比使用 channel 慢很多，为什么要使用 sync.Pool？

Question

看了sync.Pool的设计，发现是两个逻辑，为什么要用localPool来解决锁竞争。我们可以只使用 chan 来实现一个。

使用 channel 比 sync.pool 快 4 倍!

pool除了可以clear object，还有什么优势呢？

这是池实现和基准测试代码:

package client

import (
    "runtime"
    "sync"
    "testing"
)

type MPool chan interface{}


type A struct {
    s        string
    b        int
    overflow *[2]*[]*string 

}

var p = sync.Pool{
    New: func() interface{} { return new(A) },
}

var mp MPool = make(chan interface{}, 100)

func get() interface{} {
    select {
    case r := <-mp:
        return r
    default:
        return new(A)
    }
}

func put(a interface{}) {
    select {
    case mp <- a:
    default:
    }
    return
}

func pool() {
    a := p.Get()
    p.Put(a)
}


func init() {
    runtime.GOMAXPROCS(8)
}

func BenchmarkName(b *testing.B) {
    for i := 0; i < 20; i++ {
        p.Put(new(A))
    }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        for i := 0; i < 100; i++ {
            go func() {
                p.Put(p.Get())
            }()
        }
    }
}

func BenchmarkNotPool(b *testing.B) {
    for i := 0; i < 20; i++ {
        put(new(A))
    }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        for i := 0; i < 100; i++ {
            a := get()
            put(a)
        }
    }
}

Answer 1

您没有对同一事物进行基准测试，因此无法比较结果。

BenchmarkName() 启动 goroutines，它有明显的窃听，你甚至不需要等待这些 goroutines 完成，而 BenchmarkNotPool() 只是获取并放入一个对象同一个 goroutine 中的池。

如果您修改 BenchmarkName() 来做同样的事情，基准测试结果实际上表明它是另一种方式:sync.Pool 快了 3 倍多，这是是的，这就是它的用途/优势。

func BenchmarkName(b *testing.B) {
    for i := 0; i < 20; i++ {
        p.Put(new(A))
    }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        for i := 0; i < 100; i++ {
            p.Put(p.Get())
        }
    }
}

结果:

BenchmarkName-8           500000              2453 ns/op
BenchmarkNotPool-8        200000              7984 ns/op

另见相关问题:How to implement Memory Pooling in Golang