另外http://www.cnblogs.com/fengmk2/archive/2007/01/15/using-Socket.html可供参考

一Java socket 说明

所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

以J2SDK-1.3为例，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。

重要的Socket API：

java.net.Socket继承于java.lang.Object，有八个构造器，其方法并不多，下面介绍使用最频繁的三个方法，其它方法大家可以见JDK-1.3文档。

. Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。

. getInputStream方法获得网络连接输入，同时返回一个InputStream对象实例。

. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。

注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。

二网络编程中两类数据交互

一个是如何准确的定位网络上一台或多台主机，另一个就是找到主机后如何可靠高效的进行数据传输。

在TCP/IP协议中IP层主要负责网络主机的定位，数据传输的路由，由IP地址可以唯一地确定Internet上的一台主机。

而TCP层则提供面向应用的可靠（tcp）的或非可靠（UDP）的数据传输机制，这是网络编程的主要对象，一般不需要关心IP层是如何处理数据的。

目前较为流行的网络编程模型是客户机/服务器（C/S）结构。即通信双方一方作为服务器等待客户提出请求并予以响应。客户则在需要服务时向服务器提 出申请。服务器一般作为守护进程始终运行，监听网络端口，一旦有客户请求，就会启动一个服务进程来响应该客户，同时自己继续监听服务端口，使后来的客户也 能及时得到服务。

三两类传输协议：TCP；UDP

TCP是Tranfer Control Protocol的 简称，是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建 立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送 或接收操作。

UDP是User Datagram Protocol的简称，是一种无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。

比较：

UDP：1，每个数据报中都给出了完整的地址信息，因此无需要建立发送方和接收方的连接。

2，UDP传输数据时是有大小限制的，每个被传输的数据报必须限定在64KB之内。

3，UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方

TCP：1，面向连接的协议，在socket之间进行数据传输之前必然要建立连接，所以在TCP中需要连接

时间。

2，TCP传输数据大小限制，一旦连接建立起来，双方的socket就可以按统一的格式传输大的

数据。

3，TCP是一个可靠的协议，它确保接收方完全正确地获取发送方所发送的全部数据。

应用：

1，TCP在网络通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输。但是可靠的传输是要付出代价的，对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽，因此TCP传输的效率不如UDP高。

2，UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序。例如视频会议系统，并不要求音频视频数据绝对的正确，只要保证连贯性就可以了，这种情况下显然使用UDP会更合理一些。

四 Socket应用

1 Socket编程说明及简单应用

1，什么是Socket

网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket。Socket通常用来实现客户方和服务方的连接。Socket是TCP/IP协议的一个十分流行的编程界面，一个Socket由一个IP地址和一个端口号唯一确定。

但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。

2，Socket通讯的过程

Server端Listen(监听)某个端口是否有连接请求，Client端向Server 端发出Connect(连接)请求，Server端向Client端发回Accept（接受）消息。一个连接就建立起来了。Server端和Client 端都可以通过Send，Write等方法与对方通信。

对于一个功能齐全的Socket，都要包含以下基本结构，其工作过程包含以下四个基本的步骤：

　　（1） 创建Socket；

　　（2） 打开连接到Socket的输入/出流；

　　（3） 按照一定的协议对Socket进行读/写操作；

　　（4） 关闭Socket.（在实际应用中，并未使用到显示的close，虽然很多文章都推荐如此，不过在我的程序中，可能因为程序本身比较简单，要求不高，所以并未造成什么影响。）

3，创建Socket

创建Socket

java在包java.net中提供了两个类Socket和ServerSocket，分别用来表示双向连接的客户端和服务端。这是两个封装得非常好的类，使用很方便。其构造方法如下：

　　Socket(InetAddress address, int port);

　　Socket(InetAddress address, int port, boolean stream);

　　Socket(String host, int prot);

　　Socket(String host, int prot, boolean stream);

　　Socket(SocketImpl impl)

　　Socket(String host, int port, InetAddress localAddr, int localPort)

