Object Oriented Programming 2 - Concurrency

• Object Oriented Programming 2 in Java covers concurrency and multithreading.

Concurrency and Parallelism

• Concurrency involves two tasks making progress at once.
• Parallelism involves tasks being executed simultaneously.
• Java supports concurrency through language features and APIs.

Multithreading

• Applications can contain separate threads of execution.
• Each thread has its own method-call stack and program counter.
• Threads can execute concurrently while sharing application-wide resources like memory and file handles.
• Multithreading is the ability to execute multiple threads concurrently.

Performance Tip

• Single-threaded applications can suffer from poor responsiveness due to lengthy activities blocking others.
• Multithreaded applications can distribute threads across multiple cores, allowing parallel execution, and improving efficiency.
• Multithreading can also increase performance on single-processor systems by allowing another thread to use the processor when one thread is waiting.

Challenges with Concurrency

• Programming concurrent applications is difficult and error-prone.
• Most programmers should use existing collection classes and interfaces from concurrency APIs for synchronization.
• Advanced programmers can use the synchronized keyword, Object methods (wait, notify, notifyAll), Locks, and Conditions for synchronization control.
• The synchronized keyword ensures only one thread executes a block of code at a time.
• Threads entering a synchronized block see the effects of previous modifications guarded by the same lock.

Thread States and Lifecycle

• At any time, a thread can be in one of several states.

New and Runnable States

• A new thread starts its lifecycle in the new state.
• It remains in the new state until started, which moves it to the runnable state, considered ready to execute its task.

Waiting State

• A runnable thread can transition to the waiting state while waiting for another thread to perform a task.
• Transitions from waiting to runnable occur only when another thread notifies it to continue.

Timed Waiting State

• A runnable thread can enter the timed waiting state for a specified interval.
• Transitions back to runnable occur when the time interval expires or when the waited-for event occurs.
• A thread in the timed waiting state does not use a processor, even if one is available.
• A sleeping thread is in timed waiting for a sleep interval.

Blocked State

• A runnable thread transitions to the blocked state when it attempts to perform a task that cannot be completed immediately, requiring it to wait temporarily.

Terminated State

• A runnable thread enters the terminated state when it successfully completes its task or terminates otherwise, potentially due to an error.

Operating-System View of the Runnable State

• Java's runnable state includes two separate states an operating system level: ready and running.
• A thread first transitioning to runnable from the new state is in the ready state.
• A ready thread enters the running state when the operating system assigns it to a processor, referred to as dispatching the thread.
• Threads are typically given a quantum or timeslice to perform their task.
• Thread scheduling is the process determining which thread to dispatch, handled by the operating system and JVM.

Thread Priorities and Thread Scheduling

• Every Java thread has a thread priority that helps determine the order in which threads are scheduled.
• Higher-priority threads are generally more important, and should be allocated processor time before lower-priority ones.
• Thread priorities cannot guarantee the order in which threads execute.
• It is suggested to use the "Executor" interface to implement concurrency
• Most operating systems support timeslicing, enabling threads of equal priority to share a processor.
• An operating system's thread scheduler determines which thread runs next.
• One thread-scheduler implementation keeps the highest-priority thread running at all times or uses a round-robin fashion if there are multiple highest-priority threads.

Indefinite Postponement and Deadlock

• When a higher-priority thread enters the ready state, the OS preempts the running thread through preemptive scheduling.
• A steady influx of higher-priority threads could postpone lower-priority threads indefinitely, referred to as starvation.
• Operating systems employ a technique called aging to prevent starvation.
• Deadlock occurs when a waiting thread cannot proceed because it's waiting for another thread to proceed, while that other thread is also waiting for it.

Java and Concurrency

• Java simplifies concurrency with higher-level utilities, reducing complexity and errors.
• Thread priorities can be used behind the scenes, but most Java multithreading does not need setting or adjusting of thread priorities.
• Thread scheduling behavior depends on OS

Ways of Creating and Executing Threads

• Extend the Thread class.
• Implement the Runnable interface.
• Creating and Executing Threads with the Executor Framework.

Extending Thread Class

• Threads are implemented as objects that contain the run() method.

Implementing the Runnable Interface

• A Runnable object represents a "task" that executes concurrently with other tasks.

Creating and Executing Threads with the Executor Framework

• Using the Executor interface is the best method for managing Runnable objects.
• The Runnable interface declares the run method, which defines the task performed by the Runnable object.
• When a thread executing a Runnable is created and started, the thread calls the Runnable object's run method, which executes in the new thread.
• PrintTask class implements Runnable, so multiple PrintTasks can execute concurrently.
• The thread's sleep method (a static method) puts a thread into a timed waiting state for a specified amount of time.
• The sleep method can throw InterruptedException if the sleeping thread's interrupt method is called.
• Code in main is executed in the main thread, created by the JVM
• Code in the run method of PrintTask executes in the threads created in main.
• The program keeps running, even after the main method` terminates because the program will not terminate until its last thread completes execution.
• The executor interface can reuse threads and improve number of threads.
• The Executor assigns every "Runnable" execute function to a thread.
• If there are no available threads the executor creates a new thread or waits for a thread.
• The "ExecutorService" interface extends "Executor" and declares methods for managing the life cycle of an Executor.
• The "ExecutorsfunctionnewCachedThreadPool` returns a service.
• ExecutorService has a method called shutdown which will notify when the ExecutorService stops accepting new tasks, but it will keeps executes executing tasks