CS Elective

Question 1

• START OF FA1-A1 -
  The tightly coupled set of threads’ execution working on a single task is called Parallel Processing. (T/F)

Answer 1

FALSE (?)

Question 2

Parallelism naturally leads to complexity. (T/F)

Answer 2

FALSE** (CORRECT)

Question 3

Parallelism naturally leads to concurrency. (T/F)

Answer 3

TRUE

Question 4

A key advantage of distributed memory architectures is that they are more scalable than shared memory systems. (T/F)

Answer 4

TRUE

Question 5

Multiple-applications independently running, are typically called Multithreading. (T/F)

Answer 5

FALSE (CORRECT)

Question 6

Threads being blocked altogether and being executed in the sets of 32 threads are called Unit Blocks. (T/F)

Answer 6

FALSE (CORRECT)

Question 7

A Symmetric Multi-Processing (SMP) system has two or more _____ processors connected to a single _____ main memory.

Answer 7

IDENTICAL;SHARED (CORRECT)

Question 8

Threads being blocked altogether and being executed in the sets of 128 threads are called Unit Blocks. (T/F)

Answer 8

FALSE

Question 9

In most modern multi-core CPUs, cache coherency is usually handled by the _____.

Answer 9

processor hardware (CORRECT)

Question 10

If private data is used by a single-processor, then shared data is used by a multi-processor. (T/F)

Answer 10

TRUE*** (CORRECT)

Question 11

Distributed memory can be easily scaled. (T/F)

Answer 11

TRUE

Question 12

UMA stands for Universal Memory Access. (T/F)

Answer 12

FALSE (CORRECT)

Question 13

Modern multi-core PCs fall into the MIMD classification of Flynn’s Taxonomy. (T/F)

Answer 13

TRUE (CORRECT)

Question 14

Nonuniform Memory Access is often made by logically connecting multiple SMP systems together (T/F)

Answer 14

FALSE (CORRECT)

Question 15

In a concurrent memory architecture, each processor operates independently, and cannot make changes to its local memory. (T/F)

Answer 15

FALSE (CORRECT)

Question 16

Computer memory usually operates at a much faster speed than processors do. (T/F)

Answer 16

FALSE** (CORRECT)

Question 17

Distributed memory scales better than Shared memory. (T/F)

Answer 17

TRUE (CORRECT)

Question 18

Parallel computing can increase the number of tasks a program executes in a set time. (T/F)

Answer 18

TRUE (CORRECT)

Question 19

It is necessary in shared memory that the data exists on the same physical device, hence it could not be spread across a cluster of systems. (T/F)

Answer 19

FALSE (CORRECT)

Question 20

• START OF F3 -

In Java program, data race only occurs when each of the threads are incrementing a shared variable a large number of time because the JVM’s automatic data race prevention system can only protect against a small number of operations. (T/F)

Answer 20

False (CORRECT)

Question 21

A maximum of 2 threads can possess a Lock at the same time. (T/F)

Answer 21

FALSE (CORRECT)

Question 22

Which of these scenarios does NOT have the potential for a data race?
Group of answer choices

Two threads are both reading and writing the same shared variable.

One thread is reading a shared variable while another thread writes to it.

Two threads are both reading the same shared variable.

Two threads are both writing to the same shared variable.

Answer 22

Two threads are both reading the same shared variable. (CORRECT)

Question 23

Read-write locks can improve a program’s performance compared to using a standard mutex. (T/F)

Answer 23

TRUE (CORRECT)

Question 24

Two threads that are both reading and writing the same shared variable has no potential for a data race. (T/F)

Answer 24

FALSE (CORRECT)

Question 25

No thread can possess the ReadLock while another thread has a lock on the WriteLock. (T/F)

Answer 25

TRUE** (CORRECT)

Question 26

The reader-writer lock is useful especially when there are lots of threads that only need to be read. (T/F)

Answer 26

TRUE

Question 27

Data races can be hard to identify because the data race may not always occur during execution to cause a problem. (T/F)

Answer 27

TRUE (CORRECT)

Question 28

A maximum of 1 thread can possess the WriteLock of a ReentrantReadWriteLock at a time. (T/F)

Answer 28

TRUE (CORRECT)

Question 29

Locker Mutex protects critical section of the code to defend against data races, which can occur when multiple threads are concurrently accessing the same location in memory and at least one of those threads is writing to that location. (T/F)

Answer 29

TRUE (CORRECT)

Question 30

A possible strategy to resolve a livelock between multiple threads is thru randomly terminating one of the threads involved in the livelock. (T/F)

Answer 30

FALSE (CORRECT)

Question 31

Data race occurs when a thread is unable to gain access to a necessary resource, and is therefore unable to make progress. (T/F)

Answer 31

FALSE (CORRECT)

Question 32

Why is the tryLock() method useful?
Group of answer choices

If multiple threads try to acquire a lock simultaneously, the tryLock() method will randomly pick one to succeed.

It enables a thread to execute alternate operations if the lock it needs to acquire is already taken.

It enforces fairness among multiple threads competing for ownership of the same lock.

It includes built-in protection against common locking errors.

Answer 32

It enables a thread to execute alternate operations if the lock it needs to acquire is already taken. (CORRECT)

Question 33

When a thread calls Java’s tryLock() method on a Lock that is NOT currently locked by another thread the method will block until the Lock is available and then return false. (T/F)

Answer 33

FALSE (CORRECT)

Question 34

Unlike during a deadlock, the threads in a livelock scenario are actively executing without making useful progress. (T/F)

Answer 34

TRUE (CORRECT)

Question 35

The lock() method can be called recursively on a ReentrantLock object, but not on a regular Lock object. (T/F)

Answer 35

FALSE** (CORRECT)

Question 36

A thread must unlock a ReentrantLock twice before another thread can acquire it. (T/F)

Answer 36

FALSE (CORRECT)

Question 37

When the threads in the program are not making progress, you can determine if it is due to a deadlock or a livelock by using the Resource Monitor to investigate the program’s CPU usage to see if it is actively executing. (T/F)

Answer 37

TRUE (CORRECT)

Question 38

Which statement describes the relationship between Lock and ReentrantLock in Java?
Group of answer choices

The lock() method can be called recursively on a ReentrantLock object, but not on a regular Lock object.

Lock and ReentrantLock are two names for the same class.

ReentrantLock is a class that implements the Lock interface.

A ReentrantLock instantiates a new internal Lock object every time its lock() method is called.

Answer 38

ReentrantLock is a class that implements the Lock interface. (CORRECT)

Question 39

The tryLock() method is useful because if multiple threads try to acquire a lock simultaneously, the tryLock() method will randomly pick one to succeed. (T/F)

• END OF FA3-A1, 18/20 -

25* CORRECTED
35* CORRECTED

Answer 39

FALSE (CORRECT)

Question 40

• START OF FA3-A2 -

Protecting a critical section of code with mutual exclusion means that whenever a thread enters the critical section, it pauses all other threads in the program. (T/F)

Answer 40

FALSE (CORRECT)

Question 41

One thread that is reading a shared variable while another thread writes to it has no potential for a data race. (T/F)

Answer 41

FALSE (CORRECT)

Question 42

Two threads that are both reading the same shared variable has no potential for a data race. (T/F)

Answer 42

TRUE (CORRECT)

Question 43

The best use case for using a ReadWriteLock is when lots of threads need to modify the value of a shared variable. (T/F)

Answer 43

FALSE (CORRECT)

Question 44

A maximum of 2 threads can possess the ReadLock while another thread has a lock on the WriteLock? (T/F)

Answer 44

FALSE

Question 45

Data races can be hard to identify because the problems that data races cause have an insignificant impact on the program’s performance. (T/F)

Answer 45

FALSE (CORRECT)

Question 46

When the threads in the program are not making progress, you can determine if it is due to a deadlock or a livelock by using the Resource Monitor to investigate the program’s memory usage to see if it continues to grow. (T/F)

Answer 46

FALSE (CORRECT)

Question 47

When a thread calls Java’s tryLock() method on a Lock that is NOT currently locked by another thread the method will block until the Lock is available and then return true. (T/F)

Answer 47

FALSE (CORRECT)

Question 48

A ReentrantLock can be locked multiple times by different threads. (T/F)

Answer 48

FALSE (CORRECT)

Question 49

A ReentrantLock instantiates a new internal Lock object every time its lock() method is called. (T/F)

Answer 49

FALSE (CORRECT)

Question 50

Unlike during a deadlock, the threads in a livelock scenario are still making progress towards their goal. (T/F)

• END OF FA3-A2 = 20/20 -

Answer 50

FALSE (CORRECT)

Question 51

• START OF FA3-A3 -

Two threads that are both reading and writing the same shared variable has the potential for a data race. (T/F)

Answer 51

TRUE (CORRECT)

Question 52

The best use case for using a ReadWriteLock is when lots of threads need to modify the value of a shared variable, but only a few thread need to read its value. (T/F)

Answer 52

FALSE (CORRECT)

Question 53

Two threads that are both writing to the same shared variable has no potential for a data race. (T/F)

Answer 53

FALSE (CORRECT)

Question 54

The best use case for using a ReadWriteLock is when lots of threads need to read the value of a shared variable, but only a few thread need to modify its value. (T/F)

Answer 54

TRUE (CORRECT)

Question 55

Data races can be hard to identify because it is impossible to identify the potential for a data race. (T/F)

Answer 55

FALSE

Question 56

The best use case for using a ReadWriteLock is when only a few threads need to modify the value of a shared variable. (T/F)

Answer 56

FALSE (CORRECT)

Question 57

To avoid livelock, ensure that only one process takes action chosen by priority or some other mechanism, like random selection. (T/F)

Answer 57

TRUE (CORRECT)

Question 58

ReentrantLock is a class that implements the Lock interface. (T/F)

Answer 58

TRUE (CORRECT)

Question 59

The tryLock() method is useful because it enables a thread to execute alternate operations if the lock it needs to acquire is already taken. (T/F)

Answer 59

TRUE (CORRECT)

Question 60

When a thread calls Java’s tryLock() method on a Lock that is NOT currently locked by another thread the method immediately returns true. (T/F)

Answer 60

TRUE (CORRECT)

Question 61

Unlike during a deadlock, the threads in a livelock scenario are _____.

• END OF FA3-A3 = 20/20 -

Answer 61

actively executing without making useful progress (CORRECT)

Question 62

• START OF FA3-A4 -

Only 1 thread can possess the ReadLock while another thread has a lock on the WriteLock. (T/F)

Answer 62

FALSE (CORRECT)

Question 63

Protecting a critical section of code with mutual exclusion means only allowing authorized threads to execute the critical section. (T/F)

Answer 63

FALSE** (CORRECT)

Question 64

Having too many concurrent threads can lead to starvation. (T/F)

Answer 64

TRUE (CORRECT)

Question 65

A ReentrantLock can be locked by the same thread as many times depending on the operating system. (T/F)

Answer 65

FALSE (CORRECT)

Question 66

A ReentrantLock can be locked multiple times by the same thread. (T/F)

Answer 66

TRUE (CORRECT)

Question 67

How many times must a thread unlock a ReentrantLock before another thread can acquire it?

Answer 67

as many times as that thread locked it

Question 68

A thread does not need to unlock a ReentrantLock before another thread can acquire it because multiple threads can lock a ReentrantLock at the same time. (T/F)

Answer 68

FALSE (CORRECT)

Question 69

A possible strategy to resolve a livelock between multiple threads is thru implementing a randomized mechanism to determine which thread goes first. (T/F)

