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”。同步與互斥，真是線程進程調度中的老大難啊，每次編程都要小心處理這兩個問題，盡量避免不必要的錯誤。