How to: synchronize sockets?

[Aji Prasetyo]

Hello,

I am sorry, I have to ask you guys again this time. But please hear me.

Last time I studied about threads synchronization, and I've tried it.
This time, I am coding a network application and I've been trying to "synchronize" it, but no luck so far.

What I mean is: how to make Socket(); which sends something, first waits for ServerSocket() to become available and ready to receive, then actually sends the objects.

below is the sample-code. kind of long, so please bear with me. the server and client side has the same program. Sometimes the console would display this kind of exception:

Java.net.ConnectException: Connection refused: connect
at testproducerconsumer.Drop.put(ProducerConsumerApplet.java:348)
at testproducerconsumer.Producer.run(ProducerConsumerApplet.java:266)

Thank you so much beforehand.

package testproducerconsumer;
 
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintWriter;
import java.lang.reflect.InvocationTargetException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Random;
import java.util.Scanner;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
 
public class ProducerConsumerApplet extends javax.swing.JApplet {
    
    Drop drop;
    
    public void init() {
        
        drop = new Drop();
        try {
            java.awt.EventQueue.invokeAndWait(new Runnable() {
                public void run() {
                    initComponents();
                }
            });
        } catch(InterruptedException ex) { ex.printStackTrace();
        } catch(InvocationTargetException ex) { ex.printStackTrace(); }
    }
    
    public void start() {
        
        new Thread(new Producer(drop)).start();
    }
    
    /** This method is called from within the init() method to
     * initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is
     * always regenerated by the Form Editor.
     */
    // <editor-fold defaultstate="collapsed" desc=" Generated Code">                          
    private void initComponents() {
        jPanel1 = new Consumer(drop);
 
        javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
        jPanel1.setLayout(jPanel1Layout);
        jPanel1Layout.setHorizontalGroup(
            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGap(0, 376, Short.MAX_VALUE)
        );
        jPanel1Layout.setVerticalGroup(
            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGap(0, 280, Short.MAX_VALUE)
        );
 
        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                .addContainerGap())
        );
    }// </editor-fold>                        
    
    
    // Variables declaration - do not modify                     
    private javax.swing.JPanel jPanel1;
    // End of variables declaration                   
    
}
 
/*----------------------------------------------------------------------------*/
 
class Consumer extends JPanel implements Runnable {
    
    private static int xmax;
    private static int ymax;
    private static int xcntr;
    private static int ycntr;
    private static Drop drop;
    private static Random rand = new Random();
 
    public Consumer(Drop drop) {
        
        this.drop = drop;
        Thread t = new Thread(this);
        t.start();
    }
 
