请求早就发完了，服务器为什么还在等结束？

"""A real localhost TCP connection, with each direction closed separately."""
from contextlib import closing
import socket


def receive_exact(stream, size):
    data = bytearray()
    while len(data) < size:
        part = stream.recv(size - len(data))
        if not part:
            raise RuntimeError("unexpected EOF before the known request length")
        data.extend(part)
    return bytes(data)


def receive_until_eof(stream):
    chunks = []
    while True:
        part = stream.recv(1024)
        if not part:
            return b"".join(chunks)
        chunks.append(part)


def main():
    checks = 0

    def check(condition, message):
        nonlocal checks
        if not condition:
            raise AssertionError(message)
        checks += 1

    with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as listener:
        listener.settimeout(3)
        listener.bind(("127.0.0.1", 0))
        listener.listen(1)
        with closing(socket.create_connection(listener.getsockname(), timeout=3)) as client:
            peer, _ = listener.accept()
            with closing(peer):
                peer.settimeout(3)
                client.sendall(b"order=7")
                request = receive_exact(peer, 7)
                check(request == b"order=7", "all request bytes must arrive")
                # No more bytes are scheduled, but the client write side is open.
                peer.settimeout(0.1)
                try:
                    peer.recv(1)
                except TimeoutError:
                    before = "timeout_not_eof"
                else:
                    raise AssertionError("an open write side must not imply EOF")
                check(before == "timeout_not_eof", "waiting is different from EOF")
                peer.settimeout(3)

                client.shutdown(socket.SHUT_WR)
                check(peer.recv(1) == b"", "server must now see request-direction EOF")
                peer.sendall(b"accepted:7")
                peer.shutdown(socket.SHUT_WR)
                response = receive_until_eof(client)
                check(response == b"accepted:7", "client may still receive after SHUT_WR")
                try:
                    client.sendall(b"late")
                except OSError:
                    later_write = "rejected"
                else:
                    raise AssertionError("writes after SHUT_WR must not succeed")
                check(later_write == "rejected", "closed direction stays closed")
                print(f"request={request!r}; before_shutdown={before}")
                print("after_client_SHUT_WR=server_received_eof")
                print(f"client_still_received={response!r}; later_write={later_write}")
    print(f"PASS checks={checks}; sockets_closed=True")


if __name__ == "__main__":
    main()

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

/** Real, finite loopback TCP traffic. No external server is contacted. */
public final class TcpHalfCloseDemo {
    private static int checks;

    private static void check(boolean condition, String message) {
        if (!condition) throw new AssertionError(message);
        checks++;
    }

    public static void main(String[] args) throws Exception {
        InetAddress loopback = InetAddress.getByName("127.0.0.1");
        byte[] request = "order=7".getBytes(StandardCharsets.US_ASCII);
        byte[] response = "accepted:7".getBytes(StandardCharsets.US_ASCII);
        try (ServerSocket listener = new ServerSocket()) {
            listener.bind(new InetSocketAddress(loopback, 0));
            listener.setSoTimeout(3000);
            try (Socket client = new Socket()) {
                client.connect(listener.getLocalSocketAddress(), 3000);
                client.setSoTimeout(3000);
                try (Socket server = listener.accept()) {
                    server.setSoTimeout(3000);
                    OutputStream clientOutput = client.getOutputStream();
                    InputStream serverInput = server.getInputStream();
                    clientOutput.write(request);
                    clientOutput.flush();
                    check(Arrays.equals(serverInput.readNBytes(request.length), request),
                            "server must receive the request bytes");

                    server.setSoTimeout(100);
                    boolean timedOut = false;
                    try {
                        serverInput.read();
                    } catch (SocketTimeoutException expected) {
                        timedOut = true;
                    }
                    check(timedOut, "no new byte is different from EOF");
                    server.setSoTimeout(3000);

                    // Do not close clientOutput here: that would close client too.
                    client.shutdownOutput();
                    check(client.isOutputShutdown() && !client.isInputShutdown(),
                            "only the sending direction is shut down");
                    check(serverInput.read() == -1, "server must observe request EOF");
                    server.getOutputStream().write(response);
                    server.getOutputStream().flush();
                    server.shutdownOutput();
                    byte[] actualResponse = client.getInputStream().readAllBytes();
                    check(Arrays.equals(actualResponse, response),
                            "client must still receive the server response");
                    boolean rejected = false;
                    try {
                        clientOutput.write('!');
                    } catch (IOException expected) {
                        rejected = true;
                    }
                    check(rejected, "a later write after shutdownOutput must fail");
                    System.out.println("request=order=7; before_shutdown=timeout_not_eof");
                    System.out.println("after_shutdownOutput=server_read_minus_one");
                    System.out.println("client_still_received="
                            + new String(actualResponse, StandardCharsets.US_ASCII)
                            + "; later_write=rejected");
                }
            }
        }
        System.out.println("PASS checks=" + checks + "; sockets_closed=true");
    }
}