Java 服务器套接字与客户端套接字的通信

我正在尝试制作一个带有中央服务器和独立聊天客户端的多线程聊天程序。服务器有两个角色：读取来自所有聊天客户端的传入消息，并将完整列表输出回客户端。服务器正确地接收来自客户端的输入并将其打印出来。但是，客户端没有收到列表。为了便于查看影响服务器到客户端通信的代码段，我用星号标记了它们

服务器代码：

import java.net.*;
import java.util.*;
import java.io.*;
import java.lang.*;

public class ChatServer {
    public static ArrayList<String> messages =
        new ArrayList<String>();

    public static void main(String[] args) {
        int portNumber = Integer.parseInt(args[0]);
        Scanner cin = new Scanner(System.in);

        ServerSocket serverSocket;
        try {
            serverSocket = new ServerSocket(portNumber); //*
        }catch (IOException ex) {
            System.out.println("Server socket creation failed");
            //ex.printStackTrace();
            return;
        }

        try {
            int maxConnections = 10;
            int curConnections = 0;
            while (curConnections++ < maxConnections) {
                Socket clientSocket = serverSocket.accept();

                ClientConnection clientCon = new ClientConnection(clientSocket);
                Thread clientConT = new Thread(clientCon);
                //clientConT.setPriority(curConnections+1);
                clientConT.start();

                ClientOutputConnection clientOut = new          //*
                    ClientOutputConnection(clientSocket);   
                Thread clientOutT = new Thread(clientOut);      //*
                //clientOutT.setPriority((curConnections+1)*2);
                clientOutT.start();                             //*


                System.out.println("Client "+curConnections+" Connected");
            }
        }catch (IOException ex) {
            System.out.println("Client connection failed");
            ex.printStackTrace();
        }
    }
}

class ClientConnection implements Runnable {
    Socket clientSocket;

    public ClientConnection(Socket clientSocketT) {
        clientSocket = clientSocketT;
    }

    public void run() {
        try {
            System.out.println("ClientConnection server running");
            BufferedReader in = new BufferedReader(
                new InputStreamReader(clientSocket.getInputStream()));

            while (true) {
                String lineIn = null;
                if ((lineIn = in.readLine()) != null) {
                    System.out.println(lineIn);
                    ChatServer.messages.add(lineIn);
                }

                if (lineIn.equalsIgnoreCase("exit") || 
                    lineIn.equalsIgnoreCase("close"))
                    return;
            }
        }catch (Exception ex) {
            ex.printStackTrace();
        }
    } 
}

class ClientOutputConnection implements Runnable {
    private Socket clientSocket;

    public ClientOutputConnection(Socket clientSocketT) {
        clientSocket = clientSocketT;
    }

    public void run() {
        try {
            PrintWriter out = new PrintWriter(
                clientSocket.getOutputStream(), true);

            System.out.println("ClientOutputConnection running");

            int lastMssg = 0;

            while (true) {
                try {
                    //System.out.println(ChatServer.messages);
                    while (lastMssg < ChatServer.messages.size()) {
                        out.println(ChatServer.messages.get(lastMssg)+"\n");
                        //System.out.println(ChatServer.messages.get(lastMssg));
                        lastMssg++;
                    }

                    //Thread.sleep(10);
                }catch (Exception ex){
                    ex.printStackTrace();
                }
            }
        }catch(IOException ex) {
            ex.printStackTrace();
        }
    }
}

