Select Page

Introduction to Using Threads in Java

Developer.com Staff
Published: July 3, 2022

Java Developer Tutorials

Modern computer systems are designed with multiple CPU cores. These cores allow multiple processes (or multiple threads of a process) to run concurrently on different cores.

The idea behind this process – known as multithreading – is to ensure optimal use of the CPU and better application performance. As a programmer, you can design programs that allow multiple threads to be executed at the same time, in parallel, versus one at a time.

In this Java programming tutorial, developers will learn how to use the Java API to create a multithreaded application.

Read: The Top Tools for Remote Developers

What are Threads in Java?

In Java, and other programming languages, a thread is a basic unit of CPU utilization. Threads are part of a process. A simple way to look at a process is to think of a program that is being executed.

This definition is not 100% accurate, however. It is possible for a program to have multiple processes. The definition provided above is only a simple and useful way of looking at a process.

As mentioned earlier, processes contain threads. A thread shares the data, code, and other resources of a process with other threads of the same process.

In Java, developers can build multithreaded applications. Multithreading allows sections of your program to run concurrently or in parallel, thereby giving your application a significant performance boost.

It’s important to differentiate between concurrency and parallelism. A program can run concurrently while not running in parallel.

Concurrency refers to multiple parts of the same program being executed (not at the same time). These different parts are executed through time sharing. On the other hand, parallelism refers to multiple parts of the same program being executed at the same time.

It is possible to achieve concurrency on single core systems through interleaving. However, parallelism can only be achieved on a multicore system through running multiple threads on different cores.

Threads can also be used to counter the performance overhead that is caused during process creation. This is particularly important when it comes to performing repeated tasks that your program must execute.

A good example to demonstrate this would be a web server. You could let your server create a new process every time a user makes a request. However, this would require that a user to first be completed before that request of the next one is also handled.

If you were using a multithreaded application, your server would simply have a new thread to handle the new request. Since threads share the same resources of a process, this would save your program the need to allocate new resources & the overhead that comes with it.

Read: Tips to Improve Performance in Java

How to Implement Threads in Java

There are two ways in which you can use threads in your Java applications. The first way is to implement the Runnable interface. When you implement this interface, you must provide the body for the run() method in your class. This code is the one that your thread will run. Here is a code example showing how to implement a thread in Java using the Runnable interface:

class Y implements Runnable {
void run(){
// must provide method body
}
}

The second way to use threads is by extending the Thread class, which itself implements the Runnable interface. In the subclass, you need to override the run() method, as shown below:

class Z extends Thread {
}

See the fully working code example below:

class ThreadDemo extends Thread{

   public static void main(String args[]) {
       System.out.println("Printed from the thread of main()");
       ThreadDemo demo = new ThreadDemo();
       demo.start();
   }
  
   public void run(){
       System.out.println("Printed from the thread of run()");
   }
}

In the example above, there are two threads in the program. The first thread is from the main() method, since program execution begins here. The second thread in the program is from the run() method. It is important to note that, when you instantiate the class, the thread is not created immediately. The thread is created when the start() method is called.

Still want more information on creating multiple threads in Java? Check out our tutorial: Multithreading in Java for more.

Final Thoughts on Using Threads in Java

This programming tutorial has introduced how you can use the Java Threads API and the benefits of multithreading. When writing your usual Java applications, you may just leave the JVM to handle the threads for you.

The JVM generally runs one program thread at time, something that may not be suitable for systems that require speed, like gaming applications. Therefore, it is necessary for you as a programmer to learn how you can create multithreaded applications.

Read more Java programming tutorials and guides to software development.

Source: www.developer.com