• END OF FA3- A4 = 18/20 -

*63 CORRECTED

Answer 69

TRUE (CORRECT)

Question 70

• START OF FA3 - A5 -

There is no limit on the number of threads that can possess the ReadLock while another thread has a lock on the WriteLock. (T/F)

Answer 70

FALSE** (CORRECT)

Question 71

What is the maximum number of threads that can possess the WriteLock of a ReentrantReadWriteLock at the same time?

Answer 71

1 (CORRECT)

Question 72

Data races can be hard to identify because data races are caused by hardware errors and cannot be debugged in software. (T/F)

Answer 72

FALSE (CORRECT)

Question 73

Using the ++ operator to increment a variable in Java executes as a single instruction at the lowest level. (T/F)

Answer 73

FALSE (CORRECT)

Question 74

Using the ++ operator to increment a variable in Java executes as multiple instructions at the lowest level. (T/F)

Answer 74

TRUE (CORRECT)

Question 75

Which of these is a possible strategy to resolve a livelock between multiple threads?
Group of answer choices

none of the mentioned

Implement a randomized mechanism to determine which thread goes first.

Patience because if you wait long enough all livelocks will eventually resolve themself.

Randomly terminate one of the threads involved in the livelock.

Answer 75

Implement a randomized mechanism to determine which thread goes first. (CORRECT)

Question 76

A ReentrantLock can be locked once by multiple threads at the same time. (T/F)

• END OF FA3-A5 = 19/20 -

**70 CORRECTED

Answer 76

FALSE (CORRECT)

Question 77

• START OF FA3-A6 -

In Java program, data race only occurs when each of the threads are incrementing a shared variable a large number of time because a data race can only occur when multiple threads are writing to a shared variable a large enough number of times. (T/F)

Answer 77

FALSE (CORRECT)

Question 78

Protecting a critical section of code with mutual exclusion means preventing multiple threads from concurrently executing in the critical section. (T/F)

Answer 78

TRUE (CORRECT)

Question 79

There is no limit on the number of threads that can possess a Lock at the same time. (T/F)

Answer 79

FALSE (CORRECT)

Question 80

tryLock() will continuously try to acquire the lock if it is already taken by another thread. (T/F)

Answer 80

FALSE

Question 81

Starvation occurs when a thread is unable to gain access to a necessary resource, and is therefore unable to make progress. (T/F)

Answer 81

TRUE (CORRECT)

Question 82

When the threads in the program are not making progress, you can determine if it is due to a deadlock or a livelock by randomly guessing between deadlock and livelock. (T/F)

Answer 82

FALSE (CORRECT)

Question 83

tryLock() includes built-in error handling so you do not need a separate try/catch statement. (T/F)

Answer 83

FALSE

Question 84

The tryLock() method is useful because it includes built-in protection against common locking errors. (T/F)

Answer 84

FALSE (CORRECT)

Question 85

Lock and ReentrantLock are two names for the same class. (T/F)

• END OF FA3-A6 = 20/20 -

Answer 85

FALSE

Question 86

• START OF FA3-A7 -

Which of these scenario describes the best use case for using a ReadWriteLock?

Group of answer choices

Only a few threads need to both and modify the value of a shared variable.

Lots of threads need to modify the value of a shared variable, but only a few thread need to read its value.

Lots of threads need to read the value of a shared variable, but only a few thread need to modify its value.

Lots of threads need to both and modify the value of a shared variable.

Answer 86

Lots of threads need to read the value of a shared variable, but only a few thread need to modify its value.

Question 87

Using the ++ operator to increment a variable in Java executes as an atomic instruction at the lowest level. (T/F)

Answer 87

FALSE (CORRECT)

Question 88

Using the ++ operator to increment a variable in Java executes as _____ at the lowest level.
Group of answer choices

none of the mentioned

a single instruction

multiple instructions

an atomic instruction

Answer 88

multiple instructions (CORRECT)

Question 89

The number of threads that can possess a Lock at the same time depends on the operating system. (T/F)

Answer 89

FALSE (CORRECT)

Question 90

What does it mean to protect a critical section of code with mutual exclusion?
Group of answer choices

Only allow authorized threads to execute the critical section.

Whenever a thread enters the critical section pause all other threads in the program.

Prevent multiple threads from concurrently executing in the critical section.

Implement proper error handling techniques to catch any unexpected problems.

Answer 90

Prevent multiple threads from concurrently executing in the critical section.

Question 91

How many threads can possess the ReadLock while another thread has a lock on the WriteLock?
Group of answer choices

0

1

no limit

2

Answer 91

0

Question 92

The tryLock() method is useful because it enforces fairness among multiple threads competing for ownership of the same lock. (T/F)

Answer 92

FALSE

Question 93

When the threads in the program are not making progress, you can determine if it is due to a deadlock or a livelock waiting to see if the problem eventually resolves itself. (T/F)

• END OF FA3-A7 = 20/20 -

Answer 93

FALSE (CORRECT)

Question 94

• START OF FA3-A8 -

How many threads can possess a Lock at the same time?
Group of answer choices

no limit

2

0

1

Answer 94

1

Question 95

Why can potential data races be hard to identify?

Group of answer choices

The problems that data races cause have an insignificant impact on the program’s performance.

It is impossible to identify the potential for a data race.

The data race may not always occur during execution to cause a problem.

Data races are caused by hardware errors and cannot be debugged in software.

Answer 95

The data race may not always occur during execution to cause a problem.

Question 96

Deadlock occurs when each member of a group is waiting for some other member to take action, and as a result, neither member is able to make progress.

(T/F)

Answer 96

TRUE (CORRECT)

Question 97

What happens when a thread calls Java’s tryLock() method on a Lock that is NOT currently locked by another thread?
Group of answer choices

The method will block until the Lock is available and then return false

The method will block until the Lock is available and then return true

The method immediately returns true

The method immediately returns false

