Thread can be called as light weight process. Java supports multithreading , so it allows your application to perform two or more task concurrently. Multithreading can be of advantage specially when now a days, machine has multiple CPUs, so multiple tasks can be executed concurrently.
Whenever we call main method in java, it actually creates a single main thread. Although it creates other threads too but those are related to system and known as daemon threads. So if we want to create more threads to execute task concurrently , we can use multiThreading.
Thread can be created in two ways.
- By extending Thread class
- By implementing Runnable interface
By extending Thread class:
You can create your own thread by extending Thread class and override run method. You need to create object of that class and then call start() method on it to execute thread as different threads.
Create a class FirstThread.java as below.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
package org.arpit.java2blog.thread; public class FirstThread extends Thread{ public void run() { System.out.println("Thread is running"); } } |
In above program, we have created our own thread by extending Thread class and overriding run method.
Create main class named ThreadExampleMain.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package org.arpit.java2blog.thread; public class ThreadExampleMain { public static void main(String args[]) { FirstThread ft= new FirstThread(); ft.start(); } } |
In above program ,we are creating a object of FirstThread class and calling start method to execute the thread.
When you run above program, you will get following output.
|
1 2 3 |
Thread is running |
By implementing Runnable interface:
The other way is , you need to implement Runnable interface and override public void run() method. You need to instantiate the class, pass created object to Thread constructor and call start method on thread object to execute thread as different threads.
Create a class FirthThread.java as below.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
package org.arpit.java2blog.thread; public class FirstThread implements Runnable{ public void run() { System.out.println("Thread is running"); } } |
In above program, we have created our own class and implemented Runnable interface and overridden run() method.
Create main class named ThreadExampleMain.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
package org.arpit.java2blog.thread; public class ThreadExampleMain { public static void main(String args[]) { FirstThread ft= new FirstThread(); Thread t=new Thread(ft); t.start(); } } |
In above program ,we are creating a object of FirstThread class and passing it to Thread constructor and calling start method to actually execute.The start method will eventually call run method of FirstThread class.
When you run above program, you will get following output.
|
1 2 3 |
Thread is running |
Thread vs Runnable which is better?
Implementing Runnable interface is considered to be better approach than Extending Thread due to following reasons.
- Java does not support multiple inheritance so if you extend Thread class and you can not extend any other class which is needed in most of the cases.
- Runnable interface represents a task and this can be executed with help of Thread class or Executors.
- When you use inheritance, it is because you want to extend some properties of parent, modify or improve class behavior. But if you are extending thread class just to create thread, so it may not be recommended behavior for Object Oriented Programming.
You may also like:
