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

从现在开始，努力学习吧！本文《我什么时候应该将对象放回sync.Pool》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

我通过 goroutine 之间的通道传递一个大对象，一个 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修改。我不知道所有 goroutine 何时处理完该对象，以便我可以将其放回池中。

解决方案

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

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

以上就是《我什么时候应该将对象放回sync.Pool》的详细内容，更多关于的资料请关注golang学习网公众号！