4

I am designing architecture for android app -> server communication via TCP. It will be custom application protocol based on the TCP ... I am familiar with network programming, but I did not work a lot with the java (even, this is more general question then Java question) - and I did not work a lot with applications where you have undefined number of clients (in this case, in dependency of how many android app users you have). Hence I have few doubts and questions.

Scenario:

  • Users are going to install android application and login
  • After login, they will establish TCP connection with the server
  • Obviously, server side implementation needs to process requests in paralel
  • Consider that, both client and server side will be implemented using Java
  • Lets consider that application is really successfull - and it have 3mil + installations - which means a lot of users (yeah right :) )

Question: What is the best way (best practice) to implement server side in order to handle client connections for this type of application?

Based on my research, you have only three approaches possible:

  1. Using threadpool
  2. Using one thread per tcp connection
  3. Using threadpool and non blocking async approach in java (similar to what nodejs is doing with libuv)

EDIT:

Elaboration:

1. Using just a threadpool here seems "weird", due to the fact that we would need to have a huge threadpool in order to be able to assign thread per tcp connection. Using threadpool in order to serve e.g. http request (where tcp connection will be closed after request is completed), seems more then great idea.. but not for the tcp connections which are going to be used for a longer time)

2. Creating one thread per tcp connection every single time - seems limited as well (Why is creating a Thread said to be expensive?)

Java threads are implemented as native threads and huge numbers of threads is the wrong way to write a practical Java application. I suppose that this depends, of course, and what type of application you have in general.

3. Using threadpool and non blocking async approach in java (similar to what nodejs is doing with libuv).

Based on what I read (and suggested so far as well), this seems like the best approach. Maybe its just because I have more experience with this type of applications (nodejs non blocking single threaded workers) - but seems like the best solution.

Maybe there are some ways - practices I am not familiar with - which can make this process more efficient?

Can you suggest any resources (books or similar) for this type of applications?

NOTE: Please make a note that I understand, that I am able to make this process more efficient with couple of methods I am already familiar with - for example, closing tcp connection when app goes in background - and reconnecting/establishing when user is using application again and similar (but this depends from the application itself of course).

I am wondering, am I missing something here - or it is simply as it is. If you want to have a lot of users - and lot of tcp connections - you will need to use one thread for every single user (or other approaches I mentioned above).

Other resources I went through:

  1. Max number of threads - Linux
  2. Increase number of threads - JVM
  3. Max number of threads allowed to run

  4. Runnable vs Thread

  5. ... and other external resources

cool
  • 3,225
  • 3
  • 33
  • 58
  • 1
    what is the question? – OznOg Jun 30 '19 at 18:32
  • @OznOg I bolded question above (if you read the whole post). Is the only way, to handle "unknown number of clients -> server" tcp connection - by simply implementing handlers in separate threads --- in the manner "one android user --- one thread on server side" – cool Jun 30 '19 at 18:35
  • 2
    No, one thread per connection is not the only way. Check out [Netty](https://netty.io/) and [Java NIO](http://tutorials.jenkov.com/java-nio/nio-vs-io.html) – Denis Zavedeev Jun 30 '19 at 18:50
  • @caco3 Thank you for suggestion, I will check those resources for sure. – cool Jun 30 '19 at 18:51
  • 1
    The networking [library](https://github.com/jhg023/SimpleNet) that I maintain uses a fixed thread pool as well as asynchronous I/O to efficiently handle many connections without creating many threads. It probably won't be usable on Android (due to Java versioning discrepancies), but you're free to check it out to see if it can help you! – Jacob G. Jun 30 '19 at 19:19
  • @OznOg I understood that my question is decently vague (due to the fact that I want general answer - on something which changes from application to application). I updated a question outlining three different approaches which are possible to implement this type of application - in order to make it more clear. – cool Jul 03 '19 at 15:59

0 Answers0