Understanding Multiple Threads in Java

-

Introduction
In Java programming, achieving parallel execution of tasks is made possible using multithreading. This blog explores how to create and run multiple threads concurrently, why using start() is critical, how scheduling works, and additional tips like using sleep() for clearer outputs.

Demonstrating Multiple Threads

Let's start with a simple example. We define two threads—one to say “Hi” and another to say “Hello”.

class HiThread extends Thread {
  public void run() {
    for(int i = 0; i < 5; i++) {
      System.out.println("Hi");
      try { Thread.sleep(500); } catch(Exception e) {}
    }
  }
}

class HelloThread extends Thread {
  public void run() {
    for(int i = 0; i < 5; i++) {
      System.out.println("Hello");
      try { Thread.sleep(500); } catch(Exception e) {}
    }
  }
}

public class MultiThreadApp {
  public static void main(String[] args) {
    new HiThread().start();
    new HelloThread().start();
  }
}

Notice the Thread.sleep(500) call inside each loop. It slows execution for half a second, making it easier to see interleaved outputs.

Understanding Interleaving of Output

When both threads run, you might see:

  • Hi Hello Hi Hello...
  • Hello Hi Hello Hi...
  • Or even a mixed sequence.

This happens because thread execution is controlled by the operating system's scheduler, not by your code directly.

How Java Thread Scheduling Works

After initiating threads using start(), the OS scheduler decides which thread gets CPU time and when. It uses techniques like time-slicing and priorities to manage execution. On multi-core processors, true parallel execution is also possible.

Creating Threads: Two Approaches

  • Extending Thread: Inherit from the Thread class and override its run() method.
  • Implementing Runnable: Implement the Runnable interface and pass its instance to a Thread constructor.

Thread Priorities

Each thread in Java has a priority, ranging from Thread.MIN_PRIORITY (1) to Thread.MAX_PRIORITY (10). The default is Thread.NORM_PRIORITY (5). While priorities suggest scheduling order to the JVM, the OS ultimately controls execution, so results may vary.

Managing Thread Safety

When multiple threads modify shared data, issues such as race conditions may arise. Even though this video doesn’t go deep into that, it's important to know that Java provides:

  • synchronized methods/blocks
  • Volatile variables
  • Thread-safe collections and atomic classes

Key Takeaways

  • You can run multiple Java threads concurrently using start().
  • Using sleep() helps demonstrate clearer interleaving of outputs.
  • The OS scheduler governs thread execution order and timing.
  • Java supports threading via either extending Thread or implementing Runnable.
  • Thread priorities exist, but exact scheduling is not guaranteed.
  • Concurrency introduces challenges like race conditions, requiring synchronization.

Conclusion

Mastering multiple threads in Java is a vital skill—essential for building responsive and efficient applications. While this guide offers a solid starting point, the real power lies in managing synchronization, priorities, and advanced concurrency tools.

Comments

Post a Comment

Popular posts from this blog

Spring Boot on AWS EC2: Upload to S3 Securely Using IAM Role

-
When running a Spring Boot application on AWS EC2 , the most common security mistake is hardcoding AWS access keys inside application.properties . This is unnecessary and risky. AWS already provides a secure mechanism: IAM Roles attached to EC2 . In this blog, you will learn how to upload and download files to Amazon S3 from Spring Boot running on EC2 without any access keys , using: Spring Profiles AWS SDK v2 Instance Metadata Service (IMDS) IAM Roles Why Access Keys Are a Bad Idea on EC2 Typical S3 setups use: Access key Secret key Region Bucket This works only for local development. It should NOT be used on EC2. Problems with access keys: Stored in config or code (high risk) Might leak through Git, logs, or screenshots Require manual rotation Not needed if app runs on EC2 AWS automatically manages temporary credentials using the EC2 Instance Profile (IAM Role) . Architecture: EC2 → IAM Role → S3 Spring Boot app r...
Read more

Java Streams Intermediate Operations Explained with Examples

-
Image
The Java Stream API lets you process collections in a fluent, declarative style. In this post, we’ll walk through the most useful intermediate operations with simple examples. Note: Examples below use Java 8 compatible collect(Collectors.toList()) . If you’re on Java 16+, you can replace it with toList() . 1) filter() — Select elements by a condition Keeps only elements that match the predicate. List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); List<Integer> res = list.stream() .filter(num -> num % 2 != 0) // keep only odd numbers .collect(Collectors.toList()); System.out.println(res); // [1, 3, 5, 7, 9] 2) map() — Transform each element Applies a function to every element and returns a stream of results. List<String> strs = Arrays.asList("rama", "anjaneya", "krishna"); List<String> upper = strs.stream() .map(String::toUpperCase) .collect(Collectors.toList()); System.o...
Read more

ConcurrentHashMap vs Synchronized HashMap in Java

-
Image
Introduction In multi-threaded Java applications, managing shared data safely and efficiently is crucial. Two common approaches are using Synchronized HashMap (via Collections.synchronizedMap(...) ) and ConcurrentHashMap . While both aim to provide thread-safety, their implementations and performance characteristics differ significantly. This post explores these differences in detail. What is a Synchronized HashMap? Created by wrapping a regular HashMap using: Map<K, V> syncMap = Collections.synchronizedMap(new HashMap<>()); Enforces synchronization at the object level , meaning only one thread can access the map at any time (read or write). Supports null keys and values since it relies on HashMap behavior. Iterators are fail-fast , throwing ConcurrentModificationException if the map is modified while iterating. Simpler implementation, suitable when concurrency is low or performance is not cri...
Read more