CodeGym/Help with Java Tasks/How is this supposed to make sense?

Level 41

10.05.2021
507views
10comments

How is this supposed to make sense?

Question about the task

Resolved

await() - "Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted. If the current count is zero then this method returns immediately. If the current count is greater than zero then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of two things happen: The count reaches zero due to invocations of the countDown method; or Some other thread interrupts the current thread. If the current thread: has its interrupted status set on entry to this method; or is interrupted while waiting, then InterruptedException is thrown and the current thread's interrupted status is cleared." countDown() - "Decrements the count of the latch, releasing all waiting threads if the count reaches zero. If the current count is greater than zero then it is decremented. If the new count is zero then all waiting threads are re-enabled for thread scheduling purposes. If the current count equals zero then nothing happens." Even when I run the code in main, it just waits, nothing happens. Yet having the code like below it verifies. It doesn't make sense. Why call the await method, which will basically make the thread wait endlessly (because the countdown() is not called or the thread is not interrupted) ? I don't understand the point they are trying to make. Shouldn't the code be like this? You call the countdown and then the method.

public void someMethod() throws InterruptedException {
     latch.countDown();
     retrieveValue();
 }

public class Solution {

    CountDownLatch latch = new CountDownLatch(1);

    public void someMethod() throws InterruptedException {
        latch.await();
        retrieveValue();
        latch.countDown();
    }

    void retrieveValue() {
        System.out.println("Value retrieved.");
    }

    public static void main(String[] args) throws InterruptedException {
        Solution s1 = new Solution();
        s1.someMethod();
    }
}

Comments (10)

Popular
New
Old

You must be signed in to leave a comment

catalin1989

Level 37 , Romania

22 February, 15:15

It is funny, that this solution is validated and when I do this in the main method Solution s=new Solution(); s.someMethod(); It just freezes. The latch.await() makes the tread to wait indefinitely, and it will never reach latch.countDown.

Andrei

Level 41

12 May 2021, 16:34

Up. Anyone?

Thomas

Level 41 , Bayreuth, Germany

12 May 2021, 17:06

That's my solution, and please have a look at my comments there... but I can not remember anymore if it validated that way or if I just have changed it later to make it understandable for me (the mentioned line 64 of course is here line 34)

//someMethod using latch
public void someMethod() throws InterruptedException {
    latch.await();
    retrieveValue();
    //this never will be reached when threads are waiting two lines above. Calling countDown() somewhere else (eg. main)
    //will do the trick (see below line 64)... so I have no clue why CodeGym asks for that solution
    //latch.countDown();
}

void retrieveValue() {
    System.out.println("Value retrieved.");
}

public static void main(String[] args) {
    //create a Solution object
    Solution s = new Solution();

    //create 10 threads and run them. They just call someMethod (to get the Value)
    for (int i = 0; i < 10; i++) {
        new Thread(() -> {
            try {
                s.someMethod();
            } catch (InterruptedException ignore) {
            }
        }).start();
    }

    //wait a little bit (3 secs)
    try {
        TimeUnit.SECONDS.sleep(3);
    } catch (InterruptedException ignore) {}

    //now set the latch to zero so that the threads can start running
    s.latch.countDown();

Andrei

Level 41

13 May 2021, 07:50

Hi Thomas , From what I understand from your code you take out countDown() from someMethod() and call it in the main method. My question here is, considering that object s will be in await() mode, will calling countDown() from main method somehow interrupt the await() method and continue executing the rest of the code?

Thomas

Level 41 , Bayreuth, Germany

13 May 2021, 08:59

useful

yes, maybe my comments aren't that clear :) The latch object is a field of the Solution class. So everywhere (except in static methods of course) inside the Solution class I can access it. And it doesn't matter if it is an anonymous class (the Threads) inside the main method. So the threads use that object and while while they are waiting I modify that latch object in the main thread and countDown to zero. Then the waiting state get's changed andawait doesn't stop the threads anymore and they continue their work. That was the only way for me to make it work (as far as I can remember) and that was probably the reason why I have written that comments for me ;) But as said, I can not remember if the task validated with 'my' way of solving it. At least retrieving the value shouldn't work (and didn't) the CG way. After 3 secs I get the values using my way and trying the CG way then the main tasks ends while the threads just run forever (without spitting out a result). Another possible logic (at least for me) would be to set the latch to 10 and before the await call inside someMethod you countDown, then all threads will continue to work when the last thread reaches its countdown call. That's pretty much what I'd espect from the latch.

Andrei

Level 41

13 May 2021, 11:03

solution

Cool! It makes more sense now, thanks! I still don't understand why codegym mentor whould suggest this structure in the someMethod() method

public void someMethod() throws InterruptedException {
    latch.await();
    retrieveValue();
    latch.countDown();
}

I guess it will remain a mystery! 😁😅

matemate123

Level 50 , Kraków, Poland

3 June 2023, 08:38

It's funny because I validate this task only way undestandable and logically to me:

public void someMethod() throws InterruptedException {
        latch.countDown();
        retrieveValue();
        latch.await();
    }

I thing about it like that: 1. We use someMethod() in 10 different threads 2. We want waiting for every thread finish someMethod() until going forward. 3. We set CountDownLatch(10) 4. Now we have certainty that every thread retrieve values (retrieveValue()) and each tread start again from latch.await() point. I don't know if my logic is correct but opposite order in someMethod() have no sense to me at all.😅

Thomas

Level 41 , Bayreuth, Germany

4 June 2023, 06:18

That's exactly how it ought to be 😉

catalin1989

Level 37 , Romania

22 February, 15:10

This makes more sense than the requirements on codeGym.

jpcouturier

Level 29 , France, France

23 February, 13:53

Yes and here is another version passing the validation :

public void someMethod() throws InterruptedException {
    latch.countDown();
    latch.await();
    retrieveValue();
}

It could be possible for example that the retrieveValue() method need some extra-time to complete... but putting all in the same method make no sense. I think the only purpose of this task is to discover the CountDownLatch class... you can find a better example on oracle documentation :

class Driver { // ...
   void main() throws InterruptedException {
     CountDownLatch startSignal = new CountDownLatch(1);
     CountDownLatch doneSignal = new CountDownLatch(N);

     for (int i = 0; i < N; ++i) // create and start threads
       new Thread(new Worker(startSignal, doneSignal)).start();

     doSomethingElse();            // don't let run yet
     startSignal.countDown();      // let all threads proceed
     doSomethingElse();
     doneSignal.await();           // wait for all to finish
   }
 }

 class Worker implements Runnable {
   private final CountDownLatch startSignal;
   private final CountDownLatch doneSignal;
   Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
     this.startSignal = startSignal;
     this.doneSignal = doneSignal;
   }
   public void run() {
     try {
       startSignal.await();
       doWork();
       doneSignal.countDown();
     } catch (InterruptedException ex) {} // return;
   }

   void doWork() { ... }
 }