go 如何给服务做限流？

package client

import (
	"fmt"
	"strconv"
	"testing"
	"time"
)

/**
 * @Description
 * @Author guirongguo
 * @Date 2021/7/14 11:13
 **/
const layout = "2006-01-01 15:04:05"

// TestRateLimitByChan 使用channel进行限流, 通过大小固定的通道堵塞的方式实现
func TestRateLimitByChan(t *testing.T) {
	startTime := time.Now()
	t.Log("task start at " + startTime.Format(layout))
	length := 200
	limitRate := make(chan bool, 10)
	chs := make([]chan string, length)
	for i := 0; i < length; i++ {
		limitRate <- true
		chs[i] = make(chan string, 1)
		go subTask(strconv.FormatInt(int64(i), 10), chs[i], limitRate)
	}

	for _, ch := range chs {
		t.Log("task start at " + <-ch)
	}
}

// subTask子任务
func subTask(taskId string, result chan string, limitRate chan bool) {
	ch := make(chan string, 1)
	go func() {
		time.Sleep(time.Duration(1) * time.Second)
		ch <- "Task-" + taskId + " run success " + time.Now().Format(layout)
	}()

	select {
	case ret := <-ch:
		result <- ret
		<-limitRate
	case <-time.After(time.Duration(2) * time.Second):
		<-limitRate
		result <- "Task-" + taskId + " run timeout " + time.Now().Format(layout)
	}
}

// 使用计数器方式进行限流
func TestRateLimitByCount(t *testing.T) {
     // 设置每50ms往通道发一个数据
	ticker := time.NewTicker(time.Millisecond * 50)
	defer ticker.Stop()
	length := 20
	chs := make([]chan string, length)
	for i := 0; i < length; i++ {
		chs[i] = make(chan string, 1)
		go func(taskId string, ch chan string) {
			<-ticker.C
			time.Sleep(time.Duration(4) * time.Millisecond)
			ch <- "Task-" + taskId + " run success " + time.Now().Format(layout)
		}(strconv.FormatInt(int64(i), 10), chs[i])
	}
	for _, ch := range chs {
		t.Log("task start at " + <-ch)
	}
}

import (
	"fmt"
	"golang.org/x/net/netutil"
	"net"
	"net/http"
	"strconv"
	"testing"
	"time"
)
// TestRateLimitByHttpServer 使用通过httpServer的官方的限流工具进行限流
func TestRateLimitByHttpServer(t *testing.T) {
	addr := ":8080"
	listener, err := net.Listen("tcp", addr)
	if err != nil {
		fmt.Errorf("start server at %s failed", addr)
	}
	defer listener.Close()
    // 这里我限制了每次只能并发处理20个请求，多了会被拒绝
	listener = netutil.LimitListener(listener, 20)

	mux := http.DefaultServeMux
	mux.HandleFunc("/index", func(writer http.ResponseWriter, request *http.Request) {
		writer.WriteHeader(http.StatusOK)
		writer.Write([]byte("welcome to index"))
		return
	})

	http.Serve(listener, mux)
}

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

// 请求结束后释放sem信号量
func (l *limitListener) release() { <-l.sem }

func (l *limitListener) Accept() (net.Conn, error) {
	acquired := l.acquire()
	
	// 能够进入到这里一定是获得了信号量
	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()
	l.releaseOnce.Do(l.release)
	return err
}

import (
	"fmt"
	"golang.org/x/time/rate"
	"net"
	"net/http"
	"strconv"
	"testing"
	"time"
)
// 使用golang/rate 实现, 令牌桶算法
func TestRateLimitByGoRate(t *testing.T) {
	// 以每秒10个的速度放入ticker, 桶容量为4
	ticker := rate.NewLimiter(3, 2)
	length := 20
	chs := make([]chan string, length)
	for i := 0; i < length; i++ {
		chs[i] = make(chan string, 1)
		go func(taskId string, ch chan string, r *rate.Limiter) {
			if ticker.Allow() {
				ch <- "Task-" + taskId + " not allow " + time.Now().Format(layout)
			}
			time.Sleep(time.Duration(4) * time.Millisecond)
			ch <- "Task-" + taskId + " run success " + time.Now().Format(layout)
		}(strconv.FormatInt(int64(i), 10), chs[i], ticker)
	}
	for _, ch := range chs {
		t.Log("task start at " + <-ch)
	}
}

import (
	"fmt"
	"go.uber.org/ratelimit"
	"net"
	"net/http"
	"strconv"
	"testing"
	"time"
)
// 使用uber/ratelimit 实现， 漏桶算法
func TestRateLimitByUber(t *testing.T) {
	// 每秒请求100次
	ticker := ratelimit.New(3)
	length := 20
	chs := make([]chan string, length)
	for i := 0; i < length; i++ {
		chs[i] = make(chan string, 1)
		go func(taskId string, ch chan string) {
			ticker.Take()
			time.Sleep(time.Duration(1) * time.Second)
			ch <- "Task-" + taskId + " run success " + time.Now().Format(layout)
		}(strconv.FormatInt(int64(i), 10), chs[i])
	}
	for _, ch := range chs {
		t.Log("task start at " + <-ch)
	}
}