Java socket objectoutputstream multi-thread

In the client it's opening a new TCP connection for every object that is sent. This will kill performance as there is a large amount of overhead to establish a TCP connection.

From your code the server looks like it is closing the connection after handling a single object. It also closes the ServerSocket after handling a single connection which doesn't seem like it would work at all. Is the server code provided correct? Is there another loop occurring in the server code that will start up another ServerSocket?

The best approach might be to have each client thread create its own Socket which each has a separate connection to the server. If you are trying to push a lot of data and using multiple threads to achieve that then there is a good chance that the server will need multiple threads to handle the data. These sockets should be created a single time and reused to send all of the objects.

On the server side you will want to create a proper multithreaded TCP server. The general idea here is to create a single SocketServer and call its accept() method in a while loop. For each Socket that is returned from accept() you will fire up a new thread to handle the request. An example can be found here: Multithreaded Server using TCP in Java

I had the same problem and solved it by using a simple Wrapper-Class for my Sockets. The object of this class has to be present at any point where read/write actions are needed.

public class Sender implements Closeable 
{
  private final Socket sock;
  private final ObjectOutputStream out;
  private ObjectInputStream in = null;

  private final Object oLock = new Object();
  private final Object iLock = new Object();

  //optional
  public boolean isClosed(){
    return sock.isClosed();
  }

  //there is a better way to do this
  public Socket getSocket(){

    return sock;
  }

  //use this to send data
  public void send(Object o) throws IOException {
    synchronized (oLock){
        getOOS().writeObject(o);
    }
  }

  //use this to read data
  public Object get() throws IOException {
    synchronized (iLock){
        return getOIS().readObject();
    }
  }

  private ObjectOutputStream getOOS() {
    return out;
  }

  //not the best way... but wouldn't work otherwise
  private ObjectInputStream getOIS() throws IOException {
    if(in == null)
        in = new ObjectInputStream(sock.getInputStream());
    return in;
  }

  public Sender(Socket s) throws IOException {
    sock = s;
    out = new ObjectOutputStream(s.getOutputStream());
    //in = new ObjectInputStream(s.getInputStream());
    //getting the input and output stream gave me some weird deadlock
  }

  //optional
  @Override
  public String toString() {
    return sock.toString();
  }

  //flush and close if sock is not yet closed
  @Override
  public void close() throws IOException {
    if(!sock.isClosed()){
        if(out != null)
            out.flush();

        sock.close();
    }
  }
}

This one works well and fast in client (Sender is the Socket connected to the Server) and server (Sender are the Sockets connected to the clients).

Hope this helps.

Greets roop

Does you server at 9990 close the connection after reading an object, or is it failing ?

After this is sorted out, you can look at optimizing speed serialization using fast object serializers like kryo

i dont have experience in java sockets, but by the line s.setTcpNoDelay(true); i asume your program is using tcp to send the packets, try using udp instead. the tcp protocol is meant to garantee that the packet arrive to their destination, and to do this it has to verify integrity once they arrive. udp on the other hand does not do this, it only sends the packets and is not concerned about the integrity, that is why online multiplayer games use it.