Golang实现请求限流的几种办法(小结)

源码[url] ( https://github.com/golang/net/blob/master/netutil/listen.go )，基本思路就是为连接数计数，通过make chan来建立一个最大连接数的channel, 每次accept就+1，close时候就-1. 当到达最大连接数时，就等待空闲连接出来之后再accept。

// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
 
// Package netutil provides network utility functions, complementing the more
// common ones in the net package.
package netutil // import "golang.org/x/net/netutil"
 
import (
  "net"
  "sync"
)
 
// LimitListener returns a Listener that accepts at most n simultaneous
// connections from the provided Listener.
func LimitListener(l net.Listener, n int) net.Listener {
  return &limitListener{
    Listener: l,
    sem:   make(chan struct{}, n),
    done:   make(chan struct{}),
  }
}
 
type limitListener struct {
  net.Listener
  sem    chan struct{}
  closeOnce sync.Once   // ensures the done chan is only closed once
  done   chan struct{} // no values sent; closed when Close is called
}
 
// acquire acquires the limiting semaphore. Returns true if successfully
// accquired, false if the listener is closed and the semaphore is not
// acquired.
func (l *limitListener) acquire() bool {
  select {
  case <-l.done:
    return false
  case l.sem <- struct{}{}:
    return true
  }
}
func (l *limitListener) release() { <-l.sem }
 
func (l *limitListener) Accept() (net.Conn, error) {
  //如果sem满了，就会阻塞在这
  acquired := l.acquire()
  // If the semaphore isn't acquired because the listener was closed, expect
  // that this call to accept won't block, but immediately return an error.
  c, err := l.Listener.Accept()
  if err != nil {
    if acquired {
      l.release()
    }
    return nil, err
  }
  return &limitListenerConn{Conn: c, release: l.release}, nil
}
 
func (l *limitListener) Close() error {
  err := l.Listener.Close()
  l.closeOnce.Do(func() { close(l.done) })
  return err
}
 
type limitListenerConn struct {
  net.Conn
  releaseOnce sync.Once
  release   func()
}
 
func (l *limitListenerConn) Close() error {
  err := l.Conn.Close()
  //close时释放占用的sem
  l.releaseOnce.Do(l.release)
  return err
}