这个空的 select-case-default 代码块有什么作用？

池库代码中使用空 `select-case-default` 代码块来控制对清洁器例程的启动。当池被创建时，该代码块会检查空闲超时设置并相应地调整清洁器例程的行为。如果空闲超时为零或小于当前设置，则它会解除任何正在等待从清洁器通道接收的 goroutine 的阻塞，否则会启动一个新的清洁器例程来清除过期的池项。这种机制有助于确保池始终处于活动状态，并且可以根据需要释放过期的资源。

我试图理解一个池库代码，当实例化一个池结构时，调用一个名为 startcleanerlocked(t duration) 的函数，在这个函数中，有一个空的 select...case...default.. .代码块，我不明白这个代码块的作用是什么。

池接口是：

// pool interface.
type pool interface {
    get(ctx context.context) (io.closer, error)
    put(ctx context.context, c io.closer, forceclose bool) error
    close() error
}

list struct 实现 pool 接口，

type list struct {
    // new is an application supplied function for creating and configuring a
    // item.
    //
    // the item returned from new must not be in a special state
    // (subscribed to pubsub channel, transaction started, ...).
    new func(ctx context.context) (io.closer, error)

    // mu protects fields defined below.
    mu     sync.mutex
    cond   chan struct{}
    closed bool
    active int
    // clean stale items
    cleanerch chan struct{}

    // stack of item with most recently used at the front.
    idles list.list

    // config pool configuration
    conf *config
}

创建新池时，调用startcleanerlocked(t duration)函数：

// newlist creates a new pool.
func newlist(c *config) *list {
    // check config
    if c == nil || c.active < c.idle {
        panic("config nil or idle must <= active")
    }
    // new pool
    p := &list{conf: c}
    p.cond = make(chan struct{})
    p.startcleanerlocked(time.duration(c.idletimeout))
    return p
}

在startcleanerlocked(t duration)中，有一个select...case...default：

// startcleanerlocked
func (p *list) startcleanerlocked(d time.duration) {
    if d <= 0 {
        // if set 0, stalecleaner() will return directly
        return
    }
    if d < time.duration(p.conf.idletimeout) && p.cleanerch != nil {
        select {
        case p.cleanerch <- struct{}{}:
        default:
        }
    }
    // run only one, clean stale items.
    if p.cleanerch == nil {
        p.cleanerch = make(chan struct{}, 1)
        go p.stalecleaner()
    }
}

此代码块的效果是什么：

select {
    case p.cleanerch <- struct{}{}:
    default:
}

好像没什么事可做...

而在stalecleaner()中，有同样的空select..case...case，也无法理解其效果：

// staleCleaner clean stale items proc.
func (p *List) staleCleaner() {
    ticker := time.NewTicker(100 * time.Millisecond)
    for {
        select {
        case <-ticker.C:
        case <-p.cleanerCh: // maxLifetime was changed or db was closed.
        }
        p.mu.Lock()
        if p.closed || p.conf.IdleTimeout <= 0 {
            p.mu.Unlock()
            return
        }
        for i, n := 0, p.idles.Len(); i < n; i++ {
            e := p.idles.Back()
            if e == nil {
                // no possible
                break
            }
            ic := e.Value.(item)
            if !ic.expired(time.Duration(p.conf.IdleTimeout)) {
                // not need continue.
                break
            }
            p.idles.Remove(e)
            p.release()
            p.mu.Unlock()
            ic.c.Close()
            p.mu.Lock()
        }
        p.mu.Unlock()
    }
}

正确答案

select {
case p.cleanerch <- struct{}{}:
default:
}

这是一个非阻塞 select 语句。 （因为有一个default:的情况）

如果 p.cleanerch 通道的另一端有一个接收器 goroutine，即有一个当前正在“等待”接收操作的 goroutine，即 <-p.cleanerch，则 case p.cleanerch <- 结构体{}{} 立即执行，这有效地解除了接收操作 <-p.cleanerch 的阻塞，然后 goroutine 可以继续执行后面的任何语句。

如果没有接收者 goroutine，则立即执行 default: 情况，并且周围的 startcleanerlocked 函数可以继续执行 select 语句后面的任何语句。

select {
case <-ticker.C:
case <-p.cleanerCh: // maxLifetime was changed or db was closed.
}

这是一个阻塞 select 语句。 （因为没有default:的情况）

此 select 语句会阻止 for 循环，直到两个通信案例之一准备好接收为止。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。