首页 > 其他分享 >go的net/http有哪些值得关注的细节

go的net/http有哪些值得关注的细节

时间：2023-08-29 16:45:26浏览次数：36  
标签：Body http err resp goroutine time go net

 

原创 小白 小白debug 2023-08-14 08:33 发表于上海 收录于合集 #go语言1个 #面试17个 #后端19个

golang的net/http库是我们平时写代码中，非常常用的标准库。由于go语言拥有goroutine，goroutine的上下文切换成本比普通线程低很多，net/http库充分利用了这个优势，因此，它的内部实现跟其他语言会有一些区别。

其中最大的区别在于，其他语言中，一般是多个网络句柄共用一个或多个线程，以此来减少线程之间的切换成本。而golang则会为每个网络句柄创建两个goroutine，一个用于读数据，一个用于写数据。

图片读写协程

下图是net/http源码中创建这两个goroutine的地方。

图片源码中创建两个协程的地方

了解它的内部实现原理，可以帮助我们写出更高性能的代码，以及避免协程泄露造成的内存泄漏问题。

这篇文章是希望通过几个例子让大家对net/http的内部实现有更直观的理解。

 

连接与协程数量的关系

首先我们来看一个例子。

func main() {
    tr := &http.Transport{
        MaxIdleConns:    100,
        IdleConnTimeout: 3 * time.Second,
    }

    n := 5
    for i := 0; i < n; i++ {
        req, _ := http.NewRequest("POST", "https://www.baidu.com", nil)
        req.Header.Add("content-type", "application/json")
        client := &http.Client{
            Transport: tr,
            Timeout:   3 * time.Second,
        }
        resp, _ := client.Do(req)
        _, _ = ioutil.ReadAll(resp.Body)
        _ = resp.Body.Close()
    }
    time.Sleep(time.Second * 5)
    fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}

上面的代码做的事情很简单，执行5次循环http请求，最终通过runtime.NumGoroutine()方法打印当前的goroutine数量。

代码里只有三个地方需要注意：

  1. 1. Transport设置了一个3s的空闲连接超时

  2. 2. for循环执行了5次http请求

  3. 3. 程序退出前执行了5s sleep

答案输出1。也就是说当程序退出的时候，当前的goroutine数量为1，毫无疑问它指的是正在运行main方法的goroutine，后面我们都叫它main goroutine。

再来看个例子。

func main() {
    tr := &http.Transport{
        MaxIdleConns:    100,
        IdleConnTimeout: 3 * time.Second,
    }

    n := 5
    for i := 0; i < n; i++ {
        req, _ := http.NewRequest("POST", "https://www.baidu.com", nil)
        req.Header.Add("content-type", "application/json")
        client := &http.Client{
            Transport: tr,
            Timeout:   3 * time.Second,
        }
        resp, _ := client.Do(req)
        _, _ = ioutil.ReadAll(resp.Body)
        _ = resp.Body.Close()
    }
    time.Sleep(time.Second * 1)
    fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}

在原来的基础上，我们程序退出前的睡眠时间，从5s改成1s，此时输出3。也就是说除了main方法所在的goroutine，还多了两个goroutine，我们大概也能猜到，这就是文章开头提到的读goroutine和写goroutine。也就是说程序在退出时，还有一个网络连接没有断开。

这是一个TCP长连接。

图片HTTP1.1底层依赖TCP

网络五层模型中，HTTP处于应用层，它的底层依赖了传输层的TCP协议。

当我们发起http请求时，如果每次都要建立新的TCP协议，那就需要每次都经历三次握手，这会影响性能，因此更好的方式就是在http请求结束后，不立马断开TCP连接，将它放到一个空闲连接池中，后续有新的http请求时就复用该连接。

像这种长时间存活，被多个http请求复用的TCP连接，就是所谓的长连接。反过来，如果每次HTTP请求结束就将TCP连接进行四次挥手断开，下次有需要执行HTTP调用时就再建立，这样的TCP连接就是所谓的短连接。

HTTP1.1之后默认使用长连接。

图片连接池复用连接

那为什么这跟5s和1s有关系？

这是因为长连接在空闲连接池也不能一直存放着，如果一直没被使用放着也是浪费资源，因此会有个空闲回收时间，也就是上面代码中的IdleConnTimeout，我们设置的是3s，当代码在结束前sleep了5s后，长连接就已经被释放了，因此输出结果是只剩一个main goroutine。当sleep 1s时，长连接还在空闲连接池里，因此程序结束时，就还剩3个goroutine（main goroutine+网络读goroutine+网络写goroutine）。

我们可以改下代码下验证这个说法。我们知道，HTTP可以通过connection的header头来控制这次的HTTP请求是用的长连接还是短连接。connection:keep-alive 表示http请求结束后，tcp连接保持存活，也就是长连接， connection:close则是短连接。

req.Header.Add("connection", "close")

就像下面这样。

func main() {
    tr := &http.Transport{
        MaxIdleConns:    100,
        IdleConnTimeout: 3 * time.Second,
    }

    n := 5
    for i := 0; i < n; i++ {
        req, _ := http.NewRequest("POST", "https://www.baidu.com", nil)
        req.Header.Add("content-type", "application/json")
        req.Header.Add("connection", "close")
        client := &http.Client{
            Transport: tr,
            Timeout:   3 * time.Second,
        }
        resp, _ := client.Do(req)
        _, _ = ioutil.ReadAll(resp.Body)
        _ = resp.Body.Close()
    }
    time.Sleep(time.Second * 1)
    fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}

此时，会发现，程序重新输出1。完全符合我们预期。

 

resp.body是否读取对连接复用的影响

func main() {
   n := 5
   for i := 0; i < n; i++ {
      resp, _ := http.Get("https://www.baidu.com")
      _ = resp.Body.Close()
   }
   fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}

注意这里没有执行 ioutil.ReadAll(resp.Body)。也就是说http请求响应的结果并没有被读取的情况下，net/http库会怎么处理。

上面的代码最终输出3，分别是main goroutine，read goroutine 以及write goroutine。也就是说长连接没有断开，那长连接是会在下一次http请求中被复用吗？先说答案，不会复用。

我们可以看代码。resp.Body.Close() 会执行到 func (es * bodyEOFSignal) Close() error 中，并执行到es.earlyCloseFn()中。

图片图片

earlyCloseFn的逻辑也非常简单，就是将一个false传入到waitForBodyRead的channel中。那写入通道后的数据会在另外一个地方被读取，我们来看下读取的地方。

图片

bodyEOF为false, 也就不需要执行 tryPutIdleConn()方法。

tryPutIdleConn会将连接放到长连接池中备用）。

最终就是alive=bodyEOF ，也就是false，字面意思就是该连接不再存活。因此该长连接并不会复用，而是会释放。

那为什么output输出为3？这是因为长连接释放需要时间。

我们可以在结束前加一个休眠，比如再执行休眠1毫秒。

func main() {
    n := 5
    for i := 0; i < n; i++ {
        resp, _ := http.Get("https://www.baidu.com")
        _ = resp.Body.Close()
    }
    time.Sleep(time.Millisecond * 1)
    fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}

此时就会输出1。说明协程是退出中的，只是没来得及完全退出，休眠1ms后彻底退出了。

如果我们，将在代码中重新加入 ioutil.ReadAll(resp.Body)，就像下面这样。

func main() {
    n := 5
    for i := 0; i < n; i++ {
        resp, _ := http.Get("https://www.baidu.com")
        _, _ = ioutil.ReadAll(resp.Body)
        _ = resp.Body.Close()
    }
    fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}

此时，output还是输出3，但这个3跟上面的3不太一样，休眠5s后还是输出3。这是因为长连接被推入到连接池了，连接会重新复用。

下面是源码的解释。

图片图片

 

body.close()不执行会怎么样

网上都说不执行body.close()会协程泄漏（导致内存泄露），真的会出现协程泄漏吗，如果泄漏，会泄漏多少？

func main() {
    tr := &http.Transport{
        MaxIdleConns:    100,
        IdleConnTimeout: 3 * time.Second,
    }

    n := 5
    for i := 0; i < n; i++ {
        req, _ := http.NewRequest("POST", "https://www.baidu.com", nil)
        req.Header.Add("content-type", "application/json")
        client := &http.Client{
            Transport: tr,
        }
        resp, _ := client.Do(req)
        _, _ = ioutil.ReadAll(resp.Body)
        //_ = resp.Body.Close()
    }
    time.Sleep(time.Second * 1)
    fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}

我们可以运行这段代码，代码中将resp.body.close()注释掉，结果输出3。debug源码，会发现连接其实复用了。代码执行到tryPutIdleConn函数中，会将连接归还到空闲连接池中。

图片

