请求数量增加导致Go Web服务器性能急剧下降

大家好，我们又见面了啊~本文《请求数量增加导致Go Web服务器性能急剧下降》的内容中将会涉及到等等。如果你正在学习Golang相关知识，欢迎关注我，以后会给大家带来更多Golang相关文章，希望我们能一起进步！下面就开始本文的正式内容~

我正在使用 wrk 对用 go 编写的简单网络服务器进行基准测试。服务器在具有 4gb ram 的计算机上运行。测试开始时，性能非常好，代码每秒可处理 2000 个请求。但随着时间的推移，进程使用的内存逐渐增加，一旦达到 85%（我使用 top 检查这一点），吞吐量就会下降到每秒约 100 个请求。重新启动服务器后，吞吐量再次增加到最佳量。

性能下降是由于内存问题吗？为什么 go 不释放这些内存？我的 go 服务器如下所示：

func main() {
    defer func() {
        // wait for all messages to drain out before closing the producer
        p.flush(1000)
        p.close()
    }()

    http.handlefunc("/endpoint", handler)
    log.fatal(http.listenandserve(":8080", nil))
}

在处理程序中，我将传入的 protobuf 消息转换为 json，并使用融合的 kafka go 库将其写入 kafka。

var p, err = kafka.NewProducer(&kafka.ConfigMap{
    "bootstrap.servers": "abc-0.com:6667,abc-1.com:6667",
    "message.timeout.ms": "30000",
    "sasl.kerberos.keytab": "/opt/certs/TEST.KEYTAB",
    "sasl.kerberos.principal": "[email protected]",
    "sasl.kerberos.service.name": "kafka",
    "security.protocol": "SASL_PLAINTEXT",
})

var topic = "test"

func handler(w http.ResponseWriter, r *http.Request) {
    body, _ := ioutil.ReadAll(r.Body)

    // Deserialize byte[] to Protobuf message
    protoMessage := &tutorial.REALTIMEGPS{}
    _ := proto.Unmarshal(body, protoMessage)

    // Convert Protobuf to Json
    realTimeJson, _ := convertProtoToJson(protoMessage)

    _, err := fmt.Fprintf(w, "")

    if err != nil {
        log.Fatal(responseErr)
    }

    // Send to Kafka
    produceMessage([]byte(realTimeJson))
}

func produceMessage(message []byte) {
    // Delivery report
    go func() {
        for e := range p.Events() {
            switch ev := e.(type) {
            case *kafka.Message:
                if ev.TopicPartition.Error != nil {
                    log.Println("Delivery failed: ", ev.TopicPartition)
                } else {
                    log.Println("Delivered message to ", ev.TopicPartition)
                }
            }
        }
    }()

    // Send message
    _ := p.Produce(&kafka.Message{
        TopicPartition: kafka.TopicPartition{Topic: &topic, Partition: kafka.PartitionAny},
        Value:          message,
    }, nil)
}

func convertProtoToJson(pb proto.Message) (string, error) {
    marshaler := jsonpb.Marshaler{}
    json, err := marshaler.MarshalToString(pb)
    return json, err
}

解决方案

问题是，在每个请求的末尾，您调用 producemessage()，它向 kafka 发送一条消息，并启动一个 goroutine 来接收事件以检查错误。

随着传入请求的到来，您的代码会不间断地启动 goroutine，并且它们不会结束，直到您的 kafka 客户端出现问题。这需要越来越多的内存，并且可能需要越来越多的 cpu，因为要调度更多的 goroutine。

不要这样做。单个 goroutine 足以满足交付报告的目的。设置 p 变量后启动单个 goroutine，就可以开始了。

例如：

var p *kafka.Producer

func init() {
    var err error
    p, err = kafka.NewProducer(&kafka.ConfigMap{
        // ...
    }
    if err != nil {
        // Handle error
    }

    // Delivery report
    go func() {
        for e := range p.Events() {
            switch ev := e.(type) {
            case *kafka.Message:
                if ev.TopicPartition.Error != nil {
                    log.Println("Delivery failed: ", ev.TopicPartition)
                } else {
                    log.Println("Delivered message to ", ev.TopicPartition)
                }
            }
        }
    }()
}

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。