how many users can handle on android client, pc java server with socket?

Question

I made a simple app works with socket to transfer data between client and server over local network,

Server java codes:

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();
            }
        }
    }
}

and android client codes:

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);
    }
}

How many clients this can handle? Is there a better solution?

Answer 1

How many clients this can handle?

Basically your code is an iterative server. There’s one big loop, and in each pass through the loop a single connection is completely processed.

A: So in this sense it can handle only one client at a time.

If you want to suport more than one client at a time your server should service multiple clients simultaneously through the use of threads (one thread per each client connection).

The basic flow of logic in such a server is this:

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

Please refer to the following tutorial for a full explanation and even some code example.

Is there a better solution?

In the Android side, as pointed out in my comment based in the answer here. Using AsyncTask for HTTP communications can have some drawbacks like:

1. You cannot cancel a request during execution.
2. The patterns of using AsyncTask also commonly leak a reference to an Activity...

A: A library like OkHttp can apply as a more robust alternative.