　　Socket(InetAddress address, int port, InetAddress localAddr, intlocalPort)

　　ServerSocket(int port);

　　ServerSocket(int port, int backlog);

　　ServerSocket(int port, int backlog, InetAddress bindAddr)

　　其中address、host和port分别是双向连接中另一方的IP地址、主机名和端 口号，stream指明socket是流socket还是数据报socket，localPort表示本地主机的端口号，localAddr和 bindAddr是本地机器的地址（ServerSocket的主机地址），impl是socket的父类，既可以用来创建serverSocket又可 以用来创建Socket。count则表示服务端所能支持的最大连接数。例如：

　　Socket client = new Socket("127.0.01.", 80);

　　ServerSocket server = new ServerSocket(80);

　　注意，在选择端口时，必须小心。每一个端口提供一种特定的服务，只有给出正确的端口，才 能获得相应的服务。0~1023的端口号为系统所保留，例如http服务的端口号为80,telnet服务的端口号为21,ftp服务的端口号为23, 所以我们在选择端口号时，最好选择一个大于1023的数以防止发生冲突。

　　在创建socket时如果发生错误，将产生IOException，在程序中必须对之作出处理。所以在创建Socket或ServerSocket是必须捕获或抛出例外。

4，简单的Client/Server程序

1. 客户端程序

　　import java.io.*;

　　import java.net.*;

　　public class TalkClient {

　　　　public static void main(String args[]) {

　　　　　　try{

　　　　　　　　Socket socket=new Socket("127.0.0.1",4700);

　　　　　　　　//向本机的4700端口发出客户请求

　　　　　　　　BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));

　　　　　　　　//由系统标准输入设备构造BufferedReader对象

　　　　　　　　PrintWriter os=new PrintWriter(socket.getOutputStream());

　　　　　　　　//由Socket对象得到输出流，并构造PrintWriter对象

　　　　　　　　BufferedReader is=new BufferedReader(newInputStreamReader(socket.getInputStream()));

　　　　　　　　//由Socket对象得到输入流，并构造相应的BufferedReader对象

　　　　　　　　String readline;

　　　　　　　　readline=sin.readLine(); //从系统标准输入读入一字符串

　　　　　　　　while(!readline.equals("bye")){

　　　　　　　　//若从标准输入读入的字符串为 "bye"则停止循环

　　　　　　　　　　os.println(readline);

　　　　　　　　　　//将从系统标准输入读入的字符串输出到Server

　　　　　　　　　　os.flush();

　　　　　　　　　　//刷新输出流，使Server马上收到该字符串

　　　　　　　　　　System.out.println("Client:"+readline);

　　　　　　　　　　//在系统标准输出上打印读入的字符串

　　　　　　　　　　System.out.println("Server:"+is.readLine());

　　　　　　　　　　//从Server读入一字符串，并打印到标准输出上

　　　　　　　　　　readline=sin.readLine(); //从系统标准输入读入一字符串

　　　　　　　　} //继续循环

　　　　　　　　os.close(); //关闭Socket输出流

　　　　　　　　is.close(); //关闭Socket输入流

　　　　　　　　socket.close(); //关闭Socket

　　　　　　}catch(Exception e) {

　　　　　　　　System.out.println("Error"+e); //出错，则打印出错信息

　　　　　　}

　　}

}

　2. 服务器端程序

　　import java.io.*;

　　import java.net.*;

　　import java.applet.Applet;

