Lập trình mô phỏng các phương pháp kiểm tra tính an toàn của hệ

TRƯỜNG ĐẠI HỌC CÔNG NGHIỆP HÀ NỘI
KHOA CÔNG NGHỆ THÔNG TIN
---���---

BÀI TẬP LỚN
MÔN: NGUYÊN LÝ HỆ ĐIỀU HÀNH
ĐỀ TÀI: Lập trình mơ phỏng các phương pháp kiểm tra
tính an tồn của hệ

Giảng viên :
Nhóm số:

Lớp:

TS Nguyễn Bá Nghiễn
04

IT6025.2 - K15

Hà Nội, 2022


Mục lục

Mục lục..............................................................................................................1
Lời mở đầu........................................................................................................2
Chương I: Tìm hiểu về hiện tượng bế tắc..........................................................3
1.1

Khái niệm bế tắc...................................................................................3

1.2

Điều kiện xảy ra bế tắc trong hệ thống.................................................4

1.3

Các mức phòng tránh bế tắc.................................................................4

1.4

Ngăn chặn bế tắc và an toàn hệ thống..................................................5

1.4.1

Ngăn chặn bế tắc............................................................................5

1.4.2

Dãy tiến trình an tồn.....................................................................7

Chương II: Tìm hiểu về các phương pháp kiểm tra hệ an toàn.........................8
Chương III: Cài đặt thuật tốn.........................................................................10
3.1 Thuật tốn chuyển sang trạng thái an tồn.............................................10
3.2 Thuật tốn kiểm tra tính an tồn của hệ.................................................11
3.3 Cài đặt thuật tốn...................................................................................12
3.4 Ví dụ minh họa.......................................................................................16
Kết luận...........................................................................................................17
Tài liệu tham khảo...........................................................................................18

1

Lời mở đầu

Công nghệ thông tin trong giai đoạn hiện nay đang phát triển như vũ
bão ở mọi lĩnh vực hoạt động khắp nơi trên thế giới. Điều xảy ra trong vòng
vài năm qua ở Việt Nam là sự đầu tư ồ ạt vào công nghệ. Tin học đã và đang
là một trong các vấn đề không thể thiếu đối với bất kỳ công ty nào. Đặc biệt
tin học ngày càng giữ vai trò quan trọng trong vấn đề quản lý tại các tổ chức
nhất là tại các lĩnh vực thu thập thông tin. Tuy ngành công nghệ thông tin ở
nước ta mới chỉ phát triển trong vài năm trở lại đây và đang từng bước phát
triển nhưng những bước phát triển đó đã cho thấy tiềm năng lớn lao trong lĩnh
vực công nghệ thông tin ở nước ta, trong đó phát triển hệ thống thơng tin đang
là thế mạnh của đất nước. Hệ thống thông tin giúp công việc quản lý dễ dàng
hơn, nâng cao hiệu quả sản xuất, tiết kiệm được lượng lớn thời gian và công
sức.
Qua thời gian học tập và tìm hiểu học phần “Nguyên lý hệ điều hành”,
nhóm em đã chọn đề tài “Lập trình mơ phỏng các phương pháp kiểm tra hệ an
tồn”. Báo cáo thực tập gồm có 3 chương sau:
● Chương I: Tìm hiểu về hiện tượng bế tắc.
● Chương II: Tìm hiểu về các phương pháp kiểm tra hệ an toàn.
● Chương III: Cài đặt thuật toán.
Dưới sự hướng dẫn của giảng viên Nguyễn Bá Nghiễn chúng em đã tìm
hiểu và hồn thành đề tài được giao. Mong các thầy (cơ) góp ý để bài làm của
chúng em được hồn thiện hơn. Chúng em xin chân thành cảm ơn!

2


3

Chương I: Tìm hiểu về hiện tượng bế tắc

1.1 Khái niệm bế tắc
Bế tắc là trạng thái trong hệ thống có ít nhất hai tiến trình đang dừng chờ
lẫn nhau và chúng không thể chạy tiếp được, sự chờ đợi này có thể kéo dài vơ
hạn nếu khơng có sự tác động từ bên ngoài.
Hầu hết các hệ điều hành không cung cấp phương tiện ngăn chặn bế
tắc. Vấn đề bế tắc chỉ trở thành vấn đề phổ biến, xu hướng hiện hành gồm số
lượng lớn tiến trình, chương trình đa luồng, nhiều tài nguyên trên hệ thống và
đặc biệt các tập tin có đời sống dài và những máy phục vụ cơ sở dữ liệu hơn
là hệ thống đóng.
Giả sử rằng có ba Process P1, P2 và P3. Có ba tài nguyên khác nhau R1, R2
và R3. R1 được gán cho P1, R2 được gán cho P2 và R3 được gán cho P3.
Sau một thời gian, P1 yêu cầu R1 đang được P2 sử dụng. P1 tạm dừng
Process thực thi của nó vì nó khơng thể hồn thành nếu khơng có R 2. P2 cũng
u cầu R3 đang được P3 sử dụng. P2 cũng dừng Process thực thi của nó vì nó
khơng thể tiếp tục mà khơng có R 3. P3 cũng yêu cầu R1 đang được P1 sử dụng
do đó P3 cũng dừng thực thi.
Trong kịch bản này, một chu trình đang được hình thành giữa ba Process.
Khơng có Process nào đang diễn ra và tất cả đều đang chờ đợi. Máy tính
khơng phản hồi vì tất cả các Process đã bị chặn.

Hình 1. Minh họa 3 Process thực thi

4


1.2 Điều kiện xảy ra bế tắc trong hệ thống

Hiện tượng bế tắc xảy ra khi và chỉ khi trong hệ thống tồn tại bốn điều kiện
- Có tài nguyên găng:
+ Một tài nguyên bị chiếm bởi một tiến trình và khơng tiến trình nào
khác có thể sử dụng tài nguyên này.
- Có hiện tượng giữ và đợi:
+ Một tiến trình giữ ít nhất một tài ngun và chờ một số tài nguyên
khác rỗi để sử dụng. Các tài nguyên này đang bị một tiến trình khác
chiếm giữ.
- Khơng có hệ thống phân phối lại tài nguyên:
+ Tài nguyên bị chiếm giữ chỉ có thể rỗi khi tiến trình tự nguyện giải
phóng tài nguyên sau khi đã sử dụng xong.
- Có hiện tượng chờ đợi vịng trịn:
+ Một tập tiến trình {P0, P1, …, Pn} có xuất hiện điều kiện “chờ vòng” nếu
P0 chờ một tài nguyên do P1 chiếm giữ, P1 chờ một tài nguyên khác do P2
chiếm giữ, ..., Pn-1 chờ tài nguyên do Pn chiếm giữ và Pn chờ tài nguyên do
P0 chiếm giữ.

1.3 Các mức phòng tránh bế tắc
Để tránh hiện tượng bế tắc, thông thường hệ thống áp dụng ba mức:
Ngăn ngừa: Áp dụng các biện pháp để hệ không rơi vào trạng thái bế tắc.
Dự báo và tránh bế tắc: Áp dụng các biện pháp để kiểm tra các tiến trình xem
có bị rơi vào trạng thái bế tắc hay khơng. Nếu có thì thông báo trước khi bế
tắc xảy ra.
Nhận biết và khắc phục: Tìm cách phát hiện và giải quyết.

5


1.4 Ngăn chặn bế tắc và an toàn hệ thống
1.4.1 Ngăn chặn bế tắc

