P(s1);
a++;
P(s2);
v++;
V(s2);
V(s1);
(s1, s2 are semaphores). All variables are automatic. Now, consider two threads running this fragment of code simultaneously, can there be a deadlock? Why, or why not?
Solution:
Both semaphores will be acquired in the same order by both threads. Since this is a linear order, there can be no situation where a deadlock could occur.
if(a > 0)
P(s1);
else
P(s2);
b++;
P(s3);
if(b < 0 && a <= 0)
P(s1);
else if(b >= 0 && a > 0)
P(s2);
else
P(s4);
a++;
V(s4);
V(s3);
V(s2);
V(s1);
s1, s2, s3 and s4 are semaphores. All variables are automatic. Now, consider two threads running this fragment of code simultaneously, can there be a deadlock? Why, or why not?
Solution:
Yes, there can be a deadlock. Consider the scenario where thread 1 starts by locking semaphore s1 then gets switched out while thread 2 runs. Thread 2 may start running with variable a set to 0 (remember, because the variables are automatic, each thread has its own independent set). Thread 2 will acquire semaphore s2, then proceeds to acquire s3. Then, if (b<0 && a <=0), it will try to acquire s1. This forces thread 2 to wait for thread 1 which holds this semaphore. Now, thread 1 may proceed but will block when it tries to acquire semaphore s3. This forms a cyclical wait, and a deadlock occurs.
Solution:
False.
Solution:
In a safe state there exists a safe sequence -- an ordered sequence of
resource grants that would allow each process that currently holds any
resources to acquire that process's maximum resource allocation. In an
unsafe state, no such sequence exists. Thus, an OS can always prevent
deadlock when a system is in a safe state by only granting resources that
keep the system in a safe state. Conversely, if the system is in an
unsafe state, there exists at least one sequence of requests that will
deadlock the system regardless of what the OS does.
Solution:
Priority inversion is a program bug in which a high priority thread waits for a lock that
is held by a low priority thread and the low priority thread is unable to release the lock
because a medium priority thread is using the CPU (or other required resources). In effect,
the high priority thread is waiting for the medium priority thread.