　　public class TalkServer{

　　　　public static void main(String args[]) {

　　　　　　try{

　　　　　　　　ServerSocket server=null;

　　　　　　　　try{

　　　　　　　　　　server=new ServerSocket(4700);

　　　　　　　　//创建一个ServerSocket在端口4700监听客户请求

　　　　　　　　}catch(Exception e) {

　　　　　　　　　　System.out.println("can not listen to:"+e);

　　　　　　　　//出错，打印出错信息

　　　　　　　　}

　　　　　　　　Socket socket=null;

　　　　　　　　try{

　　　　　　　　　　socket=server.accept();

　　　　　　　　　　//使用accept()阻塞等待客户请求，有客户

　　　　　　　　　　//请求到来则产生一个Socket对象，并继续执行

　　　　　　　　}catch(Exception e) {

　　　　　　　　　　System.out.println("Error."+e);

　　　　　　　　　　//出错，打印出错信息

　　　　　　　　}

　　　　　　　　String line;

　　　　　　　　BufferedReader is=new BufferedReader(newInputStreamReader(socket.getInputStream()));

　　　　　　　　　//由Socket对象得到输入流，并构造相应的BufferedReader对象

　　　　　　　　PrintWriter os=newPrintWriter(socket.getOutputStream());

　　　　　　　　　//由Socket对象得到输出流，并构造PrintWriter对象

　　　　　　　　BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));

　　　　　　　　　//由系统标准输入设备构造BufferedReader对象

　　　　　　　　System.out.println("Client:"+is.readLine());

　　　　　　　　//在标准输出上打印从客户端读入的字符串

　　　　　　　　line=sin.readLine();

　　　　　　　　//从标准输入读入一字符串

　　　　　　　　while(!line.equals("bye")){

　　　　　　　　//如果该字符串为 "bye"，则停止循环

　　　　　　　　　　os.println(line);

　　　　　　　　　　//向客户端输出该字符串

　　　　　　　　　　os.flush();

　　　　　　　　　　//刷新输出流，使Client马上收到该字符串

　　　　　　　　　　System.out.println("Server:"+line);

　　　　　　　　　　//在系统标准输出上打印读入的字符串

　　　　　　　　　　System.out.println("Client:"+is.readLine());

　　　　　　　　　　//从Client读入一字符串，并打印到标准输出上

　　　　　　　　　　line=sin.readLine();

　　　　　　　　　　//从系统标准输入读入一字符串

　　　　　　　　} 　//继续循环

　　　　　　　　os.close(); //关闭Socket输出流

　　　　　　　　is.close(); //关闭Socket输入流

　　　　　　　　socket.close(); //关闭Socket

　　　　　　　　server.close(); //关闭ServerSocket

　　　　　　}catch(Exception e){

　　　　　　　　System.out.println("Error:"+e);

　　　　　　　　//出错，打印出错信息

　　　　　　}

　　　　}

　　}

2 多线程通信

1）多个客户同时连接—例子1

在实际的网络环境里，同一时间只对一个用户服务是不可行的。一个优秀的网络服务程序除了能处理用户的输入信息，还必须能够同时响应多个客户端的连接请求。在java中，实现以上功能特点是非常容易的。

设计原理：

主程序监听一端口，等待客户接入；同时构造一个线程类，准备接管会话。当一个Socket会话产生后，将这个会话交给线程处理，然后主程序继续监听。运用Thread类或Runnable接口来实现是不错的办法。

importjava.io.*;

importjava.net.*;

public classServer extends ServerSocket

{

private staticfinal int SERVER_PORT = 10000;

publicServer() throws IOException

{

super(SERVER_PORT);

try

{

while (true)

{

Socket socket= accept();

new CreateServerThread(socket);

}

}

catch(IOException e)

{}

finally

{

close();

}

}

//---CreateServerThread

classCreateServerThread extends Thread

{

private Socketclient;

privateBufferedReader in;

privatePrintWriter out;

publicCreateServerThread(Socket s) throws IOException

{

client = s;

in = newBufferedReader(new InputStreamReader(client.getInputStream(),"GB2312"));

out = newPrintWriter(client.getOutputStream(), true);

out.println("---Welcome ---");

start();

}

public voidrun()

{

try

{

String line =in.readLine();

while(!line.equals("bye"))

{

String msg =createMessage(line);

out.println(msg);

line =in.readLine();

}

out.println("---See you, bye! ---");

client.close();

}

catch(IOException e)

{}

}

private StringcreateMessage(String line)

{

xxxxxxxxx;

}

}

public staticvoid main(String[] args) throws IOException

{

new Server();

}

}