Mỗi khi phân bổ tài nguyên cho các tiến trình, hệ thống sẽ kiểm tra xem
liệu việc phân bổ đó có đẩy hệ thống vào tình trạng bế tắc hay khơng. Nếu có
tìm cách giải quyết trước khi bế tắc xảy ra.
Ngăn chặn bế tắc (deadlock prevention) là phương pháp xử lý bế tắc,
khơng cho nó xảy ra bằng cách làm cho ít nhất một điều kiện cần của bế tắc là
loại trừ lẫn nhau, giữ và chờ, khơng có đặc quyền hoặc chờ vịng khơng được
thỏa mãn (không xảy ra).
Để ngăn chặn bế tắc cần đảm bảo sao cho 4 điều kiện xảy ra bế tắc không
xảy ra đồng thời.
- Loại bỏ tài nguyên găng:
+ Loại trừ lẫn nhau: là điều kiện bắt buộc cho các tài ngun khơng sử
dụng chung được → Khó làm cho C1 khơng xảy ra vì các hệ thống
ln có các tài nguyên không thể sử dụng chung được.
- Loại bỏ yếu tố giữ và đợi: Có thể làm cho “Giữ và đợi “không xảy ra bằng
cách đảm bảo:
+ Một tiến trình ln u cầu cấp phát tài ngun chỉ khi nó khơng chiếm
giữ bất kỳ một tài ngun nào.
+ Một tiến trình chỉ thực hiện khi nó được cấp phát tồn bộ các tài
ngun cần thiết.
-

Ngăn chặn “khơng có đặc quyền “: Để ngăn chặn không cho điều kiện
này xảy ra, có thể sử dụng giao thức sau:
+ Nếu tiến trình P (đang chiếm tài nguyên R1, ..., Rn-1) yêu cầu cấp phát
tài nguyên Rn nhưng không được cấp phát ngay (có nghĩa là P phải chờ)
thì tất cả các tài nguyên R1, ..., Rn-1 phải được “thu hồi”.

6

+ Nói cách khác R1, ..., Rn-1 phải được “giải phóng” một cách áp đặt, tức
là các tài nguyên này phải được đưa vào danh sách các tài nguyên mà P
đang chờ cấp phát.
-

Mã lệnh ngăn chặn “khơng có đặc quyền”:
+ Tiến trình P yêu cầu cấp phát tài nguyên R 1, ..., Rn-1 if (R1, ..., Rn-1 rỗi)
then cấp phát tài nguyên cho P else if ({Ri ...Rj} được cấp phát cho Q
và Q đang trong trạng thái chờ một số tài nguyên S khác) then thu hồi
{Ri ...Rj} và cấp phát cho P else đưa P vào trạng thái chờ tài nguyên
R1, ..., Rn-1.

- Loại bỏ yếu tố chờ đợi vòng tròn
+ Một giải pháp ngăn chặn chờ vòng là đánh số thứ tự các tài nguyên và
bắt buộc các tiến trình yêu cầu cấp phát tài nguyên theo số thứ tự tăng
dần.
+ Giả sử có các tài nguyên {R 1, …, Rn}. Ta gán cho mỗi tài nguyên một
số nguyên dương duy nhất qua một ánh xạ 1 – 1 f: R -> N, với N là tập
các số tự nhiên.
- Giao thức ngăn chặn “Chờ vòng”:
+ Khi tiến trình P khơng chiếm giữ tài ngun nào, nó có thể yêu cầu cấp
phát nhiều thể hiện của một tài nguyên Ri bất kỳ.
+ Sau đó P chỉ có thể yêu cầu các thể hiện của tài nguyên Rj nếu và chỉ
nếu f(R j) > f(R i). Một cách khác, nếu P muốn yêu cầu cấp phát tài
nguyên R j, nó đã giải phóng tất cả các tài nguyên Ri thỏa mãn f(R i) ≥
f(R j).
+ Nếu P cần được cấp phát nhiều loại tài nguyên, P phải lần lượt yêu cầu
các thể hiện của từng tài nguyên đó.
- Ưu nhược điểm của ngăn chặn giải pháp bế tắc:

7


+ Ưu điểm: ngăn chặn bế tắc (deadlock prevention) là phương pháp tránh
được bế tắc bằng cách làm cho điều kiện cần không được thỏa mãn.
+ Nhược điểm: Giảm khả năng tận dụng tài nguyên và giảm thông lượng
của hệ thống và khơng mềm dẻo.

1.4.2 Dãy tiến trình an tồn
Cho 1 dãy tiến trình P1, P2, P3, …, Pn song hành. Dãy tiến trình được gọi là
an tồn (safe process) nếu với mọi tiến trình Pi, tài nguyên mà Pi cần có thể
được thỏa mãn bởi các tài nguyên khả dụng của hệ thống và tài nguyên do các
tiến trình Pi’ đang giữ với điều kiện i’ < i.
Hệ thống ở trạng thái an toàn tại một thời điểm nếu dãy tiến trình song
hành tại thời điểm đó có thể được sắp xếp thành dãy an toàn.

8


Chương II: Tìm hiểu về các phương pháp kiểm tra hệ an tồn

Thuật tốn banker là một thuật tốn phân bổ tài nguyên và tránh bế tắc
kiểm tra độ an tồn bằng cách mơ phỏng việc phân bổ cho số lượng tối đa có
thể được xác định trước của tất cả các tài nguyên, sau đó thực hiện kiểm tra
“trạng thái s” để kiểm tra các hoạt động có thể xảy ra, trước khi quyết định có
nên cho phép phân bổ hay khơng để tiếp tục.
Thuật tốn của Banker được đặt tên như vậy vì nó được sử dụng trong
hệ thống ngân hàng để kiểm tra xem khoản vay có thể bị xử phạt đối với một
người hay không. Giả sử có n số chủ tài khoản trong một ngân hàng và tổng
số tiền của họ là S. Nếu một người làm thủ tục vay vốn thì trước tiên ngân

hàng lấy tổng số tiền ngân hàng trừ đi số tiền cho vay và nếu số tiền còn lại
lớn hơn. hơn S thì chỉ khoản vay bị xử phạt. Nó được thực hiện bởi vì nếu tất
cả các chủ tài khoản đến rút tiền của họ thì ngân hàng có thể dễ dàng thực
hiện.
Nói cách khác, ngân hàng sẽ khơng bao giờ phân bổ tiền của mình theo
cách mà nó khơng cịn có thể đáp ứng nhu cầu của tất cả các khách hàng của
mình. Ngân hàng sẽ ln cố gắng ở trong trạng thái an toàn.
Các đặc điểm của thuật tốn Banker như sau:
● Nếu bất kỳ q trình nào u cầu một tài ngun, thì nó phải đợi.
● Thuật tốn này bao gồm các tính năng nâng cao để phân bổ tài nguyên
tối đa.
● Có giới hạn tài nguyên trong hệ thống có.
● Trong thuật tốn này, nếu bất kỳ quá trình nào nhận được tất cả các tài
nguyên cần thiết, thì nó sẽ trả lại các tài ngun đó trong một khoảng
thời gian hạn chế.

9


● Các tài nguyên khác nhau được duy trì trong thuật tốn này có thể đáp
ứng nhu cầu của ít nhất một khách hàng.
Ưu điểm:
● Nó chứa các tài nguyên khác nhau đáp ứng các yêu cầu của từng quy
trình.
● Mỗi quy trình phải cung cấp thơng tin cho hệ điều hành về các yêu cầu
tài nguyên sắp tới, số lượng tài nguyên và thời gian tài nguyên sẽ được
lưu giữ.
● Nó giúp hệ điều hành quản lý và kiểm sốt các u cầu của quy trình
đối với từng loại tài ngun trong hệ thống máy tính.
● Thuật tốn có thuộc tính Tài nguyên tối đa đại diện cho biết mỗi q

