Threadx-Priority Inversion

Undesirable situations can occur when two threads with different priorities share a common
resource. Priority inversion is one such situation; it arises when a higher-priority
thread is suspended because a lower-priority thread has acquired a resource needed by
the higher-priority thread. The problem is compounded when the shared resource is not
in use while the higher-priority thread is waiting. This phenomenon may cause priority
inversion time to become nondeterministic and lead to application failure. Consider
Figure 3.7, which shows an example of the priority inversion problem.
In this example, Thread 3 (with the lowest priority) becomes ready. It obtains mutex M
and begins its execution. Some time later, Thread 2 (which has a higher priority)
becomes ready, preempts Thread 3, and begins its execution. Then Thread 1 (which has
the highest priority of all) becomes ready. However, it needs mutex M, which is owned by Thread 3, so it is suspended until mutex M becomes available. Thus, the higher-priority
thread (i.e., Thread 1) must wait for the lower-priority thread (i.e., Thread 2) before it
can continue. During this wait, the resource protected by mutex M is not being used
because Thread 3 has been preempted by Thread 2.