Creating and Starting Java Threads

Java threads are objects like any other Java objects. Threads are instances of classjava.lang.Thread, or instances of subclasses of this class. In addition to being objects, java threads can also execute code.

Java Threads Video Tutorial

Here is a video version of this Java threads tutorial.

Creating and Starting Threads

Creating a thread in Java is done like this:

  Thread thread = new Thread();

To start the Java thread you will call its start() method, like this:

  thread.start();

This example doesn't specify any code for the thread to execute. The thread will stop again right away after it is started.

There are two ways to specify what code the thread should execute. The first is to create a subclass of Thread and override therun()method. The second method is to pass an object that implementsRunnable(java.lang.Runnableto theThreadconstructor. Both methods are covered below.

Thread Subclass

The first way to specify what code a thread is to run, is to create a subclass of Thread and override therun()method. Therun()method is what is executed by the thread after you callstart(). Here is an example of creating a JavaThreadsubclass:

  public class MyThread extends Thread {

    public void run(){
       System.out.println("MyThread running");
    }
  }

To create and start the above thread you can do like this:

  MyThread myThread = new MyThread();
  myTread.start();

Thestart()call will return as soon as the thread is started. It will not wait until therun()method is done. Therun()method will execute as if executed by a different CPU. When therun()method executes it will print out the text "MyThread running".

You can also create an anonymous subclass ofThreadlike this:

  Thread thread = new Thread(){
    public void run(){
      System.out.println("Thread Running");
    }
  }

  thread.start();

This example will print out the text "Thread running" once therun()method is executed by the new thread.

Runnable Interface Implementation

The second way to specify what code a thread should run is by creating a class that implementsjava.lang.Runnable. TheRunnableobject can be executed by aThread.

Here is a JavaRunnableexample:

  public class MyRunnable implements Runnable {

    public void run(){
       System.out.println("MyRunnable running");
    }
  }

To have therun()method executed by a thread, pass an instance ofMyRunnableto aThreadin its constructor. Here is how that is done:

   Thread thread = new Thread(new MyRunnable());
   thread.start();

When the thread is started it will call therun()method of theMyRunnableinstance instead of executing it's ownrun()method. The above example would print out the text "MyRunnable running".

You can also create an anonymous implementation ofRunnable, like this:

   Runnable myRunnable = new Runnable(){

     public void run(){
        System.out.println("Runnable running");
     }
   }

   Thread thread = new Thread(myRunnable);
   thread.start();

Subclass or Runnable?

There are no rules about which of the two methods that is the best. Both methods works. Personally though, I prefer implementingRunnable, and handing an instance of the implementation to aThreadinstance. When having theRunnable's executed by athread poolit is easy to queue up theRunnableinstances until a thread from the pool is idle. This is a little harder to do withThreadsubclasses.

Sometimes you may have to implementRunnableas well as subclassThread. For instance, if creating a subclass ofThreadthat can execute more than oneRunnable. This is typically the case when implementing a thread pool.

Common Pitfall: Calling run() Instead of start()

When creating and starting a thread a common mistake is to call therun()method of theThreadinstead ofstart(), like this:

  Thread newThread = new Thread(MyRunnable());
  newThread.run();  //should be start();

At first you may not notice anything because theRunnable'srun()method is executed like you expected. However, it is NOT executed by the new thread you just created. Instead therun()method is executed by the thread that created the thread. In other words, the thread that executed the above two lines of code. To have therun()method of theMyRunnableinstance called by the new created thread,newThread, you MUST call thenewThread.start()method.

Thread Names

When you create a Java thread you can give it a name. The name can help you distinguish different threads from each other. For instance, if multiple threads write toSystem.outit can be handy to see which thread wrote the text. Here is an example:

   Thread thread = new Thread("New Thread") {
      public void run(){
        System.out.println("run by: " + getName());
      }
   };


   thread.start();
   System.out.println(thread.getName());

Notice the string "New Thread" passed as parameter to theThreadconstructor. This string is the name of the thread. The name can be obtained via theThread'sgetName()method. You can also pass a name to aThreadwhen using aRunnableimplementation. Here is how that looks:

   MyRunnable runnable = new MyRunnable();
   Thread thread = new Thread(runnable, "New Thread");

   thread.start();
   System.out.println(thread.getName());

Notice however, that since theMyRunnableclass is not a subclass ofThread, it does not have access to thegetName()method of the thread executing it.

Thread.currentThread()

TheThread.currentThread()method returns a reference to theThreadinstance executingcurrentThread(). This way you can get access to the JavaThreadobject representing the thread executing a given block of code. Here is an example of how to useThread.currentThread():

Thread thread = Thread.currentThread();

Once you have a reference to theThreadobject, you can call methods on it. For instance, you can get the name of the thread currently executing the code like this:

   String threadName = Thread.currentThread().getName();

Java Thread Example

Here is a small example. First it prints out the name of the thread executing themain()method. This thread is assigned by the JVM. Then it starts up 10 threads and give them all a number as name ("" + i). Each thread then prints its name out, and then stops executing.

public class ThreadExample {

  public static void main(String[] args){
    System.out.println(Thread.currentThread().getName());
    for(int i=0; i
<
10; i++){
      new Thread("" + i){
        public void run(){
          System.out.println("Thread: " + getName() + " running");
        }
      }.start();
    }
  }
}

Note that even if the threads are started in sequence (1, 2, 3 etc.) they may not execute sequentially, meaning thread 1 may not be the first thread to write its name toSystem.out. This is because the threads are in principle executing in parallel and not sequentially. The JVM and/or operating system determines the order in which the threads are executed. This order does not have to be the same order in which they were started.

7 Creating and Starting Java Threads