проблема golang с каналами (с буферизацией и без буферизации)

Основная проблема заключалась в функции:

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 никогда не будет отправлен. В этом случае вам следует исключить функцию и отправить ее напрямую в канал.

Буферизация канала ортогональна рассматриваемой проблеме и должна выполняться по тем же причинам, что и буферизованный ввод-вывод, т.е. обеспечение «буфера» для записи, которая не может немедленно прогрессировать. Если код не мог работать без буфера, добавление одного только задерживает возможные взаимоблокировки.

Вам также не нужно здесь значение 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()
}