Question

我正在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何时处理了该对象，因此我可以将其放回池中。

Answer 1

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

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

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

1 个答案: