I have a very strange problem - A can listen on B, but B cannot listen on A

Question

Hello!
I have a very disturbing problem.
I have done a Paint-like program that add Point-objects on the JFrame. This porgram is networked and it contains a thread class that is sending the Point and a thread class that recieves Point objects. That makes it possible to open two instances of the program and when you paint on one of the windows, the program will send the point coordinats through a DatagramPacket to the other window. So, to make this clear, this program has ONE Sending class called Client and ONE Receiving class called Server. So when you want to make a connection, then you have to open two instances of the program.
So what is the problem?
Suppose that I have opened two instances of the program. Instance A is sending packets to port 2001 and is listening for packets on port 2000. Instance B is sending packets to port 2000 and is listening for packets on port 2001.
When I draw a point on Instance A's window, the Instance B is receiving the point and draws the point on its window.
When I draw a point on Instance B's window, the Instance A is NOT receiving the point. Instance B is listening on itself. That is the problem. Why is instance B listening for packets from itself and why doesn´t A get B's packets when B gets A's packets?
Here is the send och receive classes (called Client and Server):
class Client extends Thread
            Point p;
            Client(Point p)          
                 this.p = p;
            public void run()
                 System.out.println("Sending");
                 try
                      InetAddress toHost = InetAddress.getLocalHost();                     
                      int port = 2000;                    
                      DatagramSocket sock = new DatagramSocket();                                                   
                      String message = Integer.toString(p.x) + " " + Integer.toString(p.y);                         
                      byte[] data = message.getBytes();                    
                      DatagramPacket p = new DatagramPacket(data, data.length, toHost, port);     
                      sock.send(p);                                                                                
                 catch(SocketException se){}
                 catch(IOException ioe){}
                 catch(ConcurrentModificationException cme){}
class Server extends Thread               
            String message;
            String[] xy;
            public void run()
                 System.out.println("Receiving");
                 try
                      byte[] data = new byte[8192];
                      DatagramPacket packet = new DatagramPacket(data, data.length);
                      DatagramSocket sock = new DatagramSocket(2001);
                      while(true)     
                           sock.receive(packet);                                                                                            
                           message = new String(packet.getData(), 0, packet.getLength());                                          
                           xy = message.split(" ");                                                                 
                           Point p = new Point(Integer.parseInt(xy[0]), Integer.parseInt(xy[1]));          
                           addPoint(p);                                                                                               
                 catch(SocketException se){}
                 catch(IOException ioe){}
                 catch(ConcurrentModificationException cme){}
  }I have tried to solve this for hours but I have not found any solution.
Please, help!

Answer 1

Here is an executable example.
1. To run the first instance: Compile the code and run the application and note that it is listening on port 2000 and sending through port 2001
2. To run the second instance: Change the ServerSocket to listen on port 2001 and the DatagramSocket to send through port 2000 and compile and run the application.
3. Tell me this: Why does the first instance listen from DatagramPackets from itself and not from the other running instance while the other running instance is listening for DatagramPackets sent from the first instance? The one who can give me the answer will be the man of the month.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
import java.lang.Thread;
import java.net.*;
import java.net.DatagramPacket;
import java.io.*;
public class Paint extends JFrame
     private Board b = new Board();
     public static void main(String[] args)
          new Paint();
       public Paint()
          setDefaultCloseOperation(EXIT_ON_CLOSE);
          getContentPane().add(b, BorderLayout.CENTER);
          addKeyListener(new ChangeSizeListener());
          setSize(300, 300);
          setVisible(true);
          setFocusable(true);
       class ChangeSizeListener extends KeyAdapter
          Board b = new Board();
          public void keyPressed(KeyEvent e)
               if(KeyEvent.getKeyText(e.getKeyCode()).equalsIgnoreCase("s"))
                    try
                           int size = Integer.parseInt(JOptionPane.showInputDialog(null, "New size:", "Size", 3));
                           b.setSize(size);
                    }catch(NumberFormatException nfe){}
class Board extends JPanel
     Point p;
       private HashSet hs = new HashSet();
       int size_x;
       int size_y;
          public Board()
               size_x = 20;
               size_y = 20;
               setFocusable(true);
               setBackground(Color.white);
               addMouseListener(new L1());
               addMouseMotionListener(new L2());
               Server s = new Server();
               s.start();
          public void paintComponent(Graphics g)
               super.paintComponent(g);
               g.setColor(Color.black);
               Iterator i = hs.iterator();
               while(i.hasNext())
                 p = (Point)i.next();
                 g.fillOval(p.x, p.y, size_x, size_y);
         private void addPoint(Point p)
               hs.add(p);
               repaint();
         public void setSize(int size)
                this.size_x = size;
                this.size_y = size;
                repaint();
       class L1 extends MouseAdapter
            public void mousePressed(MouseEvent me)
                Client c = new Client(me.getPoint());
                 addPoint(me.getPoint());
                  c.start();
       class L2 extends MouseMotionAdapter
            public void mouseDragged(MouseEvent me)
                 Client c = new Client(me.getPoint());
                  addPoint(me.getPoint());
                  c.start();
       class Client extends Thread
            Point p;
            Client(Point p)
                 this.p = p;
            public void run()
                 System.out.println("Sending");
                 try
                      InetAddress toHost = InetAddress.getLocalHost();
                      int port = 2000;                 // After running a first instance of the application, change the port to listen on 2001
                      DatagramSocket sock = new DatagramSocket();
                      String message = Integer.toString(p.x) + " " + Integer.toString(p.y);
                      byte[] data = message.getBytes();
                      DatagramPacket p = new DatagramPacket(data, data.length, toHost, port);
                      sock.send(p);
                 catch(SocketException se){}
                 catch(IOException ioe){}
                 catch(ConcurrentModificationException cme){}
       class Server extends Thread
            String message;
            String[] xy;
            public void run()
                 System.out.println("Receiving");
                 try
                      byte[] data = new byte[8192];
                      DatagramPacket packet = new DatagramPacket(data, data.length);
                      DatagramSocket sock = new DatagramSocket(2001);              // After running a first instance of the application, change the DatagramSocket to listen on port 2000
                      while(true)
                         sock.receive(packet);
                         message = new String(packet.getData(), 0, packet.getLength());
                         xy = message.split(" ");
                         Point p = new Point(Integer.parseInt(xy[0]), Integer.parseInt(xy[1]));
                         addPoint(p);
                 catch(SocketException se){}
                 catch(IOException ioe){}
                 catch(ConcurrentModificationException cme){}
}