Thread & Runnable In Java

Thread 

Thread in Java is an independent path of execution which is used to run two task in parallel. When two Threads run in parallel that is called multi-threading in Java. Java is multi-threaded from start and excellent support of Thread at language level e.g. java.lang.Thread class, synchronized keyword, volatile and final keyword makes writing concurrent programs easier in Java than any other programming language e.g. C++. Being multi-threaded is also a reason of Java's popularity and being number one programming language. On the other hand if your program divides a task between two threads it also brings lot of programming challenges and issues related to synchronization, deadlock, thread-safety and race conditions. In short answer of question What is Thread in Java can be given like "Thread is a class in Java but also a way to execute something in parallel independently in Java". Thread in Java requires a task which is executed by this thread independently and that task can be either Runnable or Callable.

Runnable

Runnable represent a task in Java which is executed by Thread. java.lang.Runnable is an interface and defines only one method called run(). When a Thread is started in Java by using Thread.start() method it calls run() method of Runnable task which was passed to Thread during creation. Code written inside run() method is executed by this newly created thread. Since start() method internally calls run() method its been a doubt among Java programmers that why not directly call the run() method. This is also asked as what is difference between start() and run() method in Java. Well when you call Runnable interface run() method directly , no new Thread will be created and task defined inside run() method is executed by calling thread.  There is another interface added in Java 1. 5 called Callable which can also be used in place of Runnable interface in Java. Callable provides additional functionality over Runnable in terms of returning result of computation. Since return type of run() method is void it can not return anything which is sometime necessary. On the other hand Callable interface defines call() method which has return type as Future which can be used to return result of computation from Thread in Java.

Example 

package sachi.test.threads;

public class Program{

  public static void main (String[] args) {

    Runner r = new Runner();

    Thread t1 = new Thread(r, "Thread A");

    Thread t2 = new Thread(r, "Thread B");

    Thread s1 = new Strider("Thread C");

    Thread s2 = new Strider("Thread D");

    t1.start();

    t2.start();

    s1.start();

    s2.start();

  }

}

class Runner implements Runnable {

  private int counter;

  public void run() {

    try {

      for (int i = 0; i != 2; i++) {

        System.out.println(Thread.currentThread().getName() + ": " 

              + counter++);

        Thread.sleep(1000);

      }

    }

    catch(InterruptedException e) {

      e.printStackTrace();

    }

  }

}

class Strider extends Thread {   

  private int counter;

  Strider(String name)    {

    super(name);

  }

  public void run()   {

    try {

      for (int i = 0; i != 2; i++) {

        System.out.println(Thread.currentThread().getName() + ": " 

            + counter++);

        Thread.sleep(1000);

      }

    }

    catch(InterruptedException e)     {

      e.printStackTrace();

    }

  }

}

Output:

Thread B: 1

Thread D: 0

Thread C: 0

Thread A: 0

Thread D: 1

Thread A: 3

Thread C: 1

Thread B: 2

Difference between Threads & Runnable.

1. Implementing Runnable is the preferred way to do it. Here, you’re not really specializing or modifying the thread’s behavior. You’re just giving the thread something to run. That means composition is the better way to go.

2. Java only supports single inheritance, so you can only extend one class.

3. Instantiating an interface gives a cleaner separation between your code and the implementation of threads.

4. Implementing Runnable makes your class more flexible. If you extend thread then the action you’re doing is always going to be in a thread. However, if you extend Runnable it doesn’t have to be. You can run it in a thread, or pass it to some kind of executor service, or just pass it around as a task within a single threaded application.

5. By extending Thread, each of your threads has a unique object associated with it, whereas implementing Runnable, many threads can share the same runnable instance.