When the server validator fails,

What is this server validator ? Why will it fail ?

Can you please upload a complete and independent code sample ?

(CC: @bradfitz, but awaiting more detail)

I don't really understand this bug.

Please post a complete pair of demonstration programs (a client & server), not just snippets. Perhaps that will make it more clear.

@agnivade What is this server validator ? Why will it fail ?
the server will check the deviceId parameter, if the deviceId is empty, the server normally return a response immediately, but if the client not sends data completely，the client will wait for a long time to read maxPostHandlerReadBytes bytes.

The full code of the server is then uploaded.

client&server.zip
@bradfitz @agnivade

Wireshark packet capture results show that the response was returned to the client 8s later，Client wants to receive response message immediately

Thank you @everfighter /@winworm for providing the complete code.

The issue is within your for loop in client.go. You are sleeping for a certain time which is causing the delay. Plus varying your buffer size will also change the response time. Just simply remove the for loop and do a _, err = io.Copy(wr, f). This effectively does what you are doing in the for loop. If you want to control the buffer size, use io.CopyBuffer.

I could not see anything related to maxPostHandlerReadBytes.

Feel free to comment if you disagree with the analysis.

thank you @agnivade
I know what you mean, if the client remove pause time, can really fast reply, but in my real application scenario, users transmit audio data (normal vocals, according to every 20 ms transmission frame data 640 bytes) is in accordance with such speed.
In the above example, a 10 s of audio transmission such as user data to the server, when 1 s in the server error happened, the direct return an error json, the json must be immediately returned to the client, but the real result is that the client needs to wait for about 8 s will receive a response.

below is some debug info of source code in server.go

func (w *response) finishRequest() {
	w.handlerDone.setTrue()

	if !w.wroteHeader {
		w.WriteHeader(StatusOK)
	}
	**start := time.Now()
	w.w.Flush()
	fmt.Println("chunkedwriterclose:"+time.Since(start).String())**
	putBufioWriter(w.w)
	w.cw.close()
	w.conn.bufw.Flush()
	w.conn.r.abortPendingRead()
	// Close the body (regardless of w.closeAfterReply) so we can
	// re-use its bufio.Reader later safely.
	start = time.Now()
	w.reqBody.Close()
	fmt.Println("w.reqBody.Close():"+time.Since(start).String())
	if w.req.MultipartForm != nil {
		w.req.MultipartForm.RemoveAll()
	}
}

w.w.Flush() will invoke the below method writeHeader(p []byte)

func (cw *chunkWriter) writeHeader(p []byte) {
.......
if w.req.ContentLength != 0 && !w.closeAfterReply {
		var discard, tooBig bool

		switch bdy := w.req.Body.(type) {
		case *expectContinueReader:
			if bdy.resp.wroteContinue {
				discard = true
			}
		case *body:
			bdy.mu.Lock()
			switch {
			case bdy.closed:
				if !bdy.sawEOF {
					// Body was closed in handler with non-EOF error.
					w.closeAfterReply = true
				}
			case bdy.unreadDataSizeLocked() >= maxPostHandlerReadBytes:
				tooBig = true
			default:
				discard = true
			}
			bdy.mu.Unlock()
		default:
			discard = true
		}

		if discard {
			**_, err := io.CopyN(ioutil.Discard, w.reqBody, maxPostHandlerReadBytes+1)**
			switch err {
			case nil:
				// There must be even more data left over.
				tooBig = true
			case ErrBodyReadAfterClose:
				// Body was already consumed and closed.
			case io.EOF:
				// The remaining body was just consumed, close it.
				err = w.reqBody.Close()
				if err != nil {
					w.closeAfterReply = true
				}
			default:
				// Some other kind of error occurred, like a read timeout, or
				// corrupt chunked encoding. In any case, whatever remains
				// on the wire must not be parsed as another HTTP request.
				w.closeAfterReply = true
			}
		}
.......
}

io.CopyN(ioutil.Discard, w.reqBody, maxPostHandlerReadBytes+1) this method will cost 8s to read 256k data

this is the debug result

chunkedwriterclose:8.276652351s
abort inRead is false
abortPendingRead:5.411µs
doEarlyClose

Ok, so if I understand you correctly, you want to sleep for 20ms after every write, but still you want to get the result immediately. I will let @bradfitz decide if he wants to reopen this.