Question

我正在尝试实现http服务器：

使用某种逻辑计算更远的重定向
重定向用户
记录用户数据

目标是实现最大吞吐量（至少15k rps）。为了做到这一点，我想异步保存日志。我使用kafka作为日志记录系统，并将代码的日志记录块分离到单独的goroutine中。当前实施的总体示例：

package main

import (
    "github.com/confluentinc/confluent-kafka-go/kafka"
    "net/http"
    "time"
    "encoding/json"
)

type log struct {
    RuntimeParam  string `json:"runtime_param"`
    AsyncParam    string `json:"async_param"`
    RemoteAddress string `json:"remote_address"`
}

var (
    producer, _ = kafka.NewProducer(&kafka.ConfigMap{
        "bootstrap.servers": "localhost:9092,localhost:9093",
        "queue.buffering.max.ms": 1 * 1000,
        "go.delivery.reports": false,
        "client.id": 1,
    })
    topicName = "log"
)

func main() {
    siteMux := http.NewServeMux()
    siteMux.HandleFunc("/", httpHandler)
    srv := &http.Server{
        Addr: ":8080",
        Handler: siteMux,
        ReadTimeout:  2 * time.Second,
        WriteTimeout: 5 * time.Second,
        IdleTimeout:  10 * time.Second,
    }
    if err := srv.ListenAndServe(); err != nil {
        panic(err)
    }
}

func httpHandler(w http.ResponseWriter, r *http.Request) {
    handlerLog := new(log)
    handlerLog.RuntimeParam = "runtimeDataString"
    http.Redirect(w, r, "http://google.com", 301)
    go func(goroutineLog *log, request *http.Request) {
        goroutineLog.AsyncParam = "asyncDataString"
        goroutineLog.RemoteAddress = r.RemoteAddr
        jsonLog, err := json.Marshal(goroutineLog)
        if err == nil {
            producer.ProduceChannel() <- &kafka.Message{
                TopicPartition: kafka.TopicPartition{Topic: &topicName, Partition: kafka.PartitionAny},
                Value:          jsonLog,
            }
        }
    }(handlerLog, r)
}

问题是：

使用单独的goroutine实现异步日志记录是正确/有效还是应该使用不同的方法？（例如工人和渠道）
也许有一种方法可以进一步提高服务器的性能，我错过了什么？

Answer 1

是的，这是正确有效地使用goroutine（在评论中指出Flimzy）。我不能同意，这是一个很好的方法。

问题是处理程序可能在goroutine开始处理所有内容之前完成执行，并且请求（这是一个指针）可能已经消失，或者您可能会在中间件堆栈中进行一些竞争。我看了你的评论，这不是你的情况，但总的来说，你不应该将请求传递给goroutine。正如我从您的代码中看到的那样，您实际上只使用了请求中的RemoteAddr，为什么不直接重定向并将记录放入延迟语句中？所以，我稍微重写了你的处理程序：

func httpHandler(w http.ResponseWriter, r *http.Request) {
    http.Redirect(w, r, "http://google.com", 301)
    defer func(runtimeDataString, RemoteAddr string) {
            handlerLog := new(log)
            handlerLog.RuntimeParam = runtimeDataString
            handlerLog.AsyncParam = "asyncDataString"
            handlerLog.RemoteAddress = RemoteAddr
            jsonLog, err := json.Marshal(handlerLog)
            if err == nil {
                producer.ProduceChannel() <- &kafka.Message{
                    TopicPartition: kafka.TopicPartition{Topic: &topicName, Partition: kafka.PartitionAny},
                    Value:          jsonLog,
                }
            }
        }("runtimeDataString", r.RemoteAddr)
}

goroutine不太可能提高服务器的性能，因为您只是提前发送响应，并且这些kafka连接可能会在后台堆积并减慢整个服务器的速度。如果您发现这是瓶颈，您可以考虑在本地保存日志并将其发送到服务器之外的另一个进程（或工作池）中的kafka。这可能会随着时间推移工作负载（例如，当您有更多请求时发送更少的日志，反之亦然）。

响应后异步工作

1 个答案: