Question

我有一个goroutine，它将运行多次。但是它一次只能运行一个（单个实例）。确保某个goroutine一次只能运行一次的正确/惯用方法是什么？

这是我设计的示例代码来说明这一点：

func main() {
    // Contrived example!!!!!!
    // theCaller() may be run at multiple, unpredictable times
    // theJob() must only be run one at a time
    go theCaller()
    go theCaller()
    go theCaller()
}

func theCaller() {
    if !jobIsRunning { // race condition here!
        jobIsRunning = true
        go theJob()
    }
}

var jobIsRunning bool

// Can run multiple times, but only one at a time
func theJob() {
    defer jobDone()
    do_something()
}

func jobDone() {
    jobIsRunning = false
}

Answer 1

根据OP的问题和其他评论，看来目标是在且仅当尚未运行作业时才开始新作业。

使用受sync.Mutex保护的布尔变量来记录作业的运行状态。在开始作业时将变量设置为true，在作业完成时将变量设置为false。测试此变量以确定是否应该启动作业。

var (
    jobIsRunning   bool
    JobIsrunningMu sync.Mutex
)

func maybeStartJob() {
    JobIsrunningMu.Lock()
    start := !jobIsRunning
    jobIsRunning = true
    JobIsrunningMu.Unlock()
    if start {
        go func() {
            theJob()
            JobIsrunningMu.Lock()
            jobIsRunning = false
            JobIsrunningMu.Unlock()
        }()
    }
}

func main() {
    maybeStartJob()
    maybeStartJob()
    maybeStartJob()
}

也可以使用较低级别的sync/atomic软件包，并且比使用互斥锁具有更好的性能。

var jobIsRunning uint32

func maybeStartJob() {
    if atomic.CompareAndSwapUint32(&jobIsRunning, 0, 1) {
        go func() {
            theJob()
            atomic.StoreUint32(&jobIsRunning, 0)
        }()
    }
}

sync / atomic软件包文档警告说，软件包中的功能需要格外小心才能正确使用，并且大多数应用程序应使用sync软件包。

如何运行goroutine的单个实例

1 个答案: