1. Multithreading and Concurrency

Modern applications demand high performance and responsiveness. Whether it’s a server handling thousands of client requests, or a GUI application staying responsive while performing background tasks—concurrency and multithreading are at the heart of such solutions. Java, being one of the earliest mainstream programming languages to support multithreading natively, provides powerful constructs to implement concurrent behavior. This chapter introduces the core concepts of threads, thread life cycle, synchronization, concurrent APIs, and best practices in concurrent programming.

This chunk emphasizes the importance of multithreading in creating efficient applications. Multithreading allows multiple processes to occur simultaneously, which is vital for applications that need to operate smoothly, like servers or user interfaces. Java supports this feature inherently, giving developers tools to manage threads effectively through this chapter's topics.

Imagine a busy restaurant kitchen where multiple chefs are working on different dishes at the same time. Half of them are preparing salads while others are grilling meats. This setup ensures that orders are fulfilled faster, similar to how multithreading allows software to handle multiple tasks concurrently.

A thread is a lightweight subprocess, the smallest unit of processing. Threads share the same memory space but execute independently.

✅ Key Points: • Every Java application has at least one thread – the main thread. • You can create multiple threads to perform tasks in parallel.

A thread is akin to a mini-program within a larger program. It allows for concurrent execution of operations. In Java, every program starts with at least one thread, known as the main thread. Additional threads can be added to manage different tasks simultaneously, improving the performance of applications.

Consider a library where one person is checking out books while another is reshelving them. Both activities can happen independently and concurrently, just like threads executing tasks within a program.

There are two primary ways to create threads in Java:

1. Extending the Thread class

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running.");
    }
}
public class Test {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // starts a new thread
    }
}

2. Implementing the Runnable interface

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable thread is running.");
    }
}
public class Test {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
    }
}

Threads in Java can be created in two main ways. The first method is by extending the Thread class and overriding its run() method to define what the thread will do. The second method is by implementing the Runnable interface, which allows you to define a thread's behavior in a more flexible manner. Using Runnable is often preferred because it allows a class to extend another class.

Think of a chef who can either cook alone (extending Thread) or collaborate with a team where each member brings their own skills (implementing Runnable). The second option is often more versatile and efficient.

A thread in Java can be in one of the following states:

1. New – Created but not yet started.
2. Runnable – Eligible to run, waiting for CPU.
3. Running – Actively executing.
4. Blocked/Waiting – Waiting for a monitor lock or a signal.
5. Terminated – Execution completed or stopped.

The life cycle of a thread includes several states it can be in: 'New' when created, 'Runnable' when it can run but is waiting for CPU time, 'Running' when actively executing tasks, 'Blocked/Waiting' if it is waiting for another resource, and 'Terminated' when the execution is finished. Understanding these states helps developers manage threads more effectively.

Imagine a bus system where buses represent threads. A bus is 'New' when it is built, 'Runnable' when it waits at the station for passengers, 'Running' when it is transporting passengers, 'Blocked' if it stops due to traffic, and 'Terminated' when it completes its route.

Java relies on the JVM and underlying OS for thread scheduling. Threads are assigned priorities (1 to 10) to suggest execution order, but it’s not guaranteed.

t1.setPriority(Thread.MAX_PRIORITY); // 10

Thread scheduling determines the order in which threads are executed, handled by the Java Virtual Machine (JVM) and the operating system. You can set a thread's priority from 1 (lowest) to 10 (highest) to influence scheduling, though the actual execution order may vary.

Think of the traffic system where emergency vehicles have higher priority over regular cars. They get to move first even if both are on the same road. Similarly, higher priority threads suggest their importance, but other factors may influence who runs first.

When multiple threads access a shared resource (like a variable or object), race conditions may occur. Java provides synchronized blocks and methods to control access.

Example: Synchronized Method

class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
}

Synchronized Block

synchronized(obj) {
    // critical section
}

Synchronization is crucial when multiple threads access shared resources to prevent race conditions, which can lead to inconsistent data. Java provides synchronized methods and blocks, ensuring that only one thread can access a resource at a time, thus maintaining data integrity.

Imagine a bank where two tellers cannot access the cash register at the same time. If they did, there might be confusion over how much money is available. By having a system that allows only one teller (thread) to use the register at a time, accuracy is ensured.

Java provides methods to facilitate communication between threads: • wait() – causes the thread to wait. • notify() – wakes a single waiting thread. • notifyAll() – wakes all waiting threads. These must be used within synchronized blocks.

 synchronized(obj) {
    obj.wait();
    obj.notify();
} 

Inter-thread communication allows threads to cooperate in processing tasks. The wait() method makes a thread wait until another thread signals it using notify() or notifyAll(). These functions work best within synchronized blocks to avoid inconsistencies.

Picture a team project where one member waits for another to complete their part before proceeding. If the first member is like a thread that is waiting (wait()), the second is responsible for signaling (notify()) once they're done, allowing the first to continue working.

The java.util.concurrent package provides advanced concurrency utilities introduced in Java 5 and beyond.

Important Classes:

• ExecutorService: Thread pool executor
• Future and Callable: Represent async computation
• CountDownLatch: Allows threads to wait until others finish
• Semaphore: Controls access to a resource
• CyclicBarrier: Synchronizes threads at a barrier
• ConcurrentHashMap: Thread-safe map

Example: ExecutorService

ExecutorService executor = Executors.newFixedThreadPool(2);
Runnable task1 = () -> System.out.println("Task 1 running");
Runnable task2 = () -> System.out.println("Task 2 running");
executor.execute(task1);
executor.execute(task2);
executor.shutdown();

Example: Callable and Future

Callable<Integer> task = () -> {
    Thread.sleep(1000);
    return 123;
};
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(task);
System.out.println("Result: " + future.get()); // blocks until result is available

The java.util.concurrent package offers a variety of utility classes that simplify concurrent programming tasks. For instance, ExecutorService manages a pool of threads to efficiently execute tasks, while Callable and Future allow for asynchronous processing and retrieval of results, respectively. These utilities help manage threading complexity and enhance performance.

Imagine a hotel where guests can order room service (tasks). Instead of relying on one waiter (thread) to run around for every order, a team of waiters (thread pool) handles orders more efficiently. Guests can receive their food timely and without hassle (concurrent execution using ExecutorService).

Creating too many threads can be expensive. Thread pools manage a pool of reusable threads.

ExecutorService pool = Executors.newFixedThreadPool(5);

Advantages: • Better resource utilization • Avoids overhead of thread creation • Efficient for batch jobs and servers

Thread pools are a resource management technique that allows a predefined number of threads to be reused for executing multiple tasks. This approach significantly reduces the overhead of creating and destroying threads, enabling applications to handle multiple tasks more efficiently. It's particularly beneficial for server applications that frequently handle requests.

Think of a pizza shop with a fixed number of chefs (threads) who can prepare multiple pizzas (tasks). Instead of hiring new chefs for every order, they reuse the same chefs, ensuring quick turnaround and efficient use of time and resources.

Issue Description:

• Race Condition: When multiple threads change shared data simultaneously
• Deadlock: Two or more threads are waiting forever for each other
• Starvation: A thread waits indefinitely for a resource
• Livelock: Threads keep changing state but make no progress

Example: Deadlock

 synchronized(obj1) {
     synchronized(obj2) {
         // potential deadlock if another thread does reverse locking
     }
 }

Concurrent programming introduces several issues that can hinder performance and reliability. A race condition occurs when two threads simultaneously modify shared data, leading to unexpected results. Deadlocks happen when two threads are stuck waiting for each other, while starvation occurs when a thread is perpetually denied access to a resource. Livelock, a variant of deadlock, refers to threads that are active but still cannot progress. Understanding these issues helps developers avoid common pitfalls.

Imagine two people trying to exit a narrow hallway at the same time. If each waits for the other to move first, they become stuck (deadlock). If one person keeps stepping to the side to let the other pass but doesn't go anywhere, that's like livelock. Race conditions are like two people trying to complete a puzzle at the same time but ending up confusing the pieces.

• Minimize shared mutable state. • Prefer java.util.concurrent over low-level constructs. • Use thread pools. • Avoid nested locks to prevent deadlocks. • Prefer Atomic variables (AtomicInteger, etc.) for counters.

Best practices in concurrent programming focus on writing efficient, safe, and maintainable code. Minimizing shared mutable state reduces complexity and the risk of race conditions. Utilizing java.util.concurrent aids in better leveraging available concurrency features compared to lower-level constructs. Employing thread pools conserves resources, while avoiding nested locks can help prevent deadlock situations. Where possible, using Atomic variables ensures safe updates without the overhead of synchronization.

In a group project, one best practice is to limit how many people handle the same document to avoid confusion. Using shared drives (thread pools) is preferred over sending copies back and forth (low-level constructs) as they allow everyone to work simultaneously without stepping on each other's toes.

Multithreading and concurrency enable Java programs to perform multiple tasks simultaneously, improving performance and responsiveness. While powerful, concurrency requires careful handling of shared resources, synchronization, and potential pitfalls like race conditions and deadlocks. Java offers both low-level thread APIs and high-level concurrency utilities (ExecutorService, Callable, ConcurrentHashMap, etc.) to help developers write robust multi-threaded applications.

In summary, multithreading and concurrency are vital for creating responsive and efficient Java applications. Developers must be mindful of potential challenges, like race conditions and deadlocks, while leveraging the tools and features Java provides for effective concurrent programming.

Think of a well-oiled factory that creates products efficiently by having multiple assembly lines (threads) working simultaneously. Each worker needs to coordinate and communicate to succeed. Similarly, Java provides the necessary tools to manage multiple coding 'assembly lines' effectively.

--