BÁO CÁO BÀI TẬP LỚN HỆ ĐIỀU HÀNH ĐỀ TÀI DEADLOCK(KHÓA CHẾT) Đại Học Bách Khoa Hà Nội
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (404.12 KB, 30 trang )
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
ĐẠI HỌC BÁCH KHOA HÀ NỘI
TRƯỜNG CÔNG NGHỆ THÔNG TIN VÀ TRUYỀN THÔNG
──────── * ───────
BÀI TẬP LỚN
MÔN: NGUYÊN LÝ HỆ ĐIỀU HÀNH
DEADLOCK (BẾ TẮC)
Mã lớp học
: 141296
Giáo viên hướng dẫn : Thầy Đỗ Tuấn Anh
Sinh viên thực hiện : Nguyễn Đình Tuấn Dũng - 20215328
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
Nội dung
Chương 1: Tổng quan về deadlock................................................................................... 3
I.
Mơ hình hệ thống................................................................................................................3
II. Đặc điểm của deadlock.......................................................................................................5
1.
Điều kiện xảy ra deadlock..............................................................................................7
2.
Đồ thị cấp phát tài nguyên.............................................................................................7
III.
Các pháp xử lý deadlock................................................................................................8
IV.
Ngăn chặn deadlock........................................................................................................9
1.
Loại trừ lẫn nhau............................................................................................................9
2.
Giữ và đợi.......................................................................................................................10
3.
Khơng có quyền ưu tiên................................................................................................10
4.
Vịng lặp đợi...................................................................................................................11
5.
Ngăn chặn deadlock trong Window............................................................................12
V. Tránh xảy ra deadlock.....................................................................................................13
1.
Giải thuật đồ cấp phát tài ngun...............................................................................15
2.
Thuật tốn quản lý nhà băng:......................................................................................15
VI.
Phát hiện deadlock........................................................................................................17
1.
Có một thể hiện đối với mỗi loại tài nguyên...............................................................18
2.
Nhiều thể hiện trong một loại tài nguyên....................................................................18
3.
Sử dụng các thuật toán phát hiện deadlock................................................................20
VII.
Phục hồi từ deadlock.....................................................................................................20
1,
Kết thúc tiến trình.........................................................................................................21
VIII. Tổng kết.........................................................................................................................23
Chương 2: Ví dụ giải quyết deadlock...................................................................................25
I.
Đặt vấn đề..........................................................................................................................25
II. Cách giải quyết deadlock.................................................................................................28
TÀI LIỆU THAM KHẢO.............................................................................................................30
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
I.
Kỳ 20222
Chương 1: Tổng quan về deadlock
Mơ hình hệ thống
Hệ thống chỉ có một số hữu hạn tài nguyên cần được phân phối cho một số
luồng tiến trình hoạt động đồng thời. Các tài nguyên có thể được chia thành
một vài loại, mỗi loại bao gồm một số lượng thể hiện giống nhau. Ví dụ về
các loại tài nguyên bao gồm CPU, tệp và thiết bị I/O (như giao diện mạng
và ổ DVD). Nếu hệ thống có ba CPU, thì loại tài ngun CPU sẽ có ba thể
hiện. Tương tự, loại tài nguyên mạng có thể có hai thể hiện. Nếu một luồng
yêu cầu một thể hiện của một loại tài nguyên, việc cấp phát bất kỳ thể hiện
nào của loại đó sẽ đáp ứng u cầu. Nếu khơng, sẽ xảy ra tình trạng
“deadlock”.
Ví dụ 1.1: Giả sử có hai tiến trình: Tiến trình A và Tiến trình B. Mỗi tiến
trình đều cần truy cập vào hai tài nguyên: Tài nguyên X và Tài nguyên Y.
Đồng thời, mỗi tiến trình đang giữ một tài nguyên và yêu cầu tài nguyên
còn lại để tiếp tục cơng việc:
Tiến trình A đang giữ tài ngun X và yêu cầu tài nguyên Y.
Tiến trình B đang giữ tài nguyên Y và yêu cầu tài nguyên X.
Trong tình huống này, Tiến trình A khơng thể tiếp tục cơng việc mà nó
đang làm vì nó đang chờ đợi Tiến trình B để giải phóng tài ngun Y.
Tương tự, Tiến trình B cũng khơng thể tiếp tục cơng việc của mình vì chờ
đợi tài nguyên X mà Tiến trình A đang giữ.
Kết quả là cả hai tiến trình đều bị mắc kẹt và không thể tiếp tục thực hiện
công việc. Mỗi tiến trình đang chờ đợi một tài nguyên mà tiến trình khác
đang giữ, tạo thành một chuỗi chặn lẫn nhau và dẫn đến tình trạng
deadlock.
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
Trên các hệ thống máy tính hiện đại, Các cơng cụ đồng bộ hóa khác
nhau như khóa mutex và semaphore là nguyên nhân chính gây ra tình trạng
deadlock. Chúng cũng là các tài nguyên hệ thống. Mỗi thể hiện của một
khóa được gán cho một lớp tài nguyên riêng.
Mỗi luồng phải yêu cầu tài nguyên trước khi sử dụng và giải phóng tài
nguyên sau khi sử dụng. Quy tắc là số lượng tài nguyên yêu cầu không
được vượt quá tổng số tài nguyên còn khả dụng trong hệ thống. Trong chế
độ hoạt động bình thường, một luồng chỉ có thể sử dụng một tài nguyên
theo thứ tự:
1. Yêu cầu: nếu yêu cầu không được gán tức thì thì luồng đang yêu cầu
phải chờ cho đến khi nó nhận được tài nguyên
2. Sử dụng: Luồng có thể điều hành tài nguyên
3. Giải phóng tài nguyên.
Yêu cầu và giải phóng tài nguyên có thể được thực hiện thông qua lời
gọi hệ thống như: request () và release () device, hay open() và close() file,
hay allocate() và free(). Việc yêu cầu và giải phóng tài nguyên cũng có thể
được thực hiện thơng qua các thao tác wait() và signal() trên semaphore và
thông qua các thao tác acquire() và release() của khóa mutex. Hệ điều hành
sẽ kiểm tra để đảm bảo rằng luồng đã yêu cầu và đã được cấp phát tài
nguyên. Hệ thống sẽ ghi lại xem mỗi tài nguyên đang có sẵn hay đã được
cấp phát. Đối với mỗi tài nguyên đã được cấp phát, hệ thống cũng ghi lại
luồng mà tài nguyên đó đã được cấp phát. Nếu một luồng yêu cầu một tài
nguyên hiện đang được cấp phát cho một luồng khác, nó có thể được thêm
vào hàng đợi các luồng đang chờ tài ngun đó khả dụng.
Bế tắc là tình trạng hai hay nhiều tiến trình cùng chờ đợi một sự kiện nào
đó xảy ra. Nếu khơng có sự tác động gì từ bên ngồi, thì sự chờ đợi đó là vơ
hạn. Các sự kiện mà chúng ta quan tâm ở đây là chủ yếu về tài nguyên thu
thập và giải phóng.Tài nguyên ở đây có thể là tài nguyên vật lý hoặc tài
nguyên logic. Minh họa như ví dụ 1.1.
Nhà phát triển ứng dụng đa luồng phải luôn nhận thức về khả năng xảy
ra tình trạng chặn chỗ. Các cơng cụ như semaphore và khóa mutex được
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
thiết kế để tránh tình trạng cạnh tranh. Tuy nhiên, khi sử dụng các công cụ
này, nhà phát triển phải chú ý cẩn thận đến cách khóa được yêu cầu và giải
phóng. Nếu khơng, tình trạng deadlock có thể sẽ xảy ra.
II.
Đặc điểm của deadlock
Khi xảy ra deadlock, thì một tiến tình khơng bao giờ kết thúc việc biên
dịch và tài nguyên hệ thống có thể bị giam lại, ngăn chặn một sự kiện khác
bắt đầu. Dưới đây là một ví dụ về deadlock trong C++ sử dụng hai tiến trình
và hai tài nguyên:
------------------------------------------------------------------------------------------#include <iostream>
#include <thread>
#include <mutex>
std::mutex resource1Mutex;
std::mutex resource2Mutex;
void process1()
{
std::unique_lock<std::mutex> lock1(resource1Mutex);
std::cout << "Process 1 acquired resource 1" << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
std::unique_lock<std::mutex> lock2(resource2Mutex);
std::cout << "Process 1 acquired resource 2" << std::endl;
// Process using both resources
// Release the resources
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
}
lock2.unlock();
lock1.unlock();
void process2()
{
std::unique_lock<std::mutex> lock2(resource2Mutex);
std::cout << "Process 2 acquired resource 2" << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
std::unique_lock<std::mutex> lock1(resource1Mutex);
std::cout << "Process 2 acquired resource 1" << std::endl;
// Process using both resources
}
// Release the resources
lock1.unlock();
lock2.unlock();
int main()
{
std::thread t1(process1);
std::thread t2(process2);
t1.join();
t2.join();
}
return 0;
Nguyễn Đình Tuấn Dũng 20215328
Kỳ 20222
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
------------------------------------------------------------------------------------------1. Điều kiện xảy ra deadlock
Bốn điều kiện cần thiết gây ra deadlock
Loại trừ lẫn nhau: có ít nhất một tài ngun được giữ trong chế độ khơng
chia sẻ, và chỉ có thể một tiến trình tại thời điểm được sử dụng tài ngun
đó. Nếu có một tiến trình khác u cầu tài ngun đó thì nó phải đợi cho
đến khi tài nguyên đó được giải phóng
Giữ và chờ cấp thêm tài nguyên: một tiến trình đang giữ một tài nguyên
và nó đang muốn lấy thêm một tài nguyên khác đang bị giữ bởi một tiến
trình khác
Khơng có quyền ưu tiên: Tài ngun khơng được ưu tiên, điều đó có
nghĩa là một tài nguyên chỉ có thể giải phóng một cách tự nguyện bởi tiến
trình đang giữ nó, sau khi tiến trình hồn thành nhiệm vụ của nó
Chờ đợi vịng trịn: Cho một tập tiến trình P0, P1, ... PN và tồn tại vịng
tuần hồn P0 đợi tài ngun đang được giữ bởi P1 và P1 đợi tài nguyên
đang được giữ bởi P2 … và PN đang đợi tài nguyên được giữ bởi P1
Cả bốn điều kiện xảy ra cùng lúc thì bế tắc(deadlock) xảy ra.
2. Đồ thị cấp phát tài nguyên
Đồ thị bao gồm một tập các đỉnh V và tập hợp các cạnh E.
V được chia thành 2 loại nút:
P = {P1, P2, …, Pn}
R= {R1, R2, …, Rn}
Một cạnh có hướng từ Pi đến Rj (Pi → Rj); nó được gọi là cạnh u cầu
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
Cạnh có hướng từ Rj tới Pi (Rj → Pi); nó được gọi là cạnh gán
Ta có thể thấy từ định nghĩa đồ thị cấp phát tài ngun rằng nếu đồ thị
khơng có chu trình thì khơng có q trình nào trong hệ thống bị deadlock.
Nếu đồ thị tồn tại một chu trình thì có thể xảy ra deadlock.
III. Các pháp xử lý deadlock
Nhìn chung, chúng ta có thể xử lý deadlock theo những cách sau:
Sử dụng một giao thức để ngăn chặn hay tránh deadlock, đảm bảo rằng
hệ thống sẽ không bao giờ đi vào trạng thái deadlock.
Cho phép hệ thống đi vào trạng thái deadlock, phát hiện nó và phục hồi.
Giả vờ deadlock không bao giờ xảy ra trong hệ thống.
Phương pháp thứ ba là một phương pháp được sử dụng nhiều nhất, bao gồm
cả Linux và Window. Nó khiến các lập trình viên phải viết chương trình
tránh xảy ra deadlock
Để đảm bảo khơng xảy ra tình trạng bế tắc, hệ thống có thể sử dụng một
giao thức ngăn chặn bế tắc hoặc tránh bế tắc. Ngăn chặn bế tắc cung cấp
một tập hợp các phương pháp để đảm bảo ít nhất một trong các điều kiện
cần khơng thể xảy ra. Tránh bế tắc yêu cầu hệ điều hành được cung cấp
thông tin bổ sung trước về các tài nguyên mà một luồng sẽ yêu cầu và sử
dụng trong suốt qng đời của nó. Với thơng tin bổ sung này, hệ điều hành
có thể quyết định cho mỗi u cầu xem luồng có nên chờ hay khơng. Để
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
quyết định xem yêu cầu hiện tại có thể được thỏa mãn hay phải bị trì hỗn,
hệ thống phải xem xét các tài nguyên hiện có, tài nguyên được phân bổ hiện
tại cho mỗi luồng và các yêu cầu và giải phóng tài nguyên trong tương lai
của mỗi luồng.
Nếu hệ thống không sử dụng cơ chế chặn và tránh bế tắc, thì hệ thống có
khả năng cao bị bế tắc. Trong mơi trường này, hệ thống có thể cung cấp một
thuật tốn kiểm tra trạng thái của hệ thống để xác định xem đã xảy ra tình
trạng bế tắc hay chưa, và một thuật tốn để khơi phục từ tình trạng bế tắc
(nếu thực sự xảy ra).
Trong trường hợp khơng có thuật tốn để phát hiện và khơi phục từ tình
trạng bế tắc, chúng ta có thể đến một tình huống trong đó hệ thống đang ở
trạng thái bế tắc nhưng khơng có cách nào nhận ra điều đó đã xảy ra. Khi đó
tình trạng bế tắc khơng được phát hiện sẽ làm giảm hiệu suất của hệ thống,
vì tài nguyên đang bị giữ bởi các luồng khơng thể chạy và vì càng có nhiều
luồng, khi chúng yêu cầu tài nguyên, sẽ rơi vào trạng thái bế tắc. Cuối cùng,
hệ thống sẽ ngừng hoạt động và cần phải khởi động lại bằng tay.
Phương pháp thứ 3 mặc dù có vẻ khơng phải cách tiếp cận khả thi với bế
tắc, nó lại được sử dụng trong nhiều hệ thống. Bỏ qua khả năng xảy ra bế
tắc sẽ ít tốn chi phí hơn so với các phương pháp khác. Vì trong nhiều hệ
thống, tình trạng bế tắc xảy ra khơng thường xun (ví dụ, hai tháng xảy ra
một lần), chi phí bổ sung của các phương pháp khác có thể khơng đáng để
đầu tư.
IV.
Ngăn chặn deadlock
Có thể ngăn chặn deadlock bằng cách ngăn chặn một hoặc một vài điều
kiện xảy ra deadlock
1. Loại trừ lẫn nhau
Điều kiện loại trừ lẫn nhau: có ít nhất một tài nguyên được giữ trong
chế độ không chia sẻ, và chỉ có thể một tiến trình tại thời điểm được sử
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
dụng tài nguyên đó. Nếu có một tiến trình khác u cầu tài ngun đó thì nó
phải đợi cho đến khi tài ngun đó được giải phóng
Nhận xét: Chúng ta thường khơng thể ngăn chặn deadlock bằng cách từ
chối điều kiện loại trừ hỗ tương vì một số tài ngun thực chất khơng thể
chia sẻ.
2. Giữ và đợi
Điều kiện giữ và đợi: một tiến trình đang giữ một tài ngun và nó
đang muốn lấy thêm một tài nguyên khác đang bị giữ bởi một tiến trình
khác
Ví dụ: Giả sử chúng ta có hai tiến trình là P1 và P2, và hai tài nguyên là
R1 và R2. Mỗi tiến trình cần yêu cầu và sử dụng cả hai tài ngun để hồn
thành cơng việc của mình.
Tiến trình P1 yêu cầu tài nguyên R1 trước khi yêu cầu tài nguyên R2. Sau
đó, nó giữ R1 và tiếp tục yêu cầu R2.
Tiến trình P2 yêu cầu tài nguyên R2 trước khi yêu cầu tài nguyên R1. Sau
đó, nó giữ R2 và tiếp tục yêu cầu R1.
Với điều kiện "giữ và đợi", cả hai tiến trình đều phải yêu cầu và giữ cả hai
tài nguyên trước khi tiếp tục. Điều này đảm bảo rằng khơng có deadlock
xảy ra, vì khi một tiến trình giữ một tài nguyên, tiến trình kia khơng thể u
cầu tài ngun đó cho đến khi tiến trình đầu tiên trả lại.
Nhận xét: Địi hỏi tiến trình yêu cầu được và phân phối tất cả các tài
nguyên của nó trước khi nó bắt đầu thực hiện, hoặc chỉ cho phép tiến trình
yêu cầu tài ngun khi khơng có tài ngun nào cả.
3. Khơng có quyền ưu tiên
Điều kiện cần khơng có quyền ưu tiên: Tài ngun khơng được ưu
tiên, điều đó có nghĩa là một tài nguyên chỉ có thể giải phóng một cách tự
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
nguyện bởi tiến trình đang giữ nó, sau khi tiến trình hồn thành nhiệm vụ
của nó
Khi một tiến trình u cầu một tài nguyên, hệ thống trước tiên kiểm tra
xem tài nguyên đó có sẵn hay khơng. Nếu tài ngun có sẵn, chúng ta cấp
phát ngay cho tiến trình đó. Tuy nhiên, nếu tài ngun khơng có sẵn, chúng
ta kiểm tra xem liệu tài nguyên đó có được cấp phát cho một tiến trình nào
đó đang trong hàng đợi hay khơng. Trong trường hợp này, chúng ta sẽ lấy
tài nguyên đó từ tiến trình trong hàng đợi và cấp phát cho tiến trình hiện tại
u cầu. Nếu khơng có tiến trình nào trong hàng đợi có tài ngun đó, tiến
trình hiện tại phải đợi. Trong q trình đợi, tiến trình u cầu có thể được
ưu tiên khi có tiến trình khác u cầu tài nguyên. Điều này đảm bảo rằng tài
nguyên được sử dụng hiệu quả và khơng bị lãng phí. Khi tiến trình được cấp
phát tài ngun mới, nó có thể tái khởi động và tiếp tục thực hiện cơng việc
của mình. Đồng thời, tiến trình cũng phải khơi phục tài ngun mà nó đã
được cấp phát khi nó đang trong hàng đợi, để đảm bảo sự công bằng và hiệu
quả trong việc sử dụng tài nguyên.
Nhận xét: Phương pháp này những ưu điểm như đảm bảo an toàn và hiệu
quả trong việc sử dụng tài nguyên và tránh lãng phí, nhưng cũng có hạn chế
như khả năng xảy ra trì hỗn, tính chính xác của thơng tin trước và
overhead trong quản lý tài nguyên.
4. Vòng lặp đợi
Điều kiện thứ 4 để deadlock xảy ra là điều kiện vòng lặp đợi. Để đảm bảo
điều kiện này không bao giờ xảy ra ta áp đặt toàn bộ thứ tự của tất cả các
loại tài ngun và địi hỏi mỗi q trình trong thứ tự tăng của số lượng.
Ví dụ: Khi hai tiến trình A và B đang chờ đợi lẫn nhau để giải phóng tài
ngun mà mình đang giữ. Để ngăn chặn điều kiện này xảy ra, chúng ta có
thể áp đặt một thứ tự toàn bộ cho các loại tài nguyên và u cầu rằng mỗi
tiến trình chỉ có thể u cầu tài nguyên theo thứ tự tăng dần của chúng.
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
Nếu chúng ta có ba loại tài nguyên R1, R2 và R3, chúng ta gán cho chúng
các số nguyên tương ứng là 1, 2 và 3. Điều này có nghĩa là tiến trình chỉ có
thể yêu cầu R1 trước khi yêu cầu R2, và chỉ có thể yêu cầu R2 trước khi yêu
cầu R3. Bằng cách áp dụng thứ tự này, chúng ta đảm bảo rằng khơng có
vịng lặp đợi xảy ra giữa các tiến trình.)
Nhận xét: Ưu điểm của phương pháp ngăn chặn deadlock này là nó loại
bỏ được điều kiện vịng lặp đợi, đảm bảo rằng deadlock không xảy ra trong
hệ thống. Nó giúp đảm bảo an tồn và hiệu quả trong việc sử dụng tài
nguyên và tránh lãng phí.
Tuy nhiên, nhược điểm của phương pháp này là yêu cầu thiết lập một thứ tự
cho tất cả các loại tài nguyên và đảm bảo các quá trình tuân theo thứ tự tăng
dần của số lượng. Điều này có thể khá phức tạp và tốn thời gian để triển
khai, đặc biệt là trong các hệ thống có số lượng lớn tài nguyên và q trình.
Ngồi ra, việc áp đặt thứ tự tài nguyên có thể tạo ra sự ràng buộc và hạn chế
linh hoạt trong việc sử dụng tài nguyên.
5. Ngăn chặn deadlock trong Window
Trong Windows, việc ngăn chặn deadlock là một vấn đề quan trọng để
đảm bảo sự ổn định và hiệu quả của hệ thống. Dưới đây là một số kỹ thuật
ngăn chặn deadlock thông thường được sử dụng trong hệ điều hành
Windows.
Xếp thứ tự tài nguyên:
Đặt một thứ tự toàn cục cho các tài nguyên và yêu cầu các tiến trình tuân
thủ thứ tự cụ thể khi yêu cầu tài nguyên. Điều này ngăn chặn tình trạng chờ
lẫn nhau vòng tròn và đảm bảo sự tuân thủ quy tắc thứ tự trong việc sử dụng
tài nguyên.
Giới hạn phân phối tài nguyên
Đặt giới hạn về số lượng tài nguyên tối đa mà mỗi tiến trình có thể sử
dụng, nhằm tránh việc phân phối tài nguyên quá mức. Việc định nghĩa giới
hạn phân phối tài nguyên giúp hệ thống tránh tình trạng tất cả các tài
nguyên bị khóa và loại bỏ khả năng xảy ra deadlock.
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
Thu hồi tài nguyên trước
Hệ điều hành có khả năng cưỡng chế giải phóng tài ngun từ các tiến
trình khi cần thiết. Nếu một tiến trình đang nắm giữ tài nguyên và đang chờ
thêm tài nguyên, hệ điều hành có thể tạm thời giải phóng các tài nguyên đó
để phá vỡ tiềm năng của deadlock.
Two-Phase Locking:
Áp dụng giao thức two-phase locking để đảm bảo các tiến trình lấy và giải
phóng tài ngun theo một quy tắc nghiêm ngặt và đồng bộ. Giao thức này
thiết lập một quy tắc rõ ràng về thứ tự lấy và giải phóng khóa, từ đó giảm
khả năng xảy ra deadlock.
Thời gian chờ và hoàn tác:
Thực hiện thời gian chờ trên yêu cầu tài nguyên và cho phép tiến trình từ
bỏ việc chờ sau một khoảng thời gian nhất định. Nếu một tiến trình chờ tài
nguyên quá lâu, hệ điều hành có thể kích hoạt cơ chế hồn tác để giải phóng
tất cả các tài ngun mà tiến trình đang nắm giữ, nhằm ngăn chặn tiềm năng
của deadlock.
Các kỹ thuật ngăn chặn deadlock trên đã được tích hợp vào hệ điều hành
Windows để giảm thiểu sự xảy ra của deadlock và đảm bảo tính ổn định của
hệ thống. Tuy nhiên, việc lựa chọn và triển khai kỹ thuật phù hợp cần được
xem xét cẩn thận để đảm bảo sự hiệu quả và tương thích trong mơi trường
sử dụng thực tế.
V.
Tránh xảy ra deadlock
Ngăn chặn deadlock bằng cách hạn chế điều kiện cần để xảy ra
deadlock.
Yêu cầu thông tin bổ sung về các tài nguyên được yêu cầu.
→Các giải thuật khác nhau có sự khác nhau về lượng và loại thơng tin được
u cầu. Mơ hình đơn giản và hữu ích nhất u cầu mỗi q trình khai báo
số lớn nhất tài nguyên của mỗi loại mà nó cần. Thông tin trước về số lượng
tối đa tài nguyên của mỗi loại được yêu cầu cho mỗi quá trình, có thể xây
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
dựng một giải thuật đảm bảo hệ thống sẽ không bao giờ đi vào trạng thái
deadlock.
Trạng thái an toàn(safe state)
Một trạng thái là an tồn nếu hệ thống có thể cấp phát các tài nguyên tớ
mỗi quá trình trong một vài thứ tự và vẫn tránh deadlock.
Một trạng thái an tồn khơng là trạng thái deadlock. Do đó, trạng thái
deadlock là trạng thái khơng an tồn.
Một trạng thái khơng an tồn có thể dẫn đến deadlock.
Thứ tự của các quá trình <P1, P2, …, Pn> là một thứ tự an toàn cho
trạng thái cấp phát hiện hành nếu đối với mỗi thứ tự Pi, các tài nguyên
mà Pi yêu cầu vẫn có thể được thoả mãn bởi tài nguyên hiện có cộng với
các tài nguyên được giữ bởi tất cả Pj, với j
thì Pi có thể chờ cho đến khi tất cả Pj hoàn thành.
Khi chúng hoàn thành, Pi có thể đạt được tất cả những tài nguyên nó
cần, hoàn thành các tác vụ được gán, trả về những tài nguyên được cấp phát
cho nó và kết thúc.
Khi Pi kết thúc, Pi+1 có thể đạt được các tài nguyên nó cần .
(Khơng gian trạng thái an tồn, khơng an tồn, deadlock)
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
1. Giải thuật đồ cấp phát tài nguyên
Quy tắc:
Cạnh thỉnh cầu (claim edge): Pi → Rj hiển thị q trình Pi có thể
yêu cầu tài nguyên Rj.
Cạnh thỉnh cầu biến thành cạnh yêu cầu khi một tiến trình yêu cầu
một tài ngun.
Khi tài ngun được một tiến trình giải phóng, cạnh yêu cầu trở
thành cạnh thỉnh cầu
Hệ thống ở trong trạng thái an tồn nếu đồ thị khơng chứa chu
trình nào.
Ví dụ:
Giả sử rằng P2 u cầu R2.
Mặc dù R2 hiện rảnh nhưng chúng ta không thể cấp phát nó tới P2
vì hoạt động này sẽ tạo ra chu trình trong đồ thị.
Nếu P1 yêu cầu R2 và P2 yêu cầu R1 thì deadlock sẽ xảy ra.
Nhận xét: Thuật tốn có độ phức tạp O(n^2) và có thể rơi vào bế tắc khi
tồn tại chu trình và ngược lại
2. Thuật toán quản lý nhà băng:
Đặt vấn đề:
Giải thuật này có thể được dùng trong hệ thống ngân hàng để đảm bảo
ngân hàng không bao giờ cấp phát tiền mặt đang có của nó khi nó khơng thể
thoả mãn các yêu cầu của tất cả khách hàng.
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
Khi một quá trình mới đưa vào hệ thống, nó phải khai báo số tối đa các
thể hiện của mỗi loại tài nguyên mà nó cần. Số này có thể khơng vượt q
tổng số tài nguyên trong hệ thống.
Khi một người dùng yêu cầu tập hợp các tài nguyên, hệ thống phải xác
định việc cấp phát của các tài nguyên này sẽ để lại hệ thống ở trạng thái an
tồn hay khơng.
Nếu trạng thái hệ thống sẽ là an toàn, tài nguyên sẽ được cấp; ngược lại
quá trình phải chờ cho tới khi một vài q trình giải phóng đủ tài ngun.
Xét bài tốn với n tiến trình và m tài ngun với định nghĩa:
n= số tiến trình; m= số loại tài nguyên
Available: một vector có chiều dài m hiển thị số lượng tài nguyên sẳn
dùng của mỗi loại. Nếu Available[j]= k, có k thể hiện của loại tài
nguyên Rj sẳn dùng.
Max: một ma trận n x m định nghĩa số lượng tối đa yêu cầu của mỗi
quá trình. Nếu Max[ i , j ] = k, thì quá trình Pi có thể yêu cầu nhiều
nhất k thể hiện của loại tài nguyên Rj.
Allocation: một ma trận n x m định nghĩa số lượng tài nguyên của
mỗi loại hiện được cấp tới mỗi quá trình. Nếu Allocation[ i, j ] = k, thì
quá trình Pi hiện được cấp k thể hiện của loại tài nguyên Rj.
Need: một ma trận n x m hiển thị yêu cầu tài nguyên cịn lại của mỗi
q trình. Nếu Need[ i, j ] = k, thì q trình Pi có thể cần thêm k thể
hiện của loại tài nguyên Rj để hoàn thành tác vụ của nó.
Chú ý rằng, Need[ i, j ] = Max[ i, j ] – Allocation [ i, j ].
Cách triển khai thuật toán:
1) Gọi Work và Finish là các vector có chiều dài m và n tương ứng. Khởi
tạo Work:=Available và Finish[i]:=false cho i = 1, 2, …,n.
2) Tìm i thỏa:
a) Finish[i] = false
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
b) Need i ≤ Work.
Nếu khơng có i nào thỏa, di chuyển tới bước 4
3) Work:=Work + Allocation i
Finish[i] := true
Di chuyển về bước 2.
4) Nếu Finish[i] = true cho tất cả i, thì hệ thống đang ở trạng thái an tồn.
Nhận xét: Thuật này có độ phức tạp O(mxn^2) để quyết định trạng thái là
an tồn hay khơng.
VI.
Phát hiện deadlock
Nếu một hệ thống không thực hiện giải thuật ngăn chặn deadlock hay
tránh deadlock thì trường hợp deadlock có thể xảy ra. Trong mơi trường
này, hệ thống phải cung cấp:
Một thuật tốn có thể phát hiện ra bế tắc có xảy ra hay khơng
Một thuật tốn để khơi phục khỏi bế tắc
a)Đồ thị cấp phát tài nguyên
b) Đồ thị chờ tương ứng
1. Có một thể hiện đối với mỗi loại tài nguyên
Nguyễn Đình Tuấn Dũng 20215328
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
Trong trường hợp tất cả các tài nguyên chỉ có một phiên bản duy nhất, ta
có thể sử dụng thuật tốn phát hiện deadlock dựa trên biểu đồ chờ, được tạo
ra từ biểu đồ phân phối tài nguyên bằng cách loại bỏ các nút tài nguyên và
thu gọn các cạnh tương ứng.
Cụ thể, một cạnh từ quá trình Pi đến quá trình Pj trong biểu đồ chờ ngụ ý
rằng quá trình Pi đang chờ đợi q trình Pj giải phóng tài ngun mà Pi
đang cần. Một cạnh Pi → Pj tồn tại trong biểu đồ chờ khi và chỉ khi đồ thị
phân phối tài nguyên tương ứng chứa cả hai cạnh Pi → Rq và Rq → Pj cho
một tài nguyên Rq nào đó.
Để phát hiện deadlock, hệ thống cần duy trì một biểu đồ chờ và định kỳ
gọi một thuật tốn tìm kiếm chu trình trong biểu đồ. Một thuật tốn phát
hiện chu trình trong đồ thị yêu cầu đến thứ tự O(n^2) thao tác, với n là số
đỉnh trong đồ thị.
Điều này cho phép hệ thống phát hiện các trạng thái bế tắc và thực hiện
các biện pháp khắc phục, chẳng hạn như giải phóng tài nguyên đang được
giữ bởi một quá trình để giải quyết tình trạng bế tắc và đảm bảo sự tiếp tục
hoạt động của hệ thống.
2. Nhiều thể hiện trong một loại tài nguyên
Lược đồ đồ thị chờ không thể áp dụng đối với hệ thống cấp phát tài
nguyên với nhiều thể hiện cho mỗi loại tài nguyên. Giải thuật phát hiện
deadlock mà chúng ta mô tả sau đây có thể áp dụng cho hệ thống này(giải
thuật nhà băng):
Available: Vector với độ dài m thể hiện lượng tài nguyên có sẵn của
mỗi loại
Allocation: Một ma trận nxm thể hiện số lượng của tài nguyên mỗi loại
đang cấp phát cho mỗi tiến trình
Request: Một ma trận nxm thể hiện yêu cầu chính xác của mỗi tiến trình
B1: Cho Work và Finish là vector có độ dài là m và n. Khai báo
Work=Available. Cho n=0,1..n-1 nếu Allocation khác 0 thì Finish[i]=false
B2: Tìm i thỏa mãn: Finish[i]=false và Request<=Work
B3: Work=Work+Allocation và Finish[i]=true rồi quay lại B2
B4: Nếu Finish[i]=false,0
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
Nhận xét: Thuật tốn có độ phức tạp O(m*n^2)
Ví dụ: xét hệ thống với 5 quá trình P 0 đến P4 và 3 loại tài nguyên: A có 7
thể hiện, B có 2 thể hiện và C có 6 thể hiện. Giả sử rằng tại thời điểm T0:
allocation
request
A
B
C
A
B
C
A
B
C
P0 0
1
0
0
0
0
0
0
0
P1 2
0
0
2
0
2
P2 3
0
3
0
0
0
P3 2
1
1
1
0
0
P4 0
0
2
0
0
2
Need
A
B
C
P0
7
4
3
P1
1
2
2
P2
6
0
2
P3
0
1
1
P4
4
3
1
Nguyễn Đình Tuấn Dũng 20215328
available
IT3070 – Nguyên lý Hệ điều hành
Kỳ 20222
Hệ thống hiện ở trong trạng thái an tồn vì đã có thứ tự
3. Sử dụng các thuật tốn phát hiện deadlock
Khi nào thì chúng ta nên nạp giải thuật phát hiện deadlock? Câu trả lời
phụ thuộc vào hai yếu tố:
1) Deadlock có khả năng xảy ra thường xuyên như thế nào?
2) Bao nhiêu quá trình sẽ bị ảnh hưởng bởi deadlock khi nó sẽ ra?
Nếu deadlock xảy ra thường xun thì giải thuật phát hiện nên được nạp
lên thường xuyên.
Bế tắc xảy ra khi u cầu của các tiến trình khơng thể được đáp ứng
ngay lập tức, đặc biệt khi yêu cầu này là yêu cầu cuối cùng để hoàn thành
một chuỗi chờ đợi. Một phương pháp để phát hiện bế tắc là áp dụng thuật
tốn phát hiện mỗi khi có u cầu tài nguyên không thể được đáp ứng ngay
lập tức. Trong trường hợp đó, chúng ta có thể xác định khơng chỉ các tiến
trình bị bế tắc mà cịn các tiến trình dẫn đến tình trạng bế tắc (thường mỗi
tiến trình bị bế tắc là một phần của một chuỗi vịng lặp, và tất cả chúng
đồng thời gây ra tình trạng bế tắc). Nếu có nhiều loại tài nguyên khác nhau,
một u cầu có thể tạo ra nhiều chuỗi vịng lặp trong biểu đồ, mỗi chuỗi
vịng lặp hồn thành bởi yêu cầu gần nhất và gây ra bởi một tiến trình cụ
thể.
Tuy nhiên, việc áp dụng thuật tốn phát hiện bế tắc cho mỗi yêu cầu tài
nguyên sẽ làm tăng thời gian tính tốn. Một phương pháp thay thế hiệu quả
hơn là chỉ gọi thuật toán trong một khoảng thời gian nhất định. Nếu ta gọi
thuật toán một cách tùy ý, đồ thị tài nguyên có thể chứa nhiều chuỗi vịng
lặp. Trong trường hợp đó, khơng thể tìm thấy các tiến trình nào gây ra tình
trạng bế tắc.
VII.
Phục hồi từ deadlock
Nguyễn Đình Tuấn Dũng 20215328
