如何让线程在特定时间等待通知，并根据是否收到通知执行代码？

Question

我正在尝试实现一些UDP的变体。

服务器线程接收数据报数据包，对其进行解析，并将其传递给相应的线程。如果它收到一条消息，它会回复一条确认消息，并将其传递给ReceiveMessage线程，该线程会在屏幕上打印该消息。

我有一个SendMessage线程和一个ReceiveMessage线程。

我希望SendMessage线程发送一个数据包，并在特定的超时时间内等待确认。如果服务器收到确认，我想向SendMessage发送notify（），如果没有，我想让SendMessage线程超时，并在这两种情况下执行不同的代码。我怎样才能做到这一点？

public class ListenThread extends Thread{

protected DatagramSocket socket = null;
protected Boolean on = true;
protected String id;
protected HashMap <String,Contact> people = null;
protected String user;


public ListenThread(String macadd, String user, HashMap <String, Contact> people) throws SocketException
{
    super("ListenThread");
    this.socket = new DatagramSocket(3333);
    this.id=macadd;
    this.people = people;
    this.user = user;
}

@Override
public void run()
{


    while (on) 
            {

                byte[] buf = new byte[256];
                try{
                        // receive request
                        DatagramPacket packet = new DatagramPacket(buf, buf.length);
                        socket.receive(packet);

                        String packdetails[] = new String(packet.getData(), 0, packet.getLength()).split(":");//Important part of receiving request. Tool used to parse the request
                        InetAddress address = packet.getAddress();

                        if(packdetails[0].equals("D"))  // if it's a Detection Packet                   
                        {/* Handle what to do with Detection packets */
                            }// end of small if
                        }//end of big if
                        else if(packdetails[0].equals("M"))// implies, Message type packet
                        {
                            Timestamp t =new Timestamp(new Date().getTime());
                            //Send Acknowledgement
                            String PString = new String("A:"+id);
                            buf = PString.getBytes();
                            packet = new DatagramPacket(buf, buf.length, address, 3333);

                            new ReceiveMessage(packdetails, address, people, t).start();
                        }
                        else// if it's an acknowledgemnt
                        {
                            //notify the sendmessage thread
                        }
                    }//end of try
                    catch (UnknownHostException e) 
                    {
                        System.err.print("Unable to find IP of current machine");
                    }
                    catch (IOException except)
                    {
                        System.err.print("Network Problem : Unable to send packets!");
                    }
            }//end of while
    }//end of run

}//课程结束

public class SendMessage extends Thread{
protected Contact person = null;
protected String Message = null;

public SendMessage(Contact person, String Message)
{
    this.person=person;
    this.Message= Message;
}
@Override
public void run()
{
    System.out.println(person.getusername()+": "+Message);
    try
    {
        person.SendMessage(Message);
        Thread.currentThread().wait(500);// If i get notify => received acknowledgement
    }
    catch(IOException e)
    {
        System.err.println("Unable to send message!");
    }
    catch (InterruptedException e)
    {
        System.err.print("Woken before receiving notify");
    }
}

Answer 1

有很多方法可以实现这一点，您可以选择CountDownLatch或CyclicBarrier，其中发送方线程将等待接收方对屏障进行操作。另一种选择是，接收方线程将ack消息放入blockingQueue，发送方可以在等待队列时使用队列中的ack。

Answer 2

使用条件。等待（超时，…） 而不是对象。等待（）