1.死鎖

死鎖，顧名思義，是一種鎖住不可自行解開的死局。

在作業系統中，“死鎖”用於描述資源分配時，程序互相搶佔資源，又因為需求的資源被別的程序搶佔，只好互相等待，以至於等待迴圈中的所有程序均無法正常執行的情況。

死鎖形成需要四個條件，這四個條件缺少一個，就不會形成死鎖。

死鎖的四個條件

1）互斥條件

    即對於某資源在一段時間內僅允許一個程序佔有使用。

2）佔有且等待條件/請求和保持條件

    在程序已經佔有一個或多個資源的情況下，若它仍申請新的資源，在等待獲得新的資源時，程序仍會繼續佔有舊有資源，不會主動釋放。

3）不可搶佔條件

    直到佔有該資源的程序使用完畢之前，其他任何程序均不應該強行搶佔該資源。

4）迴圈等待條件

    若干個程序之間形成了一個等待迴圈。

2.安全狀態

若針對目前資源分配情況，系統可以找到某種次序為程序分配資源，使得所有程序能夠依次執行成功，則稱系統此時的分配狀態是安全的，分配資源的次序稱為“安全序列”。

安全狀態時系統中無死鎖，所以所有避免死鎖的演算法都儘可能地使系統進入安全狀態。

值得注意的是，即使是安全狀態下的系統，如果資源分配不當，仍然可以使系統變為不安全狀態。

3.銀行家演算法

1）設計思想

在系統中，程序發起一項資源分配請求，由系統檢查是否可以滿足該分配請求，若可以，應暫時滿足該請求，並檢視此時系統是否仍是安全狀態。

2）程式流程圖

可以分為三個功能模組，第一個模組檢查需求是否可以被滿足，第二個模組檢查系統是否安全，第三個模組是主程式，通過呼叫前兩個模組實現資源分配或請求駁回。

3）資料結構

設有m種資源，n個程序。

int[] Available[m] 系統內可用資源

int[,] Max[n,m] 程序對每種資源的最大需求

int[,] Allocation[n,m] 已分配給各個程序的資源

int[,] Need[n,m] 目前各個程序對各個資源的需求數

[顯然有Need=Max-Allocation]

int[,] Require[m] 對於各種資源的請求函式

bool[] Finish[n] 程序是否可以成功執行的標誌

int[] Work[m] 用於分配資源的向量

[定義：Work=Available-Require]

4）窗體設計

5)窗體程式碼

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace bank
{
    public partial class Form1 : Form
    {
        public int n = 1;//程序數目
        public int m = 1;//資源分類數
        int[,] Allocation;
        int[,] Max;
        int[] Available;
        int[,] Need;
        int[] Require;
        string order;//輸出安全序列

        public Form1()
        {
            InitializeComponent();

        }

        private void button1_Click(object sender, EventArgs e)
        {
            n = Convert.ToInt32( tb_proNum.Text);
            m = Convert.ToInt32(tb_resouseClass.Text);
        }

        private void button2_Click(object sender, EventArgs e)
        {
            if (rb_allocation.Checked)
            {
                tb_output.Text  += "Allocation矩陣\r\n";
                string[] str = tb_datainput.Text.Split(' ');

                 Allocation = new int[n, m];
                for (int i = 0; i < n; i++)
                {
                    tb_output.Text+="\r\n";
                   string[] temp= str[i].Split(',');
                   for (int j = 0; j < m; j++)
                   {
                       Allocation[i, j] = Convert.ToInt32(temp[j]);
                       tb_output.Text += " " + Allocation[i, j];
                   }
                }
                
            }
            else if (rb_available.Checked)
            {
                tb_output.Text += "\r\nAvailable向量\r\n";
                string[] str = tb_datainput.Text.Split(',');
                Available = new int[m];
                for (int i = 0; i < m; i++)
                {
                    Available[i] = Convert.ToInt32(str[i]);
                    tb_output.Text += " " + Available[i];
                }        
            }
            else//輸入max矩陣
            {
                tb_output.Text += "\r\nMax矩陣\r\n";
                string[] str = tb_datainput.Text.Split(' ');
                Max = new int[n, m];
                
                for (int i = 0; i < n; i++)
                {
                    tb_output.Text+="\r\n";
                    string[] temp = str[i].Split(',');
                    for (int j = 0; j < m; j++)
                    {
                        Max[i, j] = Convert.ToInt32(temp[j]);
                        tb_output.Text += " " + Max[i, j];
                    }
                }
            }
        }

        private void button3_Click(object sender, EventArgs e)
        {
            int PID = 0;
            bool[] finish = new bool[n];
            for (int i = 0; i < n; i++)
            {
                finish[i] = false;
            }
            if (tb_pid.Text == "")
                ;
            else
                PID = Convert.ToInt32(tb_pid.Text) ;


            int bigger_1 = 0;
            int bigger_2 = 0;
            ///計算Need矩陣///
            Need = new int[n, m];
            tb_output.Text += "\r\nNeed矩陣\r\n";
            for (int i = 0; i < n; i++)
            {
                tb_output.Text += "\r\n";
                for (int j = 0; j < m; j++)
                {
                    Need[i, j] = Max[i, j] - Allocation[i, j];
                    tb_output.Text += " " + Need[i, j];
                }
            }
            ///輸入Require///
            if (tb_require.Text == "")
            {
                Require = new int[m];
                for (int i = 0; i < m; i++)
                { Require[i] = 0; }
                PID = 0;
                tb_output.Text += "\r\n檢測當前狀態是否安全中…\r\n";
                if (CheckSecure(Available, finish, Need, Allocation))
                {
                    tb_output.Text += "系統目前安全"+"安全序列"+order;
                }
                else
                {
                    tb_output.Text += "系統目前不安全";

                }
            }
            else
            {
                string[] str = tb_require.Text.Split(',');
                Require = new int[m];
                for (int i = 0; i < m; i++)
                {
                    Require[i] = Convert.ToInt32(str[i]);
                    if (Require[i] > Need[PID, i])
                        bigger_1++;
                    if (Require[i] > Available[i])
                        bigger_2++;

                }

                ///檢查///
                if (bigger_1 != 0)
                {
                    tb_output.Text += "\r\n錯誤：程序申請的資源多於說明的最大量,系統無法滿足\r\n";
                }
                else if (bigger_2 != 0)
                {
                    tb_output.Text += "\r\n程序" + tb_pid.Text + "暫時阻塞\r\n";
                }
                else
                {
                    int[] temp_available = Available;
                    int[,] temp_allocation = Allocation;
                    int[,] temp_need = Need;

                    for (int j = 0; j < m; j++)
                    {
                        temp_available[j] -= Require[j];
                        temp_allocation[PID, j] += Require[j];
                        temp_need[PID, j] -= Require[j];

                    }

                    if (CheckSecure(temp_available, finish, temp_need, temp_allocation))
                    {
                        Available = temp_available;
                        Allocation = temp_allocation;
                        Need = temp_need;
                        tb_output.Text += "\r\n系統處於安全狀態，且已經分配完畢\r\n"+"安全序列"+order ;

                    }
                    else
                    { tb_output.Text += "\r\n該請求將導致系統處於不安全狀態，已經撤銷分配\r\n"; }

                }
            }
        }
///檢查安全狀態///
 public bool CheckSecure(int[] work,bool[] finish,int[,] temp_need,int[,] temp_allocation)
        {
            int num = 0;//need[i]<=work[i]的個數
            order ="";
            int[] wor = work;
            bool[] finis = finish;
            int[,] temp_nee = temp_need;
            int[,] temp_allocatio = temp_allocation;
int K=0;
while (K < 10)
{
    for (int i = 0; i < n; i++)
    {
        if (!finis[i])
        {
            for (int j = 0; j < m; j++)
            {
                if (temp_nee[i, j] <= wor[j])
                    num++;

            }
            if (num == m)
            {
                for (int j = 0; j < m; j++)
                {
                    wor[j] += temp_allocatio[i, j];
                }
                finis[i] = true;
                order += i;
                
                num = 0;

            }
            else num = 0;


        }
        else
            if (checkFinish(finis))
                return true;

    }
    K++;
} 
               

            if (checkFinish(finis))
            
                return true;
            
            else
                return false;
            }

            public bool checkFinish(bool[] f)
            {int num=0;
                foreach (bool k in f)
                {
                    if (k)
                        num++;
                    
                }
                if (num == f.Length)
                    return true;
                else return false;
            } 
    }
}

3.總結

實現功能

允許輸入資料（只輸入Available,Max,Allocation即可，Need可以自動計算，矩陣同一行元素之間用“，”隔開，換行時用空格隔開）

使用銀行家演算法進行安全檢查（若未提出請求，則應使程序號與Require後面的textbox內容為空，點選“提出請求”按鈕即可檢查當前系統安全狀態）

輸出狀態結果

輸出安全序列（注：輸出的是程序號，預設序號從0開始）

不足之處

未寫出完整的約束

不能輸出分配成功後的系統狀態

互動不夠人性化，例如沒有在輸出文字框中加入滾動條，不方便使用者檢視結果

問題

例子中經過程式計算後的need矩陣中出現了負數，不知道是為什麼，正在排查錯誤。

關鍵點

——向量比較：銀行家演算法中的向量大小比較與數學中的向量大小比較（範數比較）不同，只有向量a中的所有分量均大於向量b，才可以稱為向量a大於向量b。向量比較主要用在檢查Require是否合法，本例中使用for迴圈對於兩向量的各個分量進行比較，設定一個初始值為0的訊號變數，若任一分量小於對應分量，則將訊號變數++，迴圈結束後只需要檢查訊號變數是否為0即可知道是否前者大於後者。

——矩陣輸入：使用split方法，將字串按照給定符號（char,char[]）分隔開，並賦給一個給定大小的陣列，在本例中使用逗號和空格分開了不同列不同行的元素，定義全域性變數m與n，在給陣列賦值前需要使用mn初始化陣列大小。

——使用臨時變數代替真實變數，方便恢復變數數值。因為銀行家演算法中，若資源分配後系統不安全，要求系統必須撤銷所有分配，所以使用臨時變數可以避免大量的恢復運算，即使經過檢查後，系統為安全狀態，也只需要將臨時變數的值賦給真實變數即可。