Как явным образом освободить канал?

Question

Короткий вариант: Есть ли способ опорожнить канал, не воссоздавая его, или зацикливая его?

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

Теперь, когда транспорт был сброшен/снова подключен, я хочу «очистить» дополнительный канал, чтобы убедиться, что нет никаких других запросов на перезагрузку, которые заставили бы эту вещь снова подключиться.

Answer 1

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

На вашем канале повторного подключения отправьте время. Когда закончите с повторным подключением, отметьте время. Потребив канал повторного подключения, выбросьте все сообщения, которые старше вашего последнего повторного подключения.

Еще одно решение для блокировки для достижения этого - сделать канал повторного соединения bool. Сообщение «true» для повторного подключения. Когда повторное соединение завершено, опубликуйте «false». Затем используйте канал, пока не найдете «false».

Answer 2

Невозможно опорожнить канал без петли. Если у вас нет каких-либо параллельных приемников, то вы можете использовать этот простой цикл:

for len(ch) > 0 { 
    <-ch 
} 

Если у вас есть параллельные приемники, а затем использовать цикл:

L: 
for { 
    select { 
    case <-c: 
    default: 
     break L 
    } 
} 

Answer 3

Кажется, что вместо канала сброса вы хотите сбросить goroutine. Он будет иметь вход со стороны, отправляющей сигнал сброса, и выход на приемник. Когда этот горутин получает запрос на повторное подключение, он передает его получателю. Затем он ожидает получения подтверждения от приемника на третьем канале, отбрасывая любые запросы на повторное подключение, которые он получает в это время. Таким образом, 3 канала всего, 1 вход, 1 выход, 1 экст.

Answer 4

Другой подход использует sync.Cond и atomic, что-то вдоль линий:

type Server struct { 
    s  chan int 
    r  chan int 
    c  *sync.Cond 
    state uint32 
} 

const (
    sNormal  = 0 
    sQuitting  = 1 
    sReconnecting = 2 
) 

func New() *Server { 
    s := &Server{ 
     s: make(chan int), 
     r: make(chan int), 
     c: sync.NewCond(&sync.Mutex{}), 
    } 
    go s.sender() 
    // go s.receiver() 
    return s 
} 
func (s *Server) sender() { 
    // 
    for { 
     select { 
     case data := <-s.s: 
     //do stuff with data 
     default: 
      s.c.L.Lock() 
     L: 
      for { 
       switch atomic.LoadUint32(&s.state) { 
       case sNormal: 
        break L 
       case sReconnecting: 
       case sQuitting: 
        s.c.L.Unlock() 
        return 
       } 
       s.c.Wait() 
      } 
      s.c.L.Unlock() 
     } 
    } 
} 

//repeat for receiver 

func (s *Server) Reconnect() { 
    var cannotReconnect bool 
    atomic.StoreUint32(&s.state, sReconnecting) 
    //keep trying to reconnect 
    if cannotReconnect { 
     atomic.StoreUint32(&s.state, sQuitting) 
    } else { 
     atomic.StoreUint32(&s.state, sNormal) 
    } 
    s.c.Broadcast() 
} 

playground