socket通信意外阻塞的可能原因及解决办法

今天上午写了个小程序，实现客户端和服务器端之间数据传输。
即：客户端产生随机数，发个服务器端，服务器读取数据后加1，回传给客户端并打印。但是程序总是在通信一次后处于阻塞状态。

查了半天，原来是dos.writeInt(data), 写成了dos.write(data); 导致客户端得不到数据，整个链路中断。
1. 教训之一，必须要足够仔细，两端发送的数据格式必须一致。
2. 解决了客户端关闭之后，服务器端报异常的问题，就是直接在catch{
   server.close()
   依次关闭isRunning = false, dis, dos, socket!
}
   同样道理，防止客户端报错，也是在相应的catch里面，关闭客户端连接及循环

Server

/**
 * 
 */
package study;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author sean
 * 
 * 建立serversocket
 * 接受clientsocket
 * 建立workthread(socket),startWork
 * work:
 * 	while(true)
 * 	   int read = dis.readInt();
 *     dos.write(read+1); 
 *
 */
public class Server {

	static int port = 9999;
	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		
		ServerSocket server = new ServerSocket(port);
		System.out.println("服务器启动" + server.getLocalPort()+ " :" + server.getInetAddress());
		
		while(true){
			Socket socket = server.accept();
			System.out.println("接入...." + socket.getInetAddress() + socket.getPort());
			
			Work1 work1 = new Work1();
			work1.socket = socket;			
			new Thread(work1).start();
			
//			Work work = new Work();
//			work.socket = socket;
//			new Thread(work).start();			
		}		
	}
	
public static class Work1 implements Runnable {
		
		Socket socket = null;

		@Override
		public void run() {
			try {
				DataInputStream dis = new DataInputStream(socket.getInputStream());
				DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
				
				while(true) {
					int num = dis.readInt();					
					dos.writeInt(num + 1);
					System.out.println("server1 read data: " + num);
				}
				
				
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}			
		}
	}
}

Client

/**
 * 
 */
package study;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Random;

/**
 * @author sean
 * 1. socket 连接
 * 2. 循环
 *    获得dis, dos
 * 3. 发送随机数 random
 * 4. 接受随机数，并且判断temp+1=recv ?
 * 
 *
 */
public class Client implements Runnable {

	private static String addr = "127.0.0.1";
	private static int port = 9999;

	/**
	 * @param args
	 * @throws IOException 
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException,
			IOException {
		// TODO Auto-generated method stub

		Client client = new Client(addr, port);
		new Thread(client).start();
	}

	public Client(String addr, int port) {
		this.addr = addr;
		this.port = port;

	}

	boolean isRunning;

	@Override
	public void run() {
		// TODO Auto-generated method stub
		longConnection();
	}

	DataOutputStream dos;
	DataInputStream dis;
	Socket socket;
	Random rand = new Random(10000);

	private void longConnection() {
		// TODO Auto-generated method stub
		isRunning = true;
		while (isRunning) {
			try {
				socket = new Socket(addr, port);
				System.out.println("socket connect ok");
				dis = new DataInputStream(socket.getInputStream());
				dos = new DataOutputStream(socket.getOutputStream());
			} catch (IOException e) {
				closeSocket();
			}

			int temp;
			int checkIn = 0;

			while (isRunning) {
				temp = rand.nextInt();
				try {
					dos.writeInt(temp);
					checkIn = dis.readInt();
					System.out.println("temp:" + temp);
					System.out.println("checkin:" + checkIn);
				} catch (IOException e) {
					// TODO Auto-generated catch block
					closeSocket();
//					e.printStackTrace();
				}

			}
		}
	}

	private void closeSocket() {
		// TODO Auto-generated method stub
		isRunning = false;

		if (dis != null) {
			try {
				dis.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			dis = null;
		}

		if (dos != null) {
			try {
				dos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			dos = null;
		}

		if (socket != null) {
			try {
				socket.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			socket = null;
		}
	}
}