Threads

[Lalitha Vydyula]

Hi all,
Can anyone explain the flow of the below code. I'm really confused. Your help will be appreciated.

class NewThread implements Runnable
{
Thread t;
NewThread()
{
t = new Thread(this, "Demo Thread");
System.out.println("Child Thread: " + t);
t.start();
}
 
public void run()
{
try
{
for(int i=5;i>0;i--)
{
System.out.println("Child Thread: " + i);
Thread.sleep(500);
}
}
catch(InterruptedException e)
{
System.out.println("Child interrupyed.");
}
System.out.println("Exiting child thread");
}
}
 
class ThreadDemo1
{
public static void main(String s[])
{
new NewThread();
try
{
for(int i=5;i>0;i--)
{
System.out.println("Main Thread: " + i);
Thread.sleep(1000);
}
}
catch(InterruptedException e)
{
System.out.println("Child interrupted.");
}
System.out.println("Main thread exiting");
}
}

------------------------------
Here is the output
------------------------------
Child Thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread
Main Thread: 2
Main Thread: 1
Main thread exiting

Thanks,
-Lalitha

(Marilyn added code tags)
[ August 03, 2005: Message edited by: Marilyn de Queiroz ]

[marc weber]

What is it specifically that you're confused about?

Basically, there are 2 threads here running concurrently. Each counts down from 5 to 1, sleeping a set (minimum) amount of time with each iteration. One thread tends to sleeps longer than the other, so it will likely take longer to finish running.

However, the exact output is unpredictable, because how the threads actually end up running is determined by the (platform-dependent) thread scheduler. In fact, you're likely to see different output from one execution to the next.

[Marilyn de Queiroz]

class NewThread implements Runnable
{
    Thread t;
 
    NewThread() // line 5
    {
        t = new Thread( this , "Demo Thread" ); // line 6
        System.out.println( "Child Thread: " + t );  // line 7
        t.start(); // line 8
    }
 
    public void run()  // line 9
    {
        try
        {
            for ( int i = 5 ; i > 0 ; i-- )  // line 10
            {
                System.out.println( "Child Thread: " + i );  // line 11
                Thread.sleep( 500 ); // // line 12
            }
        }
        catch ( InterruptedException e )
        {
            System.out.println( "Child interrupyed." );
        }
        System.out.println( "Exiting child thread" );
    }
}
  
class ThreadDemo1
{
    public static void main( String s[] )
    {
        new NewThread(); // line 1
        try
        {
            for ( int i = 5 ; i > 0 ; i-- ) // line 2
            {
                System.out.println( "Main Thread: " + i ); // line 3
                Thread.sleep( 1000 );  // line 4
            }
        }
        catch ( InterruptedException e )
        {
            System.out.println( "Child interrupted." );
        }
        System.out.println( "Main thread exiting" );
    }
}  

Line 1 creates a new NewThread which calls the constructor in line 5
The constructor makes another Thread labelled "Demo Thread" in line 6.
Line 7 prints the thread created in line 6.
Line 8 calls the run() method on the thread in line 6.
The constructor exits and line 2 starts a loop to print (line 3) the thread that is running main() which is a separate thread than the one created in the NewThread constructor. The loop waits 1 second between each println call (line 4).
Meanwhile the run() method begins a loop (line 10) to print (line 11) the thread created in line 5 waiting 1/2 second between each println call (line 12).
The rest is to demonstrate that the two loops (and the two threads) are running independently of each other. The results may vary (or not) each time you run the program.