基于Java socket和多线程的简易聊天小程序

本人介绍一下基于java多线程和socket实现简易聊天室的小程序。本程序实现的目标是，一个服务端和N个客户端可以实现互相聊天，客户端一个线程用于发送消息，另一个线程负责接收消息。服务端用N个线程进行消息发送，用N个线程进行消息接收，而且消息的接收和发送互不影响。首先实现服务端，建立类TestThreadServer，首先实现服务端收发线程，用两个默认修饰符修饰的类实现：

class ServerReceiveRunnable implements Runnable{

private Socket s=null;

public ServerReceiveRunnable(Socket s){
this.s=s;
}

public void run() {
// TODO Auto-generated method stub
InputStream is=null;
DataInputStream dis=null;

try {
while(true){
is=s.getInputStream();
dis=new DataInputStream(is);
System.out.println("server received:"+dis.readUTF());
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

class ServerSendRunnable implements Runnable{

private Socket s=null;

public ServerSendRunnable(Socket s){
this.s=s;
}

public void run() {
// TODO Auto-generated method stub
OutputStream os=null;
DataOutputStream dos=null;
try {
while (true) {
os = s.getOutputStream();
dos = new DataOutputStream(os);
Scanner in = new Scanner(System.in);
String line = in.nextLine();
dos.writeUTF(line);
}
} catch (Exception e) {
// TODO: handle exception
}
}

}

<p>这两个Runnable接口的实现类通过构造方法传入一个Socket对象，在run方法中实现Socket的输入和输出。</p><p>在TestThreadServer类的main方法中首先先开启ServerSocket，用一个永远不会自动停止的while循环（此处也可以设定一个布尔类型的成员变量来控制循环的结束）来监听客户端Socket的连接情况，一旦客户端Socket传入，则立即由服务端ServerSocket捕获并绑定在两个个线程中，一个线程负责该Socket的输入，另一个线程负责该Socket的输出：</p>

public class TestThreadServer {@SuppressWarnings("resource")public static void main(String[] args) throws Exception {// TODO Auto-generated method stubServerSocket ss=null;ss=new ServerSocket(5652);while(true){Socket s=ss.accept();Runnable r1=new ServerReceiveRunnable(s);Thread t1=new Thread(r1);t1.start();Runnable r2=new ServerSendRunnable(s);Thread t2=new Thread(r2);t2.start();}}}

服务端的代码到此为止，接下来看客户端的代码，客户端代码也是大同小异，同样先用两个Runnable接口的实现类来通过传入Socket实现客户端的发送与接收：这两个Runnable接口的实现类通过构造方法传入一个Socket对象，在run方法中实现Socket的输入和输出。在TestThreadServer类的main方法中首先先开启ServerSocket，用一个永远不会自动停止的while循环（此处也可以设定一个布尔类型的成员变量来控制循环的结束）来监听客户端Socket的连接情况，一旦客户端Socket传入，则立即由服务端ServerSocket捕获并绑定在两个个线程中，一个线程负责该Socket的输入，另一个线程负责该Socket的输出：

class ClientSendRunnable implements Runnable{private Socket s=null;public ClientSendRunnable(Socket s){this.s=s;}public void run() {// TODO Auto-generated method stubOutputStream os=null;DataOutputStream dos=null;try {while(true){os=s.getOutputStream();dos=new DataOutputStream(os);Scanner in=new Scanner(System.in);String line=in.nextLine();dos.writeUTF(line);}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}class ClientReceiveRunnable implements Runnable{private Socket s=null;public ClientReceiveRunnable(Socket s){this.s=s;}public void run() {// TODO Auto-generated method stubInputStream is=null;DataInputStream dis=null;try {while(true){is=s.getInputStream();dis=new DataInputStream(is);System.out.println("client received:"+dis.readUTF());}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

在客户端这两个Runnable接口的实现类通过构造方法传入一个Socket对象，在run方法中实现Socket的输入和输出。在TestThreadServer类的main方法中首先先开启ServerSocket，用一个永远不会自动停止的while循环（此处也可以设定一个布尔类型的成员变量来控制循环的结束）来监听客户端Socket的连接情况，一旦客户端Socket传入，则立即由服务端ServerSocket捕获并绑定在两个个线程中，一个线程负责该Socket的输入，另一个线程负责该Socket的输出：

class ClientSendRunnable implements Runnable{private Socket s=null;public ClientSendRunnable(Socket s){this.s=s;}public void run() {// TODO Auto-generated method stubOutputStream os=null;DataOutputStream dos=null;try {while(true){os=s.getOutputStream();dos=new DataOutputStream(os);Scanner in=new Scanner(System.in);String line=in.nextLine();dos.writeUTF(line);}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}class ClientReceiveRunnable implements Runnable{private Socket s=null;public ClientReceiveRunnable(Socket s){this.s=s;}public void run() {// TODO Auto-generated method stubInputStream is=null;DataInputStream dis=null;try {while(true){is=s.getInputStream();dis=new DataInputStream(is);System.out.println("client received:"+dis.readUTF());}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

客户端TestThreadClient类中的main方法则开启这两个线程，实现与服务端的连接：

public class TestThreadClient {public static void main(String[] args) throws Exception{Socket s=null;s=new Socket("127.0.0.1",5652);Runnable r1=new ClientSendRunnable(s);Thread t1=new Thread(r1);t1.start();Runnable r2=new ClientReceiveRunnable(s);Thread t2=new Thread(r2);t2.start();}}

至此，这个简单的小程序就写完了，有些缺陷，比如流没有关闭，因为一旦关闭，则Socket就会关闭，导致无法用多线程实现收发信息。这两个Runnable接口的实现类通过构造方法传入一个Socket对象，在run方法中实现Socket的输入和输出。在TestThreadServer类的main方法中首先先开启ServerSocket，用一个永远不会自动停止的while循环（此处也可以设定一个布尔类型的成员变量来控制循环的结束）来监听客户端Socket的连接情况，一旦客户端Socket传入，则立即由服务端ServerSocket捕获并绑定在两个个线程中，一个线程负责该Socket的输入，另一个线程负责该Socket的输出：