    private void drawLayout(Graphics g) {
 
        /* Drawing panel's center mark.*/
        g.drawRect(xcntr - 5, ycntr - 5, 10, 10);
        g.drawLine(xcntr - 5, ycntr - 5, xcntr, ycntr - 10);
        g.drawLine(xcntr + 5, ycntr - 5, xcntr, ycntr - 10);
 
        /* Drawing X axis. */
        g.drawLine(0 + 9, ymax - 9, xmax - 9, ymax - 9);
        g.drawString("3500", xcntr + (3500 / 6), ymax - 10);
        g.drawLine(xcntr + (3500 / 6), ymax - 10, xcntr + (3500 / 6), ymax - 5);
        g.drawString("3000", xcntr + (3000 / 6), ymax - 10);
        g.drawLine(xcntr + (3000 / 6), ymax - 10, xcntr + (3000 / 6), ymax - 5);
        g.drawString("2500", xcntr + (2500 / 6), ymax - 10);
        g.drawLine(xcntr + (2500 / 6), ymax - 10, xcntr + (2500 / 6), ymax - 5);
        g.drawString("2000", xcntr + (2000 / 6), ymax - 10);
        g.drawLine(xcntr + (2000 / 6), ymax - 10, xcntr + (2000 / 6), ymax - 5);
        g.drawString("1500", xcntr + (1500 / 6), ymax - 10);
        g.drawLine(xcntr + (1500 / 6), ymax - 10, xcntr + (1500 / 6), ymax - 5);
        g.drawString("1000", xcntr + (1000 / 6), ymax - 10);
        g.drawLine(xcntr + (1000 / 6), ymax - 10, xcntr + (1000 / 6), ymax - 5);
        g.drawString("500", xcntr + (500 / 6), ymax - 10);
        g.drawLine(xcntr + (500 / 6), ymax - 10, xcntr + (500 / 6), ymax - 5);
        g.drawString("0", xcntr, ymax - 10);
        g.drawLine(xcntr, ymax - 10, xcntr, ymax - 5);
        g.drawString("-500", xcntr - (500 / 6), ymax - 10);
        g.drawLine(xcntr - (500 / 6), ymax - 10, xcntr - (500 / 6), ymax - 5);
        g.drawString("-1000", xcntr - (1000 / 6), ymax - 10);
        g.drawLine(xcntr - (1000 / 6), ymax - 10, xcntr - (1000 / 6), ymax - 5);
        g.drawString("-1500", xcntr - (1500 / 6), ymax - 10);
        g.drawLine(xcntr - (1500 / 6), ymax - 10, xcntr - (1500 / 6), ymax - 5);
        g.drawString("-2000", xcntr - (2000 / 6), ymax - 10);
        g.drawLine(xcntr - (2000 / 6), ymax - 10, xcntr - (2000 / 6), ymax - 5);
        g.drawString("-2500", xcntr - (2500 / 6), ymax - 10);
        g.drawLine(xcntr - (2500 / 6), ymax - 10, xcntr - (2500 / 6), ymax - 5);
        g.drawString("-3000", xcntr - (3000 / 6), ymax - 10);
        g.drawLine(xcntr - (3000 / 6), ymax - 10, xcntr - (3000 / 6), ymax - 5);
        g.drawString("-3500", xcntr - (3500 / 6), ymax - 10);
        g.drawLine(xcntr - (3500 / 6), ymax - 10, xcntr - (3500 / 6), ymax - 5);
 
        /* Drawing Y axis. */
        g.drawLine(0 + 9, 0 + 9, 0 + 9, ymax - 9);
        g.drawString("2500", 0 + 10, ycntr - (2500 / 6));
        g.drawLine(0 + 10, ycntr - (2500 / 6), 0 + 5, ycntr - (2500 / 6));
        g.drawString("2000", 0 + 10, ycntr - (2000 / 6));
        g.drawLine(0 + 10, ycntr - (2000 / 6), 0 + 5, ycntr - (2000 / 6));
        g.drawString("1500", 0 + 10, ycntr - (1500 / 6));
        g.drawLine(0 + 10, ycntr - (1500 / 6), 0 + 5, ycntr - (1500 / 6));
        g.drawString("1000", 0 + 10, ycntr - (1000 / 6));
        g.drawLine(0 + 10, ycntr - (1000 / 6), 0 + 5, ycntr - (1000 / 6));
        g.drawString("500", 0 + 10, ycntr - (500 / 6));
        g.drawLine(0 + 10, ycntr - (500 / 6), 0 + 5, ycntr - (500 / 6));
        g.drawString("0", 0 + 10, ycntr);
        g.drawLine(0 + 10, ycntr, 0 + 5, ycntr);
        g.drawString("-500", 0 + 10, ycntr + (500 / 6));
        g.drawLine(0 + 10, ycntr + (500 / 6), 0 + 5, ycntr + (500 / 6));
        g.drawString("-1000", 0 + 10, ycntr + (1000 / 6));
        g.drawLine(0 + 10, ycntr + (1000 / 6), 0 + 5, ycntr + (1000 / 6));
        g.drawString("-1500", 0 + 10, ycntr + (1500 / 6));
        g.drawLine(0 + 10, ycntr + (1500 / 6), 0 + 5, ycntr + (1500 / 6));
        g.drawString("-2000", 0 + 10, ycntr + (2000 / 6));
        g.drawLine(0 + 10, ycntr + (2000 / 6), 0 + 5, ycntr + (2000 / 6));
        g.drawString("-2500", 0 + 10, ycntr + (2500 / 6));
        g.drawLine(0 + 10, ycntr + (2500 / 6), 0 + 5, ycntr + (2500 / 6));
    }
    
