Question

I have code that is something like this:

var lock sync.Mutex

func DoSomething() {
  lock.Lock()
  go func() {
    defer lock.Unlock()
    // Code here
  }()
}

func Wait() {
  lock.Lock()
  lock.Unlock()
}

我需要<代码>Wait(,因为有时是因为在<条码>上,我必须打上<条码>。 Exit 。因此,在这种情况下,我需要完成。

只要I m只打上DoSomething()”一度,它就会被罚款,但当然,如果它两次叫,则第二次等到去。

DoSomething() // returns immediately
DoSomething() // waits until the first one finishes to return

如果我把锁定在 go路里,那么Wait()就在 go路开始之前就被召去。

func DoSomething() {
  go func() {
    lock.Lock()
    defer lock.Unlock()
    // Code here
  }()
}

DoSomething()
Wait() // this finishes before the goroutine even starts

我在<代码>sync中尝试了其他几个事情,但发现有些事情行之有效。

我甚至试图从<代码>DoSomething中抽出航道,将其称作 DoSomething(),但我无法这样做。

Answer 1

Disclaimer: I am still learning go. I am not 100% sure that this is the idiomatic way to go (pun intended).

这种解决办法的想法是:我们不是直接使用一种方法,而是:

start a go routine from the get-go, which waits on some signal on a channel
when we want to do something, we write to the channel
to possibly synchronize with the execution, we can pass another channel on the channel - the back communication channel

把它放在一起,我们就这样做了:

package main

import "fmt"

// This is the channel used by doSomething() to be notified when it
var doSomethingChannel = make(chan chan<- interface{})

// This is the channel we expose as interface to the outside so we can trigger "doSomething" to... do something
func DoSomethingChannel() chan<- chan<- interface{} {
    return doSomethingChannel
}

func doSomething() {
    for {
        back := <- doSomethingChannel
        // code goes here
        fmt.Println("[GOROUTINE] Executing")

        // if the back-channel is set, i.e. if the caller wants to be informed, write a signal on the back-channel
        if back != nil {
            back<- struct{}{}
        }
    }
}

func main() {
    go doSomething()
    for i := 0; i < 11; i += 1 {
        // if i is even, we want to wait, otherwise we do not want to wait
        var back chan interface{} = nil
        if i % 2 == 0 {
            back = make(chan interface{})
            fmt.Printf("[CALLER] Waiting for execution %d
", i)
        } else {
            fmt.Printf("[CALLER] Calling for execution %d, will not wait
", i)
        }
        // send the back-channel to the DoSomethingChannel, this will trigger doSomething()
        DoSomethingChannel() <- back
        if back != nil {
            // Wait if back-channel was used
            <-back
            fmt.Printf("[CALLER] %d has been done
", i)
        }
    }
}

https://go.dev/play/p/tQaf0oJiYV-"rel=“nofollow noreferer”>go.dev demo

友情链接