ขั้นตอนวิธีของนายธนาคาร

**ขั้นตอนวิธีของนายธนาคาร** (Banker’s algorithm) ซึ่งหมายถึง เป็นการแก้ปัญหาของธนาคารในกรณีที่มีลูกค้าต้องการกู้ยืมเงิน ซึ่งมีลักษณะการทำงานเหมือนโปรเซสที่ใช้ทรัพยากรในระบบปฏิบัติการทั่วๆไป (ลูกค้าเปรียบเสมือนโปรเซส และเงินที่ถูกยืมเปรียบเสมือนทรัพยากร) จากวิธีการทำงานของธนาคาร ธนาคารจะมีจำนวนเงินที่ให้ลูกค้ากู้ยืมที่จำกัด และมีรายชื่อของลูกค้าพร้อมเครดิตที่แต่ละตนจะได้รับ ลูกค้าบางคนอาจจะพยายามกู้เงินให้ได้เต็มเครดิตที่ตัวเองมี และบางครั้งลูกค้าคนนั้นก็ไม่ยอมจ่ายเงินคืนกลับให้ธนาคารจนกว่าจะได้รับจำนวนเงินที่ต้องการกู้ยืมทั้งหมด แต่นายธนาคารเองก็สามารถปฏิเสธการกู้ยืมของลูกค้าบางคนได้ ถ้าการปล่อยกู้ยืมครั้งนั้นจะทำให้เกิดความเสี่ยงทำให้ธนาคารมีเงินไม่เพียงพอที่จะให้ผู้นั้นได้กู้ยืมเพิ่มเติม และลูกค้าคนนั้นก็ไม่สามารถใช้เงินคืนแก่ธนาคารได้ 

ในระบบที่ทรัพยากร 1 ตัวสามารถให้บริการได้พร้อมกันหลายโพรเซส การใช้กราฟแทนการใช้งานทรัพยากรจะไม่เหมาะสม จึงมีการเสนออัลกอริทึมของนายธนาคาร ซึ่งเป็นอัลกอริทึมที่ใช้งานได้จริง ระบบธนาคารที่ว่าธนาคารจะไม่จ่ายเงินที่มีอยู่ให้ตามความต้องการของลูกค้าทั้งหมดได้เป็นเวลานาน (หมายถึง มีคนถอนออกอย่างเดียว ธนาคารจะไม่สามารถอยู่ได้) ดังนั้นจึงต้องมีระบบเพื่อกำหนดจำนวนสูงสุดที่จะสามารถให้บริการได้ จำนวนนี้อาจไม่จำเป็นต้องเป็นจำนวนทรัพยากรทั้งหมดที่มีอยู่ในระบบ เมื่อผู้ใช้ขอใช้กลุ่มของทรัพยากร ระบบต้องทำการตรวจสอบว่าถ้าให้ใช้แล้วระบบจะยังคงอยู่ในภาวะปลอดภัยหรือไม่ ถ้าไม่ปลอดภัยการให้ใช้ทรัพยากรต้องรอจนกว่าจะมีผู้ใช้ทรัพยากรรายอื่นที่ใช้แล้วกลับเข้าสู่ระบบ

## '''โครงสร้างของระบบนายธนาคารมีดังนี้'''
กำหนดให้มี n โพรเซส มีทรัพยากรในระบบทั้งหมด m ตัวมีข้อมูลดังนี้

1. **Available**

2. **Max**

3. **Allocation**

4. **Need**

พบว่า Need[i,j] = Max[i,j] – Allocation[i,j]

## '''อัลกอริทึมของการขอใช้ทรัพยากร'''
กำหนดให้ Request i เป็นเวกเตอร์ของการขอใช้งานสำหรับโพรเซส i ถ้า request i[j] = k หมายถึงโพรเซส i ต้องการทำงาน k บริการจากทรัพยากร j เมื่อมีการขอใช้งานทรัพยากรโดยโพรเซส i ก็ จะเกิดการทำงานดังต่อไปนี้ 

1. ถ้า Request i ≤ Need i ไปยังขั้นตอนที่ 2 นอกจากนั้น ให้แสดงข้อความเตือน เนื่องจากโพรเซสมีการใช้ทรัพยากรมากกว่าที่คาดการณ์ไว้

2. ถ้า Request i ≤ Available ไปยังขั้นตอนที่ 3 นอกจากนี้โพรเซส i ต้องรอเนื่องจากทรัพยากรไม่มีให้ใช้งาน 

3. มีการตั้งระบบลวงเพื่อใช้ทรัพยากรที่โพรเซส i ขอใช้โดยการใส่ค่าในตัวแปรต่อไปนี้ 

Available = Available – Request; 

Allocation i = Allocation i + Request i ; 

Need i = Need i – Request i ; 

ถ้าผลของการกำหนดค่าการให้ใช้ทรัพยากรออกมา พบว่าระบบอยู่ในภาวะปลอดภัย ก็จะจบสิ้นการทำงานแล้วยอมให้โพรเซส i ใช้งานทรัพยากรนั้นจริง ๆ อย่างไรก็ตามถ้าผลออกมาว่าไม่ปลอดภัย โพรเซส i ต้องรอ Request i แล้วก็จะกลับไปสู่ค่าสถานะเก่า

## '''[[Banker’s algorithm]] จะแบ่งสถานะออกเป็น 2 สถานะคือ'''
**[[สถานะไม่ปลอดภัย]] (Unsafe State)** เมื่อระบบอยู่ใน Unsafe state จะไม่มี process ใดทำงานได้สำเร็จ เนื่องจาก process ต่างๆ ร้องขอใช้ทรัพยากรตามจำนวนสูงสุดที่สามารถจะใช้ได้ แต่ระบบไม่สามารถจัดสรรทรัพยากรให้กับงานต่างๆได้จึงเกิด deadlock ขึ้น

**[[สถานะปลอดภัย]] (Safe State)** เมื่อระบบอยู่ใน safe state เมื่อจัดอันดับการใช้ resource ให้กับ process แล้วไม่เกิด deadlock

## '''ตัวอย่างขั้นตอนวิธีของนายธนาคาร'''
**Allocation                Max                 Available**

**A   B   C                A    B    C           A    B    C** 

**P0**           0    1   0               7    5     3          3     3    2

**P1**           2    0   0               3    2     2

**P2**           3    0   2               9    0     2 

**P3**           2    1   1               2    2     2

**P4**           0    0   2               4    3     3

หา **Need** จาก **Max - Allocation**

จะได้               **Need**

**A    B    C**

**P0**                 7    4    3

**P1**                 1    2    2

**P2**                 6    0    0

**P3**                 0    1    1

**P4**                 4    3    1

จัดอันดับการใช้ Resource ได้ดังนี้

**Need           ≤          Available**

**A    B   C                   A     B    C**

**P0**           7    4    3       ≤         3     3     2        ; **False**

**P1**           1    2    2       ≤         3     3     2        ; **True** ; **Work = available + allocation** = 332 + 200 = 532

**P2**           6    0    0       ≤         5     3     2        ; **False**

**P3**           0    1    1       ≤         5     3     2        ; **True ; Work** = 532 + 211 = 743

**P4**           4    3    1       ≤         6     4     3        ; **True ; Work** = 743 + 002 = 745

**P0**           7    4    3       ≤         7     4     5        ; **True ; Work** = 745 + 010 = 755

**P2**           6    0    0       ≤         7     5      5       ; **True ; Work** = 755 + 302 = 10 5 7

เรียงลำดับการใช้ Process ได้ดังนี้ P1,P3,P4,P0,P2 จึงจะไม่เกิด Deadlock เพราะอยู่ใน Safe state

## ตัวอย่างโค้ดในภาษา Python

```python
#E is Max
#A is Abailable
#C is Allocation
#R is Need

def bankers(E,A,C,R):
    n,m = len(C), len(C[0])
    terminatedProcesses = []
    deadlock = False
    while len(terminatedProcesses) < n and not(deadlock):
        deadlock = True
        for i in range(n):
            if i in terminatedProcesses:
                continue
            elif all([R[i][j] <= A[j] for j in range(m)]):
                # required resources are given to process i
                # process i terminates and gives all his resources back
                A = [C[i][j] + A[j] for j in range(m)]
                terminatedProcesses.append(i)
                deadlock = False
                #print (i, A)
    return not(deadlock), terminatedProcesses
```


## อ้างอิง

หมวดหมู่:ขั้นตอนวิธีจวบกัน