    private void drawPlots(Graphics g) {
        
        int[][] theArray;
        
        theArray = drop.take();
        for(int i = 0; i < 681; i++) {
            g.drawOval((theArray[i][0] / 6) + xcntr, (theArray[i][1] / 6) + ycntr, 1, 1);
        }
    }
    
    public void update(Graphics g) {
        
        paintComponent(g);
    }
    
    public void paintComponent(Graphics g) {
        
        super.paintComponent(g);
        Dimension d;
        
        d = getSize();
        xmax = d.width - 1;
        ymax = d.height - 1;
        xcntr = xmax / 2;
        ycntr = ymax / 2;
        g.setColor(Color.BLACK);
        drawLayout(g);
        g.setColor(Color.RED);
        drawPlots(g);
    }
    
    public void run() {
        
        while(true) {
            repaint();
            try {
                Thread.currentThread().sleep(rand.nextInt(5000));
            } catch(InterruptedException ex) { ex.printStackTrace(); }
        }
    }
 
    private void threadMessage(String message) {
        
        String threadName = Thread.currentThread().getName();
        System.out.format("%s: %s%n", threadName, message);
    }
}
 
/*----------------------------------------------------------------------------*/
 
class Producer implements Runnable {
    
    private static Drop drop;
    private static Random rand = new Random();
 
    public Producer(Drop drop) {
        
        this.drop = drop;
    }
 
    public void run() {
        
        double ALPH;
        int yCor;
        int xCor;
        int r;
        int[][] theArray;
        
        theArray = new int[681][2];
        while(true) {
            for(int i = 1; i <= 5; i++) {
                r = i * 500;
                for(int n = 0; n < 681; n++) {
                    ALPH = (double)n * (2 * Math.PI / 680);
                    xCor = (int)((double)r * Math.cos(ALPH));
                    yCor = (int)((double)r * Math.sin(ALPH));
                    theArray[n][0] = xCor;
                    theArray[n][1] = yCor;
                }
                drop.put(theArray);
                try {
                    Thread.currentThread().sleep(rand.nextInt(5000));
                } catch(InterruptedException ex) { ex.printStackTrace(); }
            }
        }
    }
 
    private void threadMessage(String message) {
        
        String threadName = Thread.currentThread().getName();
        System.out.format("%s: %s%n", threadName, message);
    }
}
 
/*----------------------------------------------------------------------------*/
 
class Drop {
    
    //True if consumer should wait for producer to send message, false
    //if producer should wait for consumer to retrieve message.
    private boolean empty = false;
 
    public synchronized int[][] take() {
        
        ObjectInputStream inNetStream = null;
        ServerSocket servsoket = null;
        Socket soket = null;
        int PORT = 4444;
        int[][] theArrayTake = new int[681][2];
        
        //Wait until message is available.
        if(empty) {
            while(empty) {
                try {
                    wait();
                } catch(InterruptedException e) {}
            }
        }
        //Toggle status.
        empty = true;
        
        threadMessage("Entering take...");
        threadMessage("Receiving theArray...");
        try {
            servsoket = new ServerSocket(PORT);
            soket = servsoket.accept();
            inNetStream = new ObjectInputStream(soket.getInputStream());
            theArrayTake = (int[][])inNetStream.readObject();
            inNetStream.close();
            soket.close();
            servsoket.close();
        } catch(ClassNotFoundException ex) { ex.printStackTrace();
        } catch(IOException ex) { ex.printStackTrace(); }
 
        //Notify producer that status has changed.
        notifyAll();
        threadMessage("Exiting take...");
        return theArrayTake;
    }
 
