Odd linked list/anonymous class behavior - executing when added?

Question

This question is related to How to Queue and Call Actual Methods... Anyway, I've decided to (after all) go with the anonymous class idea. The problem is that when I ADD my anonymous class to the linked list, it's actually calling execute() immediately... and it shouldn't be. Execute() is to be called later. Anyway, this is what I have:

private LinkedList<AgentAction> actions;
public boolean blockingSensor;

this.actions.add( new AgentAction(this) {
 public void execute() {
  //setRotationalVelocity(0);
  kinematic.setWheelsVelocity(0,0);
  this.agent.setBlockingSensors(false);
  this.agent.printLCD("Turn, blocking = "+this.agent.blockingSensor);
 }

 public Object getValue() {
  return null;
 }
});

//this is essentially the main()
public void performBehavior()
{
    //make sure to only call run() each tick, not every ms
    if ( this.oldCounter < getCounter() )
    {
        if ( !isWorking() )
        {
            run();
        }
        this.oldCounter = getCounter();
        this.actions.removeFirst().execute();
    }
}

abstract class AgentAction
{
 SimbadAgent agent;
 public AgentAction(SimbadAgent a)
 {
  this.agent = a;
 }
 public abstract void execute();
 public abstract Object getValue();
}

run() is an abstract method that is implemented by a child class. I'm just not sure why it's printing when it's added, rather than executed. I understand this would imply that performBehavior() is actually being executed multiple times rather than once per tick, but that's not the case.

Answer 1

The devil is in the details. There's almost certainly a bug somewhere in the code you're not showing (my guess is run), but let's address a deeper point. This code looks a LOT like there producer-consumer problem. If so, I recommend checking out java.util.concurrent: it's overflowing with concurrency-related goodness that makes things like this WAY easier than trying to roll your own. For your particular case, it looks like ScheduledExecutorService might be a good fit. If it's not exactly what you need, I still recommend poking around in the package; like I said, it's stuffed with handy things that will probably be a lot easier to work with than something you built yourself from the concurrency primitives.