Concurrency and Parallelism Questions and Answers for Viva

Answer-1: Concurrency is the ability of a system to handle multiple tasks at the same time but not necessarily simultaneously, while parallelism is the simultaneous execution of multiple tasks.

Answer-2: A race condition occurs when two or more processes attempt to modify shared data at the same time, leading to unpredictable or erroneous results.

Answer-3: Thread synchronization is the coordination of the execution order of threads in a multithreaded environment to avoid conflicts when accessing shared resources.

Answer-4: A deadlock occurs when two or more threads are blocked forever, waiting for each other to release resources, causing a system halt.

Answer-5: The main problems include race conditions, deadlocks, starvation, and issues with thread synchronization.

Answer-6: Thread pooling is a technique where a pool of threads is created and managed by a thread pool manager, which can be reused for executing tasks instead of creating new threads each time.

Answer-7: Parallel programming involves running multiple processes simultaneously, while multithreading is the use of multiple threads within a single process.

Answer-8: Common concurrency models include shared memory model, message-passing model, and actor-based concurrency.

Answer-9: A mutex (short for mutual exclusion) is a synchronization primitive that ensures that only one thread at a time can access a critical section of code.

Answer-10: A semaphore is a synchronization mechanism that controls access to a resource by multiple threads in a concurrent system, using a counter to manage resource allocation.

Answer-11: Thread starvation occurs when a thread is perpetually denied access to the resources it needs to execute, usually due to the scheduling algorithm prioritizing other threads.

Answer-12: Lock-free programming allows threads to work without locking resources, using atomic operations to ensure consistency and avoid blocking.

Answer-13: The producer-consumer problem is a classic synchronization issue where producers create data that consumers process, requiring synchronization to avoid conflicts in accessing shared buffers.

Answer-14: Deadlock can be avoided by using techniques like resource ordering, timeout mechanisms, or deadlock detection and recovery strategies.

Answer-15: Synchronous execution requires that one operation finishes before the next begins, while asynchronous execution allows operations to be performed independently and simultaneously.

Answer-16: A critical section is a part of the program where shared resources are accessed and requires synchronization to ensure that only one thread can access it at a time.

Answer-17: A thread-safe data structure is one that can be accessed by multiple threads concurrently without causing data corruption or unexpected behavior.

Answer-18: Lock contention occurs when multiple threads try to acquire the same lock, resulting in delays and reduced performance due to the contention for the lock.

Answer-19: Atomicity ensures that a series of operations are completed as a single, indivisible unit, preventing intermediate states from being visible to other threads.

Answer-20: Blocking operations wait for a resource to become available or for a task to finish, while non-blocking operations allow threads to continue execution without waiting.

Answer-21: A barrier is a synchronization mechanism that ensures that all threads reach a certain point in the program before any of them continue executing, ensuring synchronization between threads.

Answer-22: The fork-join model divides a task into smaller subtasks (fork), processes them in parallel, and then joins the results to produce the final output.

Answer-23: A process is an independent program with its own memory space, while a thread is a smaller unit of execution within a process, sharing the same memory space.

Answer-24: Cooperative multitasking is a scheduling method where the running process must yield control voluntarily to allow other processes to run.

Answer-25: Preemptive multitasking allows the operating system to take control of a process and switch between processes without requiring voluntary yielding from the running process.

Answer-26: Advantages include faster execution of computationally intensive tasks, better resource utilization, and improved performance for large-scale operations.

Answer-27: A thread pool is a collection of pre-instantiated, idle threads that can be reused to execute tasks, improving performance by reducing the overhead of creating and destroying threads.

Answer-28: Atomic operations are low-level operations that are completed in a single step without interruption, ensuring that shared data remains consistent.

Answer-29: A fork refers to the creation of a new thread or process, typically from a parent process, which executes concurrently with the parent.

Answer-30: Task parallelism involves breaking a program into distinct tasks that can be executed concurrently, rather than dividing a task into smaller subtasks.

Answer-31: Data parallelism involves dividing large datasets into smaller chunks and processing them in parallel across multiple threads or processes.

Answer-32: A mutex (short for mutual exclusion) is a synchronization object that ensures that only one thread at a time can access a shared resource or critical section.

Answer-33: Event-driven models use event handlers to process tasks asynchronously, while thread-based models use multiple threads to handle tasks concurrently.

Answer-34: A join operation in multithreading is used to wait for a thread to finish its execution before proceeding with the next steps in the program.

Answer-35: Non-blocking I/O allows a program to initiate an I/O operation without waiting for it to complete, allowing other operations to continue running concurrently.

Answer-36: A parallel algorithm is one that is designed to divide its tasks into smaller, independent subtasks that can be executed simultaneously to improve performance.

Answer-37: A concurrency bug occurs when a program behaves unpredictably due to issues like race conditions, deadlocks, or improper synchronization in a multithreaded environment.

Answer-38: Optimistic concurrency control allows transactions to proceed without locking resources, assuming that no conflicts will occur, and resolving any conflicts that arise.

Answer-39: Pessimistic concurrency control locks resources at the beginning of a transaction to prevent conflicts, ensuring that no other process can access the resource until the transaction is complete.

Answer-40: A concurrent queue allows multiple threads to safely enqueue and dequeue items without causing race conditions, using internal synchronization mechanisms.

Answer-41: Thread-local storage (TLS) allows each thread to have its own independent copy of a variable, ensuring that each thread does not interfere with others.

Answer-42: Load balancing distributes tasks evenly across threads or nodes in a parallel system to ensure that no single thread or node is overwhelmed, improving performance.

Answer-43: The operating system manages concurrency by providing mechanisms like thread scheduling, synchronization primitives, and resource allocation to ensure that multiple threads can run efficiently.

Answer-44: The executor framework in Java is a high-level API that manages and controls the execution of threads in a concurrent environment, simplifying task management.

Answer-45: The fork/join framework in Java is used for parallel processing, dividing tasks into smaller subtasks (fork), processing them concurrently, and then combining the results (join).

Answer-46: Concurrency improves performance by allowing multiple tasks to run simultaneously, utilizing multiple CPU cores and reducing wait times.

Answer-47: Functional programming techniques for concurrency focus on immutability and pure functions to avoid side effects and ensure thread safety in concurrent systems.

Answer-48: A condition variable is a synchronization object that allows threads to wait for certain conditions to be met before continuing execution.

Answer-49: The "wait" method causes the current thread to release the lock and wait until it is notified, while the "notify" method wakes up one or more threads waiting on the condition variable.

Answer-50: Futures and promises are constructs used to represent results that are not yet available, allowing threads to asynchronously wait for the results of computations.