我可以让线程等待锁，然后在释放后跳过它吗？

Question

Given is the following pseudo code. A function may be entered by multiple threads simultaneously. I want all threads to execute a() and c() , but b() must only be executed by those threads that were not locked when entering the synchronized block.

In other words: If a thread must wait for the lock, then I want it to wait until the lock is released and then jump over b() and continue with c() right away.

    public void code() {
        a() // check if page is present locally

        if (pageMissing) {
            synchronized (this) {
                page = b(); // get page over REST
            }
        }

        c() // access page
    }

How is this useful? Imagine b() calls an external REST function to update local data. When a thread enters, we want to be sure that the function is called and local data is updated, but once the blocking thread exits b() we know local data is current and we don't want to waste resources in having consecutive threads that were already waiting call the update function again.

Answer 1

You can have a boolean flag (instance variable) that denotes whether b() has been called or not. All threads that enter the synchronized block will check this condition before calling b() .

private boolean isDone = false;

public void code() {
    a();
    synchronized (this) {
        if (!isDone) {
            b();
            isDone = true;
        }
    }
    c();
}

Only the first thread that acquires the lock will call b() . After it succeeds, it will set the flag to true and will exit the block. All subsequent threads entering the block will fail on the if condition and hence will not invoke b() .

---

If you do not want the other threads to wait on the synchronized block's lock and want to continue to call c() , you can remove the synchronized keyword and use an AtomicBoolean and use its compareAndSet

 private AtomicBoolean isDone = new AtomicBoolean(false);

 public void code() {
    a();
    if (isDone.compareAndSet(false, true)) {
       b();
    }
    c();
}

Javadoc of compareAndSet states

Atomically sets the value to the given updated value if the current value {@code ==} the expected value.

@return {@code true} if successful. False return indicates that the actual value was not equal to the expected value.

So, the first thread that calls compareAndSet while isDone is false will succeed. The others will get false as the return value and hence won't enter the block and can thus continue.

---

UPDATE: From your comments

@user7 Yes, I am concerned with threads calling b() unnecessarily, but (see my other comment) I need those threads that arrive while b() runs to wait until it is finished before they continue with c()

Seems you need the first solution of mine.