golang动态通道的循环问题

大家好，我们又见面了啊~本文《golang动态通道的循环问题》的内容中将会涉及到等等。如果你正在学习Golang相关知识，欢迎关注我，以后会给大家带来更多Golang相关文章，希望我们能一起进步！下面就开始本文的正式内容~

我想循环浏览菜单的选项。但是，它会在第一个选项处停止，因为没有“default:”的选择是阻塞的，并且它不知道会动态显示更多选项。

以下是损坏的代码：

package main

import (
    "bytes"
    "fmt"
    "io/ioutil"
    "log"
    "os/exec"
    "strings"
    "time"

    "github.com/getlantern/systray"
    "gopkg.in/yaml.v3"
)

var menuitensptr []*systray.menuitem
var config map[string]string
var commands []string

func main() {
    config = readconfig()
    systray.run(onready, onexit)
}

func onready() {
    systray.seticon(geticon("assets/menu.ico"))
    menuitensptr = make([]*systray.menuitem,0)
    commands = make([]string,0)
    for k, v := range config {
        menuitemptr := systray.addmenuitem(k, k)
        menuitensptr = append(menuitensptr, menuitemptr)
        commands = append(commands, v)
   }
   systray.addseparator()
    // mquit := systray.addmenuitem("quit", "quits this app")
    go func() {
        for {
            systray.settitle("my tray menu")
            systray.settooltip("https://github.com/evandrojr/my-tray-menu")
            time.sleep(1 * time.second)
        }
    }()

    go func() {
        for{
            for i, menuitenptr := range menuitensptr {
                

          select { 
/// execution gets stuck here!!!!!!!
                case<-menuitenptr.clickedch:
                    execute(commands[i])
                }
            }   
            // select {
            // case <-mquit.clickedch:
            //  systray.quit()
            //  return
            // // default:
            // }
        }
    }()
}

func onexit() {
    // cleaning stuff will go here. 
}

func geticon(s string) []byte {
    b, err := ioutil.readfile(s)
    if err != nil {
        fmt.print(err)
    }
    return b
}

func execute(commands string){
    command_array:= strings.split(commands, " ")
    command:="" 
    command, command_array = command_array[0], command_array[1:]
    cmd := exec.command(command, command_array ...)
    var out bytes.buffer
    cmd.stdout = &out
    err := cmd.run()
    if err != nil {
        log.fatal(err)
    }
    // fmt.printf("output %s\n", out.string())
}

func readconfig()  map[string]string{
    yfile, err := ioutil.readfile("my-tray-menu.yaml")
    if err != nil {
         log.fatal(err)
    }
    data := make(map[string]string)
    err2 := yaml.unmarshal(yfile, &data)
    if err2 != nil {
         log.fatal(err2)
    }
    for k, v := range data {
         fmt.printf("%s -> %s\n", k, v)
    }
    return data
}

贝娄是一个丑陋的解决方法，但有效：

package main

import (
    "bytes"
    "fmt"
    "io/ioutil"
    "log"
    "os"
    "os/exec"
    "path/filepath"
    "strings"
    "time"

    "github.com/getlantern/systray"
    "gopkg.in/yaml.v3"
)

var menuItensPtr []*systray.MenuItem
var config map[string]string
var commands []string
var labels []string
var programPath string

func main() {
    setProgramPath()
    config = readconfig()
    time.Sleep(1 * time.Second)
    systray.Run(onReady, onExit)
}

func onReady() {
    systray.SetIcon(getIcon(filepath.Join(programPath,"assets/menu.ico")))
    menuItensPtr = make([]*systray.MenuItem, 0)
    i := 0
    op0 := systray.AddMenuItem(labels[i], commands[i])
    i++
    op1 := systray.AddMenuItem(labels[i], commands[i])
    i++
    op2 := systray.AddMenuItem(labels[i], commands[i])
    i++
    op3 := systray.AddMenuItem(labels[i], commands[i])
    i++

    systray.AddSeparator()
    mQuit := systray.AddMenuItem("Quit", "Quits this app")
    go func() {
        for {
            systray.SetTitle("My tray menu")
            systray.SetTooltip("https://github.com/evandrojr/my-tray-menu")
            time.Sleep(1 * time.Second)
        }
    }()

    go func() {
        for {
            select {
// HERE DOES NOT GET STUCK!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            case <-op0.ClickedCh:
                execute(commands[0])
            case <-op1.ClickedCh:
                execute(commands[1])
            case <-op2.ClickedCh:
                execute(commands[2])
            case <-op3.ClickedCh:
                execute(commands[3])
            case <-mQuit.ClickedCh:
                systray.Quit()
                return
            }
        }
    }()
}

func onExit() {
    // Cleaning stuff will go here.
}

func getIcon(s string) []byte {
    b, err := ioutil.ReadFile(s)
    if err != nil {
        fmt.Print(err)
    }
    return b
}

func setProgramPath(){
    ex, err := os.Executable()
    if err != nil {
        panic(err)
    }
    programPath = filepath.Dir(ex)
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
}

func execute(commands string) {
    command_array := strings.Split(commands, " ")
    command := ""
    command, command_array = command_array[0], command_array[1:]
    cmd := exec.Command(command, command_array...)
    var out bytes.Buffer
    cmd.Stdout = &out
    err := cmd.Run()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Output %s\n", out.String())
}

func readconfig() map[string]string {
    yfile, err := ioutil.ReadFile(filepath.Join(programPath,"my-tray-menu.yaml"))
    if err != nil {
        log.Fatal(err)
    }

    data := make(map[string]string)
    err2 := yaml.Unmarshal(yfile, &data)
    if err2 != nil {
        log.Fatal(err2)
    }

    labels = make([]string, 0)
    commands = make([]string, 0)

    for k, v := range data {
        labels = append(labels, k)
        commands = append(commands, v)
        fmt.Printf("%s -> %s\n", k, v)
    }
    fmt.Print(len(labels))
    return data
}

完整源代码在这里： https://github.com/evandrojr/my-tray-menu

正确答案

select“选择将继续进行一组可能的发送或接收操作”。 spec 阐述了如何做出此选择：

如果一个或多个通信可以继续进行，则通过统一的伪随机选择来选择一个可以继续进行的通信。否则，如果存在默认情况，则选择该情况。如果没有默认情况，“select”语句将阻塞，直到至少其中一个通信可以继续。

您的工作示例：

select {
    case <-op0.clickedch:
        execute(commands[0])
    case <-op1.clickedch:
        execute(commands[1])
    // ...
}

成功使用 select 在提供的选项之一之间进行选择。但是，如果您传递一个选项，例如

select { 
    case<-menuitenptr.clickedch:
        execute(commands[i])
    }
}  

select 将阻塞，直到 <-menuitenptr.clickedch 准备好继续（例如收到某些内容）。这实际上与不使用选择相同：

<-menuitenptr.clickedch:
execute(commands[i])

通过提供默认选项可以实现您期望的结果：

select { 
    case<-menuitenptr.clickedch:
        execute(commands[i])
    }
    default:
}  

根据上述规范的引用，如果其他选项均无法继续，则将选择 default 选项。虽然这可能有效，但这不是一个很好的解决方案，因为您最终会得到：

for {
   // check if event happened (not blocking)           
}

这会不必要地占用 cpu 时间，因为它会不断循环检查事件。更好的解决方案是启动一个 goroutine 来监视每个通道：

for i, menuitenptr := range menuitensptr {
    go func(c chan struct{}, cmd string) {
        for range c { execute(cmd) }
    }(menuitenptr.clickedch, commands[i])
}
// start another goroutine to handle quit

上面的方法可能会起作用，但确实会导致 execute 被同时调用的可能性（如果您的代码不是线程安全的，这可能会导致问题）。解决这个问题的一种方法是使用“扇入”模式（如 @kostix 和 @john 建议的 Rob Pike video 中所建议的）；像这样：

cmdChan := make(chan int)

for i, menuItenPtr := range menuItensPtr {
    go func(c chan struct{}, cmd string) {
        for range c { cmdChan <- cmd }
    }(menuItenPtr.ClickedCh, commands[i])
}

go func() {
    for {
        select { 
            case cmd := <- cmdChan:
                execute(cmd) // Handle command        
           case <-mQuit.ClickedCh:
                systray.Quit()
                return
        }
    }
}()

注意：上面的所有代码都直接输入到问题中，因此请视为伪代码！

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~