套接字阻塞接收到不一致的消息

Question

我正在为适用于套接字和1个服务器的聊天客户端系统编写测试。 我创建了3个套接字（每个线程在一个代表客户端的套接字）中选择聊天室（“美国会议室”）并全部发送1条消息，这是我要做的启动服务器，等待所有客户端进入会议室，每个发送一条消息，然后从每个套接字关闭服务器中读取所有消息，但是在读取某些套接字消息时，测试将冻结。 冻结是由以下行引起的： String line = reader.readLine(); 。 一些套接字接收到正确数量的消息（为5），另一些套接字仅冻结少于5的消息。我不知道套接字为何冻结。

public class ChatTest {
    final int NUMBER_OF_SOCKETS = 3;
    Server server = new Server();

    Map<String, Socket> mapSockets = new ConcurrentSkipListMap<>();
    List<String> socketMessages = new CopyOnWriteArrayList<>();
    List<Thread> allThreads = new CopyOnWriteArrayList<>();
    List<Socket> allsockets = new CopyOnWriteArrayList<>();
    Set<Set<String>> allSets = new HashSet<>();
    Map<Thread, Socket> mapThreadSocket = new ConcurrentHashMap<>();
    private final CyclicBarrier barrier = new CyclicBarrier(NUMBER_OF_SOCKETS);

    Thread t = new Thread(new Runnable() {
        @Override
        public void run() {
            server.start();
        }
    });

    @BeforeSuite(alwaysRun = true)
    public void startServer() {
        t.start();
    }

    @AfterSuite(alwaysRun = true)
    public void stopServer() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        server.stop();
    }

    Thread t2 = new Thread() {
        @Override
        public void run() {
            try {
                final List<String> linesFromFile = ChatSystemUtils.readFromFile(ClientTestDataConstants.TestDataFile.toString(), 50);
                System.out.println("all client threads have entered room called USA room ");
                for (int i = 0; i < NUMBER_OF_SOCKETS; i++) {
                    final PrintWriter stream = new PrintWriter(allsockets.get(i).getOutputStream(), true);
                    mapSockets.put(linesFromFile.get(i), allsockets.get(i));
                    stream.println(linesFromFile.get(i));
                    socketMessages.add(i, linesFromFile.get(i));
                }

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                for (int i = 0; i < NUMBER_OF_SOCKETS; i++) {
                    final BufferedReader reader = new BufferedReader(new InputStreamReader(allsockets.get(i).getInputStream()));
                    System.out.println("AT NEW USER");
                    Set<String> userMessages = new HashSet<>();

                    for (int j = 0; j < 5; j++) {
                        String line = reader.readLine();
                        System.out.println(line);

                        if (j > NUMBER_OF_SOCKETS) {
                            String msg = line.substring(9, line.length());
                            userMessages.add(msg);
                        }
                    }
                    userMessages.add(socketMessages.get(i));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    };

    @Test
    public void testMessagesReceived() throws IOException {
        List<Thread> threadList = new LinkedList<>();
        for (int i = 0; i < NUMBER_OF_SOCKETS; i++) {
            Runnable r = new Runnable() {
                @Override
                public void run() {
                    try {
                        barrier.await();
                    } catch (InterruptedException | BrokenBarrierException e1) {
                        e1.printStackTrace();
                    }

                    try {
                        Socket socket = new Socket("127.0.0.1", 3000);
                        allsockets.add(socket);
                        final PrintWriter stream = new PrintWriter(socket.getOutputStream(), true);
                        stream.println("USA room");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            };
            Thread t = new Thread(r);
            threadList.add(t);
        }

        for (int i = 0; i < threadList.size(); i++) {
            threadList.get(i).start();
        }

        for (int i = 0; i < threadList.size(); i++) {
            try {
                threadList.get(i).join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        t2.start();
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("most of the times we don't get here ");
    }
}

服务器类：

public final class Server {
public static boolean stopServerCalled;
private final int port;
private final String host;
private final Map<String, ChatRoom> mapRooms = ChatServerUtils.getChatRooms();
private final AtomicInteger clientID = new AtomicInteger(1);
private ServerSocket serverSocket;
private List<IClient> clientsPickingRoom;
private final ExecutorService executorService = Executors.newCachedThreadPool();

public Server() {

    final Properties prop = new Properties();

    try (final InputStream inputStream = getClass()
            .getResourceAsStream("/com/egt/chat/server/ChatServerConfig.properties")) {// read from a file of
                                                                                        // properties
        prop.load(inputStream);
    } catch (IOException e) {
        e.printStackTrace();
    }
    this.port = Integer.parseInt(prop.getProperty("port"));
    this.host = prop.getProperty("host");
    this.clientsPickingRoom = new CopyOnWriteArrayList<>();
}

public void start() {

    try {
        final InetAddress address = InetAddress.getByName(host);
        serverSocket = new ServerSocket(port, 50, address);
        System.out.println("Listening on socket : " + serverSocket);

        while (!Thread.currentThread().isInterrupted()) {

            final Socket newSocket = serverSocket.accept();

            System.out.println("Connection established with: " + newSocket);

            final ClientContainer newClient = new ClientContainer(clientID.get(), newSocket);
            executorService.execute(new ClientContainerRunnable(newClient, this));

            clientID.incrementAndGet();
            clientsPickingRoom.add(newClient);
        }

    } catch (IOException e) {
        System.out.println("Server stopped!");

    }

}
}

Answer 1

PrintWriter stream = new PrintWriter(allsockets.get(i).getOutputStream(), true);
stream.println(linesFromFile.get(i));

没有写此客户端套接字，它正在向与其连接的服务器发送一条消息。 服务器将5条线写入每个客户端套接字的位置在哪里，您可以在此处阅读：

for (int i = 0; i < NUMBER_OF_SOCKETS; i++) {
    final BufferedReader reader = new BufferedReader(new InputStreamReader(allsockets.get(i).getInputStream()));
    for (int j = 0; j < 5; j++) {
        String line = reader.readLine();
        System.out.println(line);
        // ...

如果您转储所有代码，那可能是最好的，那么我实际上可以提供帮助。 实际上，您并没有真正帮助我。