    public synchronized void put(int[][] theArrayPut) {
        
        ObjectOutputStream outNetStream = null;
        Socket soket = null;
        String AITEPC = "LapPC1";
        int PORT = 8020;
        
        //Wait until message has been retrieved.
        if(!empty) {
            while(!empty) {
                try { 
                    wait();
                } catch(InterruptedException e) {}
            }
        }
        //Toggle status.
        empty = false;
        
        threadMessage("Entering put...");
        threadMessage("Sending theArray...");
        try {
            soket = new Socket(AITEPC, PORT);
            outNetStream = new ObjectOutputStream(soket.getOutputStream());
            outNetStream.writeObject(theArrayPut);
            outNetStream.flush();
            outNetStream.close();
            soket.close();
        } catch(UnknownHostException ex) { ex.printStackTrace();
        } catch(IOException ex) { ex.printStackTrace(); }
        
        //Notify consumer that status has changed.
        notifyAll();
        threadMessage("Exiting put...");
    }
 
    private void threadMessage(String message) {
        
        String threadName = Thread.currentThread().getName();
        System.out.format("%s: %s%n", threadName, message);
    }
}

[Aji Prasetyo]

I almost forgot,

Java.net.ConnectException: Connection refused: connect
at testproducerconsumer.Drop.put(ProducerConsumerApplet.java:348)
at testproducerconsumer.Producer.run(ProducerConsumerApplet.java:266)

By the way,
testproducerconsumer.Drop.put(ProducerConsumerApplet.java:348) is this line:

soket = new Socket(AITEPC, PORT);

testproducerconsumer.Producer.run(ProducerConsumerApplet.java:266) is this line:

drop.put(theArray);

Thank you.

[Aji Prasetyo]

Let me rephrase my question,

how to make Socket(); which sends something, first waits for ServerSocket() to become available and ready to receive, then actually sends the objects.

or "How to guarantee that ServerSocket() is ready to receive by the time Socket() is sending in any transfer rate?"

I believe there should be some coding techniques for this matter.

Thank you so much beforehand.

[Stan James]

Catch the exception and try again is all that comes to mind. Did you write the server side, too? Any idea why it's not accepting connections?

[Nicholas Jordan]

/**
* Aji, try: ServerSocketChannel.java
*
* This seems to be recurrent, I believe:
*
* Windows, I/O is not interruptable. I/O and Streams 15 Friday, April 20, 2007 Nicholas Jordan
*
*
* A selectable channel for stream-oriented listening sockets is necessary
* for a reasonably efficient solution, you are using a socket from java.net
* which may be single threaded.
*
* Server-socket channels are not a complete abstraction of listening
* network sockets. Binding and the manipulation of socket options must be
* done through an associated {@link java.net.ServerSocket} object obtained by
* invoking the {@link #socket() socket} method. It is not possible to create
* a channel for an arbitrary, pre-existing server socket, nor is it possible
* to specify the {@link java.net.SocketImpl} object to be used by a server
* socket associated with a server-socket channel.
*
* A server-socket channel is created by invoking the {@link #open() open}
* method of this class. A newly-created server-socket channel is open but not
* yet bound. An attempt to invoke the {@link #accept() accept} method of an
* unbound server-socket channel will cause a {@link NotYetBoundException} to
* be thrown. A server-socket channel can be bound by invoking one of the
* {@link java.net.ServerSocket#bind(java.net.SocketAddress,int) bind} methods
* of an associated server socket.
*
* Server-socket channels are safe for use by multiple concurrent threads.
* ServerSocket.java may not be, in which idea would explain your question.
*/

Another thing I see is doing calcs in a paint method:

  d = getSize();
  xmax = d.width - 1;
  ymax = d.height - 1;
  xcntr = xmax / 2;
  ycntr = ymax / 2;
  g.setColor(Color.BLACK);
  drawLayout(g);
  g.setColor(Color.RED);
  drawPlots(g);

Don't call repaint from run, it does not make good design sense to put it there. What you do is after doing calcs, call a method that informs the OS that you would like to call paint at the next redraw. One would not call paint in this program.

Also, be though it not Saloon coding convention, I would code your Drop::run like this.

class Drop implements Runnable
{
    boolean available;
    boolean input;
    int[][] localCopyofData
   
    Drop(int[][] data)
    {
        available= Server.requestSend();//query server in constructor
    }
    
