本人介绍一下基于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 stub
ServerSocket 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 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 (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class ClientReceiveRunnable implements Runnable{
private Socket s=null;
public ClientReceiveRunnable(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("client received:"+dis.readUTF());
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.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 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 (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class ClientReceiveRunnable implements Runnable{
private Socket s=null;
public ClientReceiveRunnable(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("client received:"+dis.readUTF());
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.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的输出：