休眠5s，结果输出1，这说明达到idleConnTimeout，空闲连接断开。看起来一切正常。

将resp.Body.Close()那一行代码重新加回来，也就是下面这样，会发现代码结果依然输出3。我们是否删除这行代码，对结果没有任何影响。

func main() {
    tr := &http.Transport{
        MaxIdleConns:    100,
        IdleConnTimeout: 3 * time.Second,
    }

    n := 5
    for i := 0; i < n; i++ {
        req, _ := http.NewRequest("POST", "https://www.baidu.com", nil)
        req.Header.Add("content-type", "application/json")
        client := &http.Client{
            Transport: tr,
        }
        resp, _ := client.Do(req)
        _, _ = ioutil.ReadAll(resp.Body)
        _ = resp.Body.Close()
    }
    time.Sleep(time.Second * 1)
    fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}

既然执不执行body.close()都没啥区别，那body.close()的作用是什么呢？

它是为了标记当前连接请求中，response.body是否使用完毕，如果不执行body.close()，则resp.Body中的数据是可以不断重复读且不报错的（但不一定能读到数据），执行了body.close()，再次去读取resp.Body则会报错，如果resp.body数据读一半，处理代码逻辑就报错了，此时你不希望其他地方继续去读，那就需要使用body.close()去关闭它。这更像是一种规范约束，它可以更好的保证数据正确。

也就是说不执行body.close()，并不一定会内存泄露。那么什么情况下会协程泄露呢？

直接说答案，既不执行 ioutil.ReadAll(resp.Body) 也不执行resp.Body.Close()，并且不设置http.Client内timeout的时候，就会导致协程泄露。

比如下面这样。

func main() {
    tr := &http.Transport{
        MaxIdleConns:    100,
        IdleConnTimeout: 3 * time.Second,
    }

    n := 5
    for i := 0; i < n; i++ {
        req, _ := http.NewRequest("POST", "https://www.baidu.com", nil)
        req.Header.Add("content-type", "application/json")
        client := &http.Client{
            Transport: tr,
        }
        resp, _ := client.Do(req)
        _ = resp
    }
    time.Sleep(time.Second * 5)
    fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}

最终结果会输出11，也就是1个main goroutine + （1个read goroutine + 1个read goroutine）* 5次http请求。

前面提到，不执行ioutil.ReadAll(resp.Body)，网络连接无法归还到连接池。不执行resp.Body.Close()，网络连接就无法为标记为关闭，也就无法正常断开。因此能导致协程泄露，非常好理解。

但http.Client内timeout有什么关系？这是因为timeout是指，从发起请求到从resp.body中读完响应数据的总时间，如果超过了，网络库会自动断开网络连接，并释放read+write goroutine。因此如果设置了timeout，则不会出现协程泄露的问题。

另外值得一提的是，我看到有不少代码都是直接用下面的方式去做网络请求的。

resp, _ := http.Get("https://www.baidu.com")

这种方式用的是DefaultClient，是没有设置超时的，生产环境中使用不当，很容易出现问题。

func Get(url string) (resp *Response, err error) {
    return DefaultClient.Get(url)
}

var DefaultClient = &Client{}

 

连接池的结构

我们了解到连接池可以复用网络连接，接下来我们通过一个例子来看看网络连接池的结构。


func main() {
    tr := &http.Transport{
        MaxIdleConns:    100,
        IdleConnTimeout: 3 * time.Second,
    }

    n := 5
    for i := 0; i < n; i++ {
        req, _ := http.NewRequest("POST", "http://www.baidu.com", nil)
        req.Header.Add("content-type", "application/json")
        client := &http.Client{
            Transport: tr,
            Timeout:   3 * time.Second,
        }
        resp, _ := client.Do(req)
        _, _ = ioutil.ReadAll(resp.Body)
        _ = resp.Body.Close()
    }
    time.Sleep(time.Second * 1)
    fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}

注意这里请求的不是https，而是http。最终结果输出5，为什么？

这是因为，http://www.baidu.com会返回307，重定向到https://www.baidu.com。

图片http重定向为https

在网络中，我们可以通过一个五元组来唯一确定一个TCP连接。

图片五元组

它们分别是源ip，源端口，协议，目的ip，目的端口。只有当多次请求的五元组一样的情况下，才有可能复用连接。

放在我们这个场景下，源ip、源端口、协议都是确定的，也就是两次http请求的目的ip或目的端口有区别的时候，就需要使用不同的TCP长连接。

