Java 为什么可以'；我在文本区域显示一个字符串，从一个帧到另一个帧，处理多个线程？

我正在学习用简单的套接字示例在java中处理多线程

服务器表单

package chat_server;

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


public class TCPServer extends javax.swing.JFrame {

    ArrayList clientOutputStreams;
    ArrayList<String> users;
//    ArrayList<Object> lstUsers;

    public class ClientHandler implements Runnable {

        BufferedReader reader;
        Socket sock;
        PrintWriter client;

        public ClientHandler(Socket clientSocket, PrintWriter user) {
            client = user;
            try {
                sock = clientSocket;
                InputStreamReader isReader = new InputStreamReader(sock.getInputStream());
                reader = new BufferedReader(isReader);
            } catch (IOException e) {
                ta_chat.append("Unexpected error... \n");
            }
        }

        @Override
        public void run() {
            String message, connect = "Connect", disconnect = "Disconnect", chat = "Chat";
            String[] data;

            try {
                while ((message = reader.readLine()) != null) {
                    ta_chat.append("Received : " + message + "\n");
                    data = message.split(":");

                    for (String token : data) {
                        ta_chat.append(token + "\n");
                    }

                    if (data[2].equals(connect)) {

                        sendToChatRoom("connect");

                    } else if (data[2].equals(disconnect)) {

                        sendToChatRoom("disconnect");

                    } else if (data[2].equals(chat)) {

                        sendToChatRoom(message);
                    } else {
                        ta_chat.append("No Conditions were met. \n");
                    }
                }
            } catch (Exception ex) {
                ta_chat.append("Lost a connection. \n");
                ex.printStackTrace();
                clientOutputStreams.remove(client);
            }
        }
    }


    public TCPServer() {
        initComponents();
    }

         // initComponents()

    private void btn_startActionPerformed(java.awt.event.ActionEvent evt) {                                          
        new ChatRoom().setVisible(true);
        Thread starter = new Thread(new ServerStart());
        starter.start();

        ta_chat.append("Server started...\n");
    }                                         

    public static void main(String args[]) {

        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new TCPServer().setVisible(true);

            }
        });
    }

    public class ServerStart implements Runnable {

        @Override
        public void run() {
            clientOutputStreams = new ArrayList();
            users = new ArrayList();

            try {
                ServerSocket serverSock = new ServerSocket(2222);

                while (true) {
                    Socket clientSock = serverSock.accept();
                    PrintWriter writer = new PrintWriter(clientSock.getOutputStream());
                    clientOutputStreams.add(writer);

                    Thread listener = new Thread(new ClientHandler(clientSock, writer));
                    listener.start();
                    ta_chat.append("Got a connection. \n");
                }
            } catch (Exception ex) {
                ta_chat.append("Error making a connection. \n");
            }
        }
    }

    public void sendToChatRoom(String message) {
        Thread chatroom = new Thread(new ChatRoom(message));
        chatroom.start();
    }
    // Variables declaration - do not modify                     
    private javax.swing.JButton btn_chatroom;
    private javax.swing.JButton btn_clear;
    private javax.swing.JButton btn_end;
    private javax.swing.JButton btn_start;
    private javax.swing.JButton btn_users;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JTextArea ta_chat;
    // End of variables declaration                   
}

套餐聊天服务器；
导入java.io.*；
导入java.net。*；
导入java.util.*；
公共类TCPServer扩展了javax.swing.JFrame{
ArrayList clientOutputStreams；
ArrayList用户；
//ArrayList用户；
公共类ClientHandler实现Runnable{
缓冲读取器；
插座；
PrintWriter客户端；
公共ClientHandler（套接字clientSocket，PrintWriter用户）{
客户=用户；
试一试{
sock=clientSocket；
InputStreamReader isReader=新的InputStreamReader（sock.getInputStream（））；
读卡器=新的BufferedReader（isReader）；
}捕获（IOE异常）{
tau chat.append（“意外错误…\n”）；
}
}
@凌驾
公开募捐{
字符串消息，connect=“connect”，disconnect=“disconnect”，chat=“chat”；
字符串[]数据；
试一试{
而（（message=reader.readLine（））！=null）{
ta_chat.append（“接收：“+消息+”\n”）；
数据=message.split（“：”）；
for（字符串标记：数据）{
tau chat.append（令牌+“\n”）；
}
if（数据[2]。等于（连接））{
发送至舱室（“连接”）；
}else if（数据[2]。等于（断开连接））{
发送至舱室（“断开”）；
}else if（数据[2]。等于（聊天））{
发送至舱室（信息）；
}否则{
tau chat.append（“未满足任何条件。\n”）；
}
}
}捕获（例外情况除外）{
tau chat.append（“失去连接。\n”）；
例如printStackTrace（）；
clientOutputStreams.remove（客户端）；
}
}
}
公共TCPServer（）{
初始化组件（）；
}
//initComponents（）
私有无效btn_startActionPerformed（java.awt.event.ActionEvent evt）{
新建聊天室（）.setVisible（true）；
线程启动程序=新线程（newserverstart（））；
starter.start（）；
tau chat.append（“服务器已启动…\n”）；
}                                         
公共静态void main（字符串参数[]）{
invokeLater（new Runnable（））{
公开募捐{
新建TCPServer（）.setVisible（true）；
}
});
}
公共类ServerStart实现可运行{
@凌驾
公开募捐{
clientOutputStreams=新的ArrayList（）；
users=newarraylist（）；
试一试{
ServerSocket serverSock=新的ServerSocket（2222）；
while（true）{
Socket clientSock=serverSock.accept（）；
PrintWriter writer=新的PrintWriter（clientSock.getOutputStream（））；
clientOutputStreams.add（writer）；
线程侦听器=新线程（新ClientHandler（clientSock，writer））；
listener.start（）；
tau chat.append（“已建立连接。\n”）；
}
}捕获（例外情况除外）{
tau chat.append（“建立连接时出错。\n”）；
}
}
}
公共void发送到聊天室（字符串消息）{
线程聊天室=新线程（新聊天室（消息））；
聊天室；
}
//变量声明-不修改
私有javax.swing.JButton btn_聊天室；
私有javax.swing.JButton btn_clear；
私有javax.swing.JButton btn_end；
私有javax.swing.JButton btn_start；
私有javax.swing.JButton btn_用户；
私有javax.swing.JScrollPane-jScrollPane1；
私有javax.swing.JTextArea ta_chat；
//变量结束声明
}

聊天室表单

package chat_server;

import java.util.ArrayList;
import javax.swing.*;


public class ChatRoom extends javax.swing.JFrame implements Runnable {

    ArrayList<String> users;
    String message;

    /**
     * Creates new form ChatRoom
     */
    public ChatRoom() {
        initComponents();
    }

    public ChatRoom(String message) {
        this.message = message;
    }

    @Override
    public void run() {

        try {
            if (this.message != null) {
                System.out.println(this.message);  // run
                ta_chatroom.append(message); // can't run
            }
             ta_chatroom.append("null");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }


    private void initComponents() {
             // GUI
       }

        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new ChatRoom().setVisible(true);
            }
        });
    }

    // Variables declaration - do not modify                     
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JScrollPane jScrollPane2;
    private javax.swing.JList<String> lst_users;
    private javax.swing.JTextArea ta_chatroom;
    // End of variables declaration                   
}

套餐聊天服务器；
导入java.util.ArrayList；
导入javax.swing.*；
公共类聊天室扩展javax.swing.JFrame实现可运行{
ArrayList用户；
字符串消息；
/**
*创建新表单聊天室
*/
公共聊天室（）{
初始化组件（）；
}
公共聊天室（字符串消息）{
this.message=消息；
}
@凌驾
公开募捐{
试一试{
如果（this.message！=null）{
System.out.println（this.message）；//运行
tau chatroom.append（message）；//无法运行
}
ta_聊天室。附加（“空”）；
}捕获（例外情况除外）{
例如printStackTrace（）；
}
}
私有组件（）{
//桂
}
invokeLater（new Runnable（））{
公开募捐{
新建聊天室（）.setVisible（true）；
}
});
}
//变量声明-不修改
私有javax.swing.JScrollPane-jScrollPane1；
私有javax.swing.JScrollPane-jScrollPane2；
私有javax.swing.JList lst_用户；
私有javax.swing.JTextArea ta_聊天室；
//变量结束声明
}

我的程序包括几个线程，如创建套接字线程、发送/接收缓冲区线程、创建聊天室表单线程和打开表单线程

我的想法是当我按下启动按钮启动服务器时，这个事件也会打开聊天室窗体。我想将客户端的缓冲区写入服务器，然后它也会显示在聊天室的文本区域

我的问题是：当客户端向服务器发送请求时，聊天室线程也向聊天室发送缓冲区