Blocking Primitives in Java

sanjay101 — Tue, 30 Jun 2009 04:57:48 +0000

Since Java 5, we have thread level blocking primitives for creating locks and other synchronization classes. It is easy to build locks using spinlocks that would scale well especially if no of CPUs can match no of threads spinning. It could also waste memory cycles if contending threads outnumbers CPUs available. A prudent strategy is to do some spinning followed by blocking/ unblocking and some more spinning – all in a loop till the system is in a desirable state. No of spin cycles can be customized. Blocking mechanics could become a little complex. A lot of code gets executed from the time its decided that a thread should block to the actual blocking, providing opportunities to slip in some more spinning. Blocking primitives LockSupport.park() & LockSupport.unpark(Thread th) ( and their variants ) are in package java.util.concurrent.locks. In general, a thread Thread- like to block ( LockSupport.park() ) if the system is not in a desired state. It will be blocked till another thread Thread-B change that state in such a way that Thread-A can make progress. Here Thread-B is expected to wakeup Thread-A( LockSupport.unpark(Thread-A). For Thread-B to wakeup Thread-A, Thread-A needs to save its reference to some data structure that Thread-B can access. Here is what JavaDoc says about LockSupport.

“Methods park and unpark provide efficient means of blocking and unblocking threads that do not encounter the problems that cause the deprecated methods Thread.suspend and Thread.resume to be unusable for such purposes: Races between one thread invoking park and another thread trying to unparkit will preserve liveness, due to the permit”.

To understand the internal mechanics of LockSupport, here is one such implementation uning intrinsic lock. Pl. let me know if you find any bug with this code.

Practically speaking, Class java.util.concurrent.locks.AbstractQueuedSynchronizer provides everything needed to write custom synchronizers using a mix of spinning/ blocking primitives.

package sanjay.concurrent.example;

import java.util.concurrent.ConcurrentHashMap;

public class MyLockSupport {

final static ConcurrentHashMap map = new ConcurrentHashMap();
final static Boolean SIGNAL = new Boolean(true);

public static void park() {

  Thread thread = Thread.currentThread();
  Long threadId = thread.getId();

  synchronized ( thread ) {
   while ( !isSignalled(threadId) ) {
    try {
     thread.wait();
    } catch ( InterruptedException ie) {
     thread.interrupt();
     return;
    }
   }
   consumeSignal(threadId);
   return;
  }
}

public static void unpark(Thread thread) {
  synchronized ( thread ) {
   signal(thread.getId());
   thread.notify();
  }
}

private static boolean isSignalled(Long threadId) {
  if ( map.get(threadId) == null ) {
   return false;
  }
  return true;
}

private static void consumeSignal(Long threadId) {
map.remove(threadId);
}

private static void signal(Long threadId) {
map.put(threadId, SIGNAL);
}

}

Sanjay's Blog

Blocking Primitives in Java