14. Multithreading and Concurrency

Overview of Multithreading

What is a Thread? A thread is the smallest unit of execution in a process. A process may have one or multiple threads that share the same memory space but execute independently.

Single-threaded vs. Multi-threaded Applications

• Single-threaded: Executes tasks sequentially. Less overhead, but poor responsiveness.
• Multi-threaded: Executes multiple tasks concurrently using different threads. Improves responsiveness and performance on multi-core processors.

This chunk provides an overview of multithreading, beginning with the definition of a thread. A thread operates as a basic execution unit within a larger process, which can consist of one or more threads. When we talk about single-threaded applications, we mean programs that can only execute one task at a time, leading to a less responsive experience. In contrast, multi-threaded applications can perform several tasks at the same time, benefiting from modern multicore CPUs that can run multiple threads concurrently. This capability enhances both performance and user experience, particularly in applications where responsiveness is critical.

Think of a single-threaded application like a waiter at a restaurant who can only take care of one table at a time. The waiter takes an order, serves food, or gets the check, one at a time, causing a delay for customers. In contrast, a multi-threaded application is like a restaurant with several waiters, each handling multiple tables simultaneously, leading to faster service and a better dining experience.

Life Cycle of a Thread

The life cycle of a thread includes:

1. New – Thread object is created but not started.
2. Runnable – Thread is ready to run and waiting for CPU.
3. Running – Thread is currently executing.
4. Blocked/Waiting – Thread is waiting for a resource or signal.
5. Terminated/Dead – Thread has finished execution or been stopped.

This chunk describes the different states a thread can be in during its life cycle. Initially, when a thread object is created, it is in the New state. Once it is ready and eligible to run, it transitions to the Runnable state but may not execute immediately because it is waiting for CPU time. When the thread begins executing its code, it is in the Running state. If the thread needs to wait for resources (like input from a user or data from a database), it enters the Blocked or Waiting state. Finally, when the task is completed or the thread is stopped for some reason, it reaches the Terminated or Dead state. Understanding these states helps programmers manage threading behavior effectively.

Imagine a team of workers in a factory. When a worker is hired, they are in the 'New' state, just getting settled. Once assigned tasks, they're 'Runnable' but might need to wait for materials, putting them 'Blocked'. When they have everything they need and are actively working, they're in the 'Running' state. After finishing their tasks or being let go, they enter the 'Dead' state, just like threads that have finished executing.

Creating Threads in Java

Using the Thread Class:

class MyThread extends Thread {
  public void run() {
    System.out.println("Thread is running");
  }
}
MyThread t1 = new MyThread();
t1.start();

Using the Runnable Interface:

class MyRunnable implements Runnable {
  public void run() {
    System.out.println("Runnable thread is running");
  }
}
Thread t2 = new Thread(new MyRunnable());
t2.start();

In this section, we learn how to create threads in Java using two approaches. The first method involves extending the Thread class and overriding its run() method to define the code to be executed by that thread. After creating an instance of MyThread, calling start() initiates the thread. The second method uses the Runnable interface. By implementing this interface, you define the run() method in a separate class (MyRunnable). A new Thread object is then created using an instance of MyRunnable, and starting it executes the run() method. Both methods are valid for creating threads, but using the Runnable interface is generally more flexible, especially when using thread pools.

Think of creating a thread like hiring a person for a job. The first method (extending Thread) is like hiring someone directly and telling them what to do. The second method (implementing Runnable) is akin to asking a contractor to complete a task, allowing them to decide how best to achieve it. Both ways get the job done, but the contractor might have extra resources and flexibility to manage tasks.

Thread Methods

Commonly used methods in the Thread class:

• start() – Starts the thread.
• run() – Contains the code executed by the thread.
• sleep(ms) – Pauses the thread for specified milliseconds.
• join() – Waits for the thread to finish.
• yield() – Suggests the thread scheduler to pause current thread and allow others to execute.
• interrupt() – Interrupts the thread.

