How can I explicitly empty a channel?

The short version:
Is there a way to empty a go channel without recreating it, or looping through it?

The why:
I'm using two channels to send and receive data, and I have an extra channel to signal that a reconnect is needed.

Now when the transport has been reset/reconnected I want to 'empty' the extra channel to make sure that there is not any lingering other reset requests which would cause the thing to reconnect again.

It is not possible to empty a channel without a loop. If you don't have any concurrent receivers, then you can use this simple loop:

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

If you do have concurrent receivers, then use the loop:

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

What you're describing is inherently racy, since there may be legitimate requests to reconnect on the channel. Rather than trying to drain the channel, I would recommend keeping track of timing.

On your reconnect channel, post the time. When finished with the reconnect, note the time. While consuming the reconnect channel, throw away any messages that are older than your last reconnect.

Another more lockstep solution to achieve this is to make the reconnect channel a bool. Post "true" to reconnect. When the reconnect completes, post "false". Then consume the channel until you find "false."

Another approach is using sync.Cond and atomic, something along the lines of:

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()
}

<kbd>playground</kbd>

can't edit Simon Fox 's answer, so write here:

• if chan closed, that will got infinite loop:
  cause <-ch immediately return err.

<br>

More safer version (handle closed chan):

L:
	for {
		select {
		case _, ok := <-ch:
			if !ok { //ch is closed //immediately return err
				break L
			}
		default: //all other case not-ready: means nothing in ch for now
			break L
		}
	}

It sounds like instead of a reset channel, you want a reset goroutine. It would have an input from the side sending the reset signal, and an output to the receiver. When this goroutine receives a request to reconnect, it passes it to the receiver. Then it waits to receive an acknowledgement back from the receiver on a third channel, throwing away any reconnect requests it receives in the meantime. So 3 channels total, 1 input, 1 output, 1 ack.