import (
    "github.com/buaazp/fasthttprouter"
    "github.com/valyala/fasthttp"
    "log"
)

func main() {
    //創(chuàng)建路由
    r := fasthttprouter.New()
    r.GET("/", Index)
    if err := fasthttp.ListenAndServe(":8083", r.Handler); err != nil {
        log.Fatalf("ListenAndServe fatal: %s", err)
    }

}
func Index(ctx *fasthttp.RequestCtx) {
    ctx.WriteString("hello xiaou code!")
}

type workerPool struct {
    //匹配請求對應的handler
    WorkerFunc ServeHandler
    //最大同時處理的請求數
    MaxWorkersCount int
    
    LogAllErrors bool
    //最大空閑工作時間
    MaxIdleWorkerDuration time.Duration

    Logger Logger
    //互斥鎖
    lock         sync.Mutex
    //work數量
    workersCount int
    mustStop     bool
    // 空閑的 workerChan
    ready []*workerChan
    //是否關閉workerPool
    stopCh chan struct{}
    //sync.Pool  workerChan 的對象池
    workerChanPool sync.Pool

    connState func(net.Conn, ConnState)
}

func (s *Server) Serve(ln net.Listener) error {
    //最大連接處理數
    maxWorkersCount := s.getConcurrency()

    s.mu.Lock()
    s.ln = append(s.ln, ln)
    if s.done == nil {
        s.done = make(chan struct{})
    }
    if s.concurrencyCh == nil {
        s.concurrencyCh = make(chan struct{}, maxWorkersCount)
    }
    s.mu.Unlock()
    //workerPool進行初始化
    wp := &workerPool{
        WorkerFunc:            s.serveConn,
        MaxWorkersCount:       maxWorkersCount,
        LogAllErrors:          s.LogAllErrors,
        MaxIdleWorkerDuration: s.MaxIdleWorkerDuration,
        Logger:                s.logger(),
        connState:             s.setState,
    }
    //開啟協程,處理協程池的清理工作
    wp.Start()
    atomic.AddInt32(&s.open, 1)
    defer atomic.AddInt32(&s.open, -1)

    for {
        // 阻塞等待，獲取連接net.Conn
        if c, err = acceptConn(s, ln, &lastPerIPErrorTime); err != nil {
            ...
            return err
        }
        s.setState(c, StateNew)
        atomic.AddInt32(&s.open, 1)
        //處理獲取到的連接net.Conn
        if !wp.Serve(c) {
            //未能處理，說明已達到最大worker限制
            ...
        }
        c = nil
    }
}

func (wp *workerPool) Start() {
    //wp的關閉channel是否為空
    if wp.stopCh != nil {
        return
    }
    wp.stopCh = make(chan struct{})
    stopCh := wp.stopCh
    //指定workerChanPool的創(chuàng)建函數
    wp.workerChanPool.New = func() interface{} {
        return &workerChan{
            ch: make(chan net.Conn, workerChanCap),
        }
    }
    //開啟協程
    go func() {
        var scratch []*workerChan
        for {
            //清理空閑超時的 workerChan
            wp.clean(&scratch)
            select {
            case <-stopCh:
                return
            default:
                // 間隔10 s
                time.Sleep(wp.getMaxIdleWorkerDuration())
            }
        }
    }()
}

func acceptConn(s *Server, ln net.Listener, lastPerIPErrorTime *time.Time) (net.Conn, error) {
    for {
        c, err := ln.Accept()
        if err != nil {
            //err判斷
            ...
        }
        //校驗是否net.TCPConn連接
       // 校驗每個ip對應的連接數
        if s.MaxConnsPerIP > 0 {
            pic := wrapPerIPConn(s, c)
            if pic == nil {
                ...
                continue
            }
            c = pic
        }
        return c, nil
    }
}

func (wp *workerPool) Serve(c net.Conn) bool {
    //獲取 workerChan 
    ch := wp.getCh()
    if ch == nil {
        return false
    }
    //將連接放到channel中
    ch.ch <- c
    //返回true
    return true
}

type workerChan struct {
    lastUseTime time.Time
    ch          chan net.Conn
}

func (wp *workerPool) getCh() *workerChan {
    var ch *workerChan
    createWorker := false

    wp.lock.Lock()
    //從ready隊列中拿workerChan
    ready := wp.ready
    n := len(ready) - 1
    if n < 0 {
        if wp.workersCount < wp.MaxWorkersCount {
            createWorker = true
            wp.workersCount++
        }
    } else {
        //ready隊列不為空，從隊尾拿workerChan
        ch = ready[n]
        //隊尾置為nil
        ready[n] = nil
        //重新將ready賦值給wp.ready
        wp.ready = ready[:n]
    }
    wp.lock.Unlock()
    //ready中獲取不到workerChan,則從對象池中新建一個
    if ch == nil {
        if !createWorker {
            return nil
        }
        vch := wp.workerChanPool.Get()
        ch = vch.(*workerChan)
        //開啟一個goroutine執(zhí)行
        go func() {
            //處理ch中channel中的數據
            wp.workerFunc(ch)
            //處理完后將workerChan放回對象池
            wp.workerChanPool.Put(vch)
        }()
    }
    return ch
}

func (wp *workerPool) workerFunc(ch *workerChan) {
    var c net.Conn

    var err error
    for c = range ch.ch {
        //channel的值是nil，退出
        if c == nil {
            break
        }
        //執(zhí)行請求，并處理
        if err = wp.WorkerFunc(c); err != nil && err != errHijacked {
            ...
        }
        ...
        //將當前workerChan放入ready隊列
        if !wp.release(ch) {
            break
        }
    }

    wp.lock.Lock()
    wp.workersCount--
    wp.lock.Unlock()
}

func (s *Server) ServeConn(c net.Conn) error {
    ...
    err := s.serveConn(c)
    ...
}