Java 代理之间的确认消息

我有一个

发送方

，它从一个文件中读取并将每一行发送给

接收方

代理

通常，我希望我的

接收者

代理为收到的每一行发送确认，而

发送者

代理将被阻止（或等待），直到收到确认

这是

发送方

代理的快照代码

private volatile boolean recieved = false;
// Codes and 

            while ((line = bufferedReader.readLine()) != null) {
                // SENDING LINES ...
                String Agentname="Sender";
                ACLMessage aclMessage= new ACLMessage(ACLMessage.CONFIRM);
                aclMessage.addReceiver(new AID(Agentname,AID.ISLOCALNAME));
                aclMessage.setContent(line);
                send(aclMessage);
                if (isRecieved() == false ) { block(); return; }
                System.out.println("Value after "+isRecieved());
            } 

要接收ACL消息，请执行以下操作：

                    if (msg == null) {
                        block();
                        return;
                    }
                    else {

                        switch (msg.getPerformative()) {
// Other cases
                        case ACLMessage.INFORM:
                            System.out.println("Confirmation");
                            setRecieved(true);
                            break;

                        default:
                            break;
                        }

接收方代理在接收到消息时会发送确认消息

                case ACLMessage.CONFIRM:

                    // Process the results
                    String result = doNormalize (msg.getContent());
                    if (result!=null) {
                        //send the results to the writer
                        ACLMessage aclMessage= new ACLMessage(ACLMessage.CONFIRM);
                        aclMessage.addReceiver(new AID("Writer",AID.ISLOCALNAME));
                        aclMessage.setContent(result);
                        send(aclMessage);

// Sends a confirmation to using the method sendConfirmation
                        sendConfirmation(msg);
                    }
                    break;

                default:
                     break;
                    }
    // Code ..
    // ..
   // ..
   // ..

    public void sendConfirmation(ACLMessage aclMessage) {
    ACLMessage message = aclMessage.createReply();
    message.setPerformative(ACLMessage.INFORM);
    send(message);
}

因此，发送方使用一个标志值来帮助确定是否收到确认。为此，它使用

isRecieved（）

方法，如果该方法为false，则理想情况下应该阻止代理并等待确认消息

---

问题是当我运行代码时，

发送方

在

received（）==false

为

true

时被阻止，但它在收到确认时不会恢复

而
循环。我做错了吗？
我会用switch语句来做这种行为，比如：

public class ReadBehaviour extends Behaviour {
   private boolean isDone = false;
   private int step = 0;
   private BufferedReader bufferedReader;

   @Override
   public void action() {
       switch (step){
           case 0:
               // TODO initialize your bufferedReader
               step++;
               break;
           case 1:
               try {
                   String line = bufferedReader.readLine();
                   if(line == null){
                       isDone = true;
                   } else {
                       ACLMessage aclMessage= new ACLMessage(ACLMessage.CONFIRM);
                       aclMessage.addReceiver(new AID("Sender", AID.ISLOCALNAME));
                       aclMessage.setContent(line);
                       myAgent.send(aclMessage);
                       step++;
                   }
               } catch (IOException e) {
                   isDone = true;
               }
               break;
           case 2:
               if(isRecieved()){
                   step--;
               } else {
                   block();
               }
       }
   }

   @Override
   public boolean done() {
       return isDone;
   }
}

            while ((line = bufferedReader.readLine()) != null) {
                // SENDING EVENT LINES ...
                String Agentname="Reciever";
                ACLMessage aclMessage= new ACLMessage(ACLMessage.CONFIRM);
                aclMessage.addReceiver(new AID(Agentname,AID.ISLOCALNAME));
                aclMessage.setContent(line);
                send(aclMessage);
                // Block an Agent until a confirmation is received..
                ACLMessage aclMessage2 = blockingReceive(mt);
            }

要阻止代理行为，有多种方法：


receive（）
-非阻塞接收，返回队列中的第一条消息，如果队列为空，则返回
null
receive（MessageTemplate模式）
-与上一个模式类似，但您也可以为消息指定模式，例如特定的发送者帮助、会话ID以及组合
blockingReceive（）
-阻止接收，阻止代理，直到消息出现在队列中
阻止接收（MessageTemplate模式）
-阻止接收，带有模式

因此，添加
blockingReceive（）
或
blockingReceive（MessageTemplate模式）
会阻止代理的
行为
，直到收到某条消息为止。看起来是这样的：

public class ReadBehaviour extends Behaviour {
   private boolean isDone = false;
   private int step = 0;
   private BufferedReader bufferedReader;

   @Override
   public void action() {
       switch (step){
           case 0:
               // TODO initialize your bufferedReader
               step++;
               break;
           case 1:
               try {
                   String line = bufferedReader.readLine();
                   if(line == null){
                       isDone = true;
                   } else {
                       ACLMessage aclMessage= new ACLMessage(ACLMessage.CONFIRM);
                       aclMessage.addReceiver(new AID("Sender", AID.ISLOCALNAME));
                       aclMessage.setContent(line);
                       myAgent.send(aclMessage);
                       step++;
                   }
               } catch (IOException e) {
                   isDone = true;
               }
               break;
           case 2:
               if(isRecieved()){
                   step--;
               } else {
                   block();
               }
       }
   }

   @Override
   public boolean done() {
       return isDone;
   }
}

            while ((line = bufferedReader.readLine()) != null) {
                // SENDING EVENT LINES ...
                String Agentname="Reciever";
                ACLMessage aclMessage= new ACLMessage(ACLMessage.CONFIRM);
                aclMessage.addReceiver(new AID(Agentname,AID.ISLOCALNAME));
                aclMessage.setContent(line);
                send(aclMessage);
                // Block an Agent until a confirmation is received..
                ACLMessage aclMessage2 = blockingReceive(mt);
            }

所有的东西都在一个线程上运行吗？你能给出发送代码吗？是的，一个线程上的所有内容。发送代码是Jade提供的默认发送方法。如果所有内容都在一个线程上运行，那么为什么需要阻塞机制，因为没有其他线程会“唤醒”它们？block（）会将该行为暂停，直到收到下一条消息。这就是为什么我们在接收ACLMessages时使用：if（msg==null）{block（）；return；}。发送方的行为是具有循环的OneShotBehaviour还是CycleBehaviour？