trình có thể chứa số tài ngun tối đa trong một hệ thống.
Nhược điểm:
● Nó yêu cầu một số lượng quy trình cố định và khơng có quy trình bổ
sung nào có thể được khởi động trong hệ thống trong khi thực hiện quy
trình.
● Thuật tốn khơng cịn cho phép các quy trình trao đổi nhu cầu tối đa
của nó trong khi xử lý các tác vụ của nó.
● Mỗi tiến trình phải biết và nêu trước yêu cầu tài nguyên tối đa của
chúng cho hệ thống.
● Số lượng yêu cầu tài nguyên có thể được cấp trong một thời gian hữu
hạn, nhưng thời hạn để cấp phát tài nguyên là một năm.
Khi làm việc với thuật toán của một ngân hàng, nó yêu cầu biết về ba điều:
● Mỗi tiến trình có thể u cầu bao nhiêu cho mỗi tài nguyên trong hệ
thống. Nó được biểu thị bằng yêu cầu [ MAX ].
● Mỗi quy trình hiện đang giữ mỗi tài nguyên trong một hệ thống là bao
nhiêu. Nó được biểu thị bằng tài nguyên [ ALLOCATED ].
● Nó đại diện cho số lượng của mỗi tài nguyên hiện có trong hệ
thống. Nó được biểu thị bằng tài nguyên [ AVAILABLE ].
10


Chương III: Cài đặt thuật toán

3.1 Thuật toán chuyển sang trạng thái an tồn
Giả sử hệ có p tiến trình và r kiểu tài nguyên. Các cấu trúc dữ liệu sử dụng
trong thuật toán được xây dựng như sau:
- Available: mảng 1x r thể hiện số tài nguyên có thể sử dụng của mỗi kiểu.
Nếu Available (j) = k suy ra có k tài nguyên kiểu rj có thể sử dụng.
- Max: mảng p x r thể hiện số tài nguyên cực đại mà mỗi tiến trình yêu cầu.
Nếu Max (i, j) = k suy ra tiến trình P i chỉ có thể yêu cầu cực đại k tài nguyên

kiểu rj cực đại là k.
- Allocation: mảng p x r thể hiện số tài nguyên mỗi kiểu hiện đã phân bổ cho
các tiến trình. Nếu Allocation (i, j) = k suy ra tiến trình P i đang sử dụng k tài
nguyên kiểu rj.
- Need: mảng p x r thể hiện số tài ngun cịn cần của mỗi tiến trình. Need (i,
j) = k; Tiến trình cịn cần k tài ngun của ri.
- Need (i, j) = Max (i, j) – Allocation (i, j)
- Request: Mảng n x m thể hiện yêu cầu tài nguyên của các tiến trình
- Request (i, j) = k: tiến trình pi yều cầu k tài nguyên kiểu rj.
Quy ước: khi viết Request i thể hiện dịng thứ i của mảng (ứng với tiến
trình Pi (các biến Need i, Allocation i …).
Khi tiến trình Pi đưa ra một yêu cầu tài nguyên hệ thống tiến hành các
bước như sau:
Bước 1: If Request i <= Need i then go to Bước 2
Else Error;
Bước 2: If Request i <= Available i then go to Bước 3
11


Else Pi đợi (tài nguyên không thể phân bổ);
Bước 3: Hệ thống dự định phân bổ tài nguyên
Available i = Available i – Request i
Allocation i = Allocation i – Request i
Need i = Need i – Request i
Bước 4: Kiểm tra hệ có ở trạng thái an tồn hay khơng?
Nếu có phân bổ tài ngun theo dự tính.
Nếu khơng tiến trình Pi phải đợi cùng với tài nguyên Request i.
3.2 Thuật tốn kiểm tra tính an tồn của hệ
- Trong thuật toán sử dụng thêm hai cấu trúc dữ liệu sau:
• Work: mảng 1 x p thể hiện số tài nguyên khả dụng của hệ thống và

số tài nguyên do các tiến trình Pi đang sử dụng với điều kiện i' < i.
• Finish: mảng 1 x r đánh dấu các tiến trình đã xét.
- Thuật tốn:
Bước 1: Khởi tạo:
Work := Available;
Finish(i) = false;

(với mọi i = 1….r)

Bước 2: Tìm i sao cho Finish(i) = false và Need(i) <= Work. Nếu
khơng tìm thấy, go to bước 4.
Bước 3: Work := Work + Allocation(i);
Finish(i) = true;
go to bước 2
Bước 4: Nếu Finish(i) = true với mọi i thì hệ thống ở trạng thái an
toàn, ngược lại hệ thống sẽ gặp bế tắc.

12


3.3 Cài đặt thuật toán
#include <iostream>
#include <iomanip>
using namespace std;
#define MAX 100
void nhapDuLieu(int arr[MAX][MAX], int &m, int &n)
{
for (int i = 0; i < m; i++) {
cout << "Nhap hang thu " << i + 1 << endl;
for (int j = 0; j < n; j++) {

cin >> arr[i][j];
}
}
}
void tinhNeed(int need[MAX][MAX], int max[MAX][MAX], int
allocation[MAX][MAX], int p, int r)
{
for (int i = 0; i < p; i < i++) {
for (int j = 0; j < r; j++) {
need[i][j] = max[i][j] - allocation[i][j];
}
}
}
bool kiemTraHeAnToan(int *process, int allocation[MAX][MAX], int
max[MAX][MAX], int *available, int need[MAX][MAX], int p, int r)
{
tinhNeed(need, max, allocation, p, r);
// gan tat ca tien trinh bang false;
bool finish[p] = {0};
// luu chuoi tien trinh an toan
int trinhTuAnToan[p];
// gan work = available
int work[r];
for (int i = 0; i < r; i++) {
work[i] = available[i];
}
// trong khi tat ca cac tien trinh chua ket thuc hoac he chua an toan
int count = 0;
while (count < p) {
13

bool found = false;
for (int i = 0; i < p; i++) {
// kiem tra tien trinh ket thuc chua
if (finish[i] == 0) {
// kiem tra need <= work hay khong
int j;
for (j = 0; j < r; j++) {
if (need[i][j] > work[j]) {
break;
}
}
// neu tat ca cac need cua tien trinh thoa man
if (j == r) {
// gan work = work + allocation
for (int k = 0; k < r; k++) {
work[k] += allocation[i][k];
}
// them tien trinh vao trinh tu tien trinh an
toan
trinhTuAnToan[count++] = i;
// danh dau tien trinh ket thuc
finish[i] = 1;
found = true;
}
}
}
// neu khong tim thay tien trinh tiep theo trong trinh tu an toan
if (found == false) {

cout << "\t=> HE THONG KHONG O TRANG THAI AN
TOAN";
return false;
}
}
// neu he thong o trang thai an toan
cout << "\t=> HE THONG O TRANG THAI TOAN.\n\t=> TRINH TU
TIEN TRINH AN TOAN: ";
for (int i = 0; i < p; i++) {
cout << trinhTuAnToan[i] << " ";
}
return true;
}

14


void xuatDuLieu(int *process, int allocation[MAX][MAX], int max[MAX]
[MAX], int need[MAX][MAX], int *available, int p, int r)
{
tinhNeed(need, max, allocation, p, r);
// xuat tieu de
cout << "\n\n------------------------------------------- BANG
------------------------------------------------\n\n";
cout << setw(15) << left << " PROCESS" << setw(21) << "
ALLOCATION" << setw(21) << " MAX" << setw(21) << "
AVAILABLE" << setw(21) << " NEED" << endl;
cout << setw(15) << left << "" << setw(7) << "A" << setw(7) << "B"
<< setw(7) << "C" << setw(7) << "A" << setw(7) << "B" << setw(7) << "C";
cout << setw(7) << "A" << setw(7) << "B" << setw(7) << "C" <<

setw(7) << "A" << setw(7) << "B" << setw(7) << "C" << endl;
// xuat du lieu
for (int i = 0; i < p; i++) {
cout << setw(5) << " " << setw(10) << process[i];
for (int j = 0; j < r; j++) {
cout << setw(7) << allocation[i][j];
}
for (int j = 0; j < r; j++) {
cout << setw(7) << max[i][j];
}
if (i == 0) {
for (int j = 0; j < r; j++) {
cout << setw(7) << available[j];
}
}
else {
cout << setw(21) << "";
}
for (int j = 0; j < r; j++) {
cout << setw(7) << need[i][j];
}
cout << "\n";
}
cout << "\n\n";
}
int main()
{
int allocation[MAX][MAX], max[MAX][MAX], need[MAX][MAX];
int p, r;
15

do {
cout << "NHAP SO TIEN TRINH: "; cin >> p;
cout << "NHAP SO TAI NGUYEN: "; cin >> r;
} while (p < 1 || r < 1);
// process
int *process = new int[p];
for (int i = 0; i < p; i++) {
process[i] = i;
}
// nhap allocation
cout << "\n\tNHAP DU LIEU ALLOCATION\n";
nhapDuLieu(allocation, p, r);
// nhap max
cout << "\n\tNHAP DU LIEU MAX\n";
nhapDuLieu(max, p, r);
// nhap available
int *available = new int[r];
cout << "\n\tNHAP DU LIEU AVAILABLE\n";
for (int i = 0; i < r; i++) {
cin >> available[i];
}
// xuat du lieu
xuatDuLieu(process, allocation, max, need, available, p, r);
// kiem tra he an toan
kiemTraHeAnToan(process, allocation, max, available, need, p, r);
// giai phong bo nho
delete[] process;
delete[] available;

return 0;
}

16


3.4 Ví dụ minh họa
Bài tốn: Giả sử có 5 tiến trình và 3 kiểu tài nguyên A, B, C ở trạng thái
như sau:
Process
P0
P1
P2
P3
P4

Allocation
A B C
0 1 0
2 0 0
3 0 2
2 1 1
0 0 2

A
7
3
9
2
4

Max
B
5
2
0
2
3

C
3
2
2
2
3

Hệ có ở trạng thái an tồn hay khơng?

Hình 2. Kết quả bài tốn

17

Available
A B C
3
3
2


Kết luận

Sau thời gian nghiên cứu và làm việc nghiêm túc với sự nỗ lực của cả
nhóm dưới sự giúp đỡ chỉ bảo của thầy Nguyễn Bá Nghiễn chúng em đã hồn
thành đề tài: Lập trình mơ phỏng các phương pháp kiểm tra tính an tồn của
hệ. Qua đó, ta đã nắm được các nguyên lí trong cơ chế lập trình mơ phỏng các
phương pháp kiểm tra tính an tồn của hệ. Bên cạnh đó, nhóm chúng em đã
lập trình mơ phỏng được phương pháp kiểm tra tính an tồn của hệ bằng giải
thuật banker. Từ đó có thể giúp chúng ta kiểm tra tính an tồn của mọi hệ. Tài
liệu này chủ yếu tìm hiểu về khái niệm, sơ lược, những kiến thức chung về bế
tắc và các biện pháp ngăn chặn bế tắc, dãy tiến trình an tồn và an tồn hệ
thống, nghiên cứu về thuật tốn kiểm tra tính an tồn của hệ, quản lý tiến
trình. Phần nghiên cứu của chúng em chỉ dừng lại ở mức cơ bản nên chưa
thực sự đi sâu nhưng chúng em đã cố gắng nêu lên những vấn đề chính để
hiểu được cách hoạt động của các phương pháp kiểm tra tính an tồn của hệ.

18


Tài liệu tham khảo
[1] Nguyễn Thanh Hải - Giáo Trình Nguyên Lý Hệ Điều Hành Đại học

Công nghiệp Hà Nội, khoa công nghệ thông tin, Hà Nội 2016.
[2] Trần Thị Như Nguyệt - Giáo trình Hệ điều hành Đại học Cơng nghệ

thơng tin Thành phố Hồ Chí Minh.
[3] Nguyễn Hải Châu – Giáo trình Nguyên Lý Hệ Điều Hành Đại học

Công Nghệ - Đại học Quốc gia Hà Nội.
[4]

/>

nguyet/dh-cong-nghe-thong-tin
[5] />
19