L9 Networks & Operating Systems

Question 1

What is a thread in the context of process management?

Answer 1

• A thread is the basic unit of CPU utilization.
• It includes a thread ID, program counter, register set, and stack.
• Threads share code, data, and OS resources with other threads of the same process.

Question 2

What is the main benefit of using threads in applications?

Answer 2

• Threads enable simultaneous execution of tasks, improving responsiveness and CPU utilization.
• They are lightweight and more economical than creating new processes.

Question 3

What are the differences between concurrency and parallelism?

Answer 3

• Concurrency: Tasks appear to run in parallel through time-slicing; not necessarily at the same time.
• Parallelism: Tasks actually run at the same time on multiple processors or cores.

Question 4

How does sequential execution differ from concurrent and parallel execution?

Answer 4

• Sequential: One task executes at a time, others must wait.
• Concurrent: Multiple tasks are interleaved in execution.
• Parallel: Multiple tasks execute simultaneously on separate CPUs/cores.

Question 5

What is the lifecycle of a Java thread?

Answer 5

• NEW → RUNNABLE → RUNNING → may go to WAITING, TIMED_WAITING, BLOCKED, or TERMINATED.

Question 6

What happens when a thread enters the WAITING state?

Answer 6

• It waits indefinitely for another thread to perform an action (e.g., wait() called).

Question 7

What is Amdahl’s Law and how does it relate to multicore performance?

Answer 7

• Amdahl’s Law estimates the potential speedup of a program using multiple cores.
• Formula:
speedup ≤ 1 / (S + (1 - S)/N)
where S = serial fraction, N = number of cores.

Question 8

What are the advantages of multithreaded server architecture?

Answer 8

• Efficient handling of multiple client requests using threads instead of processes.
• Lower overhead and quicker context switching.

Question 9

How can threads be created in Java?

Answer 9

• By extending the Thread class and overriding run()
• By implementing the Runnable interface

Question 10

Why is multithreading beneficial in multicore systems?

Answer 10

• It allows actual parallel execution of threads, improving performance and scalability.

Question 11

What does the RUNNABLE state mean in Java thread lifecycle?

Answer 11

• The thread is ready to run and waiting for CPU time from the thread scheduler.

Question 12

What are the key benefits of threads over processes?

Answer 12

• Faster creation and context switching
• Shared memory space
• Improved responsiveness
• Better scalability on multicore systems

Question 13

How does Java put a thread into TIMED_WAITING state?

Answer 13

• Using methods like sleep(millis) or wait(millis)

Question 14

What is the difference between BLOCKED and WAITING states in Java?

Answer 14

• BLOCKED: Waiting for a lock
• WAITING: Waiting indefinitely for an event or action

Question 15

What are common use cases for threads in desktop applications?

Answer 15

• UI responsiveness (e.g., UI thread + background threads)
• Networking (e.g., downloading while rendering UI)
• Parallel computations

Question 16

What methods are commonly used to control thread behavior in Java?

Answer 16

• start(), run(), sleep(), wait(), notify(), interrupt()

Question 17

What happens when a thread finishes execution?

Answer 17

• It transitions to the TERMINATED state.

Question 18

Why is thread creation more efficient than process creation?

Answer 18

• Thread creation uses shared memory and resources of the process, avoiding expensive memory allocation and setup steps.

Question 19

In what scenario would concurrency not result in performance gain?

Answer 19

• On single-core systems where tasks are context-switched rather than executed in parallel; overhead may even reduce performance.

Question 20

Why is synchronization important in concurrent and parallel systems?

Answer 20

• To prevent race conditions, ensure data integrity, and avoid deadlocks when multiple threads access shared data.

Question 21

What are some risks or drawbacks of using multithreading?

Answer 21

• Deadlocks, race conditions, difficult debugging, increased complexity, and nondeterministic behavior.

Question 22

Compare RUNNABLE vs. RUNNING in Java threads.

Answer 22

• RUNNABLE: Eligible to run but waiting for CPU.
• RUNNING: Currently executing on a CPU.

Question 23

Describe an application that benefits from both concurrency and parallelism.

Answer 23

• A video game: concurrent threads for input, rendering, and audio; parallel execution on multicore systems improves performance.

Question 24

How does multithreading improve responsiveness in GUI applications?

Answer 24

• Background threads handle long-running tasks (e.g., file download), allowing the UI thread to stay interactive.

Question 25

When would you prefer implementing Runnable over extending Thread?

Answer 25

• When you need to inherit from another class (Java doesn’t support multiple inheritance), or want to decouple task logic from threading.

Question 26

What happens if you call run() directly instead of start() on a thread?

Answer 26

• It will execute like a normal method call in the current thread, not in a separate thread.

Question 27

How does Java handle thread scheduling?

Answer 27

• It’s managed by the JVM and OS; generally based on thread priority and time-slicing.