    //......
    public int send()
    {
        // availability should have been checked in constructor
        if(avialable) 
        {
           //.... much code omitted
           servsoket = new ServerSocket(PORT);
           //.... much code omitted
           while(( i < localCopyofData.length) && ( j < localCopyofData[0].length))
           servsoket.transmit(localCopyofData[i++][j++]);
        }
    public void run()
    {
        while(input)
        {
        if(available)send();else wait(timeout);
        catch( ex ){ uh, oh - error}
        }
    }
}

Also, you have your //Toggle status. reversed

//Wait until message has been retrieved. is in the wrong place as I see the problem description.

The wait loop is not coded properly by my estimation.

Much of your code concerns its authorship as the writer of the applet, and as Stan James states:  Did you write the server side, too ?

How the server runs has a lot to do with how the client is coded, is this a problem in a student lab where you have the ablilty to write according to what an instructor tells you ?

If not, is it on your own machine ? You can write a server that runs on your own maching, and by writing both sides of the transaction .... gain a much better foothold on the answer to your question.

In general, you would code a server thus:

accept()
{
    Thread t = new Thread(Handler);
    t.start();
    return;
}

Looking in the spec's it says:

/**
* Sets the server socket implementation factory for the
* application. The factory can be specified only once.
* <p>
* When an application creates a new server socket, the socket
* implementation factory's <code>createSocketImpl</code> method is
* called to create the actual socket implementation.
* <p>
* Passing <code>null</code> to the method is a no-op unless the factory
* was already set.
*/

It is very convouted to dig the logic out of OO coding practices. You just have a knotty problem, you must be willing to stay with it for us to help you.

Yes: ... guarantee that server is ready to receive by the time Socket() is sending.
And: ...... believe there should be some coding techniques for this matter.

What I do is just keep reading and writing code, much of it seems to come to understanding before long time running.

[ September 21, 2007: Message edited by: Nicholas Jordan ]
[ September 22, 2007: Message edited by: Nicholas Jordan ]

[Aji Prasetyo]

Thank you guys for your reply.

The server side code is exactly the same code as the one I already included last time. the different is only at the

private boolean empty = false;

the server side code is "true".

Thanks for the advice regarding where to call repaint() method. I have change it into

SwingUtilities.invokeLater(new Runnable(){
    public void run(){
        repaint();
    }
});

thanks for the code, but I don't want to send request to the server. you see the program I am coding is always sends packet to the other side (server to client and then client to server) periodically.

I think I am gonna try to catch the exception and try to send again. by the way, what kind of exception should I expecting for this matter?

Thank you so much.

[Nicholas Jordan]

Originally posted by Aji Tanaka:
Thank you guys for your reply.

No problem, that's what we're here for.

[Aji Tanaka:]The server side code is exactly the same code as the one I already included last time. the different is only at the ...(lost quote in pasting) ...


That simplifies working the issue enormously, just make the booean source/sink | client/server | producer/consumer (or whatever it is you wish to test) a boolean that is set in the constructor. In simplified form, your immediate coding challenges would be more effectively analyzed by what is called the Model/View/Controller approach. There are many staunch supporters of that approach here, and until one of them speaks up, I suggest moving all of your calcs and data into the data model ~ make all your paint and it's descendent forms a call into the data model that gets a precomputed array, or any other data container you may use, where all the   g.drawRect(xcntr - 5, ycntr - 5, 10, 10);   and g.drawRect(xcntr - 5, ycntr - 5, 10, 10); and g.drawOval((theArray[i][0] / 6) + xcntr, (theArray[i][1] / 6) + ycntr, 1, 1);are already done. You stay on top of what's where by using a controller class. I suggest this is where you put your main() ---> that is what worked for me.

With your calculations and data in the same class, you could put calculations in a run() method, taking some sort of wait() or sleep() to make the screen run at a visible update rate. This would have to be a loop to work, and would be run using a thread constructor for that class, but the calcs should run independently of the screen redraw.

Because you have the sources for both sides, you can run both sides in one process, using two threads -- it will make the machine run much better and is useful because you can experiment and examine changes of approach and changes of coding method, as well as thought models such as Model, View Controller || Producer, consumer || Back of envelope scrawling very effectively and rapidly. One problem solution tool called "Full-Tilt-Boogie" says to have a record player running while you work on the code.

{ }


[Aji Tanaka:]Thanks for the advice regarding where to call repaint() method. I have change it into SwingUtilities.invokeLater

Swing should have an overloaded draw line that takes a Pair of Points or something, these are easy to write, given a Base Class that does something useful, you just update an array of points or Rectangles or something, like this:

package demo;
 
import java.awt.geom.Line2D ;//
import java.util.Vector;
/*
 * Distribution under the Whiskey License.
 * See: <a href="http://java.sun.com/j2se/1.3/docs/api/java/util/Vector.html" target="_blank" rel="nofollow">http://java.sun.com/j2se/1.3/docs/api/java/util/Vector.html</a>
 */
 
 public class Victor extends Vector
 {
     Victor(int numberOfLines) throws EmptyGrapicException
     {
         /**
         * If superclass constructor throws,
         * it cannot be caught at the call to super()
         */
         super(numberOfLines);//
         if(numberOfLines > 0 )
         {
             int index = 0 ;
             do
             {
                 add
                 (
                     new Line(new Point(00.00f,00.00f),new Point(00.00f,00.00f))
                 );
             }while(++index < numberOfLines);
         }
     if(size() < numberOfLines)throw new EmptyGrapicException( Integer.toString(size()));//
     }
     // public Line getLine(int lineNumber){return super.get((Object)lineNumber) ;}//
 }
 class Line
 {
     Point p1,p2;
     Line(Point p1, Point p2)
     {
         this.p1 = p1;//
         this.p2 = p2;//
     }
 }
 class Point
 {
     float x,y;
     Point(float xin , float yin)
     {
         x = xin;
         y = yin;
     }
 }
class EmptyGrapicException extends Exception
{
    EmptyGrapicException(){super();}
    EmptyGrapicException(String s){super(s);}
}
 //eof

I commented out the get (accessor method) because I could not get it to compile. There are a great number of OO proponents here who could get the public Line getLine to work. The code provided here would solve the fixed array bounds problem by making the base class a Vector instead of using an array to hold the points and lines.

Have you run into that yet ?

Put repaints at the end of recalculation, probably doing it the way you cite. What that will allow is convoluted to explain, diecy to work out and just let that invoke later thing do it.

ji Tanaka:] .... I don't want to send request to the server. you see the program I am coding is always sends packet to the other side (server to client and then client to server) periodically.


Just put them in the same call from main, done twice: Once with a boolean true, the next call with the boolean false. Interprocess communication is not the way to go to get one of these things going. Threads can represent each end of the pipe, or channel or Socket Reguest or what ever you model it as in your Program Concept. Just call what you want the client or server to do from a method called run(), then do:

PrimeRib prServer = new PrimeRib(true);
new Thread(prServer).start();
PrimeRib prClient = new PrimeRib(false);
new Thread(prClient).start();

from main(), it will look screwy the first time you run it - and may even hang, but that is a million miles away from trying to develop on a server that is miles away and owned by someone else. Read about servlets, we have a forum here at the Ranch devoted to Servlets. There is a book by Marty Hall that is really really good, but remember to put synchronized anywhere you can in your development code: The compiler will remove any synchronized objects and so on that are not needed. For this level and type of prototyping ... it is often better not to synchronize the access to the data objects because all that happens is that you can see the machine running as it draws the screen, very useful in prototyping.

[Aji Tanaka::]I think I am gonna try to catch the exception and try to send again. by the way, what kind of exception should I expecting for this matter?

Do not program by exceptions, use them to recover from exceptions:

try{y = x / 0;}catchDivideByZeroException{y = 0;}

Here, exection continues after setting y to some sane value. Maybe it should be Float.POSITIVE_INFINITY or +1 or something. Just figure it out. Write your own exception class, as I did. Check with an if(condition) before entry and bailout in an else if things are not in a fixable scope.



[ Message edit by Nicholas Jordan: I have been thinking about this all week - you can use a static synchronized method to simulate a data transmission line. There is some tricky boolean logic to evaluate, but send/receive client/server source/sink evaluation would be greatly simplified by a static synchronized method.]
[ September 29, 2007: Message edited by: Nicholas Jordan ]