而http用的是80端口，https用的是443端口。于是连接池就为不同的网络目的地建立不同的长连接。

因此最终结果5个goroutine，其实2个goroutine来自http,2个goroutine来自https，1个main goroutine。

我们来看下源码的具体实现。net/http底层通过一个叫idleConn的map去存空闲连接，也就是空闲连接池。

图片图片

idleConn这个map的key是协议和地址，其实本质上就是ip和端口。map的value是长连接的数组（[]*persistConn），说明net/http支持为同一个地址建立多个TCP连接，这样可以提升传输的吞吐。

图片连接池的结构和逻辑

 

Transport是什么？

Transport本质上是一个用来控制http调用行为的一个组件，里面包含超时控制，连接池等，其中最重要的是连接池相关的配置。

我们通过下面的例子感受下。

func main() {
    n := 5
    for i := 0; i < n; i++ {
        httpClient := &http.Client{}
        resp, _ := httpClient.Get("https://www.baidu.com")
        _, _ = ioutil.ReadAll(resp.Body)
        _ = resp.Body.Close()
    }
    time.Sleep(time.Second * 1)
    fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}
func main() {
    n := 5
    for i := 0; i < n; i++ {
        httpClient := &http.Client{
            Transport:  &http.Transport{},
        }
        resp, _ := httpClient.Get("https://www.baidu.com")
        _, _ = ioutil.ReadAll(resp.Body)
        _ = resp.Body.Close()
    }
    time.Sleep(time.Second * 1)
    fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}

上面的代码第一个例子的代码会输出3。分别是main goroutine + read goroutine + write goroutine，也就是有一个被不断复用的TCP连接。

在第二例子中，当我们在每次client中都创建一个新的http.Transport，此时就会输出11。

说明TCP连接没有复用，每次请求都会产生新的连接。这是因为每个http.Transport内都会维护一个自己的空闲连接池，如果每个client都创建一个新的http.Transport，就会导致底层的TCP连接无法复用。如果网络请求过大，上面这种情况会导致协程数量变得非常多，导致服务不稳定。

因此，最佳实践是所有client都共用一个transport。

func main() {
    tr := &http.Transport{
        MaxIdleConns:    100,
        IdleConnTimeout: 3 * time.Second,
    }

    n := 5
    for i := 0; i < n; i++ {
        req, _ := http.NewRequest("POST", "https://www.baidu.com", nil)
        req.Header.Add("content-type", "application/json")
        client := &http.Client{
            Transport: tr,
            Timeout:   3 * time.Second,
        }
        resp, _ := client.Do(req)
        _, _ = ioutil.ReadAll(resp.Body)
        _ = resp.Body.Close()
    }
    time.Sleep(time.Second * 1)
    fmt.Printf("goroutine num is %d\n", runtime.NumGoroutine())
}

如果创建客户端的时候不指定http.Client，会默认所有http.Client都共用同一个DefaultTransport。这一点可以从源码里看出。

图片默认使用DefaultTransport图片DefaultTransport

因此当第二段代码中，每次都重新创建一个Transport的时候，每个Transport内都会各自维护一个空闲连接池。因此每次建立长连接后都会多两个协程（读+写），对应1个main goroutine+（read goroutine + write goroutine）* 5 =11。

 

别设置 Transport.Dail里的SetDeadline

http.Transport.Dial的配置里有个SetDeadline，它表示连接建立后发送接收数据的超时时间。听起来跟client.Timeout很像。

那么他们有什么区别呢？我们通过一个例子去看下。

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net"
    "net/http"
    "time"
)

var tr *http.Transport

func init() {
    tr = &http.Transport{
        MaxIdleConns: 100,
        Dial: func(netw, addr string) (net.Conn, error) {
            conn, err := net.DialTimeout(netw, addr, time.Second*2) //设置建立连接超时
            if err != nil {
                return nil, err
            }
            err = conn.SetDeadline(time.Now().Add(time.Second * 3)) //设置发送接受数据超时
            if err != nil {
                return nil, err
            }
            return conn, nil
        },
    }
}

func main() {
    for {
        _, err := Get("http://www.baidu.com/")
        if err != nil {
            fmt.Println(err)
            break
        }
    }
}