import java.net.*；
导入java.util.*；
导入java.io.*；
导入java.lang.*；
公共类聊天服务器{
公共静态ArrayList消息=
新的ArrayList（）；
公共静态void main（字符串[]args）{
int portNumber=Integer.parseInt（args[0]）；
扫描仪cin=新扫描仪（System.in）；
服务器套接字服务器套接字；
试一试{
serverSocket=新的serverSocket（端口号）//*
}捕获（IOEX异常）{
System.out.println（“服务器套接字创建失败”）；
//例如printStackTrace（）；
回来
}
试一试{
int maxConnections=10；
int-curConnections=0；
while（curConnections++

客户端代码：

import java.net.*;
import java.util.*;
import java.io.*;
import static java.lang.System.*;

public class ChatClient {
    public static void main(String[] args) {
        int portNumber = Integer.parseInt(args[0]);
        Scanner cin = new Scanner(System.in);

        PrintWriter out;
        Socket clientSocket;

        try {
            System.out.println("Break 1");
            clientSocket = new Socket("localhost", portNumber);
            System.out.println("Break 2");
            out = new PrintWriter(clientSocket.getOutputStream(), true);
        }catch (Exception ex) {
            System.out.println("PrintWriter creation failed");
            ex.printStackTrace();
            return;
        }

        //Initializes reader for server
        BufferedReader in = null;  //*
        try {
            in = new BufferedReader(
                new InputStreamReader(clientSocket.getInputStream()));   //*
        }catch (IOException ex) {
            ex.printStackTrace();
        }

        System.out.print("Enter your username: ");
        String username = cin.nextLine();
        out.println();

        ServerListener sl = new ServerListener(in, username);   //*
        Thread slT = new Thread(sl);                            //*
        //slT.setPriority(1);
        slT.start();                                            //*

        ServerOutput so = new ServerOutput(username, out);
        Thread soT = new Thread(so);                        
        //soT.setPriority(2);
        soT.start();                                        
    }
}

class ServerOutput implements Runnable {
    private String username;
    private PrintWriter out;

    public ServerOutput(String usernameT, PrintWriter outT) {
        username = usernameT;
        out = outT;
    }

    public void run() {
        Scanner cin = new Scanner(System.in);
        while (true) {
            String line = cin.nextLine();
            if (line.equalsIgnoreCase("close")) {
                out.close();
                return; 
            }

            out.write("<"+username+"> "+line+"\n");
            out.flush();

            try { Thread.sleep(10); }catch(Exception e){};
        }
    }
}

class ServerListener implements Runnable {
    private BufferedReader in;
    private String username;

    public ServerListener (BufferedReader inT, String usernameT) {
        in = inT;
        username = usernameT;
    }

    public void run() {
        System.out.println("ServerListener running");
        String line = null;
        try {
            while (true){
                //System.out.println(in.readLine());
                while ((line = in.readLine()) != null)
                    //if (line.indexOf(username) != 1)
                        System.out.println(line);
            }
        }catch (IOException ex) {
            //System.out.println("Doesnt work");
            ex.printStackTrace();
        }
    }
}

import java.net.*；
导入java.util.*；
导入java.io.*；
导入静态java.lang.System.*；
公共类聊天客户端{
公共静态void main（字符串[]args）{
int portNumber=Integer.parseInt（args[0]）；
扫描仪cin=新扫描仪（System.in）；
打印输出；
插座客户端插座；
试一试{
系统输出打印项次（“中断1”）；
clientSocket=新套接字（“localhost”，端口号）；
系统输出打印项次（“中断2”）；
out=新的PrintWriter（clientSocket.getOutputStream（），true）；
}捕获（例外情况除外）{
System.out.println（“PrintWriter创建失败”）；
例如printStackTrace（）；
回来
}
//初始化服务器的读取器
BufferedReader in=null//*
试一试{
in=新的缓冲读取器(
新的InputStreamReader（clientSocket.getInputStream（））//*
}捕获（IOEX异常）{
例如printStackTrace（）；
}
System.out.print（“输入您的用户名：”）；
字符串username=cin.nextLine（）；
out.println（）；
ServerListener sl=新的ServerListener（在中，用户名）//*
螺纹slT=新螺纹（sl）//*
//slT.setPriority（1）；
slT.start（）//*
ServerOutput so=新的ServerOutput（用户名，out）；
螺纹soT=新螺纹（so）；
//soT.设置优先级（2）；
soT.start（）；
}
}
类ServerOutput实现可运行{
私有字符串用户名；
私人打印输出；
公共服务器输出（字符串usernameT、PrintWriter输出）{
username=usernameT；
out=out；
}
公开募捐{
扫描仪cin=新扫描仪（System.in）；
while（true）{
字符串行=cin.ne
while (true) {
                try {
                    //System.out.println(ChatServer.messages);
                    while (lastMssg < ChatServer.messages.size()) {
                        out.println(ChatServer.messages.get(lastMssg)+"\n");
                        //System.out.println(ChatServer.messages.get(lastMssg));
                        lastMssg++;
                    }

                    //Thread.sleep(10);
                }catch (Exception ex){
                    ex.printStackTrace();
                }
            }