Question 28

What type of execution is illustrated in Diagram1.png?

Answer 28

* Parallel execution, where Task 1 and Task 2 run simultaneously on two separate CPUs.

Question 29

According to Diagram1.png, what happens to Task 3 and Task 4 at time t1?

Answer 29

* They are in a waiting state while Tasks 1 and 2 are running.

Question 30

At time t2 in Diagram1.png, which tasks begin execution?

Answer 30

* Task 3 and Task 4 start running after Task 1 and Task 2 terminate.

Question 31

What does the process state table in Diagram1.png describe?

Answer 31

* It shows the status (running/waiting/terminated) of each task at time t1 and t2.

Question 32

What type of execution is shown in Diagram2.png?

Answer 32

* Parallel concurrent execution, where tasks are split and interleaved across CPUs.

Question 33

How are the tasks scheduled in Diagram2.png?

Answer 33

* Tasks 1 and 2 are alternated on CPU 1, while Tasks 3 and 4 are alternated on CPU 2.

Question 34

How many CPUs are used in Diagram2.png and what is their role?

Answer 34

* Two CPUs handle interleaved chunks of four tasks concurrently.

Question 35

What execution model does Diagram3.png illustrate?

Answer 35

* Sequential execution, using a single CPU to run tasks one at a time.

Question 36

According to Diagram3.png, what is the state of Task 2 during t1?

Answer 36

* Task 2 is in a waiting state while Task 1 is running.

Question 37

In Diagram4.png, which task is likely to finish first? Why?

Answer 37

* Task 1 or 2, depending on allocation of slices and task size, since they are scheduled earlier and more frequently.

Question 38

What does Diagram5.png demonstrate about parallelism?

Answer 38

* A single task (Task 1) is split into subtasks that execute in parallel on multiple CPUs.

Question 39

Why is parallelism effective as shown in Diagram5.png?

Answer 39

* It reduces overall execution time by distributing work across processors.

Question 40

Which column in Diagram6.png describes execution on a single-core CPU?

Answer 40

* Concurrency — because multiple tasks are interleaved over time, not running simultaneously.

Question 41

What does Diagram7.png represent?

Answer 41

* A single-threaded process, containing one thread of control sharing all process resources.

Question 42

What does Diagram8.png illustrate?

Answer 42

* A multithreaded process, where multiple threads share the same code and data but have individual stacks and registers.

Question 43

What’s the significance of separate stacks for each thread in Diagram8.png?

Answer 43

* Prevents one thread’s local variables and function calls from interfering with another’s execution flow.

Question 44

What comparison is made in Diagram9.png?

Answer 44

* It compares single-threaded vs. multithreaded processes side-by-side, highlighting resource sharing and execution differences.

Question 45

How does memory sharing differ between the two processes in Diagram9.png?

Answer 45

* Single-threaded: No need for synchronization. * Multithreaded: Requires synchronization for shared code and data.

Question 46

What does Diagram10.png show about thread creation in Java?

Answer 46

* Threads can be created by implementing the Runnable interface, then defining run().

Question 47

What must be done after implementing Runnable to actually start the thread?

Answer 47

• Pass the Runnable to a Thread object and call start() on it.

Question 48

What architecture is illustrated in Diagram11.png?

Answer 48

* A multithreaded server model: server creates a new thread to handle each client request.

Question 49

How does the server maintain responsiveness in Diagram11.png?

Answer 49

* It immediately returns to listening for requests after spawning a thread to handle the current one.

Question 50

What is the formula shown in Diagram12.png and what does it describe?

Answer 50

* Amdahl’s Law: speedup ≤ 1 / (S + (1 - S)/N) * It describes theoretical performance gain from parallel processing.

Question 51

How is a thread created using extends Thread as shown in Diagram13.png?

Answer 51

* By subclassing the Thread class and overriding run() to define the task.

Question 52

What is shown in Diagram14.png about thread lifecycle?

Answer 52

* Transitions between Java thread states: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, and TERMINATED.

Question 53

Why might a thread transition from RUNNABLE to BLOCKED in Diagram14.png?

Answer 53

* It attempts to access a locked resource (e.g., enters a synchronized block while another thread holds the lock).

Question 54

What does Diagram15.png depict in Java threading?

Answer 54

* Full code example of thread creation by extending Thread, and starting it using start().

Question 55

In Diagram15.png, what does start() do that run() does not?

Answer 55

* start() creates a new thread and invokes run() asynchronously; calling run() directly runs it on the current thread.

Question 56

What is the function of the operating system in Diagram16.png?

Answer 56

* Dispatches threads from READY to RUNNING state and returns them when their time slice expires.

Question 57

What state transitions are emphasized in Diagram17.png?

Answer 57

* The diagram highlights movement between all Java thread states, triggered by events like wait(), notify(), I/O, or task completion.