Multithreading in Java

Multithreading and Parallel Programming

• Multithreading is a Java feature allowing concurrent execution of two or more program parts.
• Threads are lightweight processes within a process, utilized for maximum CPU utilization.
• Threads can exist in five states: New, Ready, Running, Blocked, and Finished.

Threads Concept

• Multiple threads can run on multiple CPUs.
• Multiple threads can share a single CPU.

Multithreading Definition

• Multithreading is a Java feature that enables concurrent execution of different parts of a program, aiming for optimal CPU utilization.
• Each program section is regarded as a thread, which is a lightweight process within a larger process.

Thread States

• A thread's lifecycle involves states like New, Ready, Running, Blocked, and Finished.
• The transitions between these states depend on various factors like thread creation, execution, and waiting.

Creating a Thread

• Threads in Java can be created by extending the Thread class or implementing the Runnable interface.
• Extending Thread involves creating a class that inherits from the Thread class and implementing the run() method.
• Implementing Runnable involves creating a class that implements the Runnable interface and implementing the run() method.
• Creating an object of the class, then invoking the start() method triggers the thread execution.

Creating Tasks and Threads

• Method for creating and implementing an external Thread using Custom Tasks, in Java.

Example: Create and Run Three Threads

• The first thread prints 'a' 100 times.
• The second thread prints 'b' 100 times.
• The third thread prints integers from 1 to 100.

The Thread Class

• A thread object has methods for creating, managing, starting, and controlling threads.
• It has states, priorities, methods, and states defined by their functions.
• The class provides essential functions like start, sleep, interrupt, and isAlive methods.

The Static yield() Method

• The yield() method of Thread class releases current thread's time slice to other threads, allowing other threads to run.
• Implemented by placing Thread.yield() in the code to achieve this behavior.

The Static sleep(milliseconds) Method

• The sleep(long mills) method suspends execution of the thread for the specified duration (milliseconds).

The join() Method

• The join() method forces a thread to wait until another thread has finished executing.
• Useful for maintaining a precise order of thread execution.
• The method is used to wait until a specific thread finishes its execution sequence.

isAlive(), interrupt(), and isInterrupted()

• isAlive() checks whether the thread is still running.
• interrupt() can interrupt a waiting thread. A thread checks whether it has been interrupted.

The Deprecated stop(), suspend(), and resume() Methods

• Java versions introduced deprecated methods, such as these within the Thread class, due to the unsafe nature.

Thread Priority

• Each thread has a default priority (Thread.NORM_PRIORITY). This can be adjusted using setPriority(int priority).
• Priorities relate to the relative execution speeds of multiple threads.

Thread Pools

• Thread pools allow efficient utilization of threads by maintaining a pool of pre-created threads, used by tasks submitted to it repeatedly and minimizing the overhead associated with creating and destroying threads repeatedly.
• Handling tasks asynchronously.

Why we Need Thread Pools

• Managing the number of threads in concurrent execution.
• Dealing with a large number of tasks in an application, rather than creating a new thread for each.
• Running multiple tasks concurrently.

CPU-Intensive Task

• Designed for operations requiring intensive CPU computation, where multiple threads are suitable concurrently.

IO-Intensive Operation

• Optimized for operations that involve input/output (I/O), like network access or disk operations, where the thread may wait, therefore a larger thread pool size is preferable, not just the number of CPU cores.

What is the Ideal Pool Size?

• The ideal pool size depends on the type of tasks (CPU-intensive or IO-intensive) and the number of CPU cores.

Thread Synchronization

• A shared resource might be corrupted if accessed concurrently by multiple threads.
• Critical region (a block of code) is the area in the program where multiple threads may interact with shared resources and is synchronized.
• Using explicit synchronization mechanisms like the synchronized keyword is crucial to prevent race conditions in multithreaded applications, allowing only one thread to execute a code block at a time.

Race Condition

• A race condition happens when the outcome of a program depends on the unpredictable order in which threads execute.
• The common problem that arises from this is a program that may return an inaccurate result.

Synchronizing Statements

• A synchronized statement ensures mutual exclusion in multithreaded programming by gaining access to a shared resource (object or static lock) and releasing it afterward.

Famous Thread Synchronization Problems

• Producer/Consumer problem: A classical synchronisation problem involving the need to coordinate tasks that produce data with tasks that consume that data to prevent race conditions and deadlock.
• Semaphores: Used for synchronization (signalling) between threads and offer a way to control access to shared resources in parallel programming.
• Deadlock: A situation where two or more threads are blocked indefinitely, waiting for each other to release resources that they hold.