Java Threading – Runnable Interface

A Runnable is an abstraction for an executable command.

It’s an interface that defined in the java.lang package:

package java.lang;

public interface Runnable{}

Usage

The Runnable interface is used extensively to execute code in Threads.

The Runnable interface has one abstract method called run():

public abstract void run ()

Normally you implement that method whenever a your class implements Runnable interface.

The method will then get called to start executing the active part of the class’ code.

Runnable Interface Grandchildren

Well we mean indirect subclasses. Runnable has alot of them so we list only afew commonly used:

Let’s now see some examples:

Java Runnable Example

Let’s see an example of Java Runnable with Threads.

1. First specify your application’s package:

   package info.tutorialsloop;

   Packages group classes.

2. Create the class:

   public class Main{}

3. Let’s make our class implement Runnable interface:

   public class Main implements Runnable {}

4. This will force us override the run() method.So we do so:

   @Override
   public void run() {
   
   }

5. Let’s create two fields at the class level.One to represent the distance our Spaceship has travelled while another a boolean to be flagged to false or true depending on whether we’ve arrived or not:

   private static int spaceship_distance=0;
   private boolean arrived=false;

6. Then go back to the run() method and add the following code:

       while (!arrived)
       {
           try{
               System.out.println("Distance in Light Years : "+spaceship_distance++);
               Thread.sleep(1000);
               if(spaceship_distance==10)
               {
                   arrived=true;
                   System.out.println("Reached Destination. Thanks.");
               }
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

7. We then create our main method:

   public static void main(String[] args) {
   
   }

8. Then add the following code in the main method:

       Main m=new Main();
       Thread myThread=new Thread(m);
       myThread.start();

   Basically we are instantiating a thread and passing in our Main class instance. We then start the thread via the start() method.

Here’s what we get:

Distance in Light Years : 0
Distance in Light Years : 1
Distance in Light Years : 2
Distance in Light Years : 3
Distance in Light Years : 4
Distance in Light Years : 5
Distance in Light Years : 6
Distance in Light Years : 7
Distance in Light Years : 8
Distance in Light Years : 9
Reached Destination. Thanks.