Re: Interrupted exception chaining

markspace schrieb:


Just replace done by the <cond> you want to anyway check.
The main point is that you cannot go, since factoring
out the programming pattern works not:

    synchronized (c) {
       while (!<cond>)
          uninterruptableWait(c);
    }

But rather simply apply the programming pattern:

    try {
       synchronized (c) {
          while (!<cond>)
             c.wait();
       }
    } catch( InterruptedException ex ) {
       Thread.currentThread().interrupt();
    }

Or if you want to scare the hell out of your clients, use:

     public interface Predicate {
        public boolean _true(Object c);
     }

    public void uninterruptableWait(Object c, Predicate p) {
       try {
          synchronized (c) {
             while (!p._true(c))
                c.wait();
           }
       } catch( InterruptedException ex ) {
          Thread.currentThread().interrupt();
       }
    }

Then what you call "SpinLock", but what I would call
"OneTimeLock". Can be implemented as follows:

     public void waitDone() {
        uninterruptableWait(lock,new Predicate() {
             return done;
        });
     }

Of course you can turn a "OneTimeLock" into a "ManyTimeLock",
for example. You can reset the done inside the synchronized
of the waitDone(). The synchronized will assure that when
you leave the synchronized the done=false holds, since no
other thread will interfer while inside the synchronized
and after the wait():

   public void waitDone() {
       try {
          synchronized( lock ) {
             while( !done )
                lock.wait();
             done=false;
          }
       } catch( InterruptedException ex ) {
          Thread.currentThread().interrupt();
       }
   }

To abstract this pattern we would need:

     public interface Predicate {
        public boolean _true(Object c);
     }

     public interface Action{
        public boolean perform(Object c);
     }

    public void uninterruptableWait(Object c, Predicate p, Action a) {
       try {
          synchronized (c) {
             while (!p._true(c))
                c.wait();
             a.perform(c);
           }
       } catch( InterruptedException ex ) {
          Thread.currentThread().interrupt();
       }
    }

And one can then do:

     public void waitDone() {
        uninterruptableWait(lock,new Predicate() {
             return done;
        }, new Action() {
             done=false;
        });
     }

Eagerly avaiting JDK 7 lambdas...

Bye