func Get(url string) ([]byte, error) {
    m := make(map[string]interface{})
    data, err := json.Marshal(m)
    if err != nil {
        return nil, err
    }
    body := bytes.NewReader(data)
    req, _ := http.NewRequest("Get", url, body)
    req.Header.Add("content-type", "application/json")

    client := &http.Client{
        Transport: tr,
    }
    res, err := client.Do(req)
    if res != nil {
        defer res.Body.Close()
    }
    if err != nil {
        return nil, err
    }
    resBody, err := ioutil.ReadAll(res.Body)
    if err != nil {
        return nil, err
    }
    return resBody, nil
}

上面这段代码，我们设置了SetDeadline为3s，当你执行一段时间，会发现请求baidu会超时，但其实baidu的接口很快，不可能超过3s。

在生产环境中，假如是你的服务调用下游服务，你看到的现象就是，你的服务显示3s超时了，但下游服务可能只花了200ms就已经响应你的请求了，并且这是随机发生的问题。遇到这种情况，我们一般会认为是“网络波动”。

但如果我们去对网络抓包，就很容易发现问题的原因 。

图片抓包结果

可以看到，在tcp三次握手之后，就会开始多次网络请求。直到3s的时候，就会触发RST包，断开连接。也就是说，我们设置的SetDeadline，并不是指单次http请求的超时是3s，而是指整个tcp连接的存活时间是3s，计算长连接被连接池回收，这个时间也不会重置。

图片SetDeadline的解释

我实在想不到什么样的场景会需要这个功能，因此我的建议是，不要使用它。

下面是修改后的代码。这个问题其实在我另外一篇文章有过详细的解释，如果你对源码解析感兴趣的话，可以去看看。

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)

var tr *http.Transport

func init() {
    tr = &http.Transport{
        MaxIdleConns: 100,
        // 下面的代码被干掉了
        //Dial: func(netw, addr string) (net.Conn, error) {
        // conn, err := net.DialTimeout(netw, addr, time.Second*2) //设置建立连接超时
        // if err != nil {
        //  return nil, err
        // }
        // err = conn.SetDeadline(time.Now().Add(time.Second * 3)) //设置发送接受数据超时
        // if err != nil {
        //  return nil, err
        // }
        // return conn, nil
        //},
    }
}


func Get(url string) ([]byte, error) {
    m := make(map[string]interface{})
    data, err := json.Marshal(m)
    if err != nil {
        return nil, err
    }
    body := bytes.NewReader(data)
    req, _ := http.NewRequest("Get", url, body)
    req.Header.Add("content-type", "application/json")

    client := &http.Client{
        Transport: tr,
        Timeout: 3*time.Second,  // 超时加在这里，是每次调用的超时
    }
    res, err := client.Do(req) 
    if res != nil {
        defer res.Body.Close()
    }
    if err != nil {
        return nil, err
    }
    resBody, err := ioutil.ReadAll(res.Body)
    if err != nil {
        return nil, err
    }
    return resBody, nil
}

func main() {
    for {
        _, err := Get("http://www.baidu.com/")
        if err != nil {
            fmt.Println(err)
            break
        }
    }
}

总结

golang的net/http部分有不少细节点，直接上源码分析怕劝退不少人，所以希望以几个例子作为引子展开话题然后深入了解它的内部实现。总体内容比较碎片化，但这个库的重点知识点基本都在这里面了。希望对大家后续排查问题有帮助。

最后

离开广东好长时间了，好久没人叫我靓仔了。

大家可以在评论区里，叫我一靓仔吗？

我这么善良质朴的愿望，能被满足吗？

如果实在叫不出口的话，能帮我点下右下角的点赞和在看吗？

 

别说了，一起在知识的海洋里呛水吧

点击下方名片，关注公众号:【小白debug】

小白debug 答应我，关注之后，好好学技术，别只是收藏我的表情包。。 63篇原创内容 公众号

不满足于在留言区说骚话？

加我，我们建了个划水吹牛皮群，在群里，你可以跟你下次跳槽可能遇到的同事或面试官聊点有意思的话题。就超！开！心！

图片

图片

文章推荐：

 

阅读 1580 小白debug   ​       写下你的留言 精选留言
  •   WarmNight   广东   连接池的结构那部分说，“放在我们这个场景下，源ip、源端口、协议都是确定的”，请教下客户端多次请求的时候，每次请求客户端的端口会不会都不一样，就会导致创建很多tcp连接【这种情况是只有压测才会出现的吗】[合十]     小白debug   (作者)   客户端端口是可能不同的，不一定是压测场景，正常并发情况下，只要没能复用长连接，就可能不一样  
  •   啊.小土豆   上海   靓仔,哦猴中以雷[嘿哈]     小白debug   (作者)   那我明天发广告你记得点个赞[旺柴][旺柴]  
  •   煎鱼

    标签：Body,http,err,resp,goroutine,time,go,net
    From： https://www.cnblogs.com/cheyunhua/p/17665243.html

相关文章

  • RESTful API规范,序列化,Django Rest_Framework
    一.RESTfulAPI规范REST全称是RepresentationalStateTransfer，中文意思是表述（编者注：通常译为表征性状态转移）。它首次出现在2000年RoyFielding的博士论文中。RESTful是一种定义WebAPI接口的设计风格，尤其适用于前后端分离的应用模式中。这种风格的理念认为后端开发任......
  • 跨境盒子：跨境电商必备，推荐5款便宜好用的Logo设计网站！
    Logo设计网站可以让企业轻松建立强大的品牌影响力，今天给大家推荐5款如今较为好用的设计网站，让设计工作轻松高效！一、Canva可画：小型企业总体最佳logo设计网站Canva是小型企业（或任何规模的企业）Logo设计的最佳网站。任何人都可以在Canva一个免费、用户友好的设计平台上为任何类型的企......
  • Kubernetes
    一、简介   k8s、Google开源。容器编排引擎。   k8s的目标是让部署容器化的应用简单且高效【powerful】，k8s提供应用部署，规划，更新，维护的一种机制。   支持自动化部署、大规模可伸缩。应用容器化管理。二、组成    一个k8s系统，通常称为一个k8s集群【......
  • netty系列之ChannelOption
    netty系列之ChannelOption 1、概述在netty启动的时候会设置相关的ChannelOption,无论是在ServerBootstrap还是在Bootstrap,接下来解释一下常用的ChannelOption2、常用ChannelOptionChannelOption.SO_BACKLOG(一般用于option–>boss)BACKLOG用于构造服务端套接字ServerSocket......
  • Http头Hostname攻击漏洞
    作者：Monyer链接：https://www.zhihu.com/question/67477221/answer/254009089来源：知乎著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。这本来是个简单得不能再简单的漏洞。不过遵循题主的诉苦，我去网上找了一圈，的确发现没有一个能把这个问题说清楚，把解决方案......
  • C#图解教程笔记 - Chapter1 C#和.NET框架
    0摘要CLR,BCL,FCL,DLL,CIL,JIT,CLI,CTS,CLS1在.NET之前20世纪90年代末，使用微软平台的Windows编程分化成许多分支。如：VisualBasic(VB)C或C++其他相关技术：Win32APIMFCCOM所有这些编程技术有一个缺点，就是它们主要针对桌面程序而不是互联网进行开发。......
  • Kubernetes集群部署三节点yum部署
    一、修改主机名（三个节点都操作）vi/etc/hostname#跟换主机名systemctlrestartsystemd-hostnamed#修改完成后重新链接服务二、同步时间（三个节点都操作）yuminstallntpdate-yntpdatetime.windows.com#时区设置cp/usr/share/zoneinfo/Asia/Shanghai/etc/localtime#最......
  • mysql报错：The last packet successfully received from the server was 51,384,505 mi
    这个报错是MySQL连接超时导致的。当MySQL客户端在一段时间内没有收到来自服务器的数据包时，会触发这个错误。产生这个错误的可能原因有：1.网络问题：可能是网络连接不稳定或延迟过高，导致数据包在传输过程中丢失或延迟。2.MySQL服务器负载过高：如果MySQL服务器负载过高，无法及......
  • 【muduo】net篇---EventLoopThread和EventLoopThreadPool
    EventLoopThread是事件循环线程，包含一个Thread对象，一个EventLoop对象。在构造函数中，把EventLoopThread::threadFunc注册到Thread对象中（线程启动时会回调）。EventLoopThreadPool是事件循环线程池，管理所有客户端连接，每个线程都有唯一一个事件循环。可以调用setThreadNum设置线程的数......
  • 【muduo】net篇---TcpServer
    TcpServer在创建的过程中，首先new出来自己的核心组件（Acceptor,loop,connectionMap,threadPool）之后TcpServer会向Acceptor注册一个新连接到来时的Connection回调函数。一旦接受到一个client的连接，就会调用TcpServer::newConnection()函数。这个函数使用round-robin算法从EventLoopThr......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99