CodeGym/Help with Java Tasks/I don't understand this task at all

Level 41

Greenfield, USA

31.03.2022
658views
11comments

I don't understand this task at all

Question about the task

Determining locking order

Java Multithreading, Level 7, Lesson 6

Under discussion

I looked at the previous task, and the previous lessons. I tried something that I was sure was not going to work:

public static boolean isLockOrderNormal(final Solution solution, final Object o1, final Object o2) throws Exception
{
    if(o1.hashCode() > o2.hashCode())
    {
        return true;
    }
    return false;
}

Just to see if the validation results would give me any clues as to how to proceed. No, no help. The thing I don't understand here... Deadlock comes from the unpredictability in what order threads are processing when it comes to conflicting synchronized blocks. So how can the isLockOrderNormal method know what order things will be handled in someMethodWithSynchronizedBlocks? After a while I gave in and looked at the solution, and holy cow I don't understand one bit of it. Why is it running anonymous threads? Why is there a while loop with no body? I really need someone to go through line by line and explain what the solution is doing, because I don't understand it at all.

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 { if(o1.hashCode() > o2.hashCode()) { 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 (11)

Popular
New
Old

You must be signed in to leave a comment

Guadalupe Gagnon

Level 37 , Tampa, United States

31 March 2022, 16:55

useful

In this task you have to code the isLockOrderNormal() to determine if the locking order is obj1 and then obj2 within the someMethodWithSynchronizedBlocks(). This means that inside the method this specific sequence of actions has to occur: obj1 locks → obj2 locks → obj2 releases → obj1 releases. Using that info I locked obj1 indefinitely and then called the sMWSB() method separately. Because I locked obj1 already 1 of 2 possible outcomes could occur in that method: - if the locking order was correct, meaning obj1 first then obj2, the code would stop at the point where obj1 is supposed to lock and wait (indefinitely) and not lock obj2; or - If the locking order was incorrect (meaning obj2 locks first then obj1) that would mean obj2 would lock and then the code would stop and wait indefinitely at the obj1 locking point. At this point obj2 would or would not be locked. According to the above algorithm the only reason it would be locked is if the locking order was incorrect. I used a flag and 3 threads to implement this: -thread 1 locked obj1 indefinitely -thread 2 called the sMWSB() -thread 3 used a synch block that locked obj2 and changed the flag. If obj2 was already locked (meaning order was incorrect) then the flag would not change. With a little creative use of the sleep() calls allowed the threads to work in order and then you can test if the flag changed or not to figure out the correct answer.

Justin Smith

Level 41 , Greenfield, USA, United States

1 April 2022, 14:10

Thank you. I think there may be some basic aspects of the double synchronized method that I'm not getting. Here are the assumptions I have at this time: 1. When code execution hits synchronized(obj1), one of two things happens. If obj1 is already locked due to another thread executing synchronized(obj1) first, then code execution of this thread pauses here and waits until the other thread exits its own synchronized(obj1) block. If obj1 is not locked then it locks it and progresses through the synchronized(obj1) block, and unlocks obj1 when exiting the block. 2. Code execution will never pause at a synchronized block if there are no threads (unless you intentionally try to break it by nesting synchronized blocks that both lock the same object, which would be silly). In other words, if the someMethodWithSynchronizedBlocks is just called from the main method and no threads are created, then the execution order is always: obj1 locks, obj2 locks, obj2 releases, obj1 releases. And all of this happens in a very tiny span of time since there is no other code running. 3. Likewise, if only one thread is created and that thread calls the method and nothing else calls the method, then it also holds true that the execution order is always: obj1 locks, obj2 locks, obj2 releases, obj1 releases. Because there are no other threads to interfere with the order. If any of this is wrong, let's stop there so I can be corrected. Otherwise... One of the things that I think is confusing me about the task is that it sounds like we're supposed to take a measurement of of whether or not a method is locking objects in the order they are passed as arguments. But with our testing method also locking the same objects, aren't we interfering with the method we're trying to test? Like, at the point when it executes solution.someMethodWithSynchronizedBlocks(o1, o2), it seems like it will always have already locked o1 and o2.

Guadalupe Gagnon

Level 37 , Tampa, United States

1 April 2022, 14:55

useful

#1 is correct #2 code is always run on a thread, so technically there are never no thread scenarios. I refer to the default thread simply as the main thread, though I am not sure if that is its official name. This thread is run when you start a program and it starts at the main() method, running line by line as you would expect. This thread can lock objects just like any other thread. Take this little bit as an example:

public static void main(String []args) throws Exception{
   Object obj1 = new Object();
   Thread x = new Thread(() -> {
      try {
         Thread.sleep(500);
         System.out.print("Testing obj1: ");
         synchronized (obj1) {
            System.out.println("obj 1 not locked");
         }
      }catch (Exception ig) {
         System.out.println("Exception occurred");
      }
   });
   x.start();
   //synchronized (obj1){
      //  while(true);
   //}
}

In this code I only create 1 thread, the variable 'x', which prints a phrase followed by a second phrase that is behind a synchronized block. It will either print out that second phrase if the object is not locked, or stop there until the object is no longer locked. Try it and see that it does print the whole phrase; then uncomment the code and try it again. After uncommenting the code the created thread wont be able to complete because it will get stopped at its synchronized block because the 'main' thread holds the lock on obj1 and is put in an infinite loop. This is to demonstrate that even though I only created 1 thread there is actually 2 threads in this small program. Additionally, the same thread can not lock itself out by having multiple nested synch blocks using the same lock. It either will hold the lock or not. Example:

main(String[] args){
   var obj1 = new Object();
   synch (obj1){
       synch (obj1) {
           sys.out("Not Locked");
       }
   }
}

Guadalupe Gagnon

Level 37 , Tampa, United States

1 April 2022, 15:06

useful

#3 The task asks that you test the method to ensure that the locking order is correct. In the code that is there you can clearly see that it is correct, however in the validation of the task they will test that your method works and correctly tests the someMethodWithSynchronizedBlocks() method when it is both correctly programmed and not.

Guadalupe Gagnon

Level 37 , Tampa, United States

1 April 2022, 15:18

useful

I think your misunderstanding is that you are taking the code given as too literal to the task at hand. You need to be able to think abstractly. Imagine that the implementation of the someMethodWithSynchronizedBlocks() is completely hidden from you but that you are given the information on how it is supposed to work: take two objects as arguments and synchronize them in the order that argument 1 locks then argument 2 locks then argument 2 unlocks then argument 1 unlocks. Your task would then be to create code that tests this to ensure that the method does in fact do what it is supposed to do.

Justin Smith

Level 41 , Greenfield, USA, United States

1 April 2022, 17:57

Sorry, what I meant by #2 was if your main method was something like:

public static void main(String[] args)
{
    Object o1 = new Object();
    Object o2 = new Object();
    Solution solution = new Solution();

    solution.someMethodWithSynchronizedBlocks(o1, o2);
}

In this case the someMethodWithSynchronizedBlocks would always produce the desired results, because there is nothing else that can interfere with its execution. And in #3, I just meant that if you instead created one additional thread, like such:

public static void main(String[] args)
{
    Object o1 = new Object();
    Object o2 = new Object();
    Solution solution = new Solution();

    Thread t = new Thread()
    {
        public void run()
        {
            solution.someMethodWithSynchronizedBlocks(o1, o2);
        }
    };
    t.start();
}

In this case there would also be no question as to the order that o1 and o2 lock and release, because again, that method is the only place where synchronization of those objects takes place. So there is no way for o2 to somehow get locked before o1. Is this correct? This, for now, is just trying to make sure that I understand synchronization correctly, I'm not yet thinking about the solution to the task. Basically, my first order of business is making sure I don't have any critical misunderstandings of how synchronization works, because if I do then there is no way I can possibly accomplish the task until I fix those misunderstandings.

Guadalupe Gagnon

Level 37 , Tampa, United States

1 April 2022, 18:24

useful

Both snippets of code that you shared will have the sMWSB() complete because nothing else will interfere with the locks. In both cases the locking order does not matter. Just remember that this task is specifically asking you to test that the locking order is in the order that the task specifies. If you trying to reason why it has to be obj1 then obj2 then you are wasting time. They could just as simply ask that you test that the locking order is obj2 then obj1. In the real world if you were to create code similar to this there may be reasons why you would want the first argument to lock before the second argument, but this is just an abstract task testing your ability to problem solve with new concepts.

Justin Smith

Level 41 , Greenfield, USA, United States

1 April 2022, 19:40

Alright, thank you. That's been very helpful. So I think, if I understand right, the isLockingOrderNormal method is basically a monitor of whether obj1 and obj2 are locked, and since it needs to check this while the someMethodWithSynchronizedBlocks is executing, that monitoring process needs to be contained within a thread. So that's why the solution has at least one anonymous thread created. If this is right, that's a huge relief, it was something I did not get before. Although I had already looked at the solution, I don't really remember it much at this point and I'll start out fresh when I get home. My first thought is, why not create a thread to track obj1 and a thread to track obj2, put them in a while loop to evaluate the order in which they are locked and released. If any component is outside of the intended order, immediately return false. If the order is allowed to complete as intended, return true. This is just my first take and it's probably wrong and I'll probably eventually end up with something similar to your solution, but I should give my first thought a try and see where it goes. I'll come back if I have any other issues. Thanks again.

Justin Smith

Level 41 , Greenfield, USA, United States

2 April 2022, 02:28

I thought I was on the right track (I tried pasting the method here but it says it exceeds the character limit by a lot, so... no can do), but I'm running into a really difficult wall. I created an anonymous thread in the isLockingOrderNormal method. How do I allow the contents of the anonymous Thread's run method to communicate with the code outside of the anonymous Thread? I tried declaring a variable in the isLockingOrderNormal method before creating the anonymous Thread, changing it in the run method, and then tracking its value in a while loop back in the isLockingOrderNormal method, but Intellij says "variable is accessed from within inner class, needs to be final or effectively final" which of course if it were final I wouldn't be able to change it. Then, I tried to have the run() method return the value for the entire isLockingOrderNormal method, but of course the return statement there will read as returning from the run() method, not the isLockingOrderNormal method that contains it, and the run() method is a void return type.

Lisa L

Level 47 , Nuremberg, Germany

2 April 2022, 04:04

You could use a field of the outer class. You could declare an array with a length of 1 and its element is modifiable within the anon class. Or you couled defina a getter in the anon class. and access it after timed joining threads. Or maybe you sleep a little bit and just check thread state then (or if it is active)?

matemate123

Level 50 , Kraków, Poland

31 May 2023, 17:44

Thank you guys for this amazing discussion. You helped me understand and solve this task!