Java Concurrency: Part 2

<p>fork() submits a task asynchronously, while invoke() executes it synchronously. (C)</p> Signup and view all the answers

<p>A mutex is owned by the thread that locks it, whereas a semaphore allows a broader access control with a count. (C)</p> Signup and view all the answers

<p>It signals the processor that the thread is waiting in a loop, allowing power optimizations. (D)</p> Signup and view all the answers

<p>It enables reads without locks but requires validation afterwards. (D)</p> Signup and view all the answers

<p>Atomic operations with precise control over memory ordering. (A)</p> Signup and view all the answers

<p>Visibility issues in multithreaded environments. (C)</p> Signup and view all the answers

<p>It uses a ring buffer for increased throughput and efficiency. (A)</p> Signup and view all the answers

<p>A thread checks a value twice and finds it unchanged while another modifies it. (D)</p> Signup and view all the answers

<p>AbortPolicy (A)</p> Signup and view all the answers

<p>When multiple locks are acquired and released in quick succession. (A)</p> Signup and view all the answers

<p>Daemon threads are background threads that allow JVM to exit, while user threads prevent it. (C)</p> Signup and view all the answers

<p>It completes when all input CompletableFutures complete. (C)</p> Signup and view all the answers

<p>To document that a field should only be accessed when holding a specific lock. (C)</p> Signup and view all the answers

<p>It reduces synchronization overhead for threads acquiring the same lock repeatedly. (D)</p> Signup and view all the answers

<p>It allows assignment of locks based on hash codes, enabling more fine-grained locking. (C)</p> Signup and view all the answers

<p>LongAdder is optimized for high contention scenarios, while AtomicLong is not. (C)</p> Signup and view all the answers

A situation where a thread reads a value twice, finds it unchanged, but another thread modified it in between. This can lead to unexpected behavior.

It uses a RejectedExecutionHandler to determine how to deal with tasks when the queue is full. There are various built-in policies like AbortPolicy, CallerRunsPolicy, DiscardPolicy, and DiscardOldestPolicy.

It combines adjacent synchronized blocks, all using the same lock, into a single block, reducing overhead from repeated acquiring/releasing.

Background threads that don't stop the Java Virtual Machine from exiting when all user threads finish. Daemon threads often handle background tasks.

User threads are the primary execution threads of the program. The JVM won't exit until all user threads complete.

It completes when all of the input CompletableFutures are finished. This is great for waiting on a group of tasks to be done.

It completes when any of the input CompletableFutures finishes. This is ideal when you only need one task done to proceed.

An annotation identifying a field or method that should only be accessed while holding a particular lock. It helps maintain thread safety by documenting access rules.

It is an optimization where a lock is biased towards the thread that first acquires it. This reduces overhead for repeated acquisitions by the same thread.

It is a Guava utility that helps create multiple locks (stripes) and assigns objects to them based on their hash codes. It allows for fine-grained locking while conserving memory.

A class in Java that manages blocking operations within the ForkJoinPool, potentially creating new workers when existing ones are blocked, preventing the pool from becoming starved of resources.

A JVM optimization technique where unnecessary synchronization is removed if the JVM detects that a lock is never shared between threads or that the locked object remains confined to a single thread.

A performance hint provided to the processor by a Java thread indicating that it's currently engaged in a spin-wait loop. This can potentially enable processor-specific optimizations aimed at reducing power consumption.

Allows tasks to register new parties dynamically during execution, adjusting the number of participating threads. This is useful for parallel algorithms where the number of subtasks is not known beforehand.

A class in Java that provides low-level access to variables with atomic operations, memory fence controls, and different memory ordering modes, offering fine-grained control over concurrent access compared to Atomic classes.

A class used in Fork/Join framework for tasks that do not return results but break down their work into smaller subtasks that can be executed in parallel.

A mode in StampedLock where a read operation is attempted without acquiring a lock, but requires validation before using the obtained data. If validation fails, the read must be retried with a regular read lock.

An attempt to acquire a write lock while currently holding a read lock on the same object. This can be problematic as it can lead to deadlocks

A technique that ensures an object is fully constructed and its reference is visible to other threads before it can be accessed, typically achieved through final fields, volatile variables, or concurrent collections.

A framework providing a foundation for implementing locks and synchronizers. It manages a queue of waiting threads and handles the technical details of synchronization.