Stop a socket listening thread?

Question

Hi all,
I'm a newbie at java socket programming, and i have a problem in implementing realibility over UDP.
This is the pseudocode of my program.
class ChatProtocol
     DatagramSocket socket;
     Thread alwaysListeningSocket;
     public ChatProtocol(parameter)
          // Some setting up
]          this.alwaysListeningSocket = this;
     public void run()
          DatagramPacket packet = new DatagramPacket(parameter);
          socket.receive(packet);
          .     // Process the incoming messages
     public void send(message)
          // Chunking the message into datagramPackets[]
          // Thread for listening for acknowledgement for each will-be-sent packets
          Thread ackListener = new Thread(new Runnable()
               public void run()
                    DatagramPacket ackPacket = new DatagramPacket(parameter);
                    socket.receive(ackPacket);
                    .     // Processing the acknowledgement
          ackListener.start(); // Start listening for ack
          for (int i = 0; i < datagramPackets.length; i++)
               socket.send( datagramPacktes[i] );
          .     // Another process
}I have an always listening socket in my program, which is done by invoking socket.receive() inside a thread
And i have a send method, which will send messages thorugh the same socket.
The problem is, i have to listen for acknowledgement for each sent packets through the same socket.
This is done by invoking socket.receive(), but if i want to invoke this method, i have to stop the previous thread first.
Is this possible, since stop() method in Thread class is deprecated?

Answer 1

So you can't predict the ordering of ACKs and other messages. You can't even predict the ordering of ACKs even if there are np other messagesI have a sequence number put into the datagram packets.
This is the format of my packets.
Packet length 16 bytes, consist of :
- Packet type, 1 byte (This will determine if the packets is a message or an ack).
- Sequence number, 1 byte.
- Payload 14 bytes.
If the receiving socket receive a wrong type of packets (ack instead of message, vica versa), the receiver thread will just drop it.
And in both cases why start another thread to receive the ACK instead of receiving it in the thread that did the send()? This makes even less sense.By 'receiving it in the thread that did the send()', do you mean that i should put it in the send() method block?
I pressume that an ack may come before the process finish sending the messages. I put it into a thread so that the process can receive ack while sending another messages.
It is not important though, because the number of packets that will be sent is relatively small. Should i just change it?
So, rethink. I would say that your always-listening socket should listen in a single thread for all messages, and notify sending threads about the acknowledgements some other way, e.g. via some data structure. You need that anyway to overcome the lack of ordering among ACKs. You need to associate each sent message that has an ACK outstanding with the thread that sent it, and when it arrives, notify that thread; have the sending thread wait(), almost certainly with a timeout, for that notification, and resend if necessary, adjusting the data structure appropriately so that a late ACK to the previous send is ignored. Or whatever is appropriate to your application protocol.I'll try to redesign my protocol. Thanks for the tips !
I'm not very good at English. Sorry if i misunderstood you in some way.