Java synchronization: how to have waiting threads not execute the synchronized task

Suppose I have a piece of code in Java that I want to be executed synchronously, however when the thread that owns the lock releases that lock, I do not want waiting threads to execute the synchronized code any more. I just want them to wait until the synchronized code has finished running.

So, when thread 1 enters the synchronized code (method, code block) it must get a lock on that code. Any subsequent threads must then wait for the first thread to finish running the code. So far, regular code synchronization.

However in my case, when the first thread is finished, and releases the lock, I want the waiting threads to skip that synchronized piece of code (the code updates a resource that is used by all threads).

How would I go about creating this in Java using the synchronization features? Currently I am not using the sync features, instead I am using a concurrent collection holding the lock (context), like herebelow. However, the process of locking still needs to be synchronized somehow, because two threads are able to get a lock on the context.

Cheers!

Kjeld

	/*
	 * A concurrently accessible set of contexts.
	 */
	private static final Set<String> LOCKED_CONTEXTS;

	static {
		LOCKED_CONTEXTS = ConcurrentHashMap.newKeySet(); // meanwhile, I replaced this with Collections.synchronizedSet(new HashSet<>()) 
	}

...

        if (!LOCKED_CONTEXTS.contains(context)) {

			LOCKED_CONTEXTS.add(context);
			log.debug("Locked context: {}", context);

			try {
				doTask();

			} finally {

				LOCKED_CONTEXTS.remove(context);
				log.debug("Released context: {}", context);
			}
		} else {

			log.debug("Waiting for context to be released: {}", context);

			while (LOCKED_CONTEXTS.contains(context)) {
			}

			log.debug("The waiting is over, context is released: {}", context);
		}

I think you want to combine a lock with a semaphore.

• tryLock on the lock
• if you got it, do work. At the end of the work, mark the semaphore as complete
• if you did not get it, wait for the semaphore to complete

Maybe I don't fully understand your use-case, but from what I get you want a piece of code to only run once for all triggers during its execution, but again if any trigger happens outside of the previous execution window.

Does this cover it?

class Work {
  private volatile boolean done;

  void queueWorkOnce() {
    done = false;
    actualWork();
  }

  private synchronized void actualWork() {
    if (!done) {
      //TODO: do work
      done = true;
    }
  }
}