Answer 97

The method immediately returns true (CORRECT)

Question 98

Having too many concurrent threads may still not lead to starvation. (T/F)

• END OF FA3-A8 = 19/20 -

Answer 98

FALSE** (CORRECT)

Question 99

• START OF FA3-A9 -

What is the maximum number of threads that can possess the ReadLock of a ReentrantReadWriteLock at the same time?
Group of answer choices

0

2

no limit

1

Answer 99

no limit (CORRECT)

Question 100

When a thread calls Java’s tryLock() method on a Lock that is NOT currently locked by another thread the method immediately returns false. (T/F)

Answer 100

FALSE

Question 101

Dining Philosophers Problem is a classic example that’s used to illustrate synchronization issues when multiple threads are competing for multiple locks. (T/F)

• END OF F3-A9 = 20/20 -

Answer 101

TRUE (CORRECT)

Question 102

To lock a mutex multiple times, using a reentrant mutex may seem like an easy way to avoid a deadlock. (T/F)

Answer 102

TRUE (CORRECT)

Question 103

A maximum of 2 threads can possess the WriteLock of a ReentrantReadWriteLock at the same time. (T/F)

Answer 103

FALSE (CORRECT)

Question 104

A thread must unlock a ReentrantLock as many times as that thread locked it before another thread can acquire it. (T/F)

• END OF FA3-A10 = 20/20 -

Answer 104

FALSE

Question 105

• START OF FA4-A1 -

Condition variables enable threads to signal each other when the state of the queue changes. (T/F)

Answer 105

TRUE (CORRECT)

Question 106

What does the semaphore’s release() method do to the counter value?

Group of answer choices

Always decrement the counter’s value.

Always increment the counter’s value.

If the counter is positive, decrement its value.

If the counter is positive, increment its value.

Answer 106

Always increment the counter’s value. (CORRECT)

(WRONG) If the counter is positive, increment its value.

Question 107

The semaphore’s release() method always increments the counter’s value.
(T/F)

Answer 107

FALSE

Question 108

The producer-consumer pattern follows FIFO method. (T/F)

Answer 108

TRUE (CORRECT)

Question 109

The consumption rate should be greater than or equal to the production rate in a producer-consumer architecture. (T/F)

Answer 109

FALSE (CORRECT)

Question 110

The consumption and production rates must be exactly the same in a producer-consumer architecture. (T/F)

Answer 110

FALSE (CORRECT)

Question 111

Track how many threads the program has created is a common use case for a counting semaphore. (T/F)

Answer 111

FALSE** (CORRECT)

Question 112

If the producer puts elements into a fixed-length queue faster than the consumer removes them, the consumer will automatically speed up to match the producer’s speed. (T/F)

Answer 112

FALSE (CORRECT)

Question 113

Distributed architecture consists of a chained-together series of producer-consumer pairs. (T/F)

Answer 113

FALSE (CORRECT)

Question 114

The semaphore’s acquire() method always increments the counter’s value. (T/F)

Answer 114

FALSE (CORRECT)

Question 115

A future is a task that can be assigned to a thread pool for execution. (T/F)

Answer 115

FALSE**

Question 116

When implementing a recursive divide-and-conquer algorithm in Java, why should you use a ForkJoinPool instead of simply creating new threads to handle each subproblem?

Group of answer choices

Using a ForkJoinPool is the only way to create an asynchronous task in Java that returns a result.

The ForkJoinPool manages a thread pool to execute its ForkJoinTasks, which reduces the overhead of thread creation.

Threads cannot recursively spawn other threads.

The ForkJoinPool automatically subdivides the problem for you.

Answer 116

The ForkJoinPool manages a thread pool to execute its ForkJoinTasks, which reduces the overhead of thread creation. (CORRECT)

Question 117

Thread is a synchronization tool? (T/F)

Answer 117

FALSE (CORRECT)

Question 118

Which one of the following is a synchronization tool?

Group of answer choices

pipe

thread

socket

semaphore

Answer 118

semaphore (CORRECT)

Question 119

It’s not possible to have data races without a race condition but possible to have race conditions without a data race. (T/F)

Answer 119

FALSE

Question 120

When it reaches the base case, a divide-and-conquer algorithm divides the problem into two smaller subproblems. (T/F)

Answer 120

FALSE (CORRECT)

Question 121

The Runnable interface’s run() method can have an optional return value, but the Callable interface’s call() method is required to always return an object. (T/F)

Answer 121

FALSE** (CORRECT)

Question 122

Threads within the same thread pool can more easily share data with each other than standard non-pool threads. (T/F)

Answer 122

TRUE

Question 123

When several processes access the same data concurrently and the outcome of the execution depends on the particular order in which the access takes place, is called?

Group of answer choices

Farace conditionlse

critical condition

dynamic condition

essential condition

• END OF FA4-A1 -
  13/20

115* CORRECTED
121* CORRECTED
111* CORRECTED
106** CORRECTED

Answer 123

“Farace conditionlse” (i think they mean RACE CONDITION)

(CORRECT)

Question 124

• START OF FA4-A2 -

The semaphore’s acquire() method increments its value if the counter is positive. (T/F)

Answer 124

FALSE

Question 125

The binary semaphore can have a positive or negative value. (T/F)

Answer 125

FALSE (CORRECT)

Question 125

The producer-consumer pattern follows LIFO method. (T/F)

Answer 125

FALSE (CORRECT)

Question 126

The binary semaphore can only be acquired and released by the same thread. (T/F)

Answer 126

FALSE (CORRECT)

Question 127

What is the difference between a binary semaphore and a mutex?
Group of answer choices

The binary semaphore can have a positive or negative value.

The binary semaphore can be acquired and released by different threads.

The binary semaphore can only be acquired and released by the same thread.

The binary semaphore will have a value of 0, 1, 2, 3, etc.

Answer 127