This chunk covers key methods available in the Thread class that manage thread behavior during execution. The start() method begins the thread's execution, while the run() method defines what the thread actually does. If a thread needs a break, the sleep(ms) method temporarily halts its execution for a specified time. The join() method is useful when one thread needs to ensure that another has completed its work before proceeding. Calling yield() hints to the scheduler to give other threads a chance to run, while interrupt() can stop a thread that is currently executing, which is helpful for resource management and responsiveness.

Consider a chef in a kitchen (the thread) who has some tasks to manage. The start() method is like the chef beginning to cook. If they need to take a break, they can use sleep(ms)—like stepping away for a few minutes. If another dish relies on the first one, the join() method ensures it finishes first. Moreover, if they want to encourage other kitchen staff (other threads) to help, they can yield() and let them take over while they take a moment.

Thread Priorities and Scheduling

• Threads can be assigned priorities using setPriority().
• JVM schedules threads based on priority but exact behavior depends on the OS scheduler.
• Priorities: MIN_PRIORITY (1), NORM_PRIORITY (5), MAX_PRIORITY (10).

This chunk introduces thread prioritization, which gives some threads higher importance than others during execution. By using the setPriority() method, developers can assign priority levels to threads. The Java Virtual Machine (JVM) uses these priorities when scheduling which thread to run next—higher priority threads may run before lower priority ones. However, the actual behavior and how effectively these priorities are honored can depend on the underlying operating system's scheduling algorithms. The standard priority levels are MIN_PRIORITY (1), NORM_PRIORITY (5), and MAX_PRIORITY (10). Setting appropriate priorities allows for better control over application responsiveness and performance.

Think of a busy office with employees prioritizing tasks. Some tasks are more urgent, needing immediate attention (high priority), while others are less critical (low priority). A good manager would ensure that urgent tasks are addressed first. Similarly, thread priorities help the CPU decide which task to perform based on how critical or important it is to respond quickly.

Concurrency and Parallelism

Concurrency: Multiple tasks are in progress at the same time (context switching). It may run on a single CPU core.

Parallelism: Tasks are literally executed at the same time using multiple CPU cores.

Concurrency ≠ Parallelism, but they can coexist.

In this chunk, we differentiate between concurrency and parallelism, two important concepts in multithreading. Concurrency refers to a situation where multiple tasks are in progress and may share the CPU, often switching context between different tasks to give the illusion of simultaneous execution, even if they don't actually run at the same moment. On the other hand, parallelism implies that multiple tasks are genuinely executing at the same time, utilizing multiple CPU cores. While these concepts are related—they can work together—it's important to understand that just because tasks are concurrent doesn't mean they are parallel.

Imagine a chef cooking several dishes (concurrency) by switching between them—he stirs one pot, then moves to the next, and so forth, making progress on all without fully finishing any immediately. In contrast, in parallelism, you might have multiple chefs cooking different dishes at the same time, each entirely focused on their tasks simultaneously. Concurrency allows for efficiency when resources (like a single chef) are limited but may not utilize the full potential of multiple resources.

Synchronization

When multiple threads access shared resources (variables, files, databases), data inconsistency may arise. Synchronization ensures that only one thread accesses a critical section at a time.

Synchronized Methods:

synchronized void increment() {
  count++;
}

Synchronized Blocks:

synchronized(this) {
  // critical section
}

In this chunk, we explore the concept of synchronization, which is crucial when multiple threads interact with shared resources. Without proper synchronization, the state of shared data could become inconsistent as threads read and write simultaneously. To prevent this, synchronization allows only one thread to enter a critical section of code at any one time, preventing conflicts. Synchronized methods and synchronized blocks are two ways to implement this in Java, ensuring that when one thread is executing a synchronized method or block, no other thread can access the same resource until it's done.

Imagine a shared kitchen where multiple chefs (threads) prepare food using the same stove (a shared resource). If all chefs work at the same time without organization, chaos ensues; they may bump into each other, and dishes might end up ruined. By using a system where only one chef can use the stove at a time (synchronization), they ensure that cooking happens smoothly, and no dish is compromised.

Inter-thread Communication

Threads can communicate using wait(), notify(), and notifyAll() methods from the Object class.

Example:

synchronized(obj) {
  obj.wait(); // thread waits
  obj.notify(); // wakes one waiting thread
}

This chunk discusses inter-thread communication, which is essential for managing interactions between threads. In scenarios where one thread needs to wait for another to complete a task or signal that it's okay to proceed, the wait(), notify(), and notifyAll() methods are utilized. A thread that calls wait() on an object will pause until another thread calls notify() (or notifyAll()), signaling that it can continue. This mechanism helps synchronize thread operations and ensures they function together effectively when sharing resources.

Picture a classroom where a teacher (one thread) is explaining a lesson (a task). During this time, students (another thread) cannot ask questions; they wait for the teacher to invite them to speak. When the teacher calls on a student to ask a question (notify()), that student can then participate (wait() ends), allowing for a smoother interaction where no one interrupts the lesson unnecessarily.

Deadlock and Its Avoidance

Deadlock: Occurs when two or more threads are blocked forever, each waiting for the other to release a lock. Example: Thread A locks Resource 1 and waits for Resource 2; Thread B locks Resource 2 and waits for Resource 1.

Avoiding Deadlock:

• Lock ordering
• Timeout for lock acquisition
• Using try-lock mechanisms (e.g., ReentrantLock.tryLock()).

In this portion, we define deadlock, a scenario where two or more threads become stuck, unable to proceed because each is waiting on the other to release resources. For example, if Thread A locks Resource 1 and is waiting for Resource 2, while Thread B locks Resource 2 and waits for Resource 1, neither can continue. To prevent this situation, developers can implement strategies like lock ordering (always acquiring locks in a consistent order), using timeouts when trying to acquire locks, or using advanced locking mechanisms that provide alternatives to simple locking.

Imagine two people trying to pass through a narrow doorway from opposite sides. Person A is blocking the door from one side while trying to let Person B go first, yet Person B is equally focused on letting Person A through. Neither can move forward—this excessive politeness represents deadlock. To avoid this, they might agree to a system where one side always yields first (lock ordering) or uses a wider door (a more effective locking strategy) to keep moving.

Thread-safe Collections and Concurrent Utilities

Java provides thread-safe collections and utilities in the java.util.concurrent package.

Key Classes:

• ConcurrentHashMap
• CopyOnWriteArrayList
• BlockingQueue
• ExecutorService
• Semaphore, CountDownLatch, CyclicBarrier

These allow high-performance concurrent programming without manually handling synchronization in many cases.

This chunk highlights Java's support for thread-safe collections and utilities, which make it much easier for developers to write concurrent applications without worrying about data inconsistencies or manually managing synchronization. Key classes like ConcurrentHashMap, CopyOnWriteArrayList, and BlockingQueue provide data structures designed to work seamlessly in multi-threaded environments. Additionally, utility classes like ExecutorService for managing thread pools and synchronization aids like Semaphore help streamline the development of concurrent applications, improving performance and reducing potential errors.

Consider a bank where multiple customers can access accounts (threads) at the same time. A thread-safe collection acts like security personnel who ensure that no two customers can access the same account simultaneously and that everything is processed accurately. This way, customers can conduct transactions without worrying about errors, similar to high-performance concurrent programming facilitated by these collections.

Executors and Thread Pools

Executors: Provide a flexible way to manage and reuse threads via thread pools.

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.execute(new Task());
executor.shutdown();

Types:

• FixedThreadPool
• CachedThreadPool
• SingleThreadExecutor
• ScheduledThreadPool

Advantages:

• Better resource management
• Avoids thread exhaustion
• Reduces latency from frequent thread creation/destruction.

In this section, we learn about executors, which are a higher-level abstraction for working with threads in Java. They manage a pool of threads and allow the developer to submit tasks without needing to manage individual thread lifecycles. By using an ExecutorService, you can create a fixed thread pool with a specified number of threads, execute tasks efficiently, and shut down the pool when done. Different types of executors offer various functionalities to fit different use cases. Key advantages of using thread pools include improved resource management, reduced overhead from creating and destroying threads frequently, and minimizing the risk of thread exhaustion, ultimately enhancing application performance.

Imagine a factory that uses machinery (threads) to produce goods. A worker (the executor) assigns tasks to the machines based on their availability without the need to constantly turn them on and off (manage threads). By efficiently utilizing the machines, production runs smoothly with minimal downtime. Using an executor is like having a smart production manager who optimizes the workflow without the chaos of machine malfunctions.

Atomic Variables

java.util.concurrent.atomic Package: Provides lock-free, thread-safe operations on single variables.

Examples:

• AtomicInteger
• AtomicBoolean
• AtomicLong

AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();

This chunk introduces atomic variables, which are special classes in the java.util.concurrent.atomic package designed for single-variable operations without the need for synchronization. Each atomic class, such as AtomicInteger, AtomicBoolean, and AtomicLong, allows for lock-free operations that are inherently thread-safe. For instance, the incrementAndGet() method in AtomicInteger updates the value atomically, ensuring that no other threads can interfere during the operation. Using atomic variables simplifies coding and enhances performance in multi-threaded environments, reducing the risk of race conditions.

Imagine bank transactions where a customer can withdraw money from an account (the variable). If two customers try to withdraw money simultaneously (threads), using regular checks might lead to errors and inconsistencies. An atomic variable is like a secure vault that allows only one transaction at a time, ensuring that every withdrawal is accurate and preventing any mishaps, making the process much safer.

Fork/Join Framework (Advanced Topic)

Used for divide-and-conquer style parallelism.

Example: Breaking a task into smaller subtasks recursively (e.g., merge sort), running them in parallel using ForkJoinPool.

ForkJoinPool pool = new ForkJoinPool();
pool.invoke(new RecursiveTaskImpl());

This section focuses on the Fork/Join Framework, which is a powerful tool in Java for performing parallel tasks that can be broken down into smaller subtasks. It is particularly useful for divide-and-conquer algorithms such as sorting. When invoked, the framework divides a main task into smaller subtasks that can be executed in parallel, significantly speeding up processing time. The ForkJoinPool manages this parallel execution, making it easier for developers to implement complex algorithms without diving deep into managing threads.

Picture a large construction project where the main job is to build a large building (task). Instead of just one crew working on the whole project, the job gets divided into many smaller parts (subtasks), such as electrical, plumbing, and framing teams. Each team works simultaneously on their part of the project. This method drastically speeds up the overall process, analogous to how the Fork/Join Framework allows tasks to be processed in parallel, enhancing efficiency between smaller jobs.

Best Practices for Multithreading

• Minimize synchronization to reduce contention.
• Prefer concurrent utilities over manual synchronization.
• Avoid sharing mutable state.
• Always shut down executor services.
• Use thread-safe data structures.
• Avoid unnecessary thread creation.
• Use thread pools for large-scale task execution.
• Use profiling tools to detect deadlocks and performance bottlenecks.

In this final chunk of the section, we outline best practices for effective multithreading. Minimizing synchronization helps reduce contention, leading to better performance. It’s advisable to use built-in concurrent utilities instead of handling synchronization manually. Additionally, avoiding shared mutable states can prevent issues and conflicts between threads. Always shutting down executor services ensures clean resource management. Utilizing thread-safe data structures further supports reliable concurrent programming. Avoiding unnecessary thread creation and opting for thread pools makes execution more efficient, while profiling tools can help identify and resolve deadlocks and performance bottlenecks.

Think of a restaurant where the kitchen staff must work smoothly together to prepare orders. If each chef keeps their workspace organized (minimizing synchronization), they can perform their duties without bumping into one another (contention). Instead of everyone shouting orders across the kitchen, having a clear system for communication (using concurrent utilities) ensures efficiency. The best practices for multithreading are like these workflows in a well-run kitchen, supporting speed, organization, and minimal errors.

--