Long running threads.

Question

Hello everyone,
Thanks for your interest in this post. I have a design question on a feature we are currently working on - I have described it below as best as I can. I would be thankful for any direction or guidance from all the good and experienced folks here in this forum :)
We have a system which receives some input data (say in the form of files or a db update) from external sources. We have a job which wakes up periodically, checks for the presence of new data and then does some parsing/data manipulation. I have posted it below and for the sake of brevity and conciseness kept it simple.
public class Work{  
    private SomeVar _var;  
    //constructor here  
    public void doWork(){  
         //run job  
}  Note we have multiple kind of input (so multiple Work classes each of which have different parse logic).
So far so good.
We have jdk 1.4 (no java.util.concurrent) and we dont have an option to use a scheduling f/w like quartz
Its simple enough and we dont have a need for Listeners, dynamic scheduling etc.
That leaves us with 2 options to implement this
Option 1
Create a thread for each kind of job on startup.
Each thread checks for presence of input data and creates a Work object to process the job.
public class WorkThread extends Thread{//some common functionality here}
public class SpecificWorkThread extends WorkThread{  
       private MetaInfo _meta;  
       //constructor  
       public void run(){  
          while(true){  
                //check for presence of input data  
                Work _w = new Work();  
                _w.doWork();  
                //sleep for some time  
pulic class Controller{
      psv main(String args[]){
     //for each job{
             WorkThread t = new SpecificWorkThread();
             t.start();
         //join on all threads
}  As you can see this would create (from the main), a long running thread for each job type
Option 2
Have the input data check in the controller clas. When there is input data to parse, create a Thread which does the parsing.
The thread in its run method parses and comes out. So for each parse cycle, a short lived thread is created, somthing like below
public class WorkController{  
       psv main(String args[]){  
               while(true){  
                  //check for input condition  
                  new SpecificWorkThread(new Work()).start();  
                 //sleep for sometime  
          public class SpecificWorkThread extends Thread{  
              private Work _work;  
              //constructor  
              public void run(){  
                    _work.doWork();  
        The difference between the two is that while the first creates long running threads per job type, in option(2) a thread is created on demand. Each thread is short lived (it does its job and dies), but then a thread needs to be created every time for a job.
Both would work and work correctly. What I would like to understand is if the options presented above just a programmer's prefence or is one option better than the other (performance, memory considerations) etc?
Thanks for your patience in reading this post.
cheers,
ram.

Answer 1

Generally creating a new thread is an expensive process. Well, everything is relative. My laptop can create & run & stop 7,000+ threads per second, test program below, YMMV. If you are dealing with thousands of thread creations per second, pooling may be sensible; if not, premature optimization is the root of all evil, etc.
public class ThreadSpeed
    public static void main(String args[])
     throws Exception
        System.out.println("Ignore the first few timings.");
        System.out.println("They may include Hotspot compilation time.");
        System.out.println("I hope you are running me with \"java -server\"!");
     for (int n = 0; n < 5; n++)
         doit();
        System.out.println("Did you run me with \"java -server\"?  You should!");
    public static void doit()
     throws Exception
        long start = System.currentTimeMillis();
        for (int n = 0; n < 10000; n++) {
         Thread thread = new Thread(new MyRunnable());
         thread.start();
         thread.join();
        long end = System.currentTimeMillis();
        System.out.println("thread time " + (end - start) + " ms");
    static class MyRunnable
     implements Runnable
     public void run()
}Edited by: sjasja on Jan 14, 2010 2:20 AM