Java Concurrency: Part 1

ExecutorService extends Executor by providing methods to manage the task lifecycle and the executor itself.

submit() returns a Future object for tasks that return results, while execute() is void and for tasks without return values.

CompletableFuture enables functional composition and combining of asynchronous computations, unlike Future's limited methods.

<p>ThreadLocal allows threads to have their own independent variables, ensuring thread confinement of data.</p> Signup and view all the answers

<p>Lock striping splits a data structure into segments, each protected by a separate lock, reducing lock contention.</p> Signup and view all the answers

<p>park() is a low-level blocking operation used by LockSupport, whereas wait() is utilized within synchronized blocks.</p> Signup and view all the answers

<p>ReadWriteLock allows multiple readers or a single writer, thereby improving concurrency for read-heavy workloads.</p> Signup and view all the answers

<p>Exchanger allows two threads to synchronously swap objects at a designated point during execution.</p> Signup and view all the answers

<p>A memory barrier ensures that all memory operations are completed in a specific order for correct visibility across threads.</p> Signup and view all the answers

<p>A write to a volatile variable guarantees visibility of preceding writes to other threads reading that variable.</p> Signup and view all the answers

<p>Synchronized blocks allow for finer-grained control by locking only specific parts of code or particular objects, which can improve performance and reduce contention.</p> Signup and view all the answers

<p>The happens-before relationship ensures that actions performed in one thread are visible to other threads, guaranteeing memory visibility across threads.</p> Signup and view all the answers

<p>Volatile variables provide visibility guarantees but not atomicity for compound actions, while atomic variables ensure both visibility and atomicity through CAS operations.</p> Signup and view all the answers

<p>ReentrantLock supports timed locking, allowing threads to attempt to acquire a lock within a specified time frame.</p> Signup and view all the answers

<p>CountDownLatch allows one or more threads to wait until a specified number of operations in other threads are completed, using a countdown mechanism.</p> Signup and view all the answers

<p>CyclicBarrier can be reused multiple times after threads are released, while CountDownLatch can only be used once before it becomes useless.</p> Signup and view all the answers

<p>Thread starvation occurs when a thread cannot access shared resources regularly, often due to other threads having higher priority or holding locks for too long.</p> Signup and view all the answers

<p>The Fork/Join framework divides tasks into smaller subtasks that can run in parallel and combines the results after processing.</p> Signup and view all the answers

<p>Phaser allows dynamic registration of parties and can handle multiple phases of execution, offering more flexibility than CyclicBarrier.</p> Signup and view all the answers

<p>Executor provides a basic interface for running tasks asynchronously, while ExecutorService extends it with methods for task lifecycle management such as shutdown and management of callable futures.</p> Signup and view all the answers

Synchronized methods acquire a lock on the entire object, ensuring exclusive access. Synchronized blocks allow locking specific code segments or objects, providing finer-grained control and potential performance optimization.

Happens-before is a memory visibility guarantee that ensures actions in one thread are observable by other participating threads. If action A happens-before B, then A's effects are visible to B.

Volatile variables guarantee visibility of changes across threads but do not offer atomicity for compound operations. Atomic variables provide both visibility and atomicity through Compare-and-Swap (CAS) operations, ensuring consistent updates for complex actions.

ReentrantLock offers more features like timed and interruptible lock attempts, fairness policies, and non-block-structured locking. Synchronized is simpler but less flexible, providing only basic locking.

CountDownLatch allows threads to wait for a set of operations to finish before proceeding. Initialized with a count, it decrements until reaching zero, releasing waiting threads.

CyclicBarrier is a reusable synchronization barrier that waits for all threads to reach a certain point before releasing them. CountDownLatch is a one-time-use barrier that releases threads when the count reaches zero.

Thread starvation happens when a thread loses its ability to access shared resources or progress due to other threads hogging the resources or having higher priority.

The Fork/Join framework applies divide-and-conquer parallelism by breaking tasks into smaller subtasks that execute concurrently, then combining the results. It's efficient for tasks that can be split into independent subproblems.

A Phaser is a synchronization barrier that coordinates multiple phases of execution. It's similar to CyclicBarrier but more flexible, allowing dynamic registration of parties.

Executor is an interface for executing Runnable or Callable tasks asynchronously. ExecutorService is a sub-interface of Executor that provides methods for managing and controlling the execution of tasks.

ExecutorService provides additional methods for managing task lifecycles and the executor itself, complementing Executor's basic execution functionality.

submit() returns a Future object, allowing you to work with tasks that have results. execute() is void and is used for tasks without results.

CompletableFuture enhances the Future interface with functional methods for composing, combining, and handling asynchronous computations. It offers a structured approach to asynchronous operations.

ThreadLocal creates thread-confined data by providing thread-local variables. Each thread has its own copy of the variable, ensuring isolation.

Lock striping divides a data structure into segments, each with its own lock, reducing contention and enhancing concurrency. Multiple threads can access different segments simultaneously.

park() and wait() both pause threads. park() is used by LockSupport for low-level blocking, while wait() is used within synchronized blocks and requires the thread to hold the object's monitor.

ReadWriteLock allows multiple readers but only one writer simultaneously. This improves concurrency for read-heavy workloads by separating read and write operations.

Exchanger allows two threads to exchange objects at a specific point. It's useful in scenarios like genetic algorithms, pipelines, and producer-consumer patterns.

interrupted() checks and clears the interrupted status of the thread, while isInterrupted() only checks the status without clearing it.

A memory barrier (fence) ensures memory operations happen in a specific order, guaranteeing proper visibility of shared variables between threads. It eliminates unexpected behaviors from compiler optimizations or caching.