golang shutdown分析

客官°小女子只卖身不卖艺 2022-01-12 03:03 248阅读 0赞

### 测试代码 ###

客户端

package main
    
    import (
    	"net/http"
    	log "github.com/sirupsen/logrus"
    	"io/ioutil"
    	"fmt"
    	"bytes"
    	"sync"
    	_"time"
    )
    
    func main() {
    	var wg sync.WaitGroup
    	var count int
    	var rw sync.RWMutex
    TEST:
    	for i := 0; i < 1; i++ {
    		wg.Add(1)
    		go func () {
    			defer wg.Done()
    			tr := http.Transport{DisableKeepAlives: false}
    			client := &http.Client{Transport: &tr}
    			for {
    				f, err := ioutil.ReadFile("data")
    				if err != nil {
    					fmt.Println("read file err", err)
    					return
    				}
    				fmt.Println(len(f))
    				reader := bytes.NewReader(f)
    				rw.Lock()
    				count += 1
    				index := count
    				rw.Unlock()
    				resp, err := client.Post("http://0.0.0.0:8888", "application/x-www-form-urlencoded", reader)
    				if err != nil {
    					rw.RLock()
    					currentCount := count
    					rw.RUnlock()
    					log.Fatal(err, index, currentCount)
    				}
    				defer resp.Body.Close()
    				data, err := ioutil.ReadAll(resp.Body)
    				if err != nil {
    					log.Fatal(err)
    				}
    				log.Printf("data[%s]", string(data))
    				// time.Sleep(time.Second)
    			}
    		}()
    	}
    	wg.Wait()
    	goto TEST
    }复制代码

服务端

package main
    
    import (
    	"fmt"
    	"io"
    	"io/ioutil"
    	"net/http"
    	"time"
    	"context"
    )
    
    type myHandler struct {
    
    }
    
    func (h myHandler)ServeHTTP(w http.ResponseWriter, r *http.Request) {
    	//print header
    	// fmt.Println("header", r.Header)
    	//debug body
    	_, err := ioutil.ReadAll(r.Body)
    	if err != nil {
    		fmt.Println("read body error", err)
    		io.WriteString(w, "read you body error!")
    		return
    	}
    	// fmt.Println("data len", len(data))
    
    	io.WriteString(w, "goad it")
    	return
    }
    
    func main() {
    	// http.HandleFunc("/", myHandler)
    	// err := http.ListenAndServe("0.0.0.0:8888", nil)
    	// if err != nil { 
    	// fmt.Println("ListenAndServe error", err)
    	// return
    	// }
    	server := &http.Server {
    		Addr: "0.0.0.0:8888",
    		Handler: myHandler{},
    	}
    
    	d := time.Duration(time.Second*10)
    	t := time.NewTimer(d)
    	defer t.Stop()
    	go func (){
    			<- t.C
    			shutdown(server)
    		}()
    	server.ListenAndServe()
    	for {
    		fmt.Println(1)
    		time.Sleep(time.Second)
    	}
    	fmt.Println(2)
    	return
    }
    
    func shutdown(server *http.Server) {
    	ctx, cancel := context.WithTimeout(context.TODO(), 3600)
    	defer cancel()
    	server.Shutdown(ctx)
    }
    复制代码

实验

代码：

服务端执行位置:

执行完这个之后会影响keepalive的执行(其实抓包可发现每15秒服务端会发送一次tcp的keepalive）

func (s *Server) doKeepAlives() bool {        return atomic.LoadInt32(&s.disableKeepAlives) == 0 && !s.shuttingDown()}func (s *Server) shuttingDown() bool {        return atomic.LoadInt32(&s.inShutdown) != 0}复制代码

上边doKeepAlives()在服务端handler完本次请求之后会执行：

//在go1.10 net/http/server.go 1845行 if !w.conn.server.doKeepAlives() { // We're in shutdown mode. We might've replied // to the user without "Connection: close" and // they might think they can send another // request, but such is life with HTTP/1.1. return }复制代码

服务端就是上边调试截图的位置

客户端就是在等待POST响应的数据

### 抓包现象 ###

可以看到服务端发送的连接断开，客户端也断开了连接，然后重新发起请求，黑色的区域忽略，那是后边调试程序停止导致的。

在closeIdles中

程序执行状态如下，右上图是server 端的调试，左下是client的状态

对应的包：

所以可以分析下如果shutdown已经执行到循环关闭当前所有连接的时候对应不同连接状态的效果

1.准备建连

拒绝连接

2.active

等待idle然后关闭连接