Question

我正在编写一个Java应用程序，用于发送和接收来自websocket服务器的消息。当应用收到消息时，可能需要一些时间来处理它。因此，我正在尝试使用多个线程来接收消息。据我所知Grizzly有选择器线程和工作线程。默认情况下，有1个选择器线程和2个工作线程，在下面的示例中，我试图将它们分别增加到5和10。在下面的示例中，我将调用onMessage方法的线程暂停10秒以模拟传入信息的处理。信息每秒都有，因此10个线程应该能够处理流量。当我分析运行时，只有1个选择器线程在运行，2个工作线程。此外，仅以10秒的间隔接收消息。表明只有一个线程正在处理流量 - 我觉得这很奇怪。在分析期间，一个工作者线程，例如Grizzly(1)收到发送的第一条消息。然后10秒后'Grizzly（2）'收到第二条消息 - 然后Grizzly(2)继续接收消息，Grizzly(1)不执行任何操作。

有人可以解释这种奇怪的行为以及如何将其改为例如10个线程不断排队等待消息？

主：

    public static void main(String[] args) {
        WebsocketTextClient client = new WebsocketTextClient();
        client.connect();
        for (int i = 0; i < 60; i++) {
            client.send("Test message " + i);
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                System.out.println("Error sleeping!");
            }
        }
    }

WebsocketTextClient.java：

import java.net.URI;
import javax.websocket.ClientEndpointConfig;
import javax.websocket.EndpointConfig;
import javax.websocket.Session;
import javax.websocket.Endpoint;
import javax.websocket.MessageHandler;
import org.glassfish.tyrus.client.ClientManager;
import org.glassfish.tyrus.client.ThreadPoolConfig;
import org.glassfish.tyrus.container.grizzly.client.GrizzlyClientProperties;

public class WebsocketTextClient {

    private ClientManager client;
    private ClientEndpointConfig clientConfig;
    WebsocketTextClientEndpoint endpoint;

    public WebsocketTextClient() {
        client = ClientManager.createClient();
        client.getProperties().put(GrizzlyClientProperties.SELECTOR_THREAD_POOL_CONFIG, ThreadPoolConfig.defaultConfig().setMaxPoolSize(5));
        client.getProperties().put(GrizzlyClientProperties.WORKER_THREAD_POOL_CONFIG, ThreadPoolConfig.defaultConfig().setMaxPoolSize(10));
    }

    public boolean connect() {
        try {
            clientConfig = ClientEndpointConfig.Builder.create().build();
            endpoint = new WebsocketTextClientEndpoint();
            client.connectToServer(endpoint, clientConfig, new URI("wss://echo.websocket.org"));
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    public boolean disconnect() {
        return false;
    }

    public boolean send(String message) {
        endpoint.session.getAsyncRemote().sendText(message);
        return true;
    }

    private class WebsocketTextClientEndpoint extends Endpoint {
        Session session;

        @Override
        public void onOpen(Session session, EndpointConfig config) {
            System.out.println("Connection opened");
            this.session = session;
            session.addMessageHandler(new WebsocketTextClientMessageHandler());
        }
    }

    private class WebsocketTextClientMessageHandler implements MessageHandler.Whole<String> {

        @Override
        public void onMessage(String message) {
            System.out.println("Message received from " + Thread.currentThread().getName() + " " + message);
            try {
                Thread.sleep(10000);
            } catch (Exception e) {
                System.out.println("Error sleeping!");
            }
            System.out.println("Resuming");
        }
    }
}

Answer 1

您似乎要问的是，WebSockets能够接收由同一客户端连接发送的多个消息，在单独的线程中处理这些消息，并在准备就绪时发送响应 - 这意味着，可能是订购。只有在客户端是多线程的情况下才会发生这种情况。

要在同一个WebSocket会话中处理多个线程，通常需要WebSockets能够多路复用来往客户端的数据。这当前不是WebSockets的一个功能，但肯定可以构建在它之上。但是，在单个通道上复用这些客户端和服务器线程会带来相当大的复杂性，因为您需要阻止所有客户端和服务器线程无意中覆盖或彼此挨饿。

MessageHandler的Java规范可能对线程模型有点模棱两可;

https://docs.oracle.com/javaee/7/api/javax/websocket/MessageHandler.html说：

每个Web套接字会话一次只使用一个线程来调用其MessageHandler。

但这里的重要术语是“socket session ”。如果您的客户端在同一WebSocket会话中发送多条消息，则服务器端处理程序将在单个线程内执行。这并不意味着你不能在线程中做很多有趣的事情，特别是如果你在两端都使用Input / OutputStreams（或Writers）。它意味着与客户端的通信只由一个线程调解。如果要复用通信，则必须在套接字上写一些内容才能这样做;这将包括开发自己的线程模型来分派请求。

更简单的解决方案是为每个客户端请求创建一个新的会话。每个客户端请求启动一个会话（即TCP连接），发送数据，并等待结果。这为您提供了多个MessageHandler线程 - 每个会话一个，符合规范。

这是在服务器端获得多线程的最直接的方法;任何其他方法都倾向于需要多路复用机制 - 根据您的使用情况，这可能不值得付出努力，并且肯定会带来一些复杂性和风险。

如果您担心客户端和服务器之间的会话数（TCP / HTTP连接），可以考虑在客户端创建一个Sessions池，并一次使用一个Session Session，每当客户端完成后，都会将会话返回到池中。

最后，也许并不直接相关：我发现当我使用Payara Micro来服务WebSocket端点时，我需要设置它：

  <resources>
    ...
    <managed-executor-service maximum-pool-size="200" core-pool-size="10" long-running-tasks="true" keep-alive-seconds="300" hung-after-seconds="300" task-queue-capacity="20000" jndi-name="concurrent/__defaultManagedExecutorService" object-type="system-all"></managed-executor-service>

默认的ManagedExecutorService仅提供单个线程。这似乎也是Glassfish的情况。这让我跑了几个小时，以为我不理解线程模型，只是池大小让我感到困惑。

线程在javax.websockets / Tyrus中

1 个答案: