什么是优先级反转?

优先级反转是一个问题,而不是解决方案。典型的例子是低优先级进程获取高优先级进程所需的资源,然后被中优先级进程抢占,因此高优先级进程在中优先级进程完成时被阻塞在资源上(有效地以低优先级执行)。

一个相当著名的例子是火星探路者探测器遇到的问题: http://www.cs.duke.edu/~carla/mars.html ,这是一本非常有趣的书。

想象三(3)个不同优先级的任务:tLow、tMed和throw。tLow和tHigh在不同的时间访问相同的关键资源;tMed做自己的事情。

1. tLow正在运行,tMed和大腿目前被阻塞(但不在关键部位)。
2. t向下进入临界区。
3. 大腿解除锁定,因为它是系统中优先级最高的任务,所以它会运行。
4. 然后,tHigh尝试进入关键资源,但由于tLow在那里而被阻塞。
5. tMed解除阻塞,因为它现在是系统中优先级最高的任务,所以它会运行。

在tLow放弃资源之前不能运行大腿。在tMed块或结束之前,不能运行tLow。任务的优先级已被颠倒;尽管具有最高优先级的大腿位于执行链的底部。

要“解决”优先级反转,必须提高tLow的优先级,使其至少与大腿一样高。有些可能会将其优先级提高到可能的最高优先级。与提高tLow的优先级同样重要的是在适当的时间降低tLow的优先级。不同的系统会采取不同的方法。

何时放弃优先权。。。

1. tLow拥有的任何资源上都不会阻止其他任务。这可能是由于超时或释放资源所致。
2. 在tLow拥有的资源上,不会阻止其他有助于提高tLow优先级的任务。这可能是由于超时或释放资源所致。
3. 当任务正在等待资源发生更改时,请降低tLow的优先级,以匹配在其资源上被阻止的最高优先级任务的优先级。

方法2是对方法1的一种改进,它缩短了tLow的优先级受到影响的时间。请注意,在此期间,它的优先级将保持在大腿的优先级。

方法#3允许tLow的优先级在必要时逐步降低,而不是一个all或nothing步骤。

根据他们认为重要的因素,不同的系统将实现不同的方法。

• 内存占用
• 复杂性
• 实时响应
• 开发人员知识

希望这有帮助。

它是 the problem 而不是解决方案。

它描述了当低优先级线程在工作期间获得锁时,高优先级线程将不得不等待它们完成(这可能需要特别长的时间,因为它们是低优先级的)。这里的反转是高优先级线程不能继续,直到低优先级线程这样做,所以实际上它现在也有低优先级。

一个常见的解决方案是让低优先级线程临时继承等待其持有的锁的每个人的高优先级。

假设应用程序有三个线程:

Thread 1 has high priority.
Thread 2 has medium priority.
Thread 3 has low priority.

假设线程1和线程3共享相同的关键部分代码

线程1和线程2在示例开始时处于休眠状态或被阻塞。线程3运行并进入关键部分。

这时,线程2开始运行,抢占线程3,因为线程2具有更高的优先级。因此,线程3继续拥有一个关键部分。

稍后,线程1开始运行,抢占线程2。线程1试图进入线程3拥有的临界区,但由于它属于另一个线程,线程1会阻塞,等待临界区。

这时,线程2开始运行,因为它的优先级高于线程3,而线程1没有运行。线程3从不释放线程1正在等待的关键部分,因为线程2继续运行。

因此,系统中优先级最高的线程thread 1在等待低优先级线程运行时被阻塞。

[假设,低流程=LP,中流程=MP,高流程=HP]

LP正在执行一个关键部分。当进入临界区时,LP必须在某个对象上获得一个锁,比如OBJ。 LP现在在临界区内。

与此同时,惠普也诞生了。由于优先级较高,CPU会执行上下文切换,而HP现在正在执行(不是同一个关键部分,而是其他一些代码)。在HP执行过程中的某个时刻,它需要在同一个OBJ上设置一个锁(可能在同一个关键节上,也可能不在同一个关键节上),但OBJ上的锁仍然由LP持有,因为在执行关键节时它被预先清空。LP现在无法放弃,因为进程处于就绪状态,未运行。现在HP被移动到阻止/等待状态。

现在,MP进来执行自己的代码。MP不需要锁定OBJ,所以它保持正常执行。HP等待LP释放锁,LP等待MP完成执行,以便LP返回到运行状态(。。执行并释放锁)。只有在LP解除锁定后,HP才能恢复到就绪状态(然后通过预先清空低优先级任务进入运行状态)

因此,这实际上意味着,在MP完成之前,LP无法执行,因此HP无法执行。因此,似乎惠普正在等待MP,尽管它们与OBJ锁没有直接关系。-> 优先级反转 .

优先级反转的解决方案是 Priority Inheritance -

将进程(a)的优先级增加到任何优先级的优先级 正在等待具有资源锁的任何资源的其他进程。

让我说得简单明了。(此答案基于上述答案,但以简洁的方式给出)。

说有资源 R 和3个过程。 L , M , H . 哪里 p(L) < p(M) < p(H) (其中 p(X) 是 X ).

说

• 一 首先开始执行,然后catch保持 右 . (独家访问 右 )
• 小时 稍后再来,还希望独占访问 右 从那以后 一 拿着它, 小时 必须等待。
• 米 后来居上 小时 和 它不需要 右 . 从那以后 米 已经得到了它想要执行的一切 一 因为它比 一 . 但是 小时 无法执行此操作,因为它有一个由锁定的资源 一 它需要执行。

现在把问题说得更清楚,实际上 米 应该等待 小时 作为完成 p(H) > p(M) 这并没有发生,这本身就是问题所在。如果许多过程如 米 来吧,别让 一 执行并释放锁 H 永远不会执行。在时间紧迫的应用中会有危险

有关解决方案,请参阅以上答案:)

优先级反转是指低优先级进程获得高优先级进程所需的资源,从而阻止高优先级进程继续进行,直到释放资源。

如: Proc1和Proc2需要访问FileA。 Proc 1的优先级高于Proc2,但Proc2设法先打开FileA。

通常Proc1的运行频率可能是Proc2的10倍,但由于Proc2保存文件,因此无法执行任何操作。

因此,最终发生的是Proc1阻塞直到Proc2完成FileA,实际上它们的优先级是“反转的”,而Proc2持有FileA的句柄。

就“解决问题”而言,如果优先级反转持续发生,它本身就是一个问题。 最糟糕的情况(大多数操作系统不会让这种情况发生)是Proc2在Proc1之前不允许运行。这将导致系统锁定,因为Proc1将继续获得分配的CPU时间,Proc2将永远不会获得CPU时间,因此文件将永远不会被释放。

优先级反转是这样发生的: 给定流程H、M和L,其中名称代表高、中、低优先级, 只有H和L有共同的资源。

比方说,我先获取资源并开始运行。因为H也需要该资源,所以它进入等待队列。 M不共享资源,因此可以开始运行。当L被任何方式中断时,M采用运行状态,因为它具有更高的优先级,并且在中断发生的瞬间运行。 尽管H的优先级比M高,但由于它在等待队列中,因此它无法获取资源,这意味着它的优先级甚至比M低。 M完成后,我将再次接管CPU,导致H一直等待。

如果阻塞的高优先级线程将其高优先级转移到保留资源的低优先级线程,则可以避免优先级反转。

当高优先级进程需要读取或修改当前由低优先级进程或低优先级进程链访问的内核数据时,就会出现调度问题。由于内核数据通常使用锁进行保护,因此高优先级进程将不得不等待低优先级进程使用资源。如果低优先级进程被抢占,而另一个具有更高优先级的进程被抢占,情况会变得更加复杂。例如,假设我们有三个流程L、M和H,它们的优先级遵循L<M<H的顺序。假设流程H需要资源R,而资源R当前正被流程L访问。通常,流程H会等待L使用资源R结束。但是,现在假设流程M可以运行,从而抢占进程L。间接地,优先级较低的进程“进程M”影响了进程H必须等待L多长时间才能放弃资源R。这个问题被称为优先级反转。它只发生在具有两个以上优先级的系统中,因此一个解决方案是只有两个优先级。这对大多数人来说是不充分的但是,通用操作系统。通常这些系统通过实现优先级继承协议来解决问题。根据该协议,访问高优先级进程所需资源的所有进程将继承高优先级,直到它们与所述资源一起完成。当它们完成时,它们的优先级将恢复为其原始值。在上面的例子中,优先级继承协议允许进程L临时继承进程H的优先级,从而防止进程M抢占其执行。当流程L已经使用资源R完成时,它将放弃从H继承的优先级并承担其原始优先级。由于资源R现在可用,流程H而不是M将运行下一个。 参考文献:亚伯拉罕·西尔伯沙茨

考虑一个有两个过程的系统, H 高度优先 L 低优先级。调度规则是这样的 小时 由于其高优先级,每当它处于就绪状态时运行。在某个时刻 一 在它的关键区域, 小时 准备运行(例如,I/O操作完成)。 小时 现在开始忙着等待,但是自从 一 从未安排 小时 正在运行, 一 从来没有机会离开关键的部分。所以 小时 永远循环。

这种情况叫做 Priority Inversion . 因为高优先级进程正在等待低优先级进程。