多次读取时，TCP服务器的读取挂起

Question

我正在测试一些TCP代码，除了一个问题外，它似乎工作正常。 当没有更多要读取的内容时，从套接字读取将挂在其中一种方法中：

这是TCP代码：

package com.comp424.service;

import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TCPService implements Runnable
{
    protected int             serverPort;
    protected InetAddress     bindAddress;

    protected ServerSocket    serverSocket  = null;
    protected boolean         isStopped     = false;
    protected Thread          runningThread = null;

    protected ExecutorService threadPool = Executors.newFixedThreadPool(10);

    public TCPService(String host,int port)
    {
        serverPort = port;

        try
        {
            bindAddress = InetAddress.getByName(host);
        }
        catch (UnknownHostException e)
        {
            throw new RuntimeException("Failed to get bind address", e);
        }
    }

    private void start()
    {
        try
        {
            serverSocket = new ServerSocket(serverPort, 10, bindAddress);
        }
        catch (IOException e)
        {
            throw new RuntimeException("Cannot open port " + serverPort, e);
        }
    }

    public void run()
    {
        synchronized (this)
        {
            runningThread = Thread.currentThread();
        }

        start();

        while (!isStopped())
        {
            Socket clientSocket = null;

            try
            {
                clientSocket = serverSocket.accept();
            }
            catch (IOException e)
            {
                if (isStopped())
                {
                    System.out.println("Server Stopped.");
                    break;
                }
                throw new RuntimeException("Error accepting client connection", e);
            }

            threadPool.execute(new ClientHandler(clientSocket));
        }
        threadPool.shutdown();

        System.out.println("Server Stopped.");
    }

    public synchronized void stop()
    {
        isStopped = true;

        try
        {
            serverSocket.close();
        }
        catch (IOException e)
        {
            throw new RuntimeException("Error closing server", e);
        }
    }    

    private synchronized boolean isStopped()
    {
        return isStopped;
    }  
}

package com.comp424.service;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

import com.comp424.impl.dao.DaoFactory;
import com.comp424.intf.dao.ICourseDao;
import com.comp424.intf.dao.IPersonDao;
import com.comp424.intf.dao.IRegisterCourseDao;
import com.comp424.model.Course;
import com.comp424.model.Person;

public class ClientHandler implements Runnable
{
    private static IRegisterCourseDao registrationDao;
    private static IPersonDao         personDao;
    private static ICourseDao         courseDao;

    protected Socket                  clientSocket = null;

    public ClientHandler(Socket socket)
    {
        registrationDao = DaoFactory.getInstance().getCourseRegistrationDao();
        personDao = DaoFactory.getInstance().getPersonDao();
        courseDao = DaoFactory.getInstance().getCourseDao();
        clientSocket = socket;
    }

    public void run()
    {
        try
        {
            String command = null;

            OutputStream output = clientSocket.getOutputStream();
            BufferedReader buffer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

            command = buffer.readLine();

            while (command != null)
            {
                String separator = ":";

                StringTokenizer tokenizer = new StringTokenizer(command, separator);

                List<String> tokens = new ArrayList<>();

                while (tokenizer.hasMoreElements())
                {
                    tokens.add((String) tokenizer.nextElement());
                }

                int operation = Integer.parseInt(tokens.get(0));

                switch (operation)
                {
                    case 1:
                        try
                        {
                            Person person = personDao.findByID(Long.parseLong(tokens.get(1)));
                            Course course = courseDao.findByID(Long.parseLong(tokens.get(2)));

                            registrationDao.register(person, course);
                            output.write(("0\r\n").getBytes());
                        }
                        catch (Exception e)
                        {
                            e.printStackTrace();
                            output.write(("1\r\n").getBytes());
                        }
                        break;

                    case 2:
                        try
                        {
                            Person person = personDao.findByID(Long.parseLong(tokens.get(1)));
                            Course course = courseDao.findByID(Long.parseLong(tokens.get(2)));

                            registrationDao.register(person, course);
                            output.write(("0\r\n").getBytes());
                        }
                        catch (Exception e)
                        {
                            e.printStackTrace();
                            output.write(("1\r\n").getBytes());
                        }
                        break;

                    case 3:
                        try
                        {
                            Person person = personDao.findByID(Long.parseLong(tokens.get(1)));

                            List<Course> courses = registrationDao.findByPerson(person);

                            for (Course c : courses)
                            {
                                output.write((c.getName() + "\r\n").getBytes());
                            }
                        }
                        catch (Exception e)
                        {
                            e.printStackTrace();
                            output.write(("1\r\n").getBytes());
                        }
                        break;

                }
                command = buffer.readLine();
            }

            output.close();
        }
        catch (IOException e)
        {
            // report exception somewhere.
            e.printStackTrace();
        }
    }
}

这是在读取返回的两个字符串而不是退出while循环之后，将其挂在findRegisteredCourses（）中的代码：

    while (response != null)
    {
        result.add(response);
        System.out.println("findRegisteredCourses():Response = " + response);
        response = reader.readLine();

    }

findRegisteredCourses（）的完整代码：

    @Override
    public List<String> findRegisteredCourses(String personID) throws Exception
    {
        try (Socket server = new Socket("localhost", 7000))
        {
            List<String> result = new ArrayList<>();

            DataOutputStream writer = new DataOutputStream(server.getOutputStream());
            BufferedReader reader = new BufferedReader(new InputStreamReader(server.getInputStream()));

            String operation = "3:" + personID + "\r\n";
            writer.writeBytes(operation);
            writer.flush();

            String response = reader.readLine();

            while (response != null)
            {
                result.add(response);
                System.out.println("findRegisteredCourses():Response = " + response);
                response = reader.readLine();

            }
            server.close();
            return result;
        }
    }

Answer 1

您将继续尝试从服务器读取数据，直到它关闭套接字为止-而服务器正在等待来自客户端的另一个命令。 双方都不会做任何事情，因为他们正在等待对方。

基本上，您需要更改协议，或者具有一些“这里是响应的结尾”指示（例如，如果在响应数据中不是有效值，则为空行），或者仅具有单个请求/响应每个连接。

您建议使用ready()方法的“解决方法”非常糟糕-它基本上意味着您假设有一个暂停就不会再有更多数据了。 也许服务器需要一段时间才能找到下一个项目。 也许网络上存在延迟-也许已经完成。 你看不出来，而且基本上你试图从事实，有没有可用的数据，现在推断信息违反了流媒体协议（如TCP）的设计。 不要那样做-修正您的协议。

Answer 2

删除了我的原始答案，因为根据@Jon Skeet的评论，该答案有误。 现在，我只发送一个特殊的数据令牌结尾，它工作正常。