Why new ObjectOutputStream for every send, and new ObjectInputStream for every receive? + manage while(true)?

Question

I have two questions.
The complete working SSCCE is at the bottom.
A simple client and server; you run the server first, then the client.
You will see two frames, each frame has a blue ball set at the upper left corner.

The ball at server side is passive
The ball at client side is active

By using your mouse you can move client ball, and you will see the server ball updates its location, but you cannot move server ball. It is OK.

The first question is if you look at the code you will find that every send requires a new ObjectOutputStream and every receive requires a new ObjectInputStream

Client:

  Runnable send = new Runnable()
  {
     ....
     //if you comment the following line the sending/receiving will not work!
     oos = new ObjectOutputStream(socket.getOutputStream());
     oos.writeObject(dp);  
     ....
  }

Server:

   Runnable receive = new Runnable()
   {
      ....
      //if you comment the following line the sending/receiving will not work!
      ois = new ObjectInputStream(socket.getInputStream());
      DataObject dp = (DataObject) ois.readObject();
      ....
   }

The correct expected behaviour is that since both objects ObjectOutputStream and ObjectInputStream have already been created at creation. There is no need to recreate them before every send and before every receive.

How to fix that?

The second question: Is there a technique to write when there is something to write and read when there is something to read?

In other words; using while(true) at sending and receiving ends causes indefinite writes and reads. So is there some trick to send only when there is some update. and to receive only when there is some thing have been sent?. I tried many tricks but non yield a good result.

Similar thing is built in with BufferedReader that is even if while(true) is used, the looping halts until there is some new line to read.

BufferedReader fromClient;

String line = fromClient.readLine();

while (!(line.equals("Bye"))
{
   System.out.println(line);
   line = fromClient.readLine();
}

---

The SSCCE:

The server package:
BallServer:

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JComponent;
import javax.swing.JFrame;


public class BallServer extends JComponent
{

   public int x;
   public int y;
   Socket socket;
   ObjectInputStream ois;
   public ServerSocket serverSocket;

   public BallServer()
   {
      try
      {
         serverSocket = new ServerSocket(2222);
         socket = serverSocket.accept();
         openStreams();
         new Thread(receive).start();
      } catch (IOException ex)
      {
         Logger.getLogger(BallServer.class.getName()).log(Level.SEVERE, null, ex);
      }
   }

   private void openStreams()
   {
      if (socket != null)
      {
         try
         {
            ois = new ObjectInputStream(socket.getInputStream());
         } catch (IOException ex)
         {
            Logger.getLogger(BallServer.class.getName()).log(Level.SEVERE, null, ex);
         }
      }
   }
   Runnable receive = new Runnable()
   {
      @Override
      public void run()
      {
         while (true)
         {
            if (socket != null)
            {
               try
               {
                  //if you comment the following line the sending/receiving will not work!
                  ois = new ObjectInputStream(socket.getInputStream());
                  DataObject dp = (DataObject) ois.readObject();
                  x = dp.x;
                  y = dp.y;
                  repaint();
                  System.out.println("x: " + x + " y: " + y);

               } catch (IOException | ClassNotFoundException ex)
               {
                  Logger.getLogger(BallServer.class.getName()).log(Level.SEVERE, null, ex);
               }
            }
         }
      }
   };

   @Override
   public void paint(Graphics g)
   {
      Graphics2D g2d = (Graphics2D) g;

      g2d.setColor(Color.WHITE);
      g2d.fillRect(0, 0, getWidth(), getHeight());

      g2d.setColor(Color.BLUE);
      g2d.fillOval(x - 50, y - 50, 100, 100);

      try
      {
         Thread.sleep(50);
      } catch (Exception ex)
      {
      }

   }

   public static void main(String[] args)
   {
      JFrame frame = new JFrame();
      frame.setTitle("Ball server");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.add(new BallServer());

      frame.pack();
      frame.setSize(650, 500);
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
   }
}

DataObject:

import java.io.Serializable;

public class DataObject implements Serializable
{
   public int x = 0;
   public int y = 0;
}

---

The client package:
ClientBall:

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JComponent;
import javax.swing.JFrame;


public class ClientBall extends JComponent
{

   public int x;
   public int y;
   Socket socket;
   DataObject dp;
   ObjectOutputStream oos;
   Thread sendThread;

   public ClientBall()
   {
      dp = new DataObject();
      this.addMouseMotionListener(new MouseMotionAdapter()
      {
         @Override
         public void mouseDragged(MouseEvent e)
         {
            x = e.getX();
            y = e.getY();

            ClientBall.this.dp.x = x;
            ClientBall.this.dp.y = y;

            repaint();
         }
      });

      setSocket();
      openStreams();
      sendThread = new Thread(send);
      sendThread.start();
   }
   Runnable send = new Runnable()
   {
      @Override
      public void run()
      {
         while (true)
         {
            if (socket != null)
            {
               try
               {
                 //if you comment the following line the sending/receiving will not work!
                  oos = new ObjectOutputStream(socket.getOutputStream());
                  oos.writeObject(dp);
                  System.out.println("client write");
               } catch (IOException ex)
               {
                  Logger.getLogger(ClientBall.class.getName()).log(Level.SEVERE, null, ex);
               }
            }
         }
      }
   };

   private void setSocket()
   {
      try
      {
         socket = new Socket("localhost", 2222);
      } catch (UnknownHostException ex)
      {
         Logger.getLogger(ClientBall.class.getName()).log(Level.SEVERE, null, ex);
      } catch (IOException ex)
      {
         Logger.getLogger(ClientBall.class.getName()).log(Level.SEVERE, null, ex);
      }
   }

   private void openStreams()
   {
      if (socket != null)
      {
         try
         {
            oos = new ObjectOutputStream(socket.getOutputStream());
         } catch (IOException ex)
         {
            Logger.getLogger(ClientBall.class.getName()).log(Level.SEVERE, null, ex);
         }
      }
   }

   @Override
   public void paint(Graphics g)
   {
      Graphics2D g2d = (Graphics2D) g;

      g2d.setColor(Color.WHITE);
      g2d.fillRect(0, 0, getWidth(), getHeight());

      g2d.setColor(Color.BLUE);
      g2d.fillOval(x - 50, y - 50, 100, 100);

      try
      {
         Thread.sleep(50);
      } catch (Exception ex)
      {
      }
   }

   public static void main(String[] args)
   {
      JFrame frame = new JFrame();
      frame.setTitle("Ball client");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.add(new ClientBall());

      frame.pack();
      frame.setSize(650, 500);
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
   }
 }

DataObject:

import java.io.Serializable;

public class DataObject implements Serializable
{
   public int x = 0;
   public int y = 0;
}

Answer 1

The correct expected behaviour is that since both objects ObjectOutputStream and ObjectInputStream have already been created at creation. There is no need to recreate them before every send and before every receive. How to fix that?

Create the once and store them where you save you socket and reuse those each time. Note: if you are accessing either i a multi-threaded way, you will need to add locking to avoid corrupting the stream.

Is there a technique to write when there is something to write and read when there is something to read?

The "something to write" is easy, just call the writeXxxx when you have something to write and not when you don't. The something to read is only possible if you know there is something to read. e.g. if for every write you expect exactly one read, this works. In the more general case you need to thread always waiting for something to read.

Answer 2

No need of this line oos = new ObjectOutputStream(socket.getOutputStream()); in run() method.

You just need to do this after writing to server or client

oos.writeObject(dp);
oos.flush();

Answer 3

The first question is if you look at the code you will find that every send requires a new ObjectOutputStream and every receive requires a new ObjectInputStream

I wouldn't say 'requires'. I would say 'performs'. It certainly isn't required, and it leads to all kinds of problems if you do it.

//if you uncomment the following line the sending/receiving will not work!
//if you uncomment the following line the sending/receiving will not work!

I agree. Why should it? Don't uncomment it. It won't work. Omit it. Or did you mean to say 'if you comment the following line' it won't work? In which case I don't agree. You should remove both lines.

How to fix that?

How to fix what?

public class BallServer extends JComponent
{

   public int x;
   public int y;
   Socket socket;
   ObjectInputStream ois;

This is all wrong. The Socket and the ObjectInputStream should be members of a Runnable class that is instantiated per accepted connection. Not members of the server class ... unless you are only expecting one connection?

Is there a technique to write when there is something to write

Yes, just call writeObject().

and read when there is something to read?

Just call readObject(). It will block until there is something to read.