套接字多线程死锁

Question

我有一个类似的问题，但是我知道当我要求阅读一行时，发件人应该发送一个行尾。

让我困惑的是，在调试中，它是有效的。可能是因为我在调试时跳过的顺序（直到现在我都不知道这会有什么不同），但我想更好地理解它。

我已经使用线程，但不是很多。

这是我的服务器类：

import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

public class Server {

    protected static List<Game> games = new ArrayList<>();
    protected static List<ServerThread> players = new ArrayList<>();

    public static void main(String[] args) throws Exception {
        int serverPort = 8945;
        Server server = new Server();
        ServerSocket welcomeSocket = new ServerSocket(serverPort);

        while (true) {
            Socket connectionSocket = welcomeSocket.accept();
            ServerThread st = new ServerThread(server,connectionSocket);
            st.start();
            int gameId = 0;
            if(players.size()>0 && players.size()%2==0){
                gameId++;
                players.get(0).outToClient.write("START " + gameId
                        + " 123 456" +"\n");
                players.get(0).outToClient.flush();
                players.get(1).outToClient.write("START " + gameId
                        + " 456 123" +"\n");
                players.get(1).outToClient.flush();
            }
        }
    }
}

线程（基于此）

import java.io.*;
import java.net.Socket;

public class ServerThread extends Thread {
    protected Server server;
    protected Socket socket;
    protected String playerName;   
    protected BufferedReader inFromClient;
    protected BufferedWriter outToClient;

    public ServerThread(Server server, Socket clientSocket) throws IOException {
        this.server = server;
        this.socket = clientSocket;
        this.inFromClient = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        this.outToClient = new BufferedWriter(new InputStreamReader(socket.getOutputStream()));
    }

    public void run() {
        while (true) {
            try {
                String line = inFromClient.readLine();
                if(line != null) {
                    String[] clientCommand = line.split(" ");
                    String commandType = clientCommand[0];
                    if (!commandType.equalsIgnoreCase("QUIT")) {
                        switch (commandType) {
                            case "JOIN":
                                playerName = clientCommand[1];
                                System.out.println(playerName + " joined");
                                Server.players.add(this);
                                break;
                            case "PLAY":
                                //nothing yet
                                break;
                            case "MSG":
                                //nothing yet
                                break;
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
                return;
            }
        }
    }

和客户：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class Client {

    private static int gameID;
    private static int order;
    private static String opponent;

    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.out.println("Usage: java Client <serverIp>");
            System.exit(1);
        }
        String serverIP = args[0];
        int serverPort = 8945;
        BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
        Socket clientSocket = new Socket(serverIP, serverPort);
        BufferedWriter outToServer = new OutputStreamWriter(clientSocket.getOutputStream());
        BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

        String line = inFromUser.readLine();
        String[] commandSentence = line.split(" ");
        String userCommandType = commandSentence[0];
        while (!userCommandType.equals("/exit")){
            switch (userCommandType){
                case "/enter":
                    String nickname = commandSentence[1];
                    outToServer.write("JOIN "+ nickname + '\n');
                    outToServer.flush();
                    while (true){
                        String serverLine = inFromServer.readLine();
                        String[] serverCommand = serverLine.split(" ");
                        String serverCommandType = serverCommand[0];
                        if(serverCommandType.equalsIgnoreCase("START")){
                            gameID = Integer.parseInt(serverCommand[1]);
                            order = Integer.parseInt(serverCommand[2]);
                            opponent = serverCommand[3];
                            System.out.printf("%5s %5s %5s",gameID,order,opponent);
                            break;
                        }                            
                    }
                case "/play":
                    //nothing yet
                    break;
                case "/msg":
                    //nothing yet
                    break;
            }
        }
    }
}

它似乎在某个地方进入了死锁，出于某种原因，除非在调试中运行，否则永远不要在向客户端发送数据的服务器类上输入该死锁

（顺便说一句，我使用的是get（0）和get（1）之类的工具，仅用于测试目的）

编辑：好吧，我愚蠢的错误是我忘记在客户端向服务器发送数据时添加outToServer.flush（）；。但是我的主要问题仍然存在，当我通过键入"/Enter创建两个客户端时

Answer 1

摆脱测试。它的正确用法很少。只需让下面的read阻塞即可。

注意：不要将流与读者和作者混为一谈。如果您正在使用BufferedInputStream进行读取，那么您应该使用BufferedOutputStream进行写入。

Answer 2

一个问题是在将命令发送到服务器的行中的客户端代码。您发送的字符串长度很小，因此需要一个outToServer。冲洗（）；正常工作