{"id":79263,"date":"2020-07-01T09:00:22","date_gmt":"2020-07-01T03:30:22","guid":{"rendered":"https:\/\/techvidvan.com\/tutorials\/?p=79263"},"modified":"2020-07-01T09:00:22","modified_gmt":"2020-07-01T03:30:22","slug":"runnable-interface-in-java","status":"publish","type":"post","link":"https:\/\/techvidvan.com\/tutorials\/runnable-interface-in-java\/","title":{"rendered":"Runnable Interface in Java to Create Threads"},"content":{"rendered":"

In this article, we will learn the Runnable interface in Java, which is a core element of Java when working with threads. Any class in Java that intends to execute threads must implement the Runnable interface.<\/p>\n

In this article, we will provide you a complete insight into the Runnable interface of Java, along with the examples. So, let us start the tutorial with the introduction to the Runnable interface in Java.<\/p>\n

\"Runnable<\/a><\/p>\n

Runnable Interface in Java<\/h3>\n

Runnable interface of Java is present in the java.lang package. It is a type of functional interface that provides a primary template for objects that we want to implement using threads.<\/p>\n

We know that there are two ways to start a new Thread: Extending the Thread class and implementing the Runnable interface. There is no need to extend or subclass a Thread class when we can perform a task by overriding only the run() method of the Runnable interface.<\/p>\n

Hence the Runnable interface provides a way for a class to be active without extending the Thread class. We need to instantiate an object of the Thread and pass it in as the target.<\/p>\n

We mostly implement the Runnable interface when using no other method than the run() method. The Runnable interface defines only one method run() with no arguments and holds the code that needs to be executed by the thread.<\/p>\n

Thus the classes implementing the Runnable interface need to override the run() method.<\/p>\n

run() Method of Runnable Interface<\/h3>\n

The runnable interface has an undefined method run(). run() has void as return type, and it takes in no arguments. Below table shows the summary of the run() method:<\/p>\n\n\n\n\n
Method<\/b><\/td>\nDescription<\/b><\/td>\n<\/tr>\n
public void run()<\/span><\/td>\nThe run() method takes no arguments. When the object of a class that implements the Runnable interface creates a thread, then the run() method is invoked in the thread, and this method executes separately.<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Steps to Create New Thread using Runnable Interface<\/h3>\n

There are following steps to create a new thread using the Runnable interface:<\/p>\n

1. The first step is to create a Java class that implements the Runnable interface.
\n2. The second step is to override the run() method of the Runnable() interface in the class.
\n3. Now, pass the Runnable object as a parameter to the constructor of the object of the Thread class while creating it. Now, this object is capable of executing the Runnable class.
\n4. Finally, invoke the start method of the Thread object.<\/p>\n

Implementing Runnable Interface<\/h3>\n

Implementing a Runnable interface is the easiest way to create a thread. We can create a thread on any object by implementing the Runnable interface. To implement a Runnable, we only have to implement the run() method.<\/p>\n

In this method, there is a code that we want to execute on a concurrent thread. We can use variables, instantiate classes, and perform an action in the run() method the same way the main thread does. The thread remains active until the return of this method.<\/p>\n

The run() method establishes an entry point to a new thread.<\/p>\n

Code to implement Runnable interface in Java:<\/strong><\/p>\n

package com.techvidvan.runnableinterface;\npublic class RunnableDemo {\n  public static void main(String[] args) {\n    System.out.println(\"From main() method: \" + Thread.currentThread().getName());\n    System.out.println(\"Creating Runnable Instance\");\n    Runnable runnable = new Runnable() {@Override\n      public void run() {\n        System.out.println(\"From run() method: \" + Thread.currentThread().getName());\n      }\n    };\n\n    System.out.println(\"Creating a Thread Instance\");\n    Thread thread = new Thread(runnable);\n\n    System.out.println(\"Launching the thread...\");\n    thread.start();\n  }\n}<\/pre>\n
Output:<\/strong><\/p>\n
From main() method: main
\nCreating Runnable Instance
\nCreating a Thread Instance
\nLaunching the thread…
\nFrom run() method: Thread-0<\/div>\n
What happens when Runnable encounters an exception?<\/h3>\n
The Runnable interface can not throw checked exceptions but it can throw RuntimeException from the run() method. The exception handler of the thread handles the uncaught exceptions if JVM is unable to handle or catch them. It also prints the stack trace and terminates the program flow.<\/p>\n
Example:<\/strong><\/p>\n
import java.io.FileNotFoundException;\npublic class RunnableDemo {\n  public static void main(String[] args) {\n    System.out.println(\"The main thread is: \" + Thread.currentThread().getName());\n    Thread t1 = new Thread(new RunnableDemo().new RunnableImplementation());\n    t1.start();\n  }\n  private class RunnableImplementation implements Runnable {\n    public void run() {\n      System.out.println(Thread.currentThread().getName() + \", executing the run() method!\");\n      try {\n        throw new FileNotFoundException();\n      }\n      catch(FileNotFoundException e) {\n        System.out.println(\"Must catch an exception here!\");\n        e.printStackTrace();\n      }\n    }\n  }\n}<\/pre>\n
Output:<\/strong><\/p>\n
The main thread is: main
\nThread-0, executing the run() method!
\nMust catch an exception here!
\njava.io.FileNotFoundException
\nat RunnableDemo$RunnableImplementation.run(Example.java:21)
\nat java.lang.Thread.run(Thread.java:748)<\/div>\n
The above output shows that Runnable class can not throw checked exceptions which is FileNotFoundException in this case. It should handle the checked exceptions in the run() method but JVM automatically handles the RuntimeExceptions.<\/p>\n
Use of Runnable class in network programming<\/h3>\n
The Runnable class can also perform multi-thread programming, especially on the server-side because a server may be getting several requests from different clients. We use multi-thread programming to tackle this in a fast and resource-efficient way.<\/p>\n
Example of a networking program using Runnable:<\/strong><\/p>\n
The following program shows a server program which creates a thread, then creates a socket and waits for a client to connect to it and asks for an input string-<\/p>\n
import java.io. * ;\nimport java.net. * ;\npublic class Example {\n  public static void main(String[] args) {\n    new Thread(new SimpleServer()).start();\n  }\n  static class SimpleServer implements Runnable {@Override\n    public void run() {\n      ServerSocket serverSocket = null;\n      while (true) {\n        try {\n          serverSocket = new ServerSocket(3333);\n          Socket clientSocket = serverSocket.accept();\n\n          BufferedReader inputReader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));\n          System.out.println(\"Client said :\t\" + inputReader.readLine())\n        }\n        catch(IOException e) {\n          e.printStackTrace();\n        }\n        finally {\n          try {\n            serverSocket.close();\n          }\n          catch(IOException e) {\n            e.printStackTrace();\n          }\n        }\n      }\n    }\n  }\n}<\/pre>\n
Thread class vs. Runnable interface<\/h3>\n
\"Thread<\/a><\/p>\n
There are many differences between the Thread class and Runnable interface on the basis of their performance, memory usage, and composition.<\/p>\n