Question

我可以用python发送数据并在服务器中接收数据，但是睡眠后超过1毫秒（如果执行一些For-loops（例如：对于范围在（0，60）中的i：打印i），结果是相同的），我使用套接字发送数据，但是在Java服务器中无法接收。

有代码：客户端是用python2编写的：

address = ('127.0.0.1', 9898)
ccc = socket(AF_INET, SOCK_STREAM)
ccc.connect(address)
ccc.send("client" + str(1) + ":before time.sleep send1111\n")
time.sleep(0.001)
ccc.send("client2:222222 after time.sleep\n")# if sleep 0.0009,can received,but 0.001 can't

服务器是用Java编写的：

 ReceiveListener listener = new ReceiveListener() {
            @Override
            public void onReceived(int clientId, String msg) {
                System.out.println(clientId + ":" + msg);
            }
        };
        ClientManager clientManager = ClientManager.getInstance(listener, 9898);
        clientManager.start();

这是类管理客户端：

public class ClientManager {
    private static ServerThread serverThread = null;
    private static ClientManager instance = null;
    private final int port;
    private ReceiveListener receiveListener = null;

    private ClientManager(ReceiveListener receiveListener, int port) {
        this.receiveListener = receiveListener;
        this.port = port;
        serverThread = new ServerThread(receiveListener, port);
    }

    public static ClientManager getInstance(ReceiveListener receiveListener, int port) {
        if (instance == null) {
            synchronized (ClientManager.class) {
                if (instance == null) {
                    instance = new ClientManager(receiveListener, port);
                }
            }
        }
        return instance;
    }

    public void stop() {
        serverThread.Stop();
        serverThread = null;
    }

    public void start() {
        if (serverThread == null) {
            serverThread = new ServerThread(receiveListener, port);
        }
        new Thread(serverThread).start();
    }

    public static class ServerThread implements Runnable {
        private ReceiveListener receiveListener;
        private static Map<Integer, HandleMsgTask> tasks = new HashMap<>();
        private final AtomicBoolean isExit = new AtomicBoolean(false);
        private ServerSocket server;
        int i = 0;

        public ServerThread(ReceiveListener receiveListener, int port) {
            try {
                this.receiveListener = receiveListener;
                this.server = new ServerSocket(port);
            } catch (IOException e) {
                System.out.println("failed：" + e.getMessage());
            }
        }

        @Override
        public void run() {
            try {
                while (!isExit.get()) {
                    System.out.println("wait devices... ... " + i);
                    Socket client = server.accept();
                    HandleMsgTask task = new HandleMsgTask(i, client, receiveListener);
                    new Thread(task).start();
                    tasks.put(i, task);
                    i++;
                    System.out.println("No:" + i);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        public static class HandleMsgTask implements Runnable {
            public final int clientId;
            public final Socket client;
            public static boolean connectStop = false;
            private final ReceiveListener ReceiveListener;

            public HandleMsgTask(int i, Socket client, ReceiveListener ReceiveListener) {
                this.clientId = i;
                this.client = client;
                this.ReceiveListener = ReceiveListener;
            }

            public void disconnectClient() {
                connectStop = true;
                try {
                    client.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void run() {
                try {
                    final String address = client.getRemoteSocketAddress().toString();
                    System.out.println(clientId + ":" + address);
                    InputStream inputStream = client.getInputStream();
                    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
                    while (reader.ready() && !connectStop) {
                        String line = reader.readLine();
                        if (ReceiveListener != null) {
                            ReceiveListener.onReceived(clientId, line);
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        public void Stop() {
            if (tasks != null) {
                for (HandleMsgTask task : tasks.values()) {
                    task.disconnectClient();
                }
                tasks.clear();
            }
            isExit.set(true);
            if (server != null) {
                try {
                    server.close();
                    System.out.println("close server");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

有人可以帮我吗？谢谢！

Answer 1

正如user207421所说，我滥用ready（）;我更改下面的代码并解决问题：编辑：

 while (!bIsStopped.get() && ((line = reader.readLine()) != null)) {
                    if (newMsgRecListener != null) {
                        newMsgRecListener.onMsgRec(clientId, line);
                    }
                }

为什么我无法通过套接字接收数据

1 个答案: