Fehler „http: Schreiben überschreitet die angegebene Inhaltslänge' in Go

Der PHP-Editor Xinyi stellt Ihnen heute einen häufigen Fehler vor, nämlich den Fehler „http: Writing überschreitet die angegebene Inhaltslänge“, der in der Go-Sprache auftritt. Wenn wir HTTP-Anfragen mit der Go-Sprache schreiben, tritt manchmal dieser Fehler auf. Der Grund für diesen Fehler liegt darin, dass die von uns im Anforderungsheader deklarierte Content-Length nicht mit der Länge des tatsächlich gesendeten Anforderungstexts übereinstimmt. Als nächstes erklären wir im Detail, warum dieser Fehler auftritt und wie man ihn beheben kann.

Frageninhalt

Ich experimentiere mit Go und habe eine Anwendung geschrieben, um eine Warteschlange von HTTP-Anfragen zu verwalten, die von einer Worker-Coroutine verarbeitet werden.

Die Parallelität scheint gut zu funktionieren, aber nach dem Zurücksenden http 响应时出现此错误：写入的内容超过声明的 Content-Length.

Der vollständige Code lautet wie folgt:

package main

import (
    "log"
    "net/http"
    "sync"
)

// Job represents a unit of work to be processed by a worker.
type Job struct {
    r *http.Request       // HTTP request to be processed
    w http.ResponseWriter // Response writer to send the result
}

// Queue manages a list of jobs to be processed by workers.
type Queue struct {
    jobs []*Job     // List of jobs in the queue
    mu   sync.Mutex // Mutex to synchronize access to the queue
    cond *sync.Cond // Condition variable for signaling
}

var q Queue // Global instance of the queue
var WORKER_POOL_SIZE = 4 // Number of workers

// Push adds a job to the queue.
func (q *Queue) Push(j *Job) {
    q.mu.Lock()
    defer q.mu.Unlock()
    q.jobs = append(q.jobs, j)
    q.cond.Signal() // Signal a waiting worker that a job is available
    log.Println("Job added to queue")
}

// Pop retrieves and removes a job from the queue.
func (q *Queue) Pop() (*Job, bool) {
    q.mu.Lock()
    defer q.mu.Unlock()
    if len(q.jobs) == 0 {
        q.cond.Wait() // If the queue is empty, wait for a signal
    }
    job := q.jobs[0]
    q.jobs = q.jobs[1:]
    log.Println("Job removed from queue")
    return job, true
}

// handler adds a job to the queue.
func handler(w http.ResponseWriter, r *http.Request) {
    // Create a job with the request and response.
    job := &Job{r, w}

    // Push the job onto the queue.
    q.Push(job)
    log.Println("Received request and added job to queue")
}

// init initializes the condition variable and starts worker goroutines.
func init() {
    q.cond = sync.NewCond(&q.mu)
    for i := 0; i < WORKER_POOL_SIZE; i++ {
        go worker()
    }
}

// worker processes jobs from the queue.
func worker() {
    for {
        job, ok := q.Pop()
        if ok {
            log.Println("Worker processing job")
            doWork(job)
        }
    }
}

// doWork simulates processing a job and sends a response.
func doWork(job *Job) {
    // Extract the "Name" parameter from the request query.
    name := job.r.URL.Query().Get("Name")

    // Check if the name is not empty.
    if name != "" {
        // Send the name as the response.
        _, err := job.w.Write([]byte("Hello, " + name))
        if err != nil {
            log.Println("Error writing response:", err)
        }
        log.Println("Response sent: Hello,", name)
    } else {
        // If the "Name" parameter is missing or empty, send an error response.
        http.Error(job.w, "Name parameter is missing or empty", http.StatusBadRequest)
        log.Println("Error: Name parameter is missing or empty")
    }
}

func main() {
    http.HandleFunc("/addJob", handler)
    log.Println("Server started and listening on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal("Error starting server:", err)
    }
}

Irgendeine Idee, wie man dieses Problem lösen kann? Glauben Sie außerdem, dass die Parallelität in Go für mich noch verbesserungswürdig ist? Danke!

Workaround

laut http.Handler Dokumentation:

dein handler 正在将请求/编写器推送到队列中，然后返回。这意味着您在处理程序返回后尝试写入 ResponseWriter ，违反了上述规定（由于没有同步，写入也可能实际发生在 return vorher oder gleichzeitig).

Es gibt viele Möglichkeiten, dieses Problem zu lösen; eine Technik ist:

// Job represents a unit of work to be processed by a worker.
type Job struct {
    r    *http.Request       // HTTP request to be processed
    w    http.ResponseWriter // Response writer to send the result
    done chan struct{}       // Closed when write competed
}

...

func handler(w http.ResponseWriter, r *http.Request) {
    // Create a job with the request and response.
    job := &Job{r, w, make(chan struct{})}

    // Push the job onto the queue.
    q.Push(job)
    log.Println("Received request and added job to queue")
    <-job.done // Wait until job has been processed
}

...

// worker processes jobs from the queue.
func worker() {
    for {
        job, ok := q.Pop()
        if ok {
            log.Println("Worker processing job")
            doWork(job)
            close(job.done) // Notify requester that we are done
        }
    }
}

Es hängt wirklich von den Anforderungen ab. Eine gängige Lösung besteht darin, einfach Kanäle zu verwenden (ein Handler sendet eine Anfrage an einen Kanal und mehrere Worker empfangen sie über denselben Kanal).

Das obige ist der detaillierte Inhalt vonFehler „http: Schreiben überschreitet die angegebene Inhaltslänge' in Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!