Topic in Operating Systems
A thread is the smallest unit of CPU scheduling: a flow of control that shares its process's code, data and open files but keeps its own stack and registers. Typical items compare user-level and kernel-level threads and the many-to-one, one-to-one and many-to-many mapping models, plus the role of lightweight processes. Amdahl's Law calculations on multicore speedup are common, as is the distinction between concurrency and parallelism. Expect questions on Pthreads and Java threads, thread pools, thread-local storage, what happens when a multithreaded process calls fork(), and asynchronous versus deferred thread cancellation.
Below are 30 practice questions from a pool of 210 Thread Management MCQs, one of 12 topics in Operating Systems. Each shows the correct answer with an explanation; when you are ready, take a timed quiz to test recall under exam conditions.
Each question below shows the correct answer with a full explanation. Use these to build conceptual understanding before attempting a timed quiz.
Q1. A thread is:
A thread is a lightweight unit of CPU utilization within a process. It has its own thread ID, program counter, register set, and stack but shares code, data, and resources with other threads in the same process.
Q2. Threads within the same process share all of the following EXCEPT:
Threads share code, data, and resources (like open files) but each thread has its own stack, program counter, and register set to maintain its individual execution context.
Q3. What is the main advantage of using threads over processes?
Threads are cheaper to create and context-switch than processes because they share the same address space and resources. Only the stack, registers, and program counter need to be saved/restored.
Q4. User-level threads are managed by:
User-level threads are managed by a user-level thread library (like POSIX Pthreads) without kernel involvement. The kernel is unaware of user-level threads.
Q5. Kernel-level threads are managed by:
Kernel-level threads are managed directly by the operating system kernel. The kernel is responsible for scheduling and managing these threads.
Q6. Multithreading benefits include all EXCEPT:
Benefits of multithreading include responsiveness, resource sharing, economy (cheaper than processes), and scalability on multiprocessor systems. It does not guarantee elimination of bugs.
Q7. POSIX Pthreads is:
POSIX Pthreads (POSIX threads) is a standardized API (IEEE 1003.1c) for creating and managing threads, commonly available on UNIX/Linux systems.
Q8. In a single-threaded process, how many threads of control exist?
A single-threaded process has exactly one thread of control. Traditional (heavyweight) processes are single-threaded, executing one sequence of instructions at a time.
Q9. Which of the following is a benefit of multithreading in web server applications?
Multithreaded web servers can handle multiple client requests concurrently by assigning each request to a separate thread, improving responsiveness and throughput.
Q10. A process can contain:
A process can contain one or more threads. Even a traditional single-threaded process has at least one thread of execution (the main thread).
Q11. What is the many-to-one threading model?
In the many-to-one model, many user-level threads are mapped to a single kernel thread. The kernel sees only one thread, so if one user thread blocks, all threads in the process block.
Q12. What is the one-to-one threading model?
In the one-to-one model, each user-level thread maps to one kernel thread. This provides more concurrency but thread creation overhead is higher. Linux and Windows use this model.
Q13. What is the disadvantage of the many-to-one threading model?
Since all user threads map to a single kernel thread, if one user thread makes a blocking system call, the kernel thread blocks, causing all other user threads in the process to block as well.
Q14. What is a thread pool?
A thread pool creates a number of threads at startup that sit idle waiting for work. When a request arrives, a thread from the pool is assigned to service it, avoiding the overhead of creating a new thread each time.
Q15. What happens to threads when fork() is called in a multithreaded program?
The behavior of fork() in multithreaded programs depends on the system. POSIX provides two versions: one duplicates all threads, another duplicates only the calling thread. Typically only the calling thread is duplicated.
Q16. What is thread cancellation?
Thread cancellation is the task of terminating a thread before it has finished. It can be asynchronous (immediate termination) or deferred (thread periodically checks if it should terminate).
Q17. What is the difference between asynchronous and deferred thread cancellation?
Asynchronous cancellation terminates the thread immediately, which can leave shared data in an inconsistent state. Deferred cancellation is safer as the thread periodically checks cancellation points.
Q18. Thread-Local Storage (TLS) allows:
Thread-Local Storage (TLS) allows each thread to have its own copy of data. Unlike local variables (visible only during a single function invocation), TLS data persists across function calls within that thread.
Q19. What is implicit threading?
Implicit threading transfers the responsibility of creating and managing threads from application developers to compilers and runtime libraries, using approaches like thread pools, OpenMP, and Grand Central Dispatch.
Q20. OpenMP is used for:
OpenMP is an API for parallel programming on shared-memory multiprocessor systems. It uses compiler directives (pragmas) to identify parallel regions that can be executed concurrently by multiple threads.
Q21. What is the many-to-many threading model and what advantage does it offer?
The many-to-many model multiplexes many user threads onto a smaller or equal number of kernel threads. It avoids the blocking issue of many-to-one and the overhead of one-to-one, but is complex to implement.
Q22. What is the two-level threading model?
The two-level model is a variation of the many-to-many model that also allows a user thread to be bound to a specific kernel thread (one-to-one binding), combining the flexibility of both approaches.
Q23. What is a Lightweight Process (LWP) in the context of user and kernel thread mapping?
An LWP is an intermediate data structure that appears as a virtual processor on which user threads can be scheduled. Each LWP is attached to a kernel thread, and user threads are multiplexed onto LWPs.
Q24. How does signal handling work in a multithreaded program?
Signal delivery in multithreaded programs can be: to the applicable thread (e.g., division by zero), to every thread (e.g., SIGKILL), to certain threads, or to a designated thread that handles all signals.
Q25. What is the scheduler activation mechanism?
Scheduler activations provide upcalls - a communication mechanism from kernel to user thread library. When a thread blocks, the kernel makes an upcall to inform the thread library, which can then schedule another thread.
Q26. What is Grand Central Dispatch (GCD)?
GCD is an Apple technology that manages concurrent operations through dispatch queues (serial and concurrent) backed by a system-managed thread pool, abstracting thread management from developers.
Q27. What is the fork-join parallelism pattern?
Fork-join parallelism divides a task into subtasks (fork), executes them in parallel using multiple threads, and then waits for all subtasks to complete and combines results (join).
Q28. What problem does the clone() system call solve in Linux that fork() doesn't?
Linux clone() provides flags to specify exactly which resources are shared between parent and child (memory, file descriptors, etc.), enabling creation of threads (share everything) or processes (share nothing).
Q29. In the context of Intel Threading Building Blocks (TBB), what is a task?
In TBB, a task is a lightweight unit of work that the runtime dynamically maps to available threads. This task-based parallelism abstracts thread management, allowing the runtime to optimize thread usage.
Q30. Why have most modern operating systems moved away from the many-to-many threading model to the one-to-one model?
Modern systems can efficiently support thousands of kernel threads, making the complexity of the many-to-many model (LWPs, scheduler activations) hard to justify. The simpler one-to-one model is sufficient and widely adopted.
Take a timed quiz drawn from 210+ questions on this topic. No signup required — your progress saves in your browser.
Start Thread Management Quiz