android客户端、pc java服务器和socket可以处理多少用户？

我制作了一个简单的应用程序，使用socket通过本地网络在客户端和服务器之间传输数据

服务器java代码：

try {
    serverSocket = new ServerSocket(8888);
    System.out.println("Listening :8888");
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

while (true) {
    try {
        socket = serverSocket.accept();
        dataInputStream = new DataInputStream(socket.getInputStream());
        dataOutputStream = new DataOutputStream(
                socket.getOutputStream());
        System.out.println("ip: " + socket.getInetAddress());
        String message = dataInputStream.readUTF();
        // System.out.println("message: " + dataInputStream.readUTF());

        try {
            JSONObject jObj = new JSONObject(message);
            String flag = jObj.getString("flag");
            if (flag.equals("request")) {
                String request = jObj.getString("request");
                if (request.equals("getGroup"))
                    dataOutputStream.writeUTF(getGroup());
                else if (request.equals("getFood")) {
                    String groupID = jObj.getString("groupID");
                    dataOutputStream.writeUTF(getFood(groupID));
                }
            }
        } catch (JSONException | IOException e) {
            e.printStackTrace();
        }
        // dataOutputStream.writeUTF("Hello!");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (socket != null) {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (dataInputStream != null) {
            try {
                dataInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (dataOutputStream != null) {
            try {
                dataOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

和android客户端代码：

class Load extends AsyncTask<String, String, String> {
    String response;

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    protected String doInBackground(String... args) {
        Socket socket = null;
        DataOutputStream dataOutputStream = null;
        DataInputStream dataInputStream = null;

        try {
            socket = new Socket("192.168.1.106", 8888);
            dataOutputStream = new DataOutputStream(socket.getOutputStream());
            dataInputStream = new DataInputStream(socket.getInputStream());
            dataOutputStream.writeUTF(utils.getGroup());
            response = dataInputStream.readUTF();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (dataOutputStream != null) {
                try {
                    dataOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (dataInputStream != null) {
                try {
                    dataInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    protected void onPostExecute(String file_url) {
        showGroup(response);
    }
}

类加载扩展异步任务{
字符串响应；
@凌驾
受保护的void onPreExecute（）{
super.onPreExecute（）；
}
受保护的字符串doInBackground（字符串…args）{
套接字=空；
DataOutputStream DataOutputStream=null；
DataInputStream DataInputStream=null；
试一试{
插座=新插座（“192.168.1.106”，8888）；
dataOutputStream=新的dataOutputStream（socket.getOutputStream（））；
dataInputStream=新的dataInputStream（socket.getInputStream（））；
dataOutputStream.writeUTF（utils.getGroup（））；
response=dataInputStream.readUTF（）；
}捕获（未知后异常e）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}最后{
if（套接字！=null）{
试一试{
socket.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
如果（dataOutputStream！=null）{
试一试{
dataOutputStream.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
如果（dataInputStream！=null）{
试一试{
dataInputStream.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}
返回null；
}
受保护的void onPostExecute（字符串文件\u url）{
showGroup（response）；
}
}

这可以处理多少个客户端？ 有更好的解决办法吗

这可以处理多少个客户端

基本上，您的代码是一个迭代服务器。有一个大循环，在每个循环中，一个连接被完全处理

A：从这个意义上讲，它一次只能处理一个客户端。

如果您希望一次支持多个客户端，则服务器应通过使用线程（每个客户端连接一个线程）同时为多个客户端提供服务

这种服务器的基本逻辑流程如下：

while (true) {
    accept a connection;
    create a thread to deal with the client;
}

---

请参考下面的完整解释，甚至一些代码示例

有更好的解决办法吗

在Android方面，正如我在回答中的评论所指出的。使用

AsyncTask

进行HTTP通信可能有一些缺点，如：

您不能在执行期间取消请求

使用AsyncTask的模式通常也会泄漏对活动的引用

---

答：像OkHttp这样的库可以作为一个更强大的替代方案应用。

请参考下面的答案stackoverflow.com/A/27341320/1082344（答案指出了为什么AsyncTask不是HTTP通信的最佳方案）@IsaacCisneros谢谢，那么服务器呢？它能处理许多客户端吗？连接没有保持，客户端只是发送一个请求并得到响应，然后连接就会关闭