Убирают ли каналы сохранение при блокировке?

Question

У меня есть кусок каналов, которые все получают то же самое сообщение:

func broadcast(c <-chan string, chans []chan<- string) { 
    for msg := range c { 
     for _, ch := range chans { 
      ch <- msg 
     } 
    } 
} 

Однако, поскольку каждый из каналов в chans потенциально считываются с разной скоростью, я не хочу, чтобы блокировать другие каналы когда я получаю медленного потребителя. Я решил эту проблему с goroutines:

func broadcast(c <-chan string, chans []chan<- string) { 
    for msg := range c { 
     for _, ch := range chans { 
      go func() { ch <- msg }() 
     } 
    } 
} 

Однако порядок сообщений, которые получают передаваемыми в каждый канал имеет важное значение. Я посмотрел на спецификации, чтобы увидеть, если каналы сохранить порядок, когда блокируется, и все, что я нашел, было это:

Если емкость больше нуля, то канал является асинхронным: коммуникационные операции удастся без блокировки, если буфер не полный (отправляет) или не пустой (получает), и элементы принимаются в том порядке, в котором они отправлены.

Для меня, если запись заблокирована, то она не отправляется, а ждет отправки. В этом предположении выше сказанное ничего не говорится о порядке отправки, когда несколько писем блокируются при записи.

Есть ли гарантии относительно порядка отправки после разблокировки канала?

Answer 1

Нет, никаких гарантий.

Даже если канал не заполнен, если два гортана запускаются примерно в одно и то же время, чтобы отправить его, я не думаю, что есть какая-то гарантия того, что сначала запускается goroutine, который был запущен первым. Поэтому вы не можете рассчитывать на поступающие сообщения.

Answer 2

Вы можете удалить сообщение, если канал заполнен (а затем установить флаг, чтобы приостановить работу клиента и отправить им сообщение о том, что они отбрасывают сообщения или что-то еще).

Что-то вдоль линий (непроверенные):

type Client struct { 
    Name string 
    ch chan<-string 
} 

func broadcast(c <-chan string, chans []*Client) { 
    for msg := range c { 
     for _, ch := range chans { 
      select { 
      case ch.ch <- msg: 
      // all okay 
      default: 
       log.Printf("Channel was full sending '%s' to client %s", msg, ch.Name) 
      } 
     } 
    } 
} 

Answer 3

В этом коде, никаких гарантий.

Основная проблема с данным примером кода заключается не в поведении канала, а в многочисленных созданных goroutines. Все goroutines «запускаются» внутри одного и того же неотъемлемого цикла без дальнейшей синхронизации, поэтому даже до того, как они начнут отправлять сообщения, мы просто не знаем, какие из них будут выполняться в первую очередь.

Однако это поднимает законный вопрос в целом: если мы каким-то образом гарантируем порядок нескольких инструкций отправки блокировки, гарантируем ли мы их получать в том же порядке?

Свойство «происшествий» перед отправкой трудно создать.Я боюсь, что это невозможно, потому что:

1. Все, что может случиться до того отправки инструкции: например, другие goroutines выполняют свои собственные отправки или не
2. goroutine блокированности посылающий не может одновременно управлять другими видами синхронизация

Например, если у меня есть 10 goroutines с номерами от 1 до 10, у меня нет способа разрешить им отправлять свой номер на канал одновременно в правильном порядке. Все, что я могу сделать, это использовать различные виды последовательных трюков, например, делать сортировку в одном одном goroutine.

Answer 4

Это дополнение к уже опубликованным ответам.

Как практически все заявили, что проблема порядок исполнения goroutines, вы можете легко координировать goroutine выполнение с использованием каналов, передавая по номеру goroutine вы хотите запустить:

func coordinated(coord chan int, num, max int, work func()) { 
    for { 
     n := <-coord 

     if n == num { 
      work() 
      coord <- (n+1) % max 
     } else { 
      coord <- n 
     } 
    } 
} 

coord := make(chan int) 

go coordinated(coord, 0, 3, func() { println("0"); time.Sleep(1 * time.Second) }) 
go coordinated(coord, 1, 3, func() { println("1"); time.Sleep(1 * time.Second) }) 
go coordinated(coord, 2, 3, func() { println("2"); time.Sleep(1 * time.Second) }) 

coord <- 0 

или с помощью центрального goroutine, который выполняет рабочих в упорядоченным образом:

func executor(funs chan func()) { 
    for { 
     worker := <-funs 
     worker() 
     funs <- worker 
    } 
} 

funs := make(chan func(), 3) 

funs <- func() { println("0"); time.Sleep(1 * time.Second) } 
funs <- func() { println("1"); time.Sleep(1 * time.Second) } 
funs <- func() { println("2"); time.Sleep(1 * time.Second) } 

go executor(funs) 

Эти методы будут, конечно, удалить все параллелизм из-за синхронизации. Тем не менее, остается неизменным.