Java 使用特定的活动线程发送到服务器

我有一个类，在这个类中，我尝试创建一些线程，然后我需要在所有

线程上发送
消息
，或者使用特定的
线程
。我似乎找不到这样做的方法，我只能使用创建的最后一个
线程
发送

下面是课堂：

公共类测试{
公开考试（）{
}
公共静态void main（字符串[]args）{
MultiThreadChatClient mc=新的MultiThreadChatClient（）；
测试st=新测试（）；
为了使（int i=0；i能够拥有一个启动多个会话的客户端，并且能够向其中一个或多个会话发送数据，客户端必须以几种方式进行更改

必须删除客户端中的静态引用
套接字实例必须创建并存储在主线程中（写入程序将用于代表一个或多个客户端会话发送消息）
每个客户端会话现在只负责读取（读取器通过构造函数传递）
该代码基于您的原始代码，旨在作为进一步增强的模板：它将管理5个客户端会话，并能够写入1个或多个客户端会话

新的主线程（例如，扫描器将首先询问客户机#1的消息，然后询问客户机#2、3、4，然后在循环中向所有人广播）：

服务器几乎相同，但管理更好，并且有更多的日志来显示哪个客户端正在通信

public class MultiThreadChatServerSync {

// The server socket.
private static ServerSocket serverSocket = null;
// The client socket.
private static Socket clientSocket = null;

// This chat server can accept up to maxClientsCount clients' connections.
private static final int maxClientsCount = 50;
private static final ClientThread[] threads = new ClientThread[maxClientsCount];

public static void main(String args[]) {

    // The default port number.
    int portNumber = 2222;
    if (args.length < 1) {
        System.out.println(
                "Usage: java MultiThreadChatServerSync <portNumber>\n" + "Now using port number=" + portNumber);
    } else {
        portNumber = Integer.valueOf(args[0]).intValue();
    }

    /*
     * Open a server socket on the portNumber (default 2222). Note that we
     * can not choose a port less than 1023 if we are not privileged users
     * (root).
     */
    try {
        serverSocket = new ServerSocket(portNumber);
        // System.out.println(serverSocket.getPort());
    } catch (IOException e) {
        System.out.println(e);
    }

    /*
     * Create a client socket for each connection and pass it to a new
     * client thread.
     */
    while (true) {
        try {
            System.out.println("Awaiting a new connection on "+serverSocket.getLocalPort());
            clientSocket = serverSocket.accept();
            int i = 0;
            for (i = 0; i < maxClientsCount; i++) {
                if (threads[i] == null) {
                    (threads[i] = new ClientThread(i, clientSocket)).start();
                    // System.out.println("A new client is created");
                    break;
                }
            }
            if (i == maxClientsCount) {
                PrintStream os = new PrintStream(clientSocket.getOutputStream());
                os.println("Server too busy. Try later.");
                os.close();
                clientSocket.close();
            }
        } catch (IOException e) {
            System.out.println(e);
        }
    }
}
}

class ClientThread extends Thread {

private BufferedReader br = null;
private PrintStream os = null;
private final Socket clientSocket;
private final int clientId;

public ClientThread(int clientId, Socket clientSocket) {
    this.clientSocket = clientSocket;
    this.clientId = clientId;
}

public void run() {

    try {
        /*
         * Create input and output streams for this client.
         */
        br = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        os = new PrintStream(clientSocket.getOutputStream());

        String line = "";
        while ((line = br.readLine()) != null) {
            System.out.printf("Client <%d> received message=<%s> via Client port: <%d>\n", clientId, line, clientSocket.getPort());
            // Echo it back (as a test)
            os.println(line);
        }
        br.close();
        os.close();
        clientSocket.close();

    } catch (IOException e) {
    }
    System.out.println("Client has closed the session");
}
}

公共类多线程ChatServerSync{
//服务器套接字。
私有静态ServerSocket ServerSocket=null；
//客户端套接字。
私有静态套接字clientSocket=null；
//此聊天服务器最多可以接受maxClientsCount客户端的连接。
私有静态最终int MaxClientScont=50；
私有静态最终ClientThread[]线程=新ClientThread[MaxClientScont]；
公共静态void main（字符串参数[]）{
//默认端口号。
int端口号=2222；
如果（参数长度<1）{
System.out.println(
用法：java多线程ChatServerSync\n“+”现在使用端口号=“+portNumber”）；
}否则{
portNumber=Integer.valueOf（args[0]）.intValue（）；
}
/*
*打开端口号上的服务器套接字（默认2222）
*如果我们不是特权用户，则无法选择小于1023的端口
*（根）。
*/
试一试{
serverSocket=新的serverSocket（端口号）；
//System.out.println（serverSocket.getPort（））；
}捕获（IOE异常）{
系统输出打印ln（e）；
}
/*
*为每个连接创建一个客户端套接字，并将其传递给新的
*客户端线程。
*/
while（true）{
试一试{
System.out.println（“在“+serverSocket.getLocalPort（）上等待新连接”）；
clientSocket=serverSocket.accept（）；
int i=0；
对于（i=0；i

如果您现在还有任何问题，请告诉我。
这将有助于了解线程的存储方式；
createThreads（）
方法，以及
sendMessage（String s）
当前的工作方式。您可能可以创建两种方法，如
sendMessageToAll（String message）
和
sendMessage（int threadId，String message）
以实现goal@IanMc我添加了这些方法。请检查它们。您提到sendMessage（）当前可以工作。我猜
os
是静态的？因为您没有使用您创建的线程。您正在主线程上调用
sendMessage（）
（因此，
os
是由最近的线程静态设置的）。您可以确认吗？或者发布所有的代码。谢谢。@IanMc os确实是静态的，但您认为我没有使用线程是什么意思？我现在包含了客户端代码，您还需要服务器代码吗？您总共有6个线程。您启动的主线程会再创建5个线程。这5个线程中的每一个都在创建一个套接字到服务器，然后在readLine（）上阻塞；但是当您从主线程调用
sendMessage
时，您没有正确使用每个线程创建的套接字-您得到了“幸运”的结果，即
os
设置在主线程中，只是因为前一个线程静态创建了它。解决方案将
  public class MultiThreadChatClient implements Runnable {

  // The client socket
  private static Socket clientSocket = null;
  // The output stream
  private static PrintStream os = null;
  // The input stream
  private static BufferedReader br;

  private static BufferedReader inputLine = null;
  private static boolean closed = false;


  public static void main(String[] args) {

    // The default port.
    int portNumber = 2222;
    // The default host.
    String host = "localhost";

    if (args.length < 2) {
      System.out.println("Usage: java MultiThreadChatClient <host> <portNumber>\n"
              + "Now using host=" + host + ", portNumber=" + portNumber);
    } else {
      host = args[0];
      portNumber = Integer.valueOf(args[1]).intValue();
    }
  }



    /*
     * Open a socket on a given host and port. Open input and output streams.
     */

    public void createThreads(){
    try {
      clientSocket = new Socket("localhost", 2222);
      inputLine = new BufferedReader(new InputStreamReader(System.in));
      os = new PrintStream(clientSocket.getOutputStream());
      br = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
    } catch (UnknownHostException e) {
      System.err.println("Don't know about host " + 2222);
    } catch (IOException e) {
      System.err.println("Couldn't get I/O for the connection to the host " + 2222);
    }
  //}

    /*
     * If everything has been initialized then we want to write some data to the
     * socket we have opened a connection to on the port portNumber.
     */
    if (clientSocket != null && os != null && br != null) {

        new Thread(new MultiThreadChatClient()).start();

    }
  }
          public void sendMessage(String mes){
          os.println(mes);
          }

  /*
   * Create a thread to read from the server. (non-Javadoc)
   * 
   * @see java.lang.Runnable#run()
   */
  public void run() {
    /*
     * Keep on reading from the socket till we receive "Bye" from the
     * server. Once we received that then we want to break.
     */
    String responseLine;
    try {
      while ((responseLine = br.readLine()) != null){

        System.out.println(responseLine);

        if (responseLine.indexOf("*** Bye") != -1)
          break;
      }
      closed = true;
    } catch (IOException e) {
      System.err.println("IOException1234:  " + e);
    }
  }
}

  public class MultiThreadChatServerSync {

  // The server socket.
  private static ServerSocket serverSocket = null;
  // The client socket.
  private static Socket clientSocket = null;


  // This chat server can accept up to maxClientsCount clients' connections.
  private static final int maxClientsCount = 50;
  private static final clientThread[] threads = new clientThread[maxClientsCount];

  public static void main(String args[]) {

    // The default port number.
    int portNumber = 2222;
    if (args.length < 1) {
      System.out.println("Usage: java MultiThreadChatServerSync <portNumber>\n"
          + "Now using port number=" + portNumber);
    } else {
      portNumber = Integer.valueOf(args[0]).intValue();
    }

    /*
     * Open a server socket on the portNumber (default 2222). Note that we can
     * not choose a port less than 1023 if we are not privileged users (root).
     */
    try {
      serverSocket = new ServerSocket(portNumber);
      //System.out.println(serverSocket.getPort());
    } catch (IOException e) {
      System.out.println(e);
    }

    /*
     * Create a client socket for each connection and pass it to a new client
     * thread.
     */
    while (true) {
      try {
        clientSocket = serverSocket.accept();
        int i = 0;
        for (i = 0; i < maxClientsCount; i++) {
          if (threads[i] == null) {
            (threads[i] = new clientThread(clientSocket, threads)).start();
            //System.out.println("A new client is created");
            break;
          }
        }
        if (i == maxClientsCount) {
          PrintStream os = new PrintStream(clientSocket.getOutputStream());
          os.println("Server too busy. Try later.");
          os.close();
          clientSocket.close();
        }
      } catch (IOException e) {
        System.out.println(e);
      }
    }
  }
}

class clientThread extends Thread {
MultiThreadChatServerSync ms = new MultiThreadChatServerSync();
  private String clientName = null;
  //private DataInputStream is = null;
   private BufferedReader br = null;
  private PrintStream os = null;
  private Socket clientSocket = null;
  private final clientThread[] threads;
  private int maxClientsCount;

  public clientThread(Socket clientSocket, clientThread[] threads) {
    this.clientSocket = clientSocket;
    this.threads = threads;
    maxClientsCount = threads.length;
    //System.out.println("Inside the Client thread");
  }

  public void run() {
    MultiThreadChatServerSync mss = new MultiThreadChatServerSync();
    int maxClientsCount = this.maxClientsCount;
    clientThread[] threads = this.threads;
    //System.out.println("Inside the run");

    try {
      /*
       * Create input and output streams for this client.
       */
      br = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
      os = new PrintStream(clientSocket.getOutputStream());




      while (true) {
        String line = br.readLine();
        System.out.println("message received via Client port: " + clientSocket.getPort());
        System.out.println("Received: " + line);

      }

    } catch (IOException e) {
    }
  }
}

public class MultiThreadChatClientRunner {

final int NO_CLIENTS = 5;
//final String HOST_IP = "192.168.2.7";
final String HOST_IP = "localhost";

public static void main(String[] args) {

    new MultiThreadChatClientRunner().start();

}

private void start() {

    Socket[] sockets = new Socket[NO_CLIENTS];
    PrintStream[] writers = new PrintStream[NO_CLIENTS];
    BufferedReader[] readers = new BufferedReader[NO_CLIENTS];

    for (int i = 0; i < NO_CLIENTS; i++) {
        System.out.println("Creating client number "+i);
        Socket clientSocket;
        try {
            clientSocket = new Socket(HOST_IP, 2222);
            writers[i] = new PrintStream(clientSocket.getOutputStream());
            readers[i] = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            new Thread(new MultiThreadChatClient(i, readers[i])).start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    int clientId = 0;
    Scanner s = new Scanner(System.in);
    while (true) {

        System.out.print("type your message for client #"+clientId);
        String ss = s.nextLine();
        ss = ss.trim().replaceAll(" +", " ");

        writers[clientId].println(ss);
        clientId = (clientId+1)%NO_CLIENTS;

        // Test to broadcast to all clients
        if (clientId == 4) {
            for (int i = 0; i<NO_CLIENTS; i++)
                writers[i].println("Broadcast message: "+ss);
        }

        try {
            Thread.sleep(400);
        } catch (InterruptedException e) {
            System.out.println("Thread was interrupted");
            break;
        }
    }
    s.close();
}

}

public class MultiThreadChatClient implements Runnable {

// The client socket
private Socket clientSocket = null;
// The output stream
private PrintStream os = null;
// The input stream
private final BufferedReader br;
private final int clientId;

public MultiThreadChatClient(int clientId, BufferedReader br) {
    super();
    this.clientId = clientId;
    this.br = br;
}

/*
 * Create a thread to read from the server. (non-Javadoc)
 * 
 * @see java.lang.Runnable#run()
 */
public void run() {
    /*
     * Keep on reading from the socket till we receive "Bye" from the
     * server. Once we received that then we want to break.
     */
    String responseLine;
    try {
        while ((responseLine = br.readLine()) != null) {

            System.out.printf("Client #%d received message=%s\n", clientId, responseLine);

            if (responseLine.indexOf("*** Bye") != -1)
                break;
        }
    } catch (IOException e) {
        System.err.println("IOException1234:  " + e);
    }
}
}

public class MultiThreadChatServerSync {

// The server socket.
private static ServerSocket serverSocket = null;
// The client socket.
private static Socket clientSocket = null;

// This chat server can accept up to maxClientsCount clients' connections.
private static final int maxClientsCount = 50;
private static final ClientThread[] threads = new ClientThread[maxClientsCount];

public static void main(String args[]) {

    // The default port number.
    int portNumber = 2222;
    if (args.length < 1) {
        System.out.println(
                "Usage: java MultiThreadChatServerSync <portNumber>\n" + "Now using port number=" + portNumber);
    } else {
        portNumber = Integer.valueOf(args[0]).intValue();
    }

    /*
     * Open a server socket on the portNumber (default 2222). Note that we
     * can not choose a port less than 1023 if we are not privileged users
     * (root).
     */
    try {
        serverSocket = new ServerSocket(portNumber);
        // System.out.println(serverSocket.getPort());
    } catch (IOException e) {
        System.out.println(e);
    }

    /*
     * Create a client socket for each connection and pass it to a new
     * client thread.
     */
    while (true) {
        try {
            System.out.println("Awaiting a new connection on "+serverSocket.getLocalPort());
            clientSocket = serverSocket.accept();
            int i = 0;
            for (i = 0; i < maxClientsCount; i++) {
                if (threads[i] == null) {
                    (threads[i] = new ClientThread(i, clientSocket)).start();
                    // System.out.println("A new client is created");
                    break;
                }
            }
            if (i == maxClientsCount) {
                PrintStream os = new PrintStream(clientSocket.getOutputStream());
                os.println("Server too busy. Try later.");
                os.close();
                clientSocket.close();
            }
        } catch (IOException e) {
            System.out.println(e);
        }
    }
}
}

class ClientThread extends Thread {

private BufferedReader br = null;
private PrintStream os = null;
private final Socket clientSocket;
private final int clientId;

public ClientThread(int clientId, Socket clientSocket) {
    this.clientSocket = clientSocket;
    this.clientId = clientId;
}

public void run() {

    try {
        /*
         * Create input and output streams for this client.
         */
        br = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        os = new PrintStream(clientSocket.getOutputStream());

        String line = "";
        while ((line = br.readLine()) != null) {
            System.out.printf("Client <%d> received message=<%s> via Client port: <%d>\n", clientId, line, clientSocket.getPort());
            // Echo it back (as a test)
            os.println(line);
        }
        br.close();
        os.close();
        clientSocket.close();

    } catch (IOException e) {
    }
    System.out.println("Client has closed the session");
}
}