Java Concurrency: Part 2

Concurrent Programming Concepts

• ABA Problem: A thread checks a value, finds it unchanged, but another thread modifies it to a different value then back to the original. This inconsistency can be prevented using version numbers or AtomicStampedReference.

ThreadPoolExecutor Rejection Policies

• AbortPolicy: Throws an exception when the queue is full.
• CallerRunsPolicy: Runs the task in the caller's thread.
• DiscardPolicy: Silently discards the task.
• DiscardOldestPolicy: Discards the oldest task in the queue and tries again.

Lock Coarsening

• Purpose: Optimizes efficiency by merging adjacent synchronized blocks on the same lock into one larger block.
• Benefit: Reduces the overhead of acquiring and releasing locks repeatedly.

Daemon vs. User Threads

• Daemon Threads: Background threads that don't prevent JVM exit when all user threads complete.
• User Threads: Needed for program termination; must complete before the JVM exits.

CompletableFuture Methods

• allOf(): Completes when all input CompletableFutures finish.
• anyOf(): Completes when any one input CompletableFuture finishes.

Thread Safety annotations

• @GuardedBy: Annotation for documenting that a field or method requires a specific lock for thread safety.

Biased Locking

• Mechanism: An optimization where a lock is biased toward whichever thread acquired it first.
• Impact: Reduces synchronization overhead when the same thread repeatedly acquires the lock.

Striped Locking

• Guava feature: Creates a fixed number of locks, distributing them based on object hash codes.
• Advantage: Improves fine-grained locking with less memory consumption compared to a single lock per object.

LongAdder vs. AtomicLong

• LongAdder: Performance improvement under high contention by using multiple variables for updates.
• AtomicLong: Employs a single variable using CAS (compare and swap) operations for updates.

ManagedBlocker and ForkJoinPool

• Workflow: ManagedBlocker enables the ForkJoinPool to manage blocking operations, potentially creating new workers to avoid starvation.

Lock Elimination

• Concept: Optimizing by removing unnecessary locks when determined that a lock isn't shared or the locked object isn't accessed outside a thread's scope.

onSpinWait (Java 9)

• Processor Hint: Advises the processor that the current thread is in a spin-wait loop, aiming for better power management.

Phaser Forking

• Feature: Allows dynamic registration and deregistration of "parties", accommodating parallel algorithms with an unknown number of subtasks.

Lock Fairness Models

• Fair Locks: Access granted in FIFO order of requests.
• Unfair Locks: May prioritize recently arrived threads; potentially higher performance.

Memory Consistency Errors

• Description: Potential discrepancies in threads' view of shared memory without proper safeguards.
• Prevention: Utilizing synchronization, volatile variables, or atomic classes.

VarHandle Class

• Enhancement: Provides low-level access to variables for atomic operations, memory fence controls, and memory ordering.
• Advantage: Offers refined control over memory access compared to Atomic classes.

RecursiveAction

• Purpose: Used in Fork/Join framework for tasks without return values, splitting workload into subtasks for parallel execution.

StampedLock Optimistic Reading

• Technique: Reads without acquiring a lock, followed by validation to ensure consistency before use.
• Retry: If validation fails during optimistic read, a regular read lock is required.

Lock Upgrading

• Mechanism: Attempting a write lock while holding a read lock.
• Problem: Can lead to deadlock if multiple threads try to upgrade simultaneously.

ForkJoinTask methods

• fork(): Submits a task asynchronously to the pool; execution is not guaranteed.
• invoke(): Executes a task synchronously in the pool; may steal work from other threads if necessary.

ThreadLocalRandom

• Benefit: Improved random number generation performance, eliminating contention by keeping separate generators for each thread.

Bytecode Synchronization

• monitorenter: Acquires a monitor (lock) on an object.
• monitorexit: Releases a monitor (lock) on an object.

ConcurrentSkipListMap

• Concurrency: Uses a skip list data structure for lock-free concurrent access by multiple threads.

Safe Publication

• Guarantee: Ensures that an object is fully initialized, and its reference is visible to other threads before use.
• Techniques: Utilizing final fields, volatile variables, or concurrent collections.

AbstractQueuedSynchronizer (AQS)

• Function: Framework for implementing locks and synchronizers, managing queues for waiting threads and performing synchronization.

Disruptor Pattern

• Difference: Employs a ring buffer with optimized algorithms (mechanical sympathy) for higher throughput versus typical blocking queues.

Mutex vs. Semaphore

• Mutex: Exclusive access; one thread owns, requires releasing by the same thread.
• Semaphore: Multiple threads can acquire; maintains a count and allows concurrent access.

Memory Barriers

• Action: Enforce order on memory operations (happens-before relationships) in the Java Memory Model.

CompletableFuture Methods (handle/exceptionally)

• handle(): Processes both successful results and exceptions; receives both as arguments.
• exceptionally(): Processes only exceptions.

LinkedTransferQueue

• Purpose: Combines queue characteristics with elements transferability where possible; can improve producer-consumer scenarios.