Java - 等待Runnable完成

Question

In my app, I have the following code running on a background thread:

MyRunnable myRunnable = new MyRunnable();
runOnUiThread(myRunnable);

synchronized (myRunnable) {
    myRunnable.wait();
}

//rest of my code

And MyRunnable looks like this:

public class MyRunnable implements Runnable {
    public void run() {

        //do some tasks

        synchronized (this) {
            this.notify();
        }
    }
}

I want the background thread to continue after myRunnable has finished executing. I've been told that the above code should take care of that, but there are two things I don't understand:

1. If the background thread acquires myRunnable's lock, then shouldn't myRunnable block before it's able to call notify() ?

2. How do I know that notify() isn't called before wait() ?

Answer 1

1. myRunnable.wait() will release the lock of myRunnable and wait notify

2. we always add a check before wait.

    //synchronized wait block while(myRunnable.needWait){ myRunnable.wait(); } //synchronized notify block this.needWait = false; myRunnable.notify(); 

Answer 2

You could also use JDK's standard RunnableFuture like this:

RunnableFuture<Void> task = new FutureTask<>(runnable, null);
runOnUiThread(task);
try {
    task.get(); // this will block until Runnable completes
} catch (InterruptedException | ExecutionException e) {
    // handle exception
}

Answer 3

1. The lock is released when the wait starts
2. That's a possibility, you can avoid it by putting the runOnUiThread within the synchronized block too (so that the runnable can't acquire the lock until the other thread is already waiting)

Answer 4

Create an Object called lock . Then after runOnUiThread(myRunnable); , you can call lock.wait() . And when your myRunnable is finish it's job, call lock.notify() . But you must declare MyRunnable as inner class, so they can share the lock object.