java - 如何使用 "implements Runnable"调用特定套接字线程中的方法？

Question

我有一个正在运行的 Java 服务器(尽管边缘有点粗糙)，其中包含 3 个主要类。

第一个类运行服务器并获取套接字以监听端口并将新连接传递给客户端处理程序。

第二个类是线程客户端处理程序

第三个是从客户端处理程序调用并处理信息的协议(protocol)类。处理信息后，协议(protocol)类会将处理后或格式化的响应返回给客户端处理程序，以传递给客户端。

优点是第二个类只需要加载从套接字接受的可接受的数据。数据可以传递到协议(protocol)处理程序，协议(protocol)处理程序可以加载您希望服务器用来与客户端通信的任何协议(protocol)。

在本例中，我加载了一个基于 telnet 的聊天类。

例如，如果有人离开聊天，客户端处理程序类可能会执行如下代码:

for (i = 0; i < currentClientsConnected; i++) {
    if(threads[i] != null && threads[i] != this) {
        outputLine = threads[i].serverprotocol.processInput("** " + username + " has left the room **");
        threads[i].out.printf(outputLine);

    }
}

这会将“** [用户名]已离开房间**”传递给serverprotocol类，然后该类以传输数据的最佳方式返回数据给客户的消息。在本例中，serverprotocol 类使用 telnet 控制代码格式化消息，告诉客户端重新绘制屏幕、添加新消息并向上滚动缓冲区中现有的当前消息。

我可能只希望客户端处理程序类将消息发送到用户位于某些聊天室的套接字，因此我不想总是发送到所有套接字。

在我的代码中，这是第 1 类 - 接受套接字的服务器类:

while (true) {
    int i;
    // Try and accept the connection
    try {
        clientSocket = serverSocket.accept();
        // System.out.printf("Remote IP:");
        // System.out.printf(clientSocket.getRemoteSocketAddress().toString());

        // Find an unused socket if one is available
        for (i = 0; i < maxClientsAllowed; i++) {

            // If found create thread
            if (threads[i] == null) {
                (threads[i] = new clientThread(clientSocket, threads)).start();
                break;
            }
        }

        // If all sockets are taken
        if (i == maxClientsAllowed) {
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
            out.printf("Server too busy. Try later.\n");
            out.close();
            clientSocket.close();
        }
    } catch(IOException e) {
        System.out.println(e);}
}

类 2 是一个扩展线程的类:

class clientThread extends Thread {
    private String clientName = null;
    private DataInputStream in;
    private PrintWriter out;
    private Socket clientSocket = null;
    private final clientThread[] threads;
    private int currentClientsConnected;
    private serverprotocol serverprotocol;

    public clientThread(Socket clientSocket, clientThread[] threads) {
        this.clientSocket = clientSocket;
        this.threads = threads;
        currentClientsConnected = threads.length;
    }

    public void run() {
    //stuff 
    }
}

我一直在拼命地尝试看看是否可以使用 implements Runnable 来实现这个工作，但是我没有运气调用线程的 processInput (或者也许是这样)应根据线程的实例编号读取 dataToBeProcessed) 方法(在此处的代码中简称为 i)。

我见过的最接近的:

https://github.com/ico77/chat-server-client/blob/master/src/main/java/hr/ivica/chat/server/ChatServer.java

它可以利用将服务器作为线程池服务器运行的优势。

但是，在本例中，sendToAll 函数通过 HashMap 直接写入与套接字关联的 PrintWriter。服务器不允许您发送到单独的协议(protocol)处理程序类，甚至不允许发送到单独的 ChatServerWorker 类实例。例如，这意味着我无法仅向套接字 1 和 3 发送消息，然后向套接字 2 发送单独的消息。

我在网上找不到一个可以在不使用extends Thread的情况下调用套接字处理程序实例的示例。

具体来说，我想保留使用以下行的能力:

threads[i].out.printf(outputLine);

或

if(threads[i].[class].[var] == 'something') {
// stuff
}

其中整数可用于引用线程实例，或该线程使用的任何类变量或方法。

我错过了什么吗？

Answer 1

您的大问题是您直接使用线程本身作为服务器和客户端线程之间的通信层，这是您不应该做的事情。

相反，创建您自己的接口(interface)消息对象来在线程之间传达不同的信息，并使用 LinkedBlockingQueue来处理它们。

你可能应该有:

• 一个队列供服务器接收消息
• 根据您的实现，为每个客户端线程提供一个队列以从服务器接收消息，或者使用一个共享队列(如果其设计为任何线程都可以处理任何消息)。

所以你可能会这样做:

消息:

public interface Message {
  accept(Server server);
}

断开连接消息(我只想做一个):

public class DisconnectionMessage implements Message {
  String username;

  public void accept(Server server) {
    server.handleMessage(this);
  }
}

服务器可运行:

public void run() {
  while(isServerOnline()) {
    Message clientMessage = queue.poll();
    clientMessage.accept(this);
  }
}

public void handleMessage(DisconnectionMessage msg) {
  // code
}

public void handleMessage(ConnectionMessage msg) {
  // code
}

etc.

客户端可运行:

private final Socket socket;
private final BlockingQueue<Message> queue;

public Client(BlockingQueue<Message> queue, Socket socket) {
  this.queue = queue;
  this.socket = socket;
}

public void run() {
  while(true) {
    Message msg = receiveMessage();
    queue.offer(msg);
  }
}