Why do I have to use new SleepingThread.join() and why can't I use, in the next line, SleepingThread.currentThread.join() or Thread.currentThread.join() ?

Question about the task

Under discussion

I hate multithreading, it makes me feel like I have learned nothing so far in Java. Why can't I use :

SleepingThread.currentThread.join() // or
Thread.currentThread.join()

public class Solution {
    public volatile static int COUNT = 4;

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < COUNT; i++) {
            new SleepingThread().join();
            //write your code here


        }
    }

    public static class SleepingThread extends Thread {
        private static volatile int threadCount = 0;
        private volatile int countdownIndex = COUNT;

        public SleepingThread() {
            super(String.valueOf(++threadCount));
            start();
        }

        public void run() {
            while (true) {
                System.out.println(this);
                if (--countdownIndex == 0) return;
                //write your code here
                try {Thread.sleep(10);}catch (InterruptedException e){
                    System.out.println("Thread interrupted");
                    //return;
                }
            }
        }

        public String toString() {
            return "#" + getName() + ": " + countdownIndex;
        }
    }
}

Comments (2)

Popular
New
Old

You must be signed in to leave a comment

Nouser

Level 36 , Germany

17 December 2020, 11:04

useful

Join has a somwhat not consistent syntax (in my opionion). The actual context waits for this Thread to die. But we're usually used to call a method on an object and if we need more info, we use a parameter. So imho join should work different. But we have to work with the syntax as it is now. The join method grabs automatically and unvisible for us the current Thread where it is called and the calling object and waits for the caller to die. Then it continues the calling context. This is probably cause the makers of the language didn't want programmers to be able to force a foreign Thread to wait for a second foreign Thread (like secondThread.join(thirdThread)). So if you try something like Thread.currentThread.join(); it will miserably fail. As written above the actual context will wait for this (Thread.currentThread) to die. But the caller and the actual context are the same. SleepingThread.currentThread() is here identical to Thread.currentThread() as SleepingThread inherits Thread. So it is just refering to the parent class' methods. And again, concurrancy is amazingly confusing. Just go through these lessons and try to not despair. Some things will get more understandable later. But Codegym isn't to good to explain that all so it will be best to read external sources, too (later, when you're in multithreading).

Andrei

Level 41

18 December 2020, 17:46

OK, I didn't really understand but thank you for trying. :) I will continue.