About calling wrapper flow read() The confusion of thread blocking after method

Everyone should have used Java Of socket Well , We usually get a socket after , Will use a wrapper flow to call read() or write() Method to complete IO, The form is similar to this

// Here we use DataInputStream packing Socket Node flow of 
Socket socket = new Socket(host,port);
DataInputStream dis = new DataInputStream(socket.getInputStream());
String str = dis.read();

On the opposite end socket Without sending a message , This process will be blocked in the fourth sentence , This makes me very confused , Why does a method of packing flow have blocking effect .

So I clicked on DataInputStream Class read() Method , It's like this inside

    public final int read(byte[] b, int off, int len) throws IOException {
    
        return this.in.read(b, off, len);
    }

Among them the in Be being DataInputStream Wrapped node flow , In other words, he actually calls the node flow read() Method .

So here comes the question , How does this node flow block threads , This node flow is through socket and get When we arrive, let's open socket Take a look .

    private volatile InputStream in;

    private static class SocketInputStream extends InputStream {
    
        private final Socket parent;
        private final InputStream in;

        SocketInputStream(Socket parent, InputStream in) {
    
            this.parent = parent;
            this.in = in;
        }

        public int read() throws IOException {
    
            byte[] a = new byte[1];
            int n = this.read(a, 0, 1);
            return n > 0 ? a[0] & 255 : -1;
        }

        public int read(byte[] b, int off, int len) throws IOException {
    
            return this.in.read(b, off, len);
        }

        public int available() throws IOException {
    
            return this.in.available();
        }

        public void close() throws IOException {
    
            this.parent.close();
        }
    }

original socket Node flow in , yes socket An inner class in inherits InputStream Interface implemented .

I can see it here , We call DataInputStream Of read() Method is actually called socket() An internal self implemented read Method . In other words, this thread is actually socket Obstructed , Analysis complete .