这个程序监听10000端口，并将接入交给CreateServerThread线程运行。CreateServerThread线程接受输入，并将输入回应客户，直到客户输入"bye"，线程结束。我们可以在createMessage方法中，对输入进行处理，并产生结果，然后把结果返回给客户。

2）多线程通信---例子2

服务端：

package com.googlecode.garbagecan.test.socket.sample2;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

public class MyServer {

public static void main(String[] args) throws IOException {

ServerSocket server = new ServerSocket(10000);

while (true) {

Socket socket = server.accept();

invoke(socket);

}

}

private static void invoke(final Socket client) throws IOException {

new Thread(new Runnable() {

public void run() {

BufferedReader in = null;

PrintWriter out = null;

try {

in = new BufferedReader(new InputStreamReader(client.getInputStream()));

out = new PrintWriter(client.getOutputStream());

while (true) {

String msg = in.readLine();

System.out.println(msg);

out.println("Server received " + msg);

out.flush();

if (msg.equals("bye")) {

break;

}

}

} catch(IOException ex) {

ex.printStackTrace();

} finally {

try {

in.close();

} catch (Exception e) {}

try {

out.close();

} catch (Exception e) {}

try {

client.close();

} catch (Exception e) {}

}

}

}).start();

}

}

客户端：

package com.googlecode.garbagecan.test.socket.sample2;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.Socket;

public class MyClient {

public static void main(String[] args) throws Exception {

Socket socket = new Socket("localhost", 10000);

BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

PrintWriter out = new PrintWriter(socket.getOutputStream());

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

while (true) {

String msg = reader.readLine();

out.println(msg);

out.flush();

if (msg.equals("bye")) {

break;

}

System.out.println(in.readLine());

}

socket.close();

}

}

3 实现信息共享:在Socket上的实时交流

网络的伟大之一也是信息共享，Server可以主动向所有Client广播消息，同时Client也可以向其它Client发布消息。下面看看如何开发一个可以实时传递消息的程序。

设计原理：

服务器端接受客户端的连接请求，同时启动一个线程处理这个连接，线程不停的读取客户端输入，然后把输入加入队列中，等候处理。在线程启动的同时将线程加入队列中，以便在需要的时候定位和取出。

import java.io.*;

import java.net.*;

import java.util.*;

import java.lang.*;

public class Server extends ServerSocket

{

private static ArrayList User_List = newArrayList();

private static ArrayList Threader = newArrayList();

private static LinkedList Message_Array =new LinkedList();

private static int Thread_Counter = 0;

private static boolean isClear = true;

protected static final int SERVER_PORT =10000;

protected FileOutputStream LOG_FILE = newFileOutputStream("d:/connect.log", true);

public Server() throwsFileNotFoundException, IOException

{

super(SERVER_PORT);

new Broadcast();

//append connection log

Calendar now = Calendar.getInstance();

String str = "[" + now.getTime().toString()+ "] Accepted a connection1512";

byte[] tmp = str.getBytes();

LOG_FILE.write(tmp);

try

{

while (true)

{

Socket socket = accept();

new CreateServerThread(socket);

}

}

finally

{

close();

}

}

public static void main(String[] args)throws IOException

{

new Server();

}

//--- Broadcast

class Broadcast extends Thread

{

public Broadcast()

{

start();

}

public void run()

{

while (true)

{

if (!isClear)

{

String tmp =(String)Message_Array.getFirst();

for (int i = 0; i < Threader.size();i++)

{

CreateServerThread client =(CreateServerThread)Threader.get(i);

client.sendMessage(tmp);

}

Message_Array.removeFirst();

isClear = Message_Array.size() > 0 ?false : true;

}

}

}

}

//--- CreateServerThread

class CreateServerThread extends Thread

{

private Socket client;

private BufferedReader in;

private PrintWriter out;

private String Username;

public CreateServerThread(Socket s) throwsIOException

{

client = s;

in = new BufferedReader(newInputStreamReader(client.getInputStream()));

out = new PrintWriter(client.getOutputStream(),true);

out.println("--- Welcome to thischatroom ---");

out.println("Input yournickname:");

start();

}

public void sendMessage(String msg)

{

out.println(msg);

}

public void run()

{

try

{

int flag = 0;

Thread_Counter++;

String line = in.readLine();

while (!line.equals("bye"))

{

if (line.equals("l"))

{

out.println(listOnlineUsers());

line = in.readLine();

continue;

}

if (flag++ == 0)

{

Username = line;

User_List.add(Username);

out.println(listOnlineUsers());

Threader.add(this);

pushMessage("[< " + Username +" come on in >]");

}

else

{

pushMessage("<" + Username +">" + line);

}

line = in.readLine();

}

out.println("--- See you, bye!---");

client.close();

}

catch (IOException e)

{}

finally

{

try

{

client.close();

}

catch (IOException e)

{}

Thread_Counter--;

Threader.remove(this);

User_List.remove(Username);

pushMessage("[< " + Username +" left>]");

}

}

private String listOnlineUsers()

{

String s ="-+- Online list-+-1512";

for (int i = 0; i < User_List.size();i++)

{

s += "[" + User_List.get(i) +"]1512";

}

s += "-+---------------------+-";

return s;

}

private void pushMessage(String msg)

{

Message_Array.addLast(msg);

isClear = false;

}

}

}

4 socket 实现对象传输

首先需要一个普通的对象类，由于需要序列化这个对象以便在网络上传输，所以实现java.io.Serializable接口就是必不可少的了，通过JOPO的方式实现对象模型的定义，例如，我们可以定义User.java

然后，在ServerSocket端使用ObjectInputStream与ObjectOutputStream对象传输方式。同样在客户端对象传输也使用这种方式。

例如：

服务端：

is = new ObjectInputStream(new BufferedInputStream(socket.getInputStream()));

os = new ObjectOutputStream(socket.getOutputStream());

Object obj = is.readObject();

User user = (User)obj;

System.out.println("user: " + user.getName() + "/" + user.getPassword());

user.setName(user.getName() + "_new");

user.setPassword(user.getPassword() + "_new");

os.writeObject(user);

os.flush();

客户端：

socket = new Socket("localhost", );

os = new ObjectOutputStream(socket.getOutputStream())

User user = new User("user_" + i, "password_" + i);

os.writeObject(user);

os.flush();

is = new ObjectInputStream(new BufferedInputStream(socket.getInputStream()));

Object obj = is.readObject();

if (obj != null) {

user = (User)obj;

System.out.println("user: " + user.getName() + "/" + user.getPassword());

五 Socket异常处理

第1个异常是 java.net.BindException:Address already in use: JVM_Bind。

该异常发生在服务器端进行newServerSocket(port)（port是一个0，65536的整型值）操作时。异常的原因是以为与port一样的一个端口已经被启动，并进行监听。此时用netstat–an命令，可以看到一个Listending状态的端口。只需要找一个没有被占用的端口就能解决这个问题。

使用Java JDK中Java.net包控制UDP协议

通过Java.net.Socket类抓取网页内容

通过java.net.Socket类抓取网页内容

通过Java.net包建立双向通讯

用来访问HTTP服务器的仿java.net功能类

第2个异常是java.net.SocketException: Connection refused: connect。

该异常发生在客户端进行 newSocket(ip, port)操作时，该异常发生的原因是或者具有ip地址的机器不能找到（也就是说从当前机器不存在到指定ip路由），或者是该ip存在，但找不到指定的端口进行监听。出现该问题，首先检查客户端的ip和port是否写错了，如果正确则从客户端ping一下服务器看是否能ping通，如果能ping通（服务服务器端把ping禁掉则需要另外的办法），则看在服务器端的监听指定端口的程序是否启动，这个肯定能解决这个问题。

第3个异常是java.net.SocketException: Socket is closed，

该异常在客户端和服务器均可能发生。异常的原因是己方主动关闭了连接后（调用了Socket的close方法）再对网络连接进行读写操作。

第4个异常是java.net.SocketException:（Connection reset或者Connectreset by peer:Socket write error）。

原因 ：用户在发送一个请求后，再次发送另一个请求，导致第一个请求中断或者

①：服务器的并发连接数超过了其承载量，服务器会将其中一些连接Down掉；
②：客户关掉了浏览器，而服务器还在给客户端发送数据；
③：浏览器端按了Stop

该异常在客户端和服务器端均有可能发生，引起该异常的原因有两个，第一个就是如果一端的Socket被关闭（或主动关闭或者因为异常退出而引起的关闭），另一端仍发送数据，发送的第一个数据包引发该异常(Connect reset by peer)。另一个是一端退出，但退出时并未关闭该连接，另一端如果在从连接中读数据则抛出该异常（Connection reset）。简单的说就是在连接断开后的读和写操作引起的。

第5个异常是java.net.SocketException: Broken pipe。

该异常在客户端和服务器均有可能发生。在第4个异常的第一种情况中（也就是抛出 SocketExcepton:Connect reset by peer:Socket write error后），如果再继续写数据则抛出该异常。前两个异常的解决方法是首先确保程序退出前关闭所有的网络连接，其次是要检测对方的关闭连接操作，发现对方关闭连接后自己也要关闭该连接。

编写网络程序时需要注意的问题

第1个问题是要正确区分长、短连接。所谓的长连接是一经建立就永久保持。短连接就是在以下场景下，准备数据—>建立连接— >发送数据—>关闭连接。很多的程序员写了多年的网络程序，居然不知道什么是长连接，什么是短连接。

第2个问题是对长连接的维护。所谓的维护包括两个方面，首先是检测对方的主动断连（既调用 Socket的close方法），其次是检测对方的宕机、异常退出及网络不通。这是一个健壮的通信程序必须具备的。检测对方的主动断连很简单，主要一方主动断连，另一方如果在进行读操作，则此时的返回值只-1，一旦检测到对方断连，则应该主动关闭己方的连接（调用Socket的close方法）。

而检测对方的宕机、异常退出及网络不通常用方法是用“心跳”，也就是双方周期性的发送数据给对方，同时也从对方接收“心跳”，如果连续几个周期都没有收到对方心跳，则可以判断对方或者宕机或者异常推出或者网络不通，此时也需要主动关闭己方连接，如果是客户端可在延迟一定时间后重新发起连接。虽然Socket有一个keep alive选项来维护连接，如果用该选项，一般需要两个小时才能发现对方的宕机、异常退出及网络不通。

第3个问题是处理效率问题。不管是客户端还是服务器，如果是长连接一个程序至少需要两个线程，一个用于接收数据，一个用于发送心跳，写数据不需要专门的线程，当然另外还需要一类线程（俗称Worker线程）用于进行消息的处理，也就是说接收线程仅仅负责接收数据，然后再分发给Worker进行数据的处理。如果是短连接，则不需要发送心跳的线程，如果是服务器还需要一个专门的线程负责进行连接请求的监听。这些是一个通信程序的整体要求，具体怎么设计你的程序，就看你自己的设计水平了。

第六个异常，ava.net.SocketException:Too many open files
原因:操作系统的中打开文件的最大句柄数受限所致，常常发生在很多个并发用户访问服务器的时候。因为为了执行每个用户的应用服务器都要加载很多文件(new一个socket就需要一个文件句柄)，这就会导致打开文件的句柄的缺乏。
解决方式： 
   a) 尽量把类打成jar包，因为一个jar包只消耗一个文件句柄，如果不打包，一个类就消耗一个文件句柄。
　 b) java的GC不能关闭网络连接打开的文件句柄，如果没有执行close()则文件句柄将一直存在，而不能被关闭。也可以考虑设置socket的最大打开数来控制这个问题。对操作系统做相关的设置，增加最大文件句柄数量。ulimit -a可以查看系统目前资源限制，ulimit -n 10240则可以修改，这个修改只对当前窗口有效。