Question

我正在开发Client-Server应用程序，但遇到了一个问题。我有ServerWorker负责一个连接的客户端，它创建2个线程，其中1个用于侦听来自此客户端的传入数据，另外1个向他发送数据。

class ServerWorker {
    private DataProcessor dataProcessor;
    private ObjectInputStream inputStream;
    private ObjectOutputStream outputStream;
    private Thread receiverThread;
    private Thread senderThread;
    private Optional<DataPacket> dataToSend;

    private ServerWorker(Socket socket) {
        try {
            dataToSend = Optional.empty();
            dataProcessor = new DataProcessor();
            receiverThread = new Thread(this::readAndProcessData);
            senderThread = new Thread(this::sendData);
            inputStream = new ObjectInputStream(socket.getInputStream());
            outputStream = new ObjectOutputStream(socket.getOutputStream());
        } catch (IOException e) {
            //TODO
        }
    }

    static ServerWorker create(Socket socket) {
        return new ServerWorker(socket);
    }

    void start() {
        receiverThread.start();
        senderThread.start();
    }

    void stop() {
        receiverThread.interrupt();
        senderThread.interrupt();
    }

    private void readAndProcessData() {
        DataPacket dataPacket;
        try {
            while((dataPacket = (DataPacket)inputStream.readObject()) != null) {
                System.out.println("incoming message: " + dataPacket.getContent());
                dataToSend = Optional.of(dataProcessor.process(dataPacket));
            }
        } catch (ClassNotFoundException | IOException e) {
            //TODO
        }
    }

    private void sendData() {
        while(true) { //TODO
            dataToSend.ifPresent(data -> {
                try {
                    outputStream.writeObject(data);
                    outputStream.flush();
                    dataToSend = Optional.empty();
                } catch (IOException e) {
                    //TODO
                }
            });
        }
    }
}

DataProcessor只是目前的一小堂课

public class DataProcessor {
   public DataPacket process(DataPacket packet){
        packet.setContent(packet.getContent().toUpperCase());
        return packet;
   }
}

当然，DataPacket对于客户端和服务器都是相同的

public class DataPacket implements Serializable {
    private String content;

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

DataProcessor和DataPackets现在只是POC的一种，它将成长为更大，更复杂的类，总之，ServerWorker将接收数据并将其传递给处理，然后，在完成一些逻辑后，返回的数据将存储在dataToSend变量中，并在发送后删除。问题是，我上面发布的代码有时只能工作。 90％的时间，当我运行服务器应用程序和客户端一个（下面的代码）时，什么都没有发生，大写的“ hello world”不会返回客户端。有趣的是，当我在调试模式下运行服务器（即使没有任何断点！）时，它也可以工作...任何想法到底出了什么问题？

 public static void main(String... args) throws Exception {
        Socket socket = new Socket("localhost", 9999);
        DataPacket dataPacket = new DataPacket();
        dataPacket.setContent("hello world");
        ObjectOutputStream os = new ObjectOutputStream(socket.getOutputStream());
        os.writeObject(dataPacket);
        os.flush();

        ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
        while((dataPacket = (DataPacket)inputStream.readObject()) != null) {
            System.out.println(dataPacket.getContent());
        }
    }

编辑＃再添加一个类，ConnectionDispatcher，该类负责创建ServerWorker个对象

class ConnectionDispatcher implements Runnable {
    private ServerSocket serverSocket;
    private List<ServerWorker> serverWorkers;
    private volatile boolean isReceiving;

    private ConnectionDispatcher(int port) throws IOException {
        serverSocket = new ServerSocket(port);
        serverWorkers = new ArrayList<>();
        isReceiving = false;
    }

    static ConnectionDispatcher create(int port) throws IOException {
       return new ConnectionDispatcher(port);
    }

    @Override
    public void run() {
        isReceiving = true;
        while(isReceiving) {
           acceptIncomingConnections();
        }
    }

    private void acceptIncomingConnections() {
        try {
            ServerWorker worker = ServerWorker.create(serverSocket.accept());
            serverWorkers.add(worker);
            worker.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Answer 1

似乎您正在从一个线程修改dataToSend，同时在另一个线程中读取其值。这不是线程安全的，正在读取其值的线程可能永远不会看到其他线程设置的更新值。因此，我将dataToSend声明为volatile。

private volatile Optional<DataPacket> dataToSend;

我还没有机会自己进行测试，但是我可以在大约一个小时内完成测试（假设此更改不能解决您的问题）。

Answer 2

您可以使用Array Blocking Queue来模拟生产者和使用者模式。

让接收者线程将新的DataPacket放入队列中，然后让发送者从队列中取出并对其进行处理并将其发送。

这将消除线程问题并充当缓冲区。

使用当前代码，当数据包到达较高速率时，它们可能会使其丢失。

我同意user930的观点，private Optional<DataPacket> dataToSend;应该是易变的。

此外，您还可以使用JavaNIO使代码具有更大的可伸缩性，您可以研究Apache Mina项目。

基于套接字的应用程序的不确定行为

2 个答案: