Clarification on Deadlock between two threads [closed] - operating-system

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 4 years ago.
Improve this question
I would like to know if my solution to this problem is correct
ThreadA and ThreadB both need both resources, P and Q, in order to do some work. Each Thread can acquire a resource with lockQ() or lockP(). The resources cannot be shared. If a Task tries to acquire a resource that is already in use, it blocks. When a Task no longer needs a resource it owns it can release it with unlockP() or unlockQ().
Each task runs its own code and uses the functions lockP(), lockQ(), doWork(), unlockP() and unlockQ(). Each thread releases its resources after invokes “doWork()”; the resources are released in the opposite order they were obtained. Show a sequence of operations for each thread so that deadlock is impossible.
Solution:
Task A
lockP();
lockQ();
doWork();
unlockQ();
unlockP();
Task B
lockP();
lockQ();
doWork();
unlockQ();
unlockP();
The reason I locked P and Q first for both, was because if the processor was executing TaskA first, TaskB would become blocked. This would allow for TaskA to finish execution, and then move on to TaskB which would e unblocked.

Answer 1

Yes your solution is correct.
An alternative is for Task B to lockQ before lockP, while Task A does lockP and lockQ. But this has the potential for dead lock if B gets Q and A gets P. In such a case both task's are blocked.
As you mention, having both acquire the resources in the same order, ensures one is blocked without causing the other to block on the other resource.
Coffman, Elphick and Shoshani (1971) identified four conditions for occurrence of a dead lock[1],
Shared resources which are used under mutual exclusion
Incremental acquisition
No preemption (once acquired, a task will not give up a resource until it has completed its work)
Wait-for cycle
You must nullify one of these conditions for a guarantee of no deadlocks occurring. By ensuring both tasks acquire the resources in the same order, you have make sure condition 4 does not hold, i.e. A, B will never both hold a resource and wait for a second resource at the same time.
[1]: Magee, Kramer, Concurrency State Models & Java Programs, page 107