Java Socket 多线程聊天室

本来这次作业我是想搞个图形界面的，然而现实情况是我把题意理解错了，于是乎失去了最初的兴致，还是把程序变成了功能正确但是“UI”不友好的console了，但是不管怎么样，前期的图形界面的开发还是很有收获的，毕竟讲真，想要把Java搞得有形有色的也是很不容易的，借助可视化的插件windowsBuilder，这个过程还是既exciting 又tiring的。

好吧 ，然而图形界面已经成为了历史，现在来说说这个功能正确的console 吧

我也是刚知道的Eclipse里面是可以跑好多个程序的，只要你的一个.java文件中有public static void main，他就能给你一个窗口，让你跑起来。只不过这些窗口堆叠在一起，需要自行选择不同的窗口进行IO操作。

总的思路是采用c/s的方式，client借助socket完成向server的发送和接受两个工作，当然了，为了体现出真实情况下的双工的特点，发送和接受是需要开两个线程的，也就是说，一个用户需要自己管理两个线程。server则相对来讲比较复杂，因为这里面涉及到了调度，server需要有发送消息给在线client的线程（这个线程要做的事情就是只要有消息就要把消息发到所有的用户的窗口），以及接受client发来的消息的线程（这个线程要做的事情就是将接收到的消息全部交给发送消息的线程，于是这两个线程之间的通信问题也是实现上的一个关键~），为了使得所有的用户消息是同步的，server需要管理一个用户线程的列表，用以实现用户的行为的控制，于是乎这就要求只要有用户请求连接服务器，服务器就要为用户新建一个线程，那么client 和server 之间靠什么来进行联系呢，那就是我们的socket了。

 

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class Client extends Thread{
    
    private static String serverIp = "127.0.0.1";
    private static int serverPort = 8001;
    
    private Socket clientsSocket;  //plays key role
    private PrintWriter pw;        // for send data
    private BufferedReader br;     // for  receive data
    
    public Client(){
        try {
            clientsSocket = new Socket(serverIp, serverPort);
            pw = new PrintWriter(clientsSocket.getOutputStream(),true);
            br = new BufferedReader(new InputStreamReader(clientsSocket.getInputStream()));
            new readServer();
            
            while(true){
                br = new BufferedReader(new InputStreamReader(System.in));
                String input = br.readLine();
                //System.out.println("this is the input :" + input);
                pw.println(input);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    class readServer extends Thread{
        private BufferedReader reader;
        
        public readServer(){
            try {
                reader =  new BufferedReader(new InputStreamReader(clientsSocket.getInputStream()));
                start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        public void run(){
            try {
                while(true){
                    String content = reader.readLine();
                    if(content.equals("bye Client")){
                        break;
                    }
                    else {
                        System.out.println(content);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) throws Exception{
        new Client();
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.LinkedList;


public class Server {
    
    private static int port = 8001;
    private static boolean prit = false;
    private static ArrayList<String> userList = new ArrayList<>();
    private static LinkedList<String> messageList = new LinkedList<>();
    private static ArrayList<ServerThread> threadsList = new ArrayList<>();
    
    private ServerSocket serverSocket;
    
    public Server(){
        try {
            serverSocket = new ServerSocket(port);
            new PrintClient();
            
            while(true){
                Socket socket = serverSocket.accept();
                new ServerThread(socket);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    class PrintClient extends Thread{
        public PrintClient(){
            start();
        }
        
        public void run(){
            while(true){
                try {
                    Thread.sleep(10);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (prit == true){
                    String msg = messageList.getFirst();
                    //System.out.println("prepare to sent to Clent");
                    for (ServerThread sThread : threadsList){
                        sThread.sendMessage(msg);
                    }
                    synchronized (messageList) {
                        messageList.removeFirst();
                    }
                    prit = messageList.size() > 0 ? true : false;
                }
            }
        }
    }
    
    class ServerThread extends Thread{
        private Socket client;
        private PrintWriter pw;
        private BufferedReader br;
        private String user;
        
        public ServerThread(Socket socket){
            try {
                client = socket;
                pw = new PrintWriter(client.getOutputStream(),true);
                br = new BufferedReader(new InputStreamReader(client.getInputStream()));
                br.readLine();
                
                pw.println("connect success input your name ~");
                start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        public void pushMessage(String msg){
            synchronized (messageList) {
                messageList.add(msg);
            }
            prit = true;
        }
        
        public void sendMessage(String msg){
            pw.println(msg);
        }
        
        
        public void run(){
            try {
                int first = 1;
                String msg = br.readLine();
                while(!msg.equals("bye")){
                    if (first == 1){
                        user = msg;
                        userList.add(user);
                        threadsList.add(this);
                        pw.println(user + " hello you can chat now ");
                        this.pushMessage("Client <" + user + "> " + "join in ~");
                        //System.out.println("the prit is " + prit);
                        first--;
                    }
                    else {
                        this.pushMessage("Client<" + user + "> "+ "say :" + msg);
                        //System.out.println("the prit is " + prit + " " + messageList.size());
                    }
                    msg = br.readLine();
                    //System.out.println(msg);
                }
                pw.println("bye Client");
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                try {
                    client.close();
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
                threadsList.remove(this);
                userList.remove(user);
                pushMessage(user + " leave ~"); 
            }
        }
    }
    
    public static void main(String[] srgs) throws Exception{
        new Server();
    }
}

在这里注意一个问题，server端的PrintClient线程在run的过程中一定要有sleep的过程，否则会因为一开始的prit设置为false而在一直在while(true)的死循环中得不到更新，也就是说线程的同步出了错，从而会出现客户端无法收到信息的错误。还有一点要注意的是作为良好的编程习惯需要注意多个线程公用的变量要注意互斥操作，防止出现多线程中的“magic bugs”。同步与互斥，真是线程进程调度中的老大难啊，每次编程都要小心处理这两个问题，尽量避免不必要的错误。