I have no clue on this one

Thanks for the help. I think your method is a little easier to understand. I tried to implement it, in the thread of locking o2, you mentioned wait for a second, did you use o2.wait(1000)? But can't pass the verification.

synchronized(o2){ Thread.wait(1000); } This locks it. If the order is correct then the second one will lock o1 within the method and stop waiting for o2 to be released. If the locking order is backwards then it will he waiting for o2 and o1 will be unlocked for the third thread.

Thanks for the reply. But it seems that syntax cannot be Thread.wait(1000); I tried either Thread.currentThread().wait(1000) or Thread.sleep(1000), but none worked :(

Thank you very much. I figured out the issue was that after the start of 3rd thread, there must be some sleep time, even 1 ms. But I don't understand why. These wait, notify stuff really drive me crazy...

You and me both

I'm having same problem. Thread.wait() can't be called in static context. solution.wait() doesn't seem to pass verification. Also why do you need to have wait(1000) timeout. Couldn't you just call wait() so it waits indefinitely?

Hi. I followed the steps suggested by Guadalupe and it still doesn't work. Can someone help me here? Here's what I was able to do by reading the discussion between Guadalupe and Bill Wu:

public static boolean isLockOrderNormal(final Solution solution, final Object o1, final Object o2) throws Exception {
    final String[] strings = {null};

    Thread t1 = new Thread() {
        @Override
        public void run() {
            synchronized (o2) {
                try {
                    Thread.currentThread().wait(1000);
                } catch (InterruptedException e) {}
            }
        }
    };

    Thread t2 = new Thread() {
        @Override
        public void run() {
            solution.someMethodWithSynchronizedBlocks(o1, o2);
        }
    };

    Thread t3 = new Thread() {
        @Override
        public void run() {
            synchronized (o1) {
                try {
                    strings[0] = "o1";
                    Thread.sleep(100);
                } catch (InterruptedException e) {}
            }
        }
    };

    if(strings[0] == null)
        return true;

    return false;
}

This doesn't pass the first condition: "The isLockOrderNormal method must return true if the someMethodWithSynchronizedBlocks method synchronizes first using the o1 object and then o2." Thanks.

@Henrique Your threads have been created, but do not do anything. You may want to consider starting them. Also, the correct use is Thread.sleep() and not Thread.Wait(). I was incorrect with that above. Next, there should be no sleep in the third thread, you will want it to be directly after you start all threads. So, once you change the wait to sleep and then remove the sleep from line 28, add this at line 33:

t1.start();
t2.start();
t3.start();
Thread.sleep(10);

and you should pass. This works because the Thread t1 (at lines 4-13) will lock o2. So o2 is locked when the next thread, t2, calls isLockOrderNormal. If the order is normal, meaning the first parameter is locked followed by the second parameter (you pass in o1 then o2), then o1 will get locked and the thread will stop because o2 is already locked and waiting for the sleeping thread t1 to continue (for 1000 milliseconds). If the locking order is incorrect, meaning the second parameter is locked then the first, when the method is called with those parameters, o2 would already be locked and the method would stop there until the sleeping thread releases its lock and therefore o1 would not be locked. Now the third thread, t3, locks o1 and changes the value at index 0. If, as mentioned above, the order was normal then o1 would be locked and waiting for the first thread to release o2 so the second thread could proceed. If the locking order was not normal then o1 would not be locked and the third thread could proceed immediately. You need that small sleep after starting the three threads because the main thread continues running and pass over lines 34 and 35 before the other threads are still working. I don't know if this is the best solution to this problem, but it seems logical and worked for me.

Hey, Guadalupe, thanks for your answer. Just after I posted here, I tried to start(); the threads, and it still didn't work. Now I have changed some things and it passed. I believe the problem was really the wait(); method, and also the time I put inside sleep(); Thanks for your time! You're the best!

Thanks for the advice. But I'm still confused about how to check the someMethodWithSynchronizedBlocks(), should I call it inside isLockOrderNormal() and then create another thread as you said, so both will try to lock o1 and o2?