我应该什么时候把对象放回sync.Pool

Question

我正在通过goroutines之间的通道传递一个大对象，一个goroutine用于发布，许多goroutine订阅和等待消息，它是如此频繁，以至于我想使用sync.Pool来减少分配的数量，示例代码如下：

package main

import (
    "log"
    "sync"
    "time"
)

var pool *sync.Pool

type object struct {
    info string
    // other stuff
}

func initPool() {
    pool = &sync.Pool{
        New: func() interface{} {
            return new(object)
        },
    }
}

var (
    lock     sync.RWMutex
    registry = make(map[string][]chan interface{})
)

func sub(topic string) chan interface{} {
    ch := make(chan interface{}, 10)
    lock.Lock()
    registry[topic] = append(registry[topic], ch)
    lock.Unlock()
    return ch
}

// publish goroutine
func pub() {
    ticker := time.NewTicker(time.Second)
    o := pool.Get().(*object)
    o.info = "new"
    // do something

    for _ = range ticker.C {
        lock.RLock()
        for topic, chs := range registry {
            if o.info != "new" {
                log.Printf("error")
            }
            if topic == "hello" {
                for _, ch := range chs {
                    select {
                    case ch <- o:
                    default:
                    }
                }
            }
        }
        lock.RUnlock()
    }
}

func run(topic string) {
    ch := sub(topic)
    for {
        select {
        case o := <-ch:
            switch o := o.(type) {
            case *object:
                if o.info != "new" {
                    log.Printf("error")
                }

                // do something
                time.Sleep(time.Second)
                o.info = "used"
                pool.Put(o)
            }
        }
    }
}

func main() {
    initPool()

    for i := 0; i <= 100; i++ {
        go run("hello")
    }
    pub()
}

问题是从池中借用的对象可以被多个goroutine访问，所以如果一个goroutine在使用之后将其放回到池中，它可能会被其他goroutine修改。我不知道对象什么时候被所有的goroutines处理过，这样我就可以把它放回到池中。

Answer 1

一个人应该在用完池化对象后调用pool.Put()，即它被认为是“垃圾”。

如果您将o放回pub中的池中，那么在run处理之前，循环的下一次迭代可能会获得相同的对象，并为其属性分配新值。因此，在处理完对象之后，将对象放回池中的正确位置是run。