Question

我目前正在阅读来自Arduino的输入，其中串口使用两个goroutines。

这些例程的目的是使第一个例程可以读入输入并输出数据，然后第二个例程也这样做。当我执行另一个例行程序时，我想要一个goroutine执行，这与哪个例程执行无关紧要。这是我的代码：

package main

import (
    "log"
    "github.com/tarm/serial"
    "bufio"
    "sync"
    "fmt"
)


func readFirstLine(scanner *bufio.Scanner, port *serial.Port, wg *sync.WaitGroup){
    defer wg.Done()
    for scanner.Scan() {
        fmt.Println("\n", scanner.Text())
    }    
}

func readSecondLine(scanner *bufio.Scanner, port *serial.Port, wg *sync.WaitGroup){

    defer wg.Done()
    for scanner.Scan() {
        fmt.Println("\n", scanner.Text())
    }
}

func main() {
    usbRead := &serial.Config{Name: "COM5", Baud: 9600, ReadTimeout: 0}
    port, err := serial.OpenPort(usbRead)
    var wg sync.WaitGroup
    wg.Add(2)


    if err != nil {
        log.Fatal(err)
    }

    scanner := bufio.NewScanner(port)

    for {
    go readFirstLine(scanner, port, &wg)
    go readSecondLine(scanner, port, &wg)
    wg.Wait()

    }
}

这是预期的输出（因为只有三个数据行，我希望每个goroutine每次读取并输出相同的三行 - 这将循环播放）：

{"temperature":[27.7],"humidity":[46.9],"sensor":"DHT22"}
{"temperature":[25.41545],"sensor":"LM35DZ"}
{"blink":["true"],"actuator":"arduinoLED"}
{"temperature":[27.7],"humidity":[46.9],"sensor":"DHT22"}
{"temperature":[25.41545],"sensor":"LM35DZ"}
{"blink":["true"],"actuator":"arduinoLED"}

但是，这是实际输出：

,46.[25.41545,25.41545,25.41545],"sensor":"LM35DZ"}
 {"blink":["true","true","true"],"actuato ":"arduinoLED"}
 {"tempertemperature":[25.41545,25.41545,25.41545],"sensor":"LM35DZ"}
 {"blink":["true","true","true"],"actuator":"arduinoLED"}
 {"tempert"eep uratr:" [hum.7],"t  idiy[: "se],n  :"Dr"H  }
 2"{  perema  ":[re2  54541]  nsoser  LM3"5

如您所见，数据存在冲突。

我的问题是：我知道你必须使用某种同步机制来确保在第一个goroutine执行完毕后执行一个go例程。我是这种语言的新手（并从串口读取）所以我不确定我是否正确使用 sync.WaitGroup 来实现所需的结果。我很想知道如何解决这个问题，或者我是否应该使用不同的同步机制以及如何正确使用它。

Answer 1

此处使用的sync.WaitGroup将确保您的主goroutine在异步工作人员完成工作之前不会退出。

但正如你已经正确地注意到目前没有执行goroutines执行命令的方法。你可以使用＆＃34;令牌＆＃34;基于渠道;想象一下传球，你只能在拿球的时候上班。

func readFirstLine(scanner *bufio.Scanner, port *serial.Port, wg *sync.WaitGroup, ch chan<- struct{}){
    defer wg.Done()
    defer func () {ch <-struct {}{}}() // write a token to the channel when done
    for scanner.Scan() {
        fmt.Println("\n", scanner.Text())
    }
}

func readSecondLine(scanner *bufio.Scanner, port *serial.Port, wg *sync.WaitGroup, ch <- chan struct{}){
    <-ch // don't start work until the notification / token is received
    defer wg.Done()
    for scanner.Scan() {
        fmt.Println("\n", scanner.Text())
    }
}

func main() {
    // trimmed ...

    ch := make(chan struct{})

    for {
        go readFirstLine(scanner, port, &wg, ch)
        go readSecondLine(scanner, port, &wg, ch)
        wg.Wait()

    }
}

但是：正如评论中所指出的那样，你不允许goroutine2继续进行，直到goroutine1完成执行，这意味着你正在强制执行一个＆＃34; serial＆＃34;对并发程序结构的约束。

相反，您可以通过删除go和sync.WaitGroup来删除并发，然后按顺序调用函数，因为这是您尝试实现的目标。

如何正确使用同步机制从串行端口

1 个答案: