Java Socket上的Read操作阻塞问题详解

Socket上的Read操作阻塞问题

从Socket上读取对端发过来的数据一般有两种方法

1）按照字节流读取

        BufferedInputStream in = new BufferedInputStream(socket.getInputStream());
        int r = -1;
        List<Byte> l = new LinkedList<Byte>();
        while ((r = in.read()) != -1) {
            l.add(Byte.valueOf((byte) r));
        }

2）按照字符流读取

        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));        
        String s;
        while ((s = in.readLine()) != null) {
            System.out.println("Reveived: " + s);
        }

这两个方法read()和readLine()都会读取对端发送过来的数据，如果无数据可读，就会阻塞直到有数据可读。或者到达流的末尾，这个时候分别返回-1和null。

这个特性使得编程非常方便也很高效。

但是这样也有一个问题，就是如何让程序从这两个方法的阻塞调用中返回。

总结一下，有这么几个方法

1）发送完后调用Socket的shutdownOutput()方法关闭输出流，这样对端的输入流上的read操作就会返回-1。

注意不能调用socket.getInputStream().close()。这样会导致socket被关闭。

当然如果不需要继续在socket上进行读操作，也可以直接关闭socket。

但是这个方法不能用于通信双方需要多次交互的情况。

2）发送数据时，约定数据的首部固定字节数为数据长度。这样读取到这个长度的数据后，就不继续调用read方法。

3）为了防止read操作造成程序永久挂起，还可以给socket设置超时。

如果read()方法在设置时间内没有读取到数据，就会抛出一个java.net.SocketTimeoutException异常。

例如下面的方法设定超时3秒。

socket.setSoTimeout(3000);

Socket编程---read方法阻塞问题

java通信项目简单写了个聊天室，实现群聊私聊了，就大言不惭地往简历上写了对java网络编程和多线程有了一定的了解。给客户端各自开了线程，写了句server.accept()、Socket client=new Socket("127.0.0.1",9999)，就叫了解了? Too young too simple.

然而一问，BIO和NIO有什么区别？--- 纳尼？什么玩意儿？

• 那你说说你那个聊天室的流? --- 卧槽，这有什么好说的，get啊，输入流用来读的，输出流用来写数据给对方的
• 可能知道我没get到点吧，那你自己说一下你的通信项目吧 --- 哈哈，先创建一个ServerSocket对象，然后accept等客户端来连，给每个客户端都开一个线程各自处理
• 奥，你是给每个客户端都开了一个线程啊============ 结束会话

聊完了啊，可是我并不知道发生了什么，这特么到底要问啥啊。现在一想，可能对方觉得我特么就是傻缺吧，一个只会码而没有思想的人。

那不管，先不说BIO和NIO，通过这个，我倒是好像get到他是不是在跟我说流的阻塞问题。那么，总结一下吧。

讲文件流的时候，我们会看到这两个read方法，看一下api

如果只是使用一次，那么没有数据读的时候，会一直阻塞，然后想执行下面那是不可能的了，直到有数据可读；

如果用在while里，那么没读到文件末尾，也是一直阻塞的，直到被返回-1。

文件它是自己知道读到文件末尾了，那么我们的Socket是两端的通信，一直等待着对方传来数据的，并不知道啥时候会完，所以就会一直不会等于-1，阻塞在while循环里了，下面的代码就不会被执行。

package SocketIO; 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
 
public class Server { 
	public static void main(String[] args) throws IOException {
		String m = "";
		ServerSocket ss =  new ServerSocket(9999);
		Socket s = ss.accept();
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"...connected...");
		m = ip+"...connected...";
		InputStream in = s.getInputStream();
		int len = 0;
		byte[] buf = new byte[1024];
		while((len=in.read(buf))!=-1){
			m += new String(buf);
		}
		System.out.println(m);
		
		OutputStream out = s.getOutputStream();
		out.write("饭菜马上到".getBytes());
		out.flush();
		in.close();
		out.close();
		s.close();
		ss.close();
	}
}

package SocketIO; 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException; 
public class Client {
 
	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket s = new Socket("127.0.0.1", 9999);
		OutputStream out = s.getOutputStream();
		out.write("我肚子饿了".getBytes());
		out.flush();
		String m = "";
		InputStream in = s.getInputStream();
		byte[] buf = new byte[1024];
		int len = 0;
		while((len=in.read(buf))!=-1){
			m += new String(buf);
		}
		System.out.println(m);
		in.close();
		out.close();
		s.close();
	} 
}

当客户端连接上服务器时，把“我肚子饿了”写给服务器，服务器读的时候不知道客户端发没发完，就一直阻塞在while循环里，故服务器的console只会输出

,

而客户端的console什么也不会输出

那么，我们只用加一句，

客户端写完数据后，就直接把输出流shutdown，那么服务器读到的就会是-1，跳出循环，继续往下执行。那为什么服务器写完数据后不把输出流shutdown，你没看见所有的流都close了吗？客户端当然会读到-1，进而输出我们想看到的东东了。如果你还不服，你把close都注释掉，看看效果（都注释掉了客户端读的时候又阻塞了），再加上s.shutdownOutput()再看看效果（这会又恢复正常了）。

这个例子其实只是想说明socket编程中流的read方法是阻塞的。

那么，回到我们的聊天室来，我一个服务器要处理这么多个客户端，如果一个客户端的read方法阻塞了，那别的客户端不都得等着它吗？显然，这是不可能的。那，一个客户端给一个线程吧，让它们自己阻塞自己的。

对于服务器端而言，给每个客户端启动一个线程，然后在每个客户端各自的线程里循环去读客户端发来的数据，没的话阻塞等待直到有，有的话转发，所以阻塞在循环里也无所谓，反正while循环之外我暂时也没想着执行。当然，还是要把它结束掉。

对于服务器端，先读后转发，嵌在一个循环里，不会有什么问题。

而对于客户端而言，我要随时监听去读，又想着随时去写。那写的操作不能在读的循环里了啊，只能写在外面。而读的操作又是一直阻塞着的，岂会让出时间让你写？那，大招来了。你把读的操作放一个线程里不就得了，由它去阻塞，想怎么读就怎么读。那互不影响的话，我也想怎么写就怎么写啊。

写的操作我就不截图了，就是在主线程里完成的。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程网。