The binary semaphore can be acquired and released by different threads. (CORRECT)

Question 127

The average rates of production and consumption has not relation in a producer-consumer architecture? (T/F)

Answer 127

TRUE** (CORRECT)

Question 128

In addition to modifying the counter value, what else does calling the semaphore’s release() method do?

Group of answer choices

nothing else

Signal another thread waiting to acquire the semaphore.

Block and wait until the semaphore is available.

Block all other threads waiting on the semaphore.

Answer 128

Signal another thread waiting to acquire the semaphore. (CORRECT)

Question 128

Calling the semaphore’s release() method blocks and waits until the semaphore is available. (T/F)

Answer 128

FALSE (CORRECT)

Question 129

Semaphore is a synchronization tool? (T/F)

Answer 129

TRUE (CORRECT)

Question 130

When implementing a recursive divide-and-conquer algorithm in Java, the ForkJoinPool automatically subdivides the problem for you. (T/F)

Answer 130

FALSE (CORRECT)

Question 131

Threads provide a convenient way to group and organize a collection of related threads. (T/F)

Answer 131

FALSE (CORRECT)

Question 132

What is the difference between Java’s Callable and Runnable interfaces?

Group of answer choices

Only Callable objects can be submitted to an ExecutorService.

A Runnable object cannot be used to create a Future.

The Runnable interface’s run() method can have an optional return value, but the Callable interface’s call() method is required to always return an object.

The Callable interface’s call() method returns a result object but the Runnable interface’s run() method does not.

Answer 132

The Callable interface’s call() method returns a result object but the Runnable interface’s run() method does not. (CORRECT)

Question 133

Condition variables work together with the OS execution scheduler serving as a monitor. (T/F)

Answer 133

FALSE

Question 134

A Runnable object cannot be used to create a Future. (T/F)

Answer 134

FALSE (CORRECT)

Question 134

A race condition is a flaw in the timing or ordering of a program’s execution that causes incorrect behavior. (T/F)

Answer 134

TRUE (CORRECT)

Question 135

Condition variables work together with a process serving as a monitor.
(T/F)

• END OF FA4-A2=18/20 -

**128 CORRECTED

Answer 135

FALSE (CORRECT)

Question 136

• START OF FA4-A3 -

Create an extra thread to release the locks at random intervals to breakup a deadlock is a possible strategy to prevent deadlocks when multiple threads will need to acquire multiple locks. (T/F)

Answer 136

FALSE** (CORRECT)

Question 137

Prioritizing the locks so that all threads will acquire them in the same relative order is a possible strategy to prevent deadlocks when multiple threads will need to acquire multiple locks. (T/F)

Answer 137

TRUE (CORRECT)

Question 138

Which of these is a possible strategy to prevent deadlocks when multiple threads will need to acquire multiple locks?

Group of answer choices

Prioritize the locks so that all threads will acquire them in the same relative order.

Create a single “master lock” that all threads must first acquire before locking or unlocking any of the other locks.

Hope that you get lucky and a deadlock doesn’t occur.

Create an extra thread to release the locks at random intervals to breakup a deadlock.

Answer 138

Prioritize the locks so that all threads will acquire them in the same relative order. (CORRECT)

Question 139

Tracking how long a program has been running is a common use case for a counting semaphore. (T/F)

Answer 139

FALSE (CORRECT)

Question 140

Calling the semaphore’s release() method signals another thread waiting to acquire the semaphore. (T/F)

Answer 140

FALSE**

Question 140

If the producer puts elements into a fixed-length queue faster than the consumer removes them, the queue will fill up and cause an error. (T/F)

Answer 140

TRUE (CORRECT)

Question 141

Creating a single “master lock” that all threads must first acquire before locking or unlocking any of the other locks is a possible strategy to prevent deadlocks when multiple threads will need to acquire multiple locks. (T/F)

Answer 141

TRUE

Question 142

Pipeline architecture consists of a chained-together series of producer-consumer pairs. (T/F)

Answer 142

TRUE

Question 143

Heisenbug is a software bug that seems to disappear or alter its behavior when you try to study it. (T/F)

Answer 143

TRUE (CORRECT)

Question 143

What does a divide-and-conquer algorithm do when it reaches the base case?
Group of answer choices

Solve all of the subproblems that have been created.

Divide the problem into two smaller subproblems.

Recursively solve a set of smaller subproblems.

Stop subdividing the current problem and solve it.

Answer 143

Stop subdividing the current problem and solve it. (CORRECT)

Question 144

When using a thread pool in Java, the host operating system assigns submitted tasks to specific threads within the available pool to execute. (T/F)

Answer 144

FALSE (CORRECT)

Question 145

Why are thread pools useful?

Group of answer choices

Threads like to relax and go for a swim every once in a while.

They reuse threads to reduce the overhead that would be required to create a new, separate thread for every concurrent task.

They provide a convenient way to group and organize a collection of related threads.

Threads within the same thread pool can more easily share data with each other than standard non-pool threads.

Answer 145

They reuse threads to reduce the overhead that would be required to create a new, separate thread for every concurrent task.

Question 146

When using a thread pool in Java, the thread pool executor service assigns submitted tasks to specific threads within the available pool to execute. (T/F)

Answer 146

TRUE (CORRECT)

Question 147

A deadlock avoidance algorithm dynamically examines the system storage state to ensure that a circular wait condition can never exist. (T/F)

Answer 147

FALSE** (CORRECT)

Question 148

When using a thread pool in Java, the compiler assigns submitted tasks to specific threads within the available pool to execute. (T/F)

Answer 148

FALSE (CORRECT)

Question 149

When it reaches the base case, a divide-and-conquer algorithm recursively solves a set of smaller subproblems. (T/F)

Answer 149

FALSE (CORRECT)

Question 150

Socket is a synchronization tool? (T/F)

• END OF FA4-A3 = 16/20 -

**153 CORRECTED
**144 CORRECTED
**140 CORRECTED

Answer 150

FALSE (CORRECT)

Question 151

-START OF FA4-A4 -
The semaphore’s release() method increments its value if the counter is positive. (T/F)

Answer 151

FALSE**

Question 152

FIFO architecture consists of a chained-together series of producer-consumer pairs. (T/F)

Answer 152

FALSE

Question 153

When should a thread typically signal a condition variable?

Group of answer choices

It doesn’t matter.

after doing something to change the state associated with the condition variable but before unlocking the associated mutex

after unlocking the associated mutex

after locking the associated mutex and checking whether or not the condition is true

Answer 153

after doing something to change the state associated with the condition variable but before unlocking the associated mutex (?)

(WRONG) after locking the associated mutex and checking whether or not the condition is true

Question 154

Which of these is a common use case for a counting semaphore?

Group of answer choices

Track how many threads the program has created.

Track how long a program has been running.

Enforce mutual exclusion in a critical section of code.

Track the availability of a limited resource.

Answer 154

Track the availability of a limited resource. (CORRECT)

Question 155

When implementing a recursive divide-and-conquer algorithm in Java, the ForkJoinPool manages a thread pool to execute its ForkJoinTasks, which reduces the overhead of thread creation. (T/F)

Answer 155

TRUE (CORRECT)

Question 156

A future serves as a placeholder to access a result that may not been computed yet. (T/F)

Answer 156

TRUE (CORRECT)

Question 157

When it reaches the base case, a divide-and-conquer algorithm solves all of the subproblems that have been created. (T/F)

Answer 157

FALSE (CORRECT)

Question 158

Threads reuse threads to reduce the overhead that would be required to create a new, separate thread for every concurrent task. (T/F)

• END OF FA4-A4 = 17/20 -

**157 CORRECTED
**164 CORRECTED
** 153 CORRECTED

Answer 158

TRUE** CORRECT

Question 159

• START OF FA4-A5 -

The semaphore’s acquire() method always decrements the counter’s value. (T/F)

Answer 159

FALSE (CORRECT)

Question 160

Calling the semaphore’s release() method blocks all other threads waiting on the semaphore. (T/F)

Answer 160

TRUE** (CORRECT)

Question 161

If the producer puts elements into a fixed-length queue faster than the consumer removes them, the producer will run out of elements to put in the queue. (T/F)

Answer 161

FALSE (CORRECT)

Question 162

The semaphore’s acquire() method decrements its value if the counter is positive. (T/F)

Answer 162

TRUE (CORRECT)

Question 163

A barrier for a group of threads or processes in the source code means any thread/process must stop at this point and cannot proceed until all other threads/processes reach this barrier. (T/F)

Answer 163

TRUE (CORRECT)

Question 164

A future serves as the counterpart to a programming past. (T/F)

Answer 164

FALSE

Question 165

When implementing a recursive divide-and-conquer algorithm in Java, threads cannot recursively spawn other threads. (T/F)

• END OF FA4-A5 = 19/20 -

166 CORRECTED

Answer 165

FALSE (CORRECT)

Question 166

• START OF FA4-A6 -

What happens if the producer puts elements into a fixed-length queue faster than the consumer removes them?
Group of answer choices

The consumer will automatically speed up to match the producer’s speed.

The producer will run out of elements to put in the queue.

The queue will fill up and cause an error.

The queue will continuously expand to hold the extra items.

Answer 166

The queue will fill up and cause an error.

Question 167

Which architecture consists of a chained-together series of producer-consumer pairs?

Group of answer choices

FIFO

pipeline

distributed

client-server

Answer 167

pipeline (CORRECT)

Question 168

When it reaches the base case, a divide-and-conquer algorithm stops subdividing the current problem and solve it. (T/F)

Answer 168

TRUE (CORRECT)

Question 168

The consumption rate should be less than or equal to the production rate in a producer-consumer architecture. (T/F)

Answer 168

FALSE

Question 169

Condition variables work together with a thread serving as a monitor. (T/F)

• END OF FA4-A6 = 20/20 -

Answer 169

FALSE (CORRECT)

Question 170

• START OF FA4-A7 -

Client-server architecture consists of a chained-together series of producer-consumer pairs. (T/F)

Answer 170

FALSE

Question 171

Enforcing mutual exclusion in a critical section of code is a common use case for a counting semaphore. (T/F)

Answer 171

FALSE** (CORRECT)

Question 172

What does the semaphore’s acquire() method do to the counter value?

Group of answer choices

Always decrement the counter’s value.

If the counter is positive, decrement its value.

If the counter is positive, increment its value.

Always increment the counter’s value.

Answer 172

If the counter is positive, decrement its value.

Question 173

The binary semaphore will have a value of 0, 1, 2, 3, etc. (T/F)

Answer 173

FALSE

Question 174

The semaphore’s release() method always decrements the counter’s value. (T/F)

Answer 174

FALSE

Question 175

A future allows a program to change how it will function the next time it is run. (T/F)

Answer 175

FALSE

Question 176

A deadlock avoidance algorithm dynamically examines the resources to ensure that a circular wait condition can never exist. (T/F)

• END OF FA4-A7 = 18/20 -

**183 CORRECTED
**178 CORRECTED

Answer 176

FALSE** (CORRECT)

Question 177

• START OF FA4-A8 -

Condition variables work together with a mutex serving as a monitor. (T/F)

Answer 177

TRUE

Question 178

A deadlock avoidance algorithm dynamically examines the __________ to ensure that a circular wait condition can never exist.

system storage state

resource allocation state

resources

operating system

• END OF FA4-A8 = 18/20 -

**185 PENDING CORRECTION

Answer 178

resource allocation state (?)

(WRONG) system storage state

Question 179

• START OF FA4-A9 -

How should the average rates of production and consumption be related in a producer-consumer architecture?
Group of answer choices

It doesn’t matter.

The consumption rate should be less than or equal to the production rate.

The consumption and production rates must be exactly the same.

The consumption rate should be greater than or equal to the production rate.

Answer 179

The consumption rate should be greater than or equal to the production rate.

Question 180

When using a thread pool in Java, the _____ assigns submitted tasks to specific threads within the available pool to execute.

Group of answer choices

host operating system

thread pool executor service

compiler

programmer

Answer 180

thread pool executor service

Question 181

The Callable interface’s call() method returns a result object but the Runnable interface’s run() method does not. (T/F)

Answer 181

TRUE

Question 182

Only Callable objects can be submitted to an ExecutorService. (T/F)

• END OF FA4-A9 = 19 / 20 -

Answer 182

FALSE

Question 183

• START OF FA4-A10 -

Data races can occur when two or more threads concurrently access the same memory location. (T/F)

Answer 183

TRUE

Question 184

Pipe is a synchronization tool? (T/F)

• END OF FA4-A10 = 20/20 -

Answer 184

FALSE

Question 185

• START OF SA2 -

In Java program, data race only occurs when each of the threads are incrementing a shared variable a large number of time because the large number of write operations on the shared variable provided more opportunities for the data race to occur. (T/F)

Answer 185

TRUE (CORRECT)

Question 186

In the Java program to demonstrate a data race, why did the data race only occur when each of the threads were incrementing a shared variable a large number of time?
Group of answer choices

The JVM’s automatic data race prevention system can only protect against a small number of operations.

A data race can only occur when multiple threads are writing to a shared variable a large enough number of times.

The large number of write operations on the shared variable provided more opportunities for the data race to occur.

none of the mentioned

Answer 186

The large number of write operations on the shared variable provided more opportunities for the data race to occur.

Question 187

A thread must unlock a ReentrantLock once before another thread can acquire it. (T/F)

Answer 187

TRUE

Question 188

The semaphore’s release() method decrements its value if the counter is positive. (T/F)

Answer 188

FALSE

Question 189

When implementing a recursive divide-and-conquer algorithm in Java, using a ForkJoinPool is the only way to create an asynchronous task in Java that returns a result. (T/F)

Answer 189

FALSE

Question 190

When using a thread pool in Java, the programmer assigns submitted tasks to specific threads within the available pool to execute. (T/F)

Answer 190

FALSE

Question 191

The binary semaphore can be acquired and released by different threads.

Answer 191

TRUE

Question 192

• FA1 CONTINUATION -

Read-write can improve a program’s performance compared to using a standard mutex. (T/F)

Answer 192

TRUE (CORRECT)

Question 193

Unlike during a deadlock, the threads in a livelock scenario are stuck in a blocked state waiting on other threads. (T/F)

Answer 193

FALSE (CORRECT)

Question 194

Which of these is a possible strategy to resolve a livelock between multiple threads?

Answer 194

Implement a randomize mechanism to determine which thread goes first. (CORRECT)

Question 195

Which of these scenario describes the best use case for using a ReadWriteLock?

Answer 195

Lots of threads need to read the value of a shared variable, but only a few thread need to modify its value. (CORRECT)

Question 196

tryLock() is a non-blocking version of the lock() method.
(T/F)

Answer 196

TRUE (CORRECT)

Question 197

The threads in your program are clearly not making progress. How might you determine if it is due to a deadlock or a livelock?

Answer 197

Use the Resource Monitor to investigate the program’s CPU usage to see if it is actively executing. (CORRECT)

Question 198

Only 1 thread can possess a Lock at the same time. (T/F)

Answer 198

TRUE (CORRECT)

Question 199

Try lock or try enter is a blocking version of the lock or acquire method (T/F)

Answer 199

FALSE (CORRECT)

Question 200

Protecting a critical section of code with mutual exclusion means implementing proper error handling techniques to catch any unexpected problems (T/F)

Answer 200

FALSE (CORRECT)

Question 201

Which statement describes the relationship between Lock and ReentrantLock in Java?

Answer 201

ReentrantLock is a class that implements the Lock interface. (CORRECT)

Question 202

The four classifications of Flynn’s Taxonomy are based on the number of concurrent instruction streams and I/O streams available in the architect (T/F)

Answer 202

TRUE (CORRECT)

Question 203

An SMP system is a single processor connected to a single shared memory often through a serial circuit (T/F)

Answer 203

FALSE (CORRECT)

Question 204

Threads being blocked altogether and being executed in the sets of 8 threads are called Unit Blocks. - cache (T/F)

Answer 204

FALSE (CORRECT)

Question 205

A key advantage of distributed memory architectures is that they are _____ than shared memory systems

Answer 205

LESS COMPLEX (CORRECT)

Question 206

The four classifications of Flynn’s Taxonomy are based on the number of concurrent instruction streams and I/O streams available in the architecture (T/F)

Answer 206

TRUE (CORRECT)

Question 207

Multiple-applications dependently running, are typically called Multithreading (T/F)

Answer 207

FALSE (CORRECT)

Question 208

serialIn a concurrent memory architecture, each processor operates independently, and cannot make changes to its local memory. (T/F)

Answer 208

FALSE (CORRECT)

Question 209

Distributed processing is the term used for simultaneous access to a resource, physical or logical. (T/F)

Answer 209

FALSE (CORRECT)

Question 210

Public data is used by a multi-processor (T/F)

Answer 210

FALSE (CORRECT)

Question 211

A key advantage of distributed memory architecture is that they are more responsive than shared memory system. (T/F)

Answer 211

FALSE (CORRECT)

Question 212

Private data is used by a single-processor (T/F)

Answer 212

TRUE (CORRECT)

Question 213

The on-chip memory which is local to every multithreaded Multiple Instruction Single Data (MISD) Processor is called local memory (T/F)

Answer 213

FALSE (CORRECT)

Question 214

In a parallel memory architecture, each processor operates independently, and if it makes changes to its local memory, that change is not automatically reflected in the memory of other processors (T/F)

Answer 214

FALSE (CORRECT)

Question 215

Each core of modern processors’ has their own cache that stores frequently accessed data (T/F)

Answer 215

TRUE (CORRECT)

Question 216

Uniform Memory Access is often made by physically connecting multiple SMP systems together (T/F)

Answer 216

FALSE (CORRECT)

Question 217

An SMP system has two or more identical processors which are connected to a single shared memory often through a system bus (T/F)

Answer 217

TRUE (CORRECT)

Question 218

The on-chip memory which is local to every multithreaded Single Instruction Single Data (SISD) Processor is called local memory. (T/F)

Answer 218

FALSE (CORRECT)

Question 219

Parallel processing has single execution flow (T/F)

Answer 219

FALSE (CORRECT)

Question 220

The machine object created by the operating system, managing, scheduling, and executing is a thread of DIMS instructions. (T/F)

Answer 220

FALSE (CORRECT)

Question 221

In parallel processing, several instructions are executed simultaneously. (T/F)

Answer 221

TRUE (CORRECT)

Question 222

Parallel computing can increase the _____.

All of these answers.

number of tasks a program executes in a set time.

speed at which a program executes a set number of tasks
scale of problems a program can tackle

Answer 222

All of these answers. (CORRECT)

Question 223

Parallel computing can increase the speed at which a program executes a set number of tasks (T/F)

Answer 223

TRUE (CORRECT)

Question 224

An SMP system a single processor connected to a single shared memory often through a serial circuit. (T/F)

Answer 224

FALSE (CORRECT)

Question 225

Modern multi-core PCs fall into the SIMD classification of Flynn’s Taxonomy (T/F)

Answer 225

FALSE (CORRECT)

Question 226

Modern multi-core PCs fall into the MISD classification of Flynn’s Taxonomy (T/F)

Answer 226

FALSE (CORRECT)

Question 227

Data transfer over a bus is much faster (T/F)

Answer 227

FALSE (CORRECT)

Question 228

Cache coherency is not an issue handled by the hardware in multicore processors (T/F)

Answer 228

FALSE (CORRECT)

Question 229

Shared memory always scales well (T/F)

Answer 229

FALSE (CORRECT)

Question 230

Distributed processing has single execution flow (T/F)

Answer 230

FALSE (CORRECT)

Question 231

A key advantage of distributed memory architectures is that they are more responsive than shared memory systems (T/F)

Answer 231

FALSE (CORRECT)

Question 232

A single applications independently running, is typically called Multithreading (T/F)

Answer 232

FALSE (CORRECT)

Question 233

The four classifications of Flynn’s Taxonomy are based on the number of concurrent _____ streams and _____ streams available in the architecture

Answer 233

INSTRUCTION; DATA (CORRECT)

Question 234

UMA stands for Uniform Memory Allocation (T/F)

Answer 234

FALSE (CORRECT)

Question 235

Processes being blocked altogether and being executed in the sets of 32 processes are called Unit Blocks (T/F)

Answer 235

FALSE (CORRECT)

Question 236

If public data is used by a single-processor, then shared data is used by a multi-processor (T/F)

Answer 236

FALSE (CORRECT)

Question 237

In a concurrent memory architecture, each processor operates independently, and if it makes changes to its local memory, that change is not automatically reflected in the memory of other processors (T/F)

Answer 237

FALSE (CORRECT)

Question 238

In a distributed memory architecture, each processor operates independently, and if it makes changes to its local memory, that change is not automatically reflected in the memory of other processors (T/F)

Answer 238

TRUE (CORRECT)

Question 239

Parallelism naturally leads to dependency (T/F)

Answer 239

FALSE (CORRECT)

Question 240

A symmetric Multi-Processing (SMP) system has two or more identical processors connected to a single shared main memory (T/F)

Answer 240

TRUE (CORRECT)

Question 241

The tightly coupled set of processes’ execution working on a single task is called Parallel Processing (T/F)

Answer 241

FALSE (CORRECT)

Question 242

A Symmetric Multi-Processing (SMP) system has two or more dissimilar processors connected to a single shared main memory (T/F)

Answer 242

FALSE (CORRECT)

Question 243

The machine object created by the hardware, managing, scheduling, and executing is a thread of SIMS instructions. (T/F)

Answer 243

FALSE (CORRECT)

Question 244

Shared memory doesn’t necessarily mean all of the data exists on the same physical device, hence it could be spread across a cluster of systems (T/F)

Answer 244

TRUE (CORRECT)

Question 245

UMA stands for United Memory Access (T/F)

Answer 245

FALSE (CORRECT)

Question 246

The on-chip memory which is local to every multithreaded Multiple Instruction Multiple Data (MIMD) Processor is called local memory (T/F)

Answer 246

FALSE (CORRECT)

Question 247

The machine object created by the hardware, managing, scheduling, and executing is a thread of DIMS instructions (T/F)

Answer 247

FALSE (CORRECT)

Question 248

A symmetric Multi-Processing (SMP) system has two or more identical processors connected to a single distributed main memory (T/F)

Answer 248

FALSE (CORRECT)

Question 249

Threads being blocked altogether and being executed in the sets of 2 threads are called Unit Blocks (T/F)

Answer 249

FALSE (CORRECT)

Question 250

The four classifications of Flynn’s Taxonomy are based on the number of concurrent program streams and data streams available in the architecture (T/F)

Answer 250

FALSE (CORRECT)

Question 251

Distributed memory cannot be easily scaled (T/F)

Answer 251

FALSE (CORRECT)

Question 252

• FA2 CONTINUATION -

https://docs.google.com/document/d/1NaHvQjuEc8pTytp3-zC-P9N9YwZ2e2xKyEPnMKqxvW8/edit