面试题与答案

Concurrency in Java is the ability of multiple threads to execute independently and simultaneously.

A process has its own memory space, while threads within a process share the same memory space.

The synchronized keyword is used to control access to critical sections of code by allowing only one thread at a time to execute it.

Thread Safety ensures that a piece of code can be safely executed by multiple threads without causing data corruption or unexpected behavior.

The Executor framework provides a higher-level replacement for managing threads and thread pools.

wait() and notify() are methods used for inter-thread communication. wait() makes a thread wait until another thread invokes notify() or notifyAll().

The volatile keyword ensures that a variable's value is always read and written from and to the main memory, preventing thread-local caching.

The java.util.concurrent package provides a framework for concurrent programming, including high-level abstractions such as Executors, Concurrent Collections, and synchronization utilities.

ReentrantLock is an implementation of the Lock interface that allows a thread to acquire the lock multiple times without deadlocking.

AtomicInteger provides atomic operations for integer variables, ensuring that operations are performed in an atomic and thread-safe manner.

Deadlock occurs when two or more threads wait indefinitely for each other to release the resources, resulting in a situation where no thread can proceed.

ConcurrentHashMap is a thread-safe implementation of the Map interface, providing high concurrency without the need for explicit synchronization.

Phaser is a synchronization barrier that allows a set of threads to wait for each other to reach a common phase before proceeding.

ForkJoinPool is a specialized implementation of ExecutorService designed for parallel processing and efficient handling of recursive algorithms.

CountDownLatch is a synchronization aid that allows one or more threads to wait until a set of operations in other threads completes.

CyclicBarrier is a synchronization aid that allows a set of threads to wait for each other to reach a common barrier point before proceeding.

Future represents the result of an asynchronous computation, and FutureTask is a concrete implementation of the Future interface.

Semaphore is a synchronization aid that allows a fixed number of threads to access a certain resource concurrently.

Exchanger is a synchronization point at which threads can pair and swap elements within pairs.

LockSupport provides low-level thread park and unpark mechanisms, useful for building higher-level synchronization abstractions.

CopyOnWriteArrayList is a thread-safe variant of ArrayList in which all mutative operations (add, set, etc.) are implemented by making a fresh copy of the underlying array.

Phaser is a synchronization barrier that allows a set of threads to wait for each other to reach a common phase before proceeding.

ReadWriteLock provides a pair of associated locks for read and write access, allowing multiple threads to read the data concurrently or a single thread to write it exclusively.

ScheduledExecutorService is an extension of ExecutorService that supports delayed and periodic task execution.

BlockingQueue is a queue that supports operations that wait for the queue to become non-empty when retrieving an element and wait for space to become available when storing an element.

ForkJoinPool is a specialized implementation of ExecutorService designed for parallel processing and efficient handling of recursive algorithms.

CompletableFuture is a higher-level replacement for the Future interface, providing a more flexible and composable way to handle asynchronous computations.

Lock interface provides a more flexible and sophisticated way to control access to shared resources compared to the traditional synchronized keyword.

StampedLock is a read-write lock that supports optimistic reading, allowing for better concurrency in certain scenarios.

ThreadLocal provides thread-local variables, allowing each thread to have its own instance of a variable.