Starting new threads

Hi,

I am new to java concurant programming and trying out with few examples.I wanted to start 5 threads and stop them by printing (System.out.println) Thread1 started,Thread2Started,Thread3Started etccc then Thread1stopped,Thread1stopped etccc..
I have writen the below program.Please help tp change it to produce all started messages once then stopped messages.
public class SimpleThread {

public static void main (String[] args) {
for(int i=0;i<5;i++)
new RunnableTask(i).start();
}
}
class RunnableTask extends Thread
{

RunnableTask(int i)
{
super(String.valueOf(i));
}
public void run()
{
System.out.println("Thread "+this.getName()+"Started");
System.out.println("Thread "+this.getName()+"Stopped");
}
}

Regards
Radha

Well, this might not be as simple as you had hoped. Threads tend to execute in their own order unless you force order upon them using various synchronization tools. To get an idea of how synchronization tools work, I suggest reading the Java Concurrency Tutorial.

For your application, this task becomes relatively simple using one of the new(ish) locking mechanisms from the java.util.concurrent package. Basically, you have 5 tasks, and want to make sure they all reach a certain point (after the 'started' message) before they can continue. This is the perfect use for the CountDownLatch. An example:

package concurrency;

import java.util.concurrent.CountDownLatch;

public class CountDown
{
    public static void main(String[] args)
    {
        final int threadCount = 5;
        
        CountDownLatch cdl = new CountDownLatch(threadCount);
        for (int i = 1; i <= threadCount; i++)
        {
            new RunnableTask(cdl, i).start();
        }
    }

static class RunnableTask extends Thread
    {
        private final CountDownLatch latch;
        private final int id;
        
        RunnableTask(CountDownLatch cdl, int i)
        {
            this.latch = cdl;
            this.id = i;
        }
        
        public void run()
        {
            System.out.println("Thread "+id+" started.");
            
            try
            {
                latch.countDown(); //let other threads know I reached here
                latch.await(); //Wait until all threads reached here
            } 
            catch (InterruptedException ie)
            {
                ie.printStackTrace();
            }
            
            System.out.println("Thread " + id + " ended.");
        }
    }
}

Just as an FYI, it is normally frowned upon to extend Thread, unless you absolutely need to. Instead, implement the Runnable interface and pass it to a new thread: