What will I learn?
This tutorial covers following topics:
Requirements
Difficulty
Intermediate, you must have good knowledge of basics of Java programming to catch up this tutorial.
Tutorials Content
In the previous tutorial, we learned different stages of Lifecycle of thread and creating threads using thread class. Now we will create the thread by converting classes into threads.
Converting class to thread
In our first part of this tutorial series we discussed in detail on how threads are created using thread class, now we are converting classes into a thread. This way of creating threads is also known as the creation of thread by implementing a Runnable interface.
Here, Runnable interface is implemented in class which declares the run() method which creates the thread. At first, we will create a class which implements the Runnable interface and then we run() method to create threads. And we will call start() method to run the thread.
Example:
We will see by example with two classes AreaSquare and PeriSquare to calculate area and perimeter of square respectively. Both of the classes implement Runnable interfaces.
We use run() method to create thread objects and is initiated in ThreadTesting class by start() method.
//creating class which implements Runnable interface
class AreaSquare implements Runnable
{
//run method to create thread
public void run()
{
int[] len = {5,6,7};
for (int i = 0; i< len.length; i++ )
{
int area = len[i] * len[i];
System.out.println("Area is " + area);
}
}
}
class PeriSquare implements Runnable
{
public void run()
{
int[] len = {7,8,9};
for (int i = 0; i< len.length; i++ )
{
int perimeter = 4 * len[i];
System.out.println("Perimeter is " + perimeter);
}
}
}
class ThreadTesting
{
//main method
public static void main(String args[])
{
//creating class object
AreaSquare a = new AreaSquare();
//thread object
Thread thread1 = new Thread(a);
//invoking run method
thread1.start();
PeriSquare b = new PeriSquare();
Thread thread2 = new Thread(b);
thread2.start();
}
}
Output:
Area is 25
Perimeter is 28
Area is 36
Perimeter is 32
Area is 49
Perimeter is 36
BUILD SUCCESSFUL (total time: 0 seconds)
As mentioned in first part of this tutorial, we have three threads in total, two threads we created by implementing the Runnable interface and one as the main program.
All the threads are running independently and they may be executed whenever processor can have time for them thus, they don't have a special sequence of outputs.
Differences between the two ways of creating threads
We created threads by extending Thread class and by implementing the Runnable interface. There are differences between these methods and advantages of using one way over another. Some of them are listed below:
Implementing runnable interface will not inherit all the method we needed or not needed of Thread class as extending Thread class.
As multiple inheritance is not supported in Java, extending a class with Thread class won't allow that particular class to extend other class but using Runnable interface we can extend our Thread class.
Just to use run() method we have to extend our class with Thread class which means we aren't modifying any other thing and it isn't good practice in object-oriented programming so implementing Runnable will be the best choice while creating threads.
Runnable interface shares same object space whereas extending Thread class has different object space for different threads, thus implementing Runnableuses less memory.
Conclusion
We learned to create threads by converting the class to a thread and concluded implementing the Runnable interface is better than extending Thread class while creating threads.
All above codes can be found on my GitHub link. Click here to download.
What's next?
In coming tutorials we will learn:
Curriculam
Multithreading in Java : Part I