This tutorial covers the basic concepts of multithreading in Java. It begins with explaining what is multithreading, and then shows how to create your first threads in Java using two basic approaches – extending
Thread class and implementing
Runnable interface. Both approaches are explained with Java code examples showing thread creation and execution. Lastly, the tutorial explains the reasons why ‘implementing
Runnable’ approach for creating threads is preferred over ‘extending
Conceptual basics of multithreading
(Note – You can skip the theory part in this section if you already understand basic concepts of multithreading; but I would recommend that you still give it a quick look!)
Usually when we talk of multi-programming we refer to multiple programs running on a processor. A program is a set of instructions which when executed provides a specific functionality. An example of a commonly used program is a word processor such as MS Word. From the operating system point-of-view executing instances of programs are individual processes with each process having its own memory address space allocated to it.
As a process runs, it might need to take care of multiple internal tasks in parallel in order to deliver the complete set of functionalities which it offers. For example, as a person types in the word processor, there are multiple tasks running in the background. One task is responsible for saving changes in the document in a recovery file. Another task checks for spelling and grammatical errors as the user types. Yet another task does the basic task of displaying what a user types in the editor and so on.
All the above mentioned tasks are internal to the word processor program, i.e. they share the same memory address space which has been allocated to the word processor by the operating system. At the same time these internal tasks need to execute together or in parallel to ensure the program’s functionalities are available to its users at the same time. Each of these parallel tasks are the smallest units of independent work carried out by program, and are instances of individual threads working to make the whole program work together.
To summarize the relation between programs, processes and threads. A program in execution is a process, and an executing process can have multiple threads running in parallel within it to accomplish multiple tasks that the process needs to carry out. The diagram below depicts the relationship between processes and threads.
Thread management classes in Java are all designed around management of parallel internal threads of work over their entire lifecycle – from creation to destruction. As we study basic and advanced features for multithreading in Java in this and upcoming tutorials in Java Concurrency series, we will cover all aspects related to defining, managing and optimizing threads.
To run a piece of functionality in parallel, you will need to first encapsulate it as a separate thread and then execute that thread. Let us now learn how to define and run individual thread instances as per our needs.
Creating and running a thread defined by extending Thread class
The first way of defining your own thread functionality involves sub-classing the
java.lang.Thread class. An instance of
Thread class holds a single thread of execution of a running program.
Creation of a new parallel thread using
Thread class involves the following 3 steps –
- Define a class which extends
- Override the
Threadclass, and write your custom thread logic in it.
- Invoke the
start()method on your custom
Threadsubclass to start the thread execution.
Let us now look at a code example showing thread creation by extending
Thread class, which is followed by detailed explanation of the code –
Thread. It overrides the method
run(), and provides a simple implementation which prints a single line string.
- In the
RunningThreadsclass an instance of
firstThread, is created using its default constructor.
firstThread.start()method is then invoked which starts the execution of the code inside
firstThreadin a parallel new thread.
- The newly created thread then executes and prints the line
"First thread ran"as output.
Creating and running a thread defined by implementing Runnable interface
The second way to create a parallel thread is by implementing
java.lang.Runnable interface. There are 4 steps involved in creating and running a separate thread using
- Define a class which implements
- Override the
Runnableinterface, and write your custom thread logic in it.
- Wrap the
Runnableinstance inside a new
Threadinstance. This is accomplished by using one of the multiple constructors provided by
Threadclass which accept the
Runnableinterface as parameter.
- Invoke the
start()method on the newly created
Threadinstance to start the thread execution.
Let us now see a Java code example showing how to create and run a separate custom thread by implementing
Runnable interface –
Runnableinterface. It overrides the abstract method
Runnable, and prints a single line string as part of its implementation.
RunningThreadscreates an instance of a
Threadby using its single parameter constructor which accepts a
- A parallel thread of execution for the logic contained in
SecondThreadis started by invoking the
- The parallel thread started and printed the string –
"Second thread ran"as its output.
Comparing the two approaches for thread creation
Runnable interface is preferred over extending
Thread class due to the following reasons –
- Java allows extending only a single base class. But it allows implementing multiple interfaces. So, if you extend
Thread, you cannot subclass any other class. But when you implement
Runnableyou can potentially extend another class when required.
- When a thread is implemented by extending
Threadclass then each thread instance created has a unique object associated with it. On the other hand, when you implement a thread by implementing
Runnable, and the same instance is used to create multiple
Threadinstances, then the same object is passed to different threads. So, if you create ‘n’ threads by using
extends Thread, you end up with ‘n’
Threadobjects. But when you create ‘n’ threads by using a single instance of class
implementing Runnable, you end up with only ‘1’
- From a design perspective, if you want to enhance the behavior of any class by overriding multiple of its methods, then you should extend it. So, if you need to enhance
Threadclass’ behavior by implementing methods other than
run()then only you should subclass
Thread, else implement
Runnable, and pass this instance of
Threadto start your parallel thread.
Runnablegives you the option of executing your threads via the
Executerframework as it only accepts
Runnableinstances and not
In this tutorial we understood the conceptual basics of multithreading, and then learnt how to create and run threads using
Thread class and
Runnable interface with code examples. We also looked at the preferred way of creating threads and understood the reasons for the preference. In the next tutorial, i.e. 2nd part of Java Concurrency Series, we will go through the lifecycle of a thread, look at thread priorities, and understand daemon and non-daemon threads.