默认值会阻止 select 被发送到频道

各位小伙伴们，大家好呀！看看今天我又给各位带来了什么文章？本文标题是《默认值会阻止 select 被发送到频道》，很明显是关于Golang的文章哈哈哈，其中内容主要会涉及到等等，如果能帮到你，觉得很不错的话，欢迎各位多多点评和分享！

我正在开发一个个人项目，该项目将在带有一些传感器的 raspberry pi 上运行。

从传感器读取数据的函数和处理套接字连接的函数在不同的 goroutine 中执行，因此，为了在从传感器读取数据时在套接字上发送数据，我创建了一个 chan []byte main 函数并将其传递给 goroutine。

我的问题出在这里：如果我连续进行多次写入，则只有第一个数据到达客户端，而其他数据则不会。但是如果我在发送函数中添加一点 time.sleep ，所有数据都会正确到达客户端。

无论如何，这是这个小程序的简化版本：

package main

import (
    "net"
    "os"
    "sync"
    "time"
)

const socketName string = "./test_socket"

// create to the socket and launch the accept client routine
func launchServerUDS(ch chan []byte) {
    if err := os.RemoveAll(socketName); err != nil {
        return
    }
    l, err := net.Listen("unix", socketName)
    if err != nil {
        return
    }
    go acceptConnectionRoutine(l, ch)
}

// accept incoming connection on the socket and
// 1) launch the routine to handle commands from the client
// 2) launch the routine to send data when the server reads from the sensors
func acceptConnectionRoutine(l net.Listener, ch chan []byte) {
    defer l.Close()
    for {
        conn, err := l.Accept()
        if err != nil {
            return
        }
        go commandsHandlerRoutine(conn, ch)
        go autoSendRoutine(conn, ch)

    }
}

// routine that sends data to the client
func autoSendRoutine(c net.Conn, ch chan []byte) {
    for {
        data := <-ch
        if string(data) == "exit" {
            return
        }
        c.Write(data)
    }
}

// handle client connection and calls functions to execute commands
func commandsHandlerRoutine(c net.Conn, ch chan []byte) {
    for {
        buf := make([]byte, 1024)
        n, err := c.Read(buf)
        if err != nil {
            ch <- []byte("exit")
            break
        }
        // now, for sake of simplicity , only echo commands back to the client
        _, err = c.Write(buf[:n])
        if err != nil {
            ch <- []byte("exit")
            break
        }
    }
}

// write on the channel to the autosend routine so the data are written on the socket
func sendDataToClient(data []byte, ch chan []byte) {
    select {
    case ch <- data:
        // if i put a little sleep here, no problems
        // i i remove the sleep, only data1 is sent to the client
        // time.Sleep(1 * time.Millisecond)
    default:
    }
}

func dummyReadDataRoutine(ch chan []byte) {
    for {
        // read data from the sensors every 5 seconds
        time.Sleep(5 * time.Second)
        // read first data and send it
        sendDataToClient([]byte("dummy data1\n"), ch)
        // read second data and send it
        sendDataToClient([]byte("dummy data2\n"), ch)
        // read third data and send it
        sendDataToClient([]byte("dummy data3\n"), ch)
    }
}

func main() {
    ch := make(chan []byte)
    wg := sync.WaitGroup{}
    wg.Add(2)
    go dummyReadDataRoutine(ch)
    go launchServerUDS(ch)
    wg.Wait()
}

我认为使用睡眠来同步写入是不正确的。如何解决这个问题，同时保持函数在不同的 goroutine 上运行。

解决方案

主要问题出在函数中：

func senddatatoclient(data []byte, ch chan []byte) {
    select {
    case ch <- data:
        // if i put a little sleep here, no problems
        // if i remove the sleep, only data1 is sent to the client
        // time.sleep(1 * time.millisecond)
    default:
}

如果调用函数时通道 ch 尚未准备好，则将采用 default 情况，并且 data 将永远不会被发送。在这种情况下，您应该删除该功能并直接发送到频道。

缓冲通道与当前的问题正交，并且应该出于与缓冲 io 类似的原因来完成，即为无法立即进行的写入提供“缓冲区”。如果代码在没有缓冲区的情况下无法进行，则添加缓冲区只会延迟可能的死锁。

您也不需要此处的 exit 哨兵值，因为您可以在通道上进行范围调整并在完成后将其关闭。然而，这仍然忽略写入错误，但这又需要一些重新设计。

for data := range ch {
    c.write(data)
}

您还应该小心地通过通道传递切片，因为很容易丢失对哪个逻辑进程拥有所有权并将修改后备数组的跟踪。从给出的信息来看，我不能说通过通道传递读+写数据是否可以改善架构，但这不是您在大多数 go 网络代码中发现的模式。

jimb 给出了很好的解释，所以我认为他的答案更好。

我已在此答案中包含了我的部分解决方案。

我认为我的代码是清晰和简化的，但正如吉姆所说，我可以做得更简单和更清晰。我将旧代码发布出来，以便人们可以更好地理解如何发布更简单的代码，而不是像我一样搞得一团糟。

正如chmike所说，我的问题并不像我想象的那样与套接字有关，而仅与通道有关。在无缓冲通道上写入是问题之一。将无缓冲通道更改为缓冲通道后，问题得到解决。无论如何，这段代码不是“好代码”，可以按照 jimb 在他的答案中写的原则进行改进。

这是新代码：

package main

import (
    "net"
    "os"
    "sync"
    "time"
)

const socketName string = "./test_socket"

// create the socket and accept clients connections
func launchServerUDS(ch chan []byte, wg *sync.WaitGroup) {
    defer wg.Done()
    if err := os.RemoveAll(socketName); err != nil {
        return
    }
    l, err := net.Listen("unix", socketName)
    if err != nil {
        return
    }
    defer l.Close()
    for {
        conn, err := l.Accept()
        if err != nil {
            return
        }
        // this goroutine are launched when a client is connected
        // routine that listen and echo commands
        go commandsHandlerRoutine(conn, ch)
        // routine to send data read from the sensors to the client
        go autoSendRoutine(conn, ch)
    }
}

// routine that sends data to the client
func autoSendRoutine(c net.Conn, ch chan []byte) {
    for {
        data := <-ch
        if string(data) == "exit" {
            return
        }
        c.Write(data)
    }
}

// handle commands received from the client
func commandsHandlerRoutine(c net.Conn, ch chan []byte) {
    for {
        buf := make([]byte, 1024)
        n, err := c.Read(buf)
        if err != nil {
            // if i can't read send an exit command to autoSendRoutine and exit
            ch <- []byte("exit")
            break
        }
        // now, for sake of simplicity , only echo commands back to the client
        _, err = c.Write(buf[:n])
        if err != nil {
            // if i can't write back send an exit command to autoSendRoutine and exit
            ch <- []byte("exit")
            break
        }
    }
}

// this goroutine reads from the sensors and write to the channel , so data are sent
// to the client if a client is connected
func dummyReadDataRoutine(ch chan []byte, wg *sync.WaitGroup) {
    x := 0
    for x < 100 {
        // read data from the sensors every 5 seconds
        time.Sleep(1 * time.Second)
        // read first data and send it
        ch <- []byte("data1\n")
        // read second data and send it
        ch <- []byte("data2\n")
        // read third data and send it
        ch <- []byte("data3\n")
        x++
    }
    wg.Done()
}


func main() {
    // create a BUFFERED CHANNEL
    ch := make(chan []byte, 1)
    wg := sync.WaitGroup{}
    wg.Add(2)
    // launch the goruotines that handle the socket connections
    // and read data from the sensors
    go dummyReadDataRoutine(ch, &wg)
    go launchServerUDS(ch, &wg)
    wg.Wait()
}

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