Thảo luận Bài 7

HANDLE s;
s=CreateSemaphore(0, n, max, t);
//n: tạo đèn hiệu với giá trị ban đầu là n.
//max: giá trị tối đa được phép có của đèn hiệu.
//t: là tên của đèn hiệu. Tên có thể là 1 chuỗi kí tự nằm trong ngoặc kép hoặc là số 0, nếu là số 0 thì đèn hiệu không tên hay là đèn hiệu nạt danh.
Phân biệt đèn hiệu không tên với đèn hiệu có tên:
_Đèn hiệu có tên dùng để liên lạc giữa các tiến trình nặng truyền thống.
_Đèn hiệu không tên chỉ được dùng để liên lạc bên trong lòng của tiến trình truyền thống(giữa các luồng của nó).
_Đèn hiệu có tên còn được gọi là đèn hiệu liên tiến trình.
_Đèn hiệu không tên còn được gọi là đèn hiệu nội tiến trình, nó sẽ bảo mật tốt hơn.
WaitForSingleObject(s, timeout): chờ cho đến khi đèn hiệu mà mục quản của nó lưu trong biến s có giá trị là khác 0 với thời gian không quá thời gian timeout.
Timeout: chờ đến khi đèn xanh nhưng không quá 5000ms.
Wait(s): chờ 1 đối tượng.
Signal(s): tăng giá trị của mục quản trong biến s lên 1.

ReleaseSemaphore(s, 1, NULL): nhả giá trị của đèn hiệu(tăng lên 1 nhưng không vượt quá max)

PhamThiThao (I22B) đã viết:các bạn giúp mình vs

SemEmpty và SemFull là 2 đèn hiệu

-SemEmpty: Chứa mục quản của đèn hiệu dùng để quản lý số khoang trống trong bộ đệm
- SemFull: Chứa mục quản của đèn hiệu dùng để quản lý số sản phẩm trong bộ đệm

Các bạn đóng góp ý kiến thêm nhé

TranVuSang (I22B) đã viết:


HANDLE s;
s=CreateSemaphore(0, n, max, t);
//n: tạo đèn hiệu với giá trị ban đầu là n.
//max: giá trị tối đa được phép có của đèn hiệu.
//t: là tên của đèn hiệu. Tên có thể là 1 chuỗi kí tự nằm trong ngoặc kép hoặc là số 0, nếu là số 0 thì đèn hiệu không tên hay là đèn hiệu nạt danh.
Phân biệt đèn hiệu không tên với đèn hiệu có tên:
_Đèn hiệu có tên dùng để liên lạc giữa các tiến trình nặng truyền thống.
_Đèn hiệu không tên chỉ được dùng để liên lạc bên trong lòng của tiến trình truyền thống(giữa các luồng của nó).
_Đèn hiệu có tên còn được gọi là đèn hiệu liên tiến trình.
_Đèn hiệu không tên còn được gọi là đèn hiệu nội tiến trình, nó sẽ bảo mật tốt hơn.
WaitForSingleObject(s, timeout): chờ cho đến khi đèn hiệu mà mục quản của nó lưu trong biến s có giá trị là khác 0 với thời gian không quá thời gian timeout.
Timeout: chờ đến khi đèn xanh nhưng không quá 5000ms.
Wait(s): chờ 1 đối tượng.
Signal(s): tăng giá trị của mục quản trong biến s lên 1.

ReleaseSemaphore(s, 1, NULL): nhả giá trị của đèn hiệu(tăng lên 1 nhưng không vượt quá max)

Thanks bạn nha, Giải thích rõ và chi tiết,

- Đèn hiệu có tên (hay còn được gọi là đèn hiệu liên tiến trình) dùng để liên lạc giữa các tiền trình nặng truyền thống.
- Đèn hiệu không tên (hay còn được gọi là đèn hiệu nội tiến trình) chỉ được dùng để liên lạc bên trong nội bộ tiền trình truyền thống (giữa các luồng của nó). Ưu đểm của đèn hiệu không tên này là nó thực hiện công việc nhanh và tính bảo mật của nó cũng tốt hơn.

HANDLE semEmpty,semFull;//hai đèn hiệu
semEmpty: dùng để chứa mục quản của đèn hiệu quản lý số khoang trống trong bộ đệm.
semFull: chứa mục quản của đèn hiệu dùng để quản lý số sản phẩm trong bộ đệm.
CRITICAL_SECTION critSec://biến kiểu mục quản
critSec: là biến chứa đối tượng đèn hiệu nhị phân dùng để bảo vệ đoạn tương tranh trong chương trình.

các hàm trong Producer và Consumer tương đương trong thư viện Win32 là:
wait(semEmpty) <=> WaitForSingleObject(semEmpty, INFINITE) //chờ đến khi có chỗ trống
wait(critSec) <=> EnterCriticalSection(&critSec) //thuộc đoạn đăng nhập vào đoạn tương tranh

// đưa sản phẩm vào buffer
{
buffer[in]=nextProduced++;
in=(in+1)%BUFFER_SIZE;

}
//lấy sản phẩm từ buffer
{
nextConsumed=buffer[out];
out=(out+1)%BUFFER_SIZE;
}

signal(critSec) <=> ReleaseSemaphore(semFull, 1, NULL) // tăng giá trị của đèn nằm trong mục quản semFull lên 1

signal(critSec) <=> LeaveCriticalSection(&critSec) //đăng xuất khỏi đoạn tương tranh

-Đèn hiệu có tên dùng để liên lạc giữa các tiền trình nặng truyền thống.
- Đèn hiệu không tên được dùng để liên lạc bên trong nội bộ của tiến trình truyền thống (giữa các luồng của nó).Ưu đểm của đèn hiệu không tên này là nó thực hiện công việc nhanh và tính bảo mật của nó cũng tốt hơn.
Bài toán Producer-Consumer dùng kỹ thuật Busy-Waiting trước đây có nhược điểm là làm cho máy tính bị chậm, tiêu tốn CPU.
Cải tiến bài toán này dùng kỹ thuật đèn hiệu có ưu điểm: chờ cho đến khi có chỗ trống, 1 khi chưa có chỗ trống thì phải chờ. Điều này làm cho không cần tiêu tốn CPU vô ích=> Máy tính sẽ nhanh hơn.
Đoạn code khai báo đèn hiệu
# Define BUFFER_SIZE 10 // Định nghĩa 1 biến BUFFER_SIZE với max =10
int buffer[BUFFER_SIZE];
char(BUFFER_SIZE);
int in=0;// Khai báo con trỏ in
int out=0;// Khai báo con trỏ out
int nextproduced=1;
HANDEL SemEmty,SemFull;// Khai báo hai đèn hiệu
CRITICAL_SECTION critsec;// Biến chứa đối tượng đèn hiệu nhị phân dùng để bảo vệ đoạn tương tranh trong chương trình.
item nextProduced;

while (1) { //lặp vô hạn để tạo 1 sản phẩm và đưa vào nextProduced
entry section
while (((in + 1) % BUFFER_SIZE) == out);
buffer[in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
exit section
}

item nextConsumed;
while (1) {


while (in == out);
entry section
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
// Tiêu thụ sản phảm trong nextConsumed
exit section
}

Đảm bảo tính nhất quán của tài nguyên dùng chung.
Tránh được hiện tượng Deadlock
ví dụ :
bạn a lên bản viết một lá đơn phần họ tên ghi là lê văn a và phần ký tên là lê văn b. lúc sau đó bạn b lên bảng sửa lại phần ký tên cho đúng là lê văn a . lúc đó phái dưới lớp có bạn c lấy máy ảnh chụp lại cái bảng đang lúc bạn b đang sửa lại phần ký tên mới gi là lê văn , dẫn đến nội dung sai lệch, không hoàn chỉnh và thiếu nhất quán. đáng lẽ bạn c phải chờ bạn b thực hiện song công việc là sửa phần ký tên là lê văn a song rồi mới chụp thì nội dung mới đúng.

Có 5 người ăn trên 1 bàn tròn
Mỗi người cần 2 chiếc đũa để ăn.
Trên bàn, chỉ có 5 chiếc đũa xếp xoay vòng và xen kẽ mỗi người.
Người nào có đủ 2 chiếc đũa sẽ sử dụng và ăn được.

Bài toán này thể hiện sự khó khăn việc phân phối tài nguyên giữa các process

Đồng bộ hóa tiến trình là điều khiển công việc của luồng và tiến trình sao cho logic và đáp ứng yêu cầu đặt ra.
Mục đích của đồng bộ hóa tiến trình.
- Đảm bảo tính nhất quán của tài nguyên dùng chung.
ví dụ: bài toán sản xuất tiêu thụ.
một bạn trong lớp lên bảng (tài nguyên dùng chung của lớp) ghi thông tin cá nhân nhưng chưa ghi xong thì bạn khác dưới lớp chụp lại thông tin trên sẽ không đúng. muốn lấy thông tin chính xác thì bạn dưới lớp cần lấy thông tin của bạn trên bảng ghi phải chờ bạn ấy ghi hết thông tin rồi mới chụp ảnh.
- Tránh Deadlock ( hiện tượng kẹt tiến trình).
ví dụ: hiện tượng kẹt xe khi có cảnh sát giao thông điều tiết phân luồng thì sẽ không còn kẹt xe .

- Ví dụ có n tiến trình { P0 , P1 ,....., Pn-1 }. Mỗi tiến trình có đoạn mã gọi là Đoạn tương tranh trong đó tiến trình có thể truy cập và thay đổi vùng nhớ, tập tin hay tài nguyên chung.
- Tính Loại trừ lẫn nhau hay Loại trừ tương hỗ (Mutual Exclusion) về phương diện thời gian: Khi có 1 tiến trình đang ở trong Đoạn tương tranh của nó thì không có tiến trình nào khác trong nhóm cũng tại đoạn như vậy, nghĩa là: Mỗi thời điểm chỉ có 1 tiến trình được phép truy cập hoặc thay đổi tài nguyên chung.
- Các tiến trình tương tranh có cấu trúc mã bao gồm Entry Section (Đoạn Đăng nhập), Critical Section (Đoạn Tương tranh), Exit Section (Đoạn Đăng xuất) và các Remainder Section (Đoạn Còn lại).

- Với tác nguyên Wait có vòng lặp vô tận kiểm tra biến đếm S có nhỏ hơn 0 hay không, điều đó làm cho các tiến trình có thể tự khoá mình (Block Itself) và chuyển sang trạng thái waiting, sau đó xếp vào hàng chờ của đèn hiệu. Trình điều phối CPU có thể chọn tiến trình khác trong hàng chờ Ready để thực hiện.

- Khi một tiến trình nào đó thực hiện lệnh Signal(S), một tiến trình P nào đó đang chờ tại S được lựa chọn và đánh thức bằng lệnh WakeUP(P) để chuyển P từ trang thái Waiting sang trạng thái Ready. Lúc này trình điều phối có thể cho P thực thi ngay hay không còn tuỳ thuộc vào giải thuật cụ thể.

HANDLE semEmpty, semFull; //hai đèn hiệu
CRITICAL_SECTION critSec;//Biến kiểu Mutex
void Producer(void * p)
{
while (1)
{
// ... Sản xuất (nextProduced)
// Chờ đến khi có chỗ trống
WaitForSingleObject(semEmpty, INFINITE);
EnterCriticalSection(&critSec);
//…Sắp sản phẩm vào Buffer
// Tăng (semFull) lên 1
ReleaseSemaphore(semFull, 1, NULL);
LeaveCriticalSection(&critSec);
SuspendThread(GetCurrentThread());
}
}
void Consumer()
{
int nextConsumed;
while (1)
{
// Chờ đến khi có sản phẩm
WaitForSingleObject(semFull, INFINITE);
EnterCriticalSection(&critSec);
nextConsumed=buffer[out];
out=(out+1)%BUFFER_SIZE;
// Tăng (semEmpty) lên 1
ReleaseSemaphore (semEmpty, 1, NULL);
LeaveCriticalSection(&critSec);
// ... Tiêu thụ (nextConsumed)
SuspendThread(GetCurrentThread());
}
}
- Biến semEmpty dùng để chứa mục quản của đèn hiệu quản lý số vùng trống trong bộ đệm.
- Biến semFull dùng để chứa mục quản của đèn hiệu quản lý số sản phẩm trong bộ đệm.
- CritSec là đối tượng đèn hiệu kiểu mutex dùng để bảo vệ đoạn tương tranh để đảm bảo tính loại trừ lẫn nhau trong công việc của các tiến trình với tài nguyên dùng chung.

Đoạn tương tranh là doạn mã cho tiến trình mà khi thực hiện nó truy cập, tác động và thay đổi được tài nguyên dùng chung.
Còn đoạn mã ko truy cập, tác động và thay đổi được tài nguyên dùng chung là đoạn còn lại
Tính Loại trừ lẫn nhau hay Loại trừ tương hỗ (Mutual Exclusion) về phương diện thời gian: Khi có 1 tiến trình đang ở trong đoạn tương tranh của nó thì không có tiến trình nào khác trong nhóm cũng tại đoạn như vậy, nghĩa là: Mỗi thời điểm chỉ có 1 tiến trình được phép truy cập và/hoặc thay đổi tài nguyên chung.
ví dụ: Trong 1 trường học chỉ có 1 phòng sử dụng máy chiếu. Ban giám hiệu sẽ là Hệ điều hành điều phối sắp xếp thời khóa biểu cho các lớp sử dụng máy chiếu. Nghĩa là trong 1 khung giờ chỉ có 1 lớp sử dụng may1 chiếu. Các lớp còn lại phải chờ tới lượt mới được sử dụng.

PhamThiThao (I22B) đã viết:

SeemFull : chứa mục quản của đèn hiệu , quản lí số sản phẩm ko bộ đệm

Ví dụ như trên : 1 lớp học có 100 chỗ ngồi, chỉ có 70 chỗ chứa đủ Sinh viên, 30 chỗ còn lại trống
Vậy : SemFull = 70

mình nge dc Thầy giảng dc như vậy thôi , có j sai sót, mong các bạn sửa và bổ sung nhé

HoBaoQuoc_I22B đã viết:

PhamThiThao (I22B) đã viết:tại sao vậy các bạn

Theo mình được biết:
semEmpty =10 là vì semEmpty dùng để chứa mục quản của đèn hiệu và quản lý vùng trống trong bộ đệm nên giá trị nó bằng 10
semFull=0 là vì dùng để chứa sản phẩm trong bộ đệm nên giá trị ban đầu nó sẽ bằng 0.

Mong các bạn và thầy góp ý thêm...

Mình cùng ý kiến

PhamThiThao (I22B) đã viết:các bạn giúp mình vs

SemEmpty : dùng để chứa mục quản của đèn hiệu , để quản lí số khoang trống trong bộ đệm

Ví dụ : 1 lớp học có 100 chỗ ngồi, chỉ có 70 chỗ chứa đủ Sinh viên, 30 chỗ còn lại trống
Vậy : SemEmpty = 30

Admin
- SemEmpty là biến kiểu HANDLE dùng chứa Mục quản của đèn hiệu !
- Cần phân biệt Mục quản với Giá trị của đèn hiệu có mục quản như vậy !

LeThanhQuang (I22B) đã viết:- Đèn hiệu có tên (hay còn được gọi là đèn hiệu liên tiến trình) dùng để liên lạc giữa các tiền trình nặng truyền thống.
- Đèn hiệu không tên (hay còn được gọi là đèn hiệu nội tiến trình) chỉ được dùng để liên lạc bên trong nội bộ tiền trình truyền thống (giữa các luồng của nó). Ưu đểm của đèn hiệu không tên này là nó thực hiện công việc nhanh và tính bảo mật của nó cũng tốt hơn.

Mình xin bổ sung về việc phân biệt đèn không tên và có tên khi đọc code.

s = CreateSemaphore(0, n, max, t) // Hàm tạo một đèn hiệu.
t: tên của đèn hiệu.
- Tạo một đèn hiệu không tên: gán t = 0 (còn được gọi là nặc danh)
- Tạo một đèn hiệu có tên: gán t = "chuỗi_ký_tự" // với chuỗi là tên của đèn

LETHIANHDAO48(I22B) đã viết:HANDLE semEmpty, semFull; //hai đèn hiệu
CRITICAL_SECTION critSec;//Biến kiểu Mutex
void Producer(void * p)
{
while (1)
{
// ... Sản xuất (nextProduced)
// Chờ đến khi có chỗ trống
WaitForSingleObject(semEmpty, INFINITE);
EnterCriticalSection(&critSec);
//…Sắp sản phẩm vào Buffer
// Tăng (semFull) lên 1
ReleaseSemaphore(semFull, 1, NULL);
LeaveCriticalSection(&critSec);
SuspendThread(GetCurrentThread());
}
}
void Consumer()
{
int nextConsumed;
while (1)
{
// Chờ đến khi có sản phẩm
WaitForSingleObject(semFull, INFINITE);
EnterCriticalSection(&critSec);
nextConsumed=buffer[out];
out=(out+1)%BUFFER_SIZE;
// Tăng (semEmpty) lên 1
ReleaseSemaphore (semEmpty, 1, NULL);
LeaveCriticalSection(&critSec);
// ... Tiêu thụ (nextConsumed)
SuspendThread(GetCurrentThread());
}
}
- Biến semEmpty dùng để chứa mục quản của đèn hiệu quản lý số vùng trống trong bộ đệm.
- Biến semFull dùng để chứa mục quản của đèn hiệu quản lý số sản phẩm trong bộ đệm.
- CritSec là đối tượng đèn hiệu kiểu mutex dùng để bảo vệ đoạn tương tranh để đảm bảo tính loại trừ lẫn nhau trong công việc của các tiến trình với tài nguyên dùng chung.

Bạn post code thì cần phải giải thích rõ hơn đây là ứng dụng cho 2 đèn hiệu hay 3 đèn hiệu để các member trong diễn đàn còn biết chứ...
(theo mình chắc đây là ứng dụng cho 3 đèn hiệu )

Giải thích đoạn code thực thi đèn hiệu trong windows: bài toán Producer-Consumer được đồng bộ bằng 2 đèn hiệu. Các bạn nào nghĩ học hôm t6 (1/4/2013) tham khảo nha

Lưu ý: tất cả được khai báo theo kiểu C++
typedef int semaphore;
semaphore s = n;
wait (s);
signal (s);

Giải thích
typedef int semaphore; //tạo 1 kiểu dữ liệu semaphore (kiểu đèn hiệu, kiểu số nguyên)
semaphore s = n; //tạo 1 biến s kiểu semaphore và gán dữ liệu đầu tiên cho nó lúc khởi tạo là n (đã cho trước)
wait (s);
// đây chính là đoạn:
wait (semaphore s)
{ // s là kiểu semaphore ( đây là đèn hiệu)
while ( S <= 0 ); //chờ bận nếu s<=0
S --; //Giảm s đi 1, khi bắt đầu thực hiện thì giảm màu đèn
}
signal (s);
// đây chính là đoạn
signal (semaphore S)
{ // tham số s là kiểu semaphore
S ++; // Tăng s lên 1, cũng như là đổi màu đèn hiệu khi thực hiện xong
}
--------------------------------------------------------
HANDLE s;
s=CreateSemaphore (0, n, max, t);
WaitForSingleObject (s, timeout);
ReleaseSemaphore (s, 1, NULL);

Giải thích:
HANDLE s; //tạo 1 biến s (xem như là semaphore) kiểu HANDLE là mục quản được định nghĩa sẵn
s=CreateSemaphore (0, n, max, t);
//gán giá trị khởi tạo cho biến s (kiểu HANDLE) bằng hàm CreateSemaphore() với 4 tham số
0: không cần quan tâm tham số này.
n: tham số truyền vào giá trị khởi tạo đầu tiên cho đèn hiệu
max: tham số max (giá trị tối đa được phép có của đèn hiệu)
t: tham số tên đèn hiệu (chuỗi ký tự nào đó hoặc là 0) [Nếu đặt nó là chuỗi ký tự thì s là Liên tiến trình,
Nếu đặt nó là 0 thì nó là Nội tiến trình].
WaitForSingleObject (s, timeout);
// s là tên đèn truyền vào, timeout là thông số chờ với thời gian timeout (tính theo mili giây). Nều hết thời gian timeout mà đèn hiệu không bật thì vẫn thực thi đoạn code.
/* timeout = INFINITE (vô hạn) hoặc số mili giây chờ */

ReleaseSemaphore (s, 1, NULL);
- Tham số 1 :truyền vào biến cụ thể kiểu HANDLE (ví dụ: s ) như là đèn hiệu cần tăng màu lên.
- Tham số 2:thông số số màu đèn hiệu cần tăng lên ( 1, hay 2,3...)
- Tham số 3: có thể là một biến nguyên x nào đó dùng để nhận giá trị của đèn hiệu trước khi tăng.


Mong các bạn góp ý thêm

Ở đoạn code:
s=CreateSemaphore (0, n, max, t), ngay chỗ tham số t có 1 vấn đề:
vậy taị sao có đèn hiệu liên tiến trình mà dùng thêm đèn hiệu nội tiến trình ?
- Liên tiến trình: dùng để liên lạc giữa các tiền trình nặng truyền thống với nhau
---> nếu t được gán = 1 chuỗi ký tự nào đó thì được dùng bên trong của 1 lớp
- Nội tiến trình: chỉ được dùng để liên lạc bên trong nội bộ tiền trình truyền thống.Ưu đểm: nó thực hiện công việc nhanh và tính bảo mật của nó cũng tốt hơn
----> nếu t=0 đèn hiệu không tên (nặc danh) tăng tốc công việc + bảo mật

Mời các bạn góp ý hơn

Mình có thắc mắc ở đoạn code sau:
s=CreateSemaphore (0, n, max, t), ngay chỗ tham số t có 1 vấn đề:
- giá trị chỗ tham số t luôn là 1 chuỗi ký tự hoặc là 0, nếu gán giá trị vào tham số t là 1 giá trị là 1 số nào đó sẽ như thế nào?
mong thầy và các bạn góp ý thêm

- Mục đích của đồng bộ hóa công việc các tiến trình là đảm bảo Tính nhất quán của tài nguyên chung và Tránh được hiện tượng Deadlock( Hiện tượng kẹt tiến trình )
+ Đảm bảo tính nhất quán của tài nguyên dùng chung.
+ Tránh được hiện tượng Deadlock (Hiện tượng kẹt tiến trình) .

Ví dụ: Hệ thống tín hiệu đèn giao thông giữa các giao lộ. Khi làn đuờng có đèn đỏ thì tất cả các phuơng tiện đang lưu thông trên làn đường đó phải dừng lại để nhuờng đường cho các phuơng tiện ở làn đường kia lưu thông.Mục đích nhằm đảm bảo trật tự và tránh tình trạng kẹt xe.

TruongTranThanhTu(I22B) đã viết:Mình có thắc mắc ở đoạn code sau:
s=CreateSemaphore (0, n, max, t), ngay chỗ tham số t có 1 vấn đề:
- giá trị chỗ tham số t luôn là 1 chuỗi ký tự hoặc là 0, nếu gán giá trị vào tham số t là 1 giá trị là 1 số nào đó sẽ như thế nào?
mong thầy và các bạn góp ý thêm

mình có câu nói này:"không nên quan trọng hóa vấn đề", bạn cứ suy nghĩ cách đơn giản là được rồi. nếu bạn muốn có thể chạy code thử..., sau đó sẽ ra kết quả như yêu cầu ban thôi. Nên tập trung cho những phần chính trong bài, mấy cái "rau ria" đó khi nào có time bạn quay lại khám phá sau cũng được

Trong bài toán sản xuất có 3 đèn hiệu (2 đèn chính và 1 đèn phụ):

semEmpty : dùng để chứa mục quản của đèn hiệu quản lý số khoan trống trong bộ điệm
semFull : dùng để chứa mục quản của đèn hiệu quản lý số sản phẩm trống trong bộ điệm
critSec : chứa đối tượng của đèn hiệu như phần dùng để bảo vệ đoạn tương tranh trong chưa trình.

VD: Chú bảo vệ (semEmpty) sẽ quản lý số chổ ngồi (số khoan trống) trong lớp học. Lớp trưởng (semFull) sẽ quản lý số sinh viên (sản phẩm).
Thầy (critSec) sẽ cho duy nhất một sinh viên lên bảng giải bài tập.
Các bạn góp ý giúp mình.

HANDLE semEmpty, semFull;
CRITICAL_SECTION critSec;
void Producer(void * p)
{
while (1)
{
// ... Sản xuất (nextProduced)
// Chờ đến khi có chỗ trống
WaitForSingleObject(semEmpty, INFINITE);
EnterCriticalSection(&critSec);
//…Sắp sản phẩm vào Buffer
// Tăng (semFull) lên 1
ReleaseSemaphore(semFull, 1, NULL);
LeaveCriticalSection(&critSec);
SuspendThread(GetCurrentThread());
}
}
void Consumer()
{
int nextConsumed;
while (1)
{
// Chờ đến khi có sản phẩm
WaitForSingleObject(semFull, INFINITE);
EnterCriticalSection(&critSec);
nextConsumed=buffer[out];
out=(out+1)%BUFFER_SIZE;
// Tăng (semEmpty) lên 1
ReleaseSemaphore (semEmpty, 1, NULL);
LeaveCriticalSection(&critSec);
// ... Tiêu thụ (nextConsumed)
SuspendThread(GetCurrentThread());
}
}