I don't know what's going on

Question about the task

Under discussion

I try on my intelij and everything run fine. But i think that maybe something went wrong. atleast first two requirement. It's weird. I mean why it can return true and false on same condition.

Implement the logic of the isLockOrderNormal method, which should determine:
whether the order of the synchronized blocks in the someMethodWithSynchronizedBlocks method matches the order of the arguments passed to it.
If o1 is synchronized first and then o2, the method should return true.
Otherwise, false.

Requirements:

The isLockOrderNormal method must return true if the someMethodWithSynchronizedBlocks method synchronizes first using the o1 object and then o2.
The isLockOrderNormal method must return false if the someMethodWithSynchronizedBlocks method synchronizes first using the o2 object and then o1.
The isLockOrderNormal method should NOT be private.
The Solution class must NOT be declared with the final modifier.

package com.codegym.task.task27.task2707; /* Determining locking order */ public class Solution { public void someMethodWithSynchronizedBlocks(Object obj1, Object obj2) { synchronized (obj1) { synchronized (obj2) { System.out.println(obj1 + " " + obj2); } } } public static boolean isLockOrderNormal(final Solution solution, final Object o1, final Object o2) throws Exception { //do something here final String[] s = {null, null}; new Thread(new Runnable() { @Override public void run() { synchronized (o2){ try{ Thread.sleep(100); }catch (Exception e){ } } } }).start(); new Thread(new Runnable() { @Override public void run() { solution.someMethodWithSynchronizedBlocks(o1,o2); s[0] = "hau"; } }).start(); new Thread(new Runnable() { @Override public void run() { synchronized (o1){ s[1] = "hau"; try{ Thread.sleep(100); }catch (Exception e){ } } } }).start(); while (s[1] == null){ Thread.sleep(1); } if(s[0] != null) { return true; } return false; } public static void main(String[] args) throws Exception { final Solution solution = new Solution(); final Object o1 = new Object(); final Object o2 = new Object(); System.out.println(isLockOrderNormal(solution, o1, o2)); } }

Comments (2)

Popular
New
Old

You must be signed in to leave a comment

Seb

Level 41 , Crefeld, Germany

30 January 2020, 00:55

There's a problem in the program's logic. In the first thread you are locking the object o2 and you are then calling Thread.sleep(100). That's fine - though to make it even clearer one could increase the sleep time to 500 for instance. In the second thread you are calling solution.someMethodWithSynchronizedBlocks(o1, o2). That's fine as well. In the third thread you are locking the object o1 and setting s[1] to a value that will enable us to check if the locking order is as expected. That's good too. However, you should not call Thread.sleep in the third thread and you should also not have a while loop that waits as long as s[1] is null, and finishes once s[1] is not null anymore. This is the main issue here. The next check if(s[0] != null) will most likely always return true in view of the sleep times and the while loop that you set up. I suggest you adjust the code as follows: Increase the sleep time of the first thread to 500. Ged rid of the sleep method in the third thread. Get rid of the while loop - only call Thread.sleep(1) instead. Then check if(s[1]) == null). If that's the case, you can return true as the locking order is as expected. If s[1] is not null, return false.

Seb

Level 41 , Crefeld, Germany

30 January 2020, 00:55

What's the logic behind this? You lock o2 for half a second in the first thread. At the same time the second thread will try to access o1 and o2 via solution.someMethodWithSynchronizedBlocks(o1, o2). At this moment in time o2 should still be locked due to the synchronized sleep block in thread 1. Thus, the second thread has now locked o1 and is waiting for o2 to be released. In the meantime the third thread "tries" to lock the object o1, which actually is currently locked by the second thread that is waiting for o2 to be released. The following check if(s[1] == null) should return true as at this moment in time the third thread was not able to lock o1. Now, if the check if(s[1] == null) returns false in this little about 500ms timeframe, then this means that the locking order in the solution.someMethodWithSynchronizedBlocks call is opposite as expected - say o2 and o1 are in the opposite order. In this case the solution.someMethodWithSynchronizedBlocks first tried to lock o2, which was still locked by the first thread, and thus could not lock o1 directly, but had to wait for the first thread to release o2. In the meantime the third thread could lock o1 and set the value in the array. I hope this makes sense to you. My description ended up being way longer than I expected... :-P ;-)