死锁：
两个以上的进程互相都要求对方已经占有的资源，导致无法继续继续执行下去的现象。
死锁产生的条件：
环路等待，互斥，保持和等待，不剥夺。
打破死锁的的条件：
死锁预防，死锁避免，死锁检测，死锁解除。
考点为死锁避免重的银行家算法：
| 互斥条件 | 两个条件a和吧，两个线程都要得到这两个资源才能运行， 线程1获得了a等待获取b，线程2获取了b等待获取a，两个线程相互竞争、等待，产生死锁 |
|---|---|
| 请求和保持条件 | 1、线程已经保持至少一个资源，并保持这个资源不释放：保持不释放 2、线程要获取新的资源请求、但是该资源已经被别的线程占用：请求已占用 |
| 不剥夺条件 | 保持的资源只能线程执行完了才能释放 |
| 环路等待条件 | 即线程1在等待线程2释放资源，线程2在等待线程1释放资源，产生环路 |
有序资源法
有个两个资源R1和R2，给R1和R2编号为1、2，让线程获取资源的顺序为1，2，从而避免死锁
线程1获取资源：R1，R2
线程2获取资源：R1，R2
银行家算法：
- 对于进程发出的每一个系统可以满足的资源请求命令加以检测，如果发现分配资源后系统进入不安全状态，则不予分配。
- 若分配资源后系统仍处于安全状态，则实施分配。
- 与死锁预防相比，提高了资源利用率，但检测分配后系统是否安全增加了系统开销。
在系统中必须设置这样四个数据结构：
1）Available向量：系统中可利用的资源数目
2）Max矩阵：每个进程对每种资源的最大需求量
3）Allocation矩阵：每个进程已分配的各类资源的数目
4）Need矩阵：每个进程还需要的各类资源数
5）State状态：
5）Work矩阵：初始化Available，后面永远都是Available-Need+Allocated
具体计算公式：
Need=Max - Allocation
Work计算：
①初始化： Work = Available
②往后都是：Work = Need+Work
Available = Work + Allocation
| 进程 | Allocation（已分配资源数） | Max（最大需求量） | Available（可用资源数） |
|---|---|---|---|
| A B C D | A B C D | A B C D | |
| P0 | 0 0 1 2 | 0 0 1 2 | 1 5 2 0 |
| P1 | 1 0 0 0 | 1 7 5 0 | |
| P2 | 1 3 5 4 | 2 3 5 6 | |
| P3 | 0 0 1 4 | 0 6 5 6 |
使用银行家算法回答下面问题：
- 请写出Need矩阵？
- 系统是否处于安全状态？为什么？
- 如果进程P1发来一个请求Request1(0,4,2,0)，这个请求能否立刻被满足？为什么？
解答：
- 请写出Need矩阵？
- 系统是否处于安全状态？为什么？
最终得到结果是线程安全，P0 -> P2 -> P1 -> P3
上面都是我的草稿理解：
下面我在用文字描述一下：
这个计算过程比较复杂，我也是看了好多篇博客才弄懂。
首先，要弄懂请拿出一张草稿纸，跟着上图做一遍。
第一步，把Need和Allocation先按照P0到P3的顺序列出图；
第二步，首先按照顺序尝试P0，将Available向量初始化给Work；
第三步，判断线程是否安全，用State状态来代表，类似于if(Work - Need > 0)的操作判断boolean。即1520-0000 = true，那么第一个执行进程就是P0；
第四步，计算Work+Allocation：1520 + 0012 = 1532；
第五步，执行P1进程，将这个1532存入临时变量temp，判断state= 1532+1354 - 0750 = false，得等待（阻塞）
第六步，执行P2进程，判断state = 1532 - 1002 = 0530 = true；
第七步，将临时变量temp直接赋给P2的Work，此时Work=1532；
第八步，计算Work+Allocation：1532 + 1354 = 2886；
第九步，重试或唤醒P1进程，将2886存入临时变量temp，判断state= 2886 - 0750 = 2136 = true；
第十步，将临时变量temp直接赋给P1的Work，此时Work = 2886；
第十一步，计算Work+Allocation：2886 + 1000 = 3886；
第十二步，执行P3进程，将3886直接赋给P3的Work，Work = 3886；
第十三步，判读state=3886-0642 = 3244 = true；
第十四步，计算Work+Allocation：3886 + 0014 = 3 8 9 10；
最终，得到结果线程安全，执行顺序：P0 -> P2 -> P1 -> P3。
总结：当Work<Need时优先执行该进程，算出Work+Allocation后，表的第二行的Work = 第一行的Work+Allocation，这样循环操作直至表格填充完整。
简化步骤：(Available[n]-Need[n]）、(Work[n-1]+Allocation[n-1]-Need[n])
P0:1520-0000=true，满足条件
P1:(1520+0012)-0750=false，不满足条件
P2:1532-1002=true，满足条件
P1:(1532+1354)-0750=true，满足条件
P3:(2886+1000)-0642=true，满足条件
- 如果进程P1发来一个请求向量Request1(0,4,2,0)，这个请求能否立刻被满足？为什么？
首先按照银行家算法检查：
①Request1(0,4,2,0)<=Need1(0,7,5,0)
②Request1(0,4,2,0)<=Available(1,5,2,0)
③通过后，修改Available值=1520-0420=1100，Need1 = 0750-0420=0330，Allocation1=1000+0420=1420，其他值不变。
然后将Available分配给P0,P1,P2,P3: (Available[n]-Need[n]）、(Work[n-1]+Allocation[n-1]-Need[n])
P0:1100-0000=true ,满足条件
P1:(1100+0012)-0330=false,不满足条件，等待
P2:1112-1002=true，满足条件
P1:(1112+1354)-0330=true，满足条件
P3:(2466+1420)-0642=true，满足条件
参考链接：https://blog.csdn.net/LightUpHeaven/article/details/86025426
https://blog.csdn.net/qq_22701869/article/details/107272617
https://blog.csdn.net/qq_41541801/article/details/93765001
https://blog.csdn.net/weixin_43356265/article/details/89604631
若有收获，就点个赞吧
0 人点赞
