Java-仅执行一次方法

Question

I have a simple problem:

Class A{

    B b;

    public void doSth{ 
         //This method should execute only once
         b.modify(); //calls doSth() again...
    }
}

As the program runs, an instance of A is passed to B, and B calls doSth (as a callback for instance). b.modify makes B to call A.doSth() again, which will infinite sequence of calls. What I want to achieve is this: I want to execute doSth() once, modify B, then upon next execution somehow stop the chain of inifinite calls and do not execute b.modify .

Any suggestions greatly appreciated.

Answer 1

Add a state flag to your class:

Class A {

    B b;
    private volatile boolean called;

    public synchronized void doSth { 
         if (called) return;
         called = true;
         b.modify();
    }
}

Use volatile if multiple threads are in play.

Answer 2

You can have a boolean field and set it true the first time you call the method.

Class A{
    boolean isModified = false;
    B b;

    public void doSth{ 
        if(!isModified) {
            this.isModified = true;
            b.modify();
        }
    }
}

Answer 3

I'd try to find a solution that doesn't involve circular dependencies. Do A and B really have to reference eachother? On a higher level, what are you trying to achieve? Could you post some client code using A and B objects?

Answer 4

Add a boolean alreadyExecuted to class A and modify the implementation of doSmth() to

 public void doSth{ 
     if(!alreadyExecuted){
         alreadyExecuted = true; 
         b.modify(); 

     }
}

Answer 5

Consider this as a Hack...

Use boolean variable

Class A{

    B b;
    public isOk = true;

    public void doSth{ 

        if (isOk){

         b.modify(); 
         isOk = false;

        }

}

Answer 6

maybe you should change design to not call those method recursively, or if you cant just add parameter to your doSth method

doSth(boolean modify)
 {
  if (modify) 
  {
    b.modify();
  }
  ...
 }

Answer 7

This is a fix for "best" example, coz noone should really use it in concurrent/multithreading cases. You can get both threads run "if" and both will pass to the next line. It's better to use CAS here, something like:

private final AtomicBoolean called = new AtomicBoolean();

and then

if (!called.compareAndSet(false, true)) return;

or if you prefer to use "plain and pure" style, use double checking with synchronized:

private volatile boolean called;

and then

boolean mayPass = false;
if (!called) {
  synchronized(this) { // or some external object
    if (!called) {
      called = true;
      mayPass = true;
    }
  }
}
if (!mayPass) return;
...

Answer 8

Put your job in the constructor

Class A{

   B b;

   A(){
       //This should execute only once
       b.modify(); //calls doSth() again...
   }

}