Chunk就是将大文件分成块，一个块对应着一个Http请求，然后会对每个Http进行编号，然后在接收方重组。

    正常的Http请求都是客户端请求，服务器返回然后就结束了。而Chunk不会，是会一直等待服务器多次发送数据，发送数据完成后才会结束。

    怎么判断一个Http是不是Chunk？
    通过Header中的Transfer-Encoding = Chunked

    怎么判断是否传输结束？
    每个Http中的body中分为 length 和 chunked data 。length 就是传输的数据长度，chunked data就是实际的传输数据。二者通过换行符分隔。当收到length = 0的http时，就说明传输完成了。
    image.png

    demo

    1. package main
    3. import (
    4.     "fmt"
    5.     "io"
    6.     "log"
    7.     "net/http"
    8.     "time"
    9. )
    11. func httpServer() {
    12.     http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    13.         flusher, ok := w.(http.Flusher)
    14.         if !ok {
    15.             panic("expected http.ResponseWriter to be an http.Flusher")
    16.         }
    18.         for i := 1; i <= 10; i++ {
    19.             w.Write([]byte(fmt.Sprintf("rsp-%d", i)))
    20.             flusher.Flush() // Trigger "chunked" encoding and send a chunk...
    21.             time.Sleep(1 * time.Second)
    22.         }
    23.     })
    25.     log.Print("Listening on localhost:8080")
    26.     log.Fatal(http.ListenAndServe(":8080", nil))
    27. }
    29. func httpClien() {
    30.     resp, err := http.Get("http://localhost:8080")
    31.     if err != nil {
    32.         // handle error
    33.     }
    34.     fmt.Println(resp.Header)
    36.     defer resp.Body.Close()
    38.     var buf = make([]byte, 40960)
    40.     for {
    41.         n, err := resp.Body.Read(buf)
    42.         fmt.Println(n, err)
    43.         if n != 0 || err != io.EOF { // simplified
    44.             fmt.Println(string(buf[:n]))
    45.         }
    46.         time.Sleep(1 * time.Second)
    47.     }
    48. }
    50. func main() {
    51.     go httpServer()
    52.     go httpClien()
    54.     time.Sleep(100 * time.Second)
    55. }