Question

So I have been trying to write a java program, that involves Threads. It is basically a problem where a thread asks a shared memory resource(cell class in the code below) for permission to move. I’ll show you an example of the code in the thread. The three mentioned methods from the cell class are synchronized methods, however they don’t implement wait or notify’s.

public void run() {
    try{
        while(true){
            Random r = new Random();
            Thread.sleep(r.nextInt(1000));
            //asks the class cell permission to move if the cell is free.
            if(cell.asksAccess(xi, yi, xf, yf)){
                cell.releaseCell(xi, yi); //release the previous cell
                move(); // move the object
                cell.blockCell(xi, yi); // blocks the cell where the object is now staying.
                setChanged();
                notifyObservers();
            }
        }
    } catch (InterruptedException e) {
    }
}

private void move() {
    int dx = xf - xi;
    int dy = yf - yi;

    xi += (int) Math.signum(dx);
    yi += (int) Math.signum(dy);
}

Like I said before, all the cell class methods invoked are synchronized. My problem is that this is not working as I expected and when I did a sysout to debug, it showed that the threads are not always moving forward and sometimes they even move back to where they were in the beginning and I can’t understand why since the move method always tells them to go forward and never back. Is this a sync problem with the cell class? Or is it the move method? Any help would be a lot appreciated.

Answer 1

First, lets consider the move method. Assuming that:

• the xi, xf, yi and yf variables are instance variables of the Runnable, and
• there are no other (callback) methods that access or update them,

then we can conclude that those variables are “thread confined” and no synchronization is required.

So where is the problem? Well I think it is here:

if (cell.asksAccess(xi, yi, xf, yf)) {
    cell.releaseCell(xi, yi); //release the previous cell
    move(); // move the object
    cell.blockCell(xi, yi); // blocks the cell where the object is now staying.
    setChanged();
    notifyObservers();
}

I can see two issues:

• I think you said that askCell, blockCell and releaseCell synchronize on the cell object. But the problem is that the sequence “ask, block, release” needs to be atomic.
• Your code seems to be releasing a cell(?) at xi, yi … and then blocking it again. The comments seem to imply that you should be calling cell.blockCell(xf, yf) instead.

---

… what is the best way to take care of the synchronization of that sequence?

Without seeing the related code, it is hard to say what the best way is. But one way to do it would be to make it one call on the cell object … and deal with the move and notifications afterwards; e.g. something like this:

if (cell.checkAndMove(xi, yi, xf, yf)) {
    move(); // move the object
    setChanged();
    notifyObservers();
}  

where checkAndMove is defined in the Cell class as:

public synchronized boolean checkAndMove(int xi, int yi, int xf, int yf) {
    boolean ok = this.asksAccess(xi, yi, xf, yf);
    if (ok) {
        this.releaseCell(xi, yi);
        this.blockCell(xi, yi);
    }
    return ok;
}