Thảo luận Bài 5

NguyenHoangThangI12A đã viết:Câu 2: Trình bày nguyên lý tập nguồn và cho ví dụ minh họa
Tập luồng (Thread Pools):
• Tiến trình cha tạo lập sẵn một tập luồng khi khởi động.
• Các luồng trong tập luồng luôn sẵn sàng chờ công việc.
• Khi tiến trình cha (ví dụ Web Server) nhận thêm một yêu cầu, một luồng được đánh thức và đưa vào vận hành.
• Phục vụ xong, luồng được đưa trả về tập luồng.
• Nếu số yêu cầu lớn hơn số luồng trong tập, tiến trình cha chờ đến khi có luồng được giải phóng.
Ví dụ:
Trong một doanh trai quân đội sẽ có một tướng lĩnh (tiến trình cha) và sẽ có một đội binh (tập luồng).
Đội binh này sẽ sẵn sàng chiến đầu khi có mệnh lệnh (sẵn sàng chờ công việc).
Khi có một tên địch đột nhập, Tướng lĩnh sẽ điều binh sĩ 1 (một luồng) đi bắt tên địch (một luồng được đánh thức và đưa vào vận hành).
Trong khi đó, lại có thêm một tên địch khác đột nhập (nhận thêm một yêu cầu), Tướng lĩnh sẽ điều binh sĩ 2 (một luồng) đi bắt địch (một luồng khác được đánh thức và đưa vào vận hành).
Sau khi bắt địch xong, binh sĩ sẽ trở về doanh trại (luồng được trả về tập luồng)

Code:

#include<windows.h>
#include<stdio.h>
#include<conio.h>
#define BUFFER_SIZE 10;
int buffer[BUFFER_SIZE];
int in;
int out;
int nextproduced=1;
void Producer()
{
   while(1)//vòng lặp bất tận
   {
      while(((in+1)% BUFFER_SIZE)==out);
      buffer[in]=nextproduced ++;//khi gán xong sẽ tăng lên 1
      in=(in+1)% BUFFER_SIZE;
      SuspendThread(GetcurrenThread());//luồng trạng thái hiện hành được chuyển sang trạng thái ngủ cho đến khi được đánh thức
      //GetcurrenThread()-> trả về mục quản của luồng hiện hành
      
   }
}
void Consumed()
{
   int nextconsumed;
   while(1)
   {
      while(in==out);
      nextconsumed = buffer[out];
      out=(out+1)% BUFFER_SIZE;
      Sleep(GetTickCount()% 5000);//ngủ 1 khoảng thời gian cho trước
      //GetTickCount() -> nhận số mili giây trôi qua kể từ khi hệ điều hành khởi động cho đến thời điểm gọi hàm này

   }
}


hoanggiangI12C đã viết:Thầy hỏi tai sao nên dùng code chung và dùng có chung có ưu điểm gì: .Có bạn trả lời rằng là dễ quản lý.Thầy nói đúng nhưng chưa chính xác lắm.và thầy nói nếu có sữa code thì thầy chỉ sửa 1 lần .Nếu sữa code riêng lẽ thì phải sữa rất nhiều. Còn theo em thì sử dụng 1 code chung sẽ dễ đồng bộ và dễ quản lý hơn. Tuy nhiên ở thực tế ta nên dùng 2-3 code chung để giả sử có bị virus hay bị 1 ai đó thay đổi code thì vẫn còn các code khác để sử dụng.

Code:


#include <stdio.h>
#include <conio.h>
#include <windows.h>

#define BUFFER_SIZE  10  // số khoang chứa bộ đệm

int buffer[BUFFER_SIZE]; //  mảng số nguyên gồm buffer_size phần tử
int in=0;         // trỏ đến vị trí trống kế tiếp
int out=0;         // trỏ đến vị trí sản phẩm

int nextProduced=1;      //khi sản phẩm được sản xuất thì nextProduced tăng 1

void Producer(){
   while (1){      //  vòng lặp bất tận
      // ... Sản xuất (nextProduced)

      while(((in+1)%BUFFER_SIZE)==out); //  khi sản phẩm được sản xuất
      buffer[in]=nextProduced++;   // gán sản phẩm vào  mảng buffer và tăng nextProduced thêm 1
      in=(in+1)%BUFFER_SIZE;      // xoay vòng khi mảng buffer đầy
      SuspendThread(GetCurrentThread());   //luồng sản xuất hiện hành được chuyển sang trạng thái ngủ cho đến khi gọi lại sản xuất (GetCurrentThread( ) : trả về mục quản của luồng hiện hành)
   }
}

void Consumer(){
   int nextConsumed; 
   while (1){
      while(in==out);   //chờ bận
      nextConsumed=buffer[out];
      out=(out+1)%BUFFER_SIZE; // xoay vòng khi buffer đầy
      // ... Tiêu thụ (nextConsumed)
      Sleep(GetTickCount()%5000); // nghỉ 1 khoảng thời gian cho trước là 5s
      /* GetTickCount( ) : nhận số milli giây trôi qua từ khi HĐH khởi động cho đến khi gọi hàm này*/
   }
}

void ShowBuffer()
{   
// In nội dung Buffer   
}

int main(){
   HANDLE ProducerHandle1, ProducerHandle2;  // chứa mục quản luồng sản xuất ProducerHandle1, ProducerHandle2
   HANDLE ConsumerHandle1, ConsumerHandle2;  // chứa mục quản luồng tiêu thụ ConsumerHandle1, ConsumerHandle2
DWORD ProducerID1, ProducerID2;   //cấp ID (Identification number) cho sản phẩm mới được tạo
DWORD ConsumerID1, ConsumerID2;

   // Tạo 2 luồng sản xuất trong trạng thái ngủ
   ProducerHandle1=CreateThread(0,0, (LPTHREAD_START_ROUTINE)Producer, 0, 4, &ProducerID1);

   ProducerHandle2=CreateThread(0,0, (LPTHREAD_START_ROUTINE)Producer, 0, 4, &ProducerID2);

// Producer  tên hàm điều khiển của nhà sản xuất. 4 sau khi khởi tạo luồng sẽ ngủ

// Tạo 2 luồng tiêu thụ thi hành ngay
        ConsumerHandle1=CreateThread(0,0, (LPTHREAD_START_ROUTINE)Consumer,0, 0, &ConsumerID1);

   ConsumerHandle2=CreateThread(0,0, (LPTHREAD_START_ROUTINE)Consumer,0, 0, &ConsumerID2);

 // Consumer  tên hàm điều khiển của nhà tiêu thụ. 0 sau khi khởi tạo luồng sẽ chạy ngay

   while(1){
      printf("\n- Nhấn P/p để sản xuất, 0 để kết thúc:”);
      switch (getch()){
         case 'P':
            ResumeThread(ProducerHandle1); // đánh thức luồng 1
            break;
         case 'p':
            ResumeThread(ProducerHandle2); // đánh thức luồng 2
            break;
         case '0':
            CloseHandle(ProducerHandle1); // đóng luồng nhà sản xuất 1
            CloseHandle(ProducerHandle2);
            CloseHandle(ConsumerHandle1); // đóng luồng nhà tiêu thụ 1
            CloseHandle(ConsumerHandle2);
            return 0;
      }
      Sleep(1);   // luồng chính ngủ 1 milli giây trước khi xuất kết quả ra màn hình
      ShowBuffer(); //xuất kết quả
   }
}



• CPU đơn nhân, đơn luồng: giống như việc chỉ có một cửa vào, và trong
  đó có một bác sĩ chỉ khám lần lượt từng người với điều kiện mỗi người
  hết 10 phút, trong đó ưu tiên khám hết nữ giới sau đó mới đến lượt nam
  giới - thời gian khám hết nhóm người đó sẽ rất lâu và nam giới phải chờ
  lâu hơn mặc dù đến sớm.
  
• CPU đơn nhân, đa luồng: giống như việc có một cửa, mỗi người khám 10
  phút, khám xen kẽ cả nam giới và nữ giới. Giải quyết được việc người
  nào đến trước thì xong trước.
  
• CPU đơn nhân, đa luồng, có công nghệ phân luồng ảo: Giống như có một
  cửa, ai khám xong trước thì ra trước (có thể dưới 10 phút), có hai bác
  sĩ phụ nhau chia theo từng công đoạn lúc này thời gian nhanh hơn nhiều
  cho việc khám tất cả nhóm người.
  
• CPU đa nhân: Giống như phòng khám có hai cửa, trong đó có hai nhóm
  bác sĩ độc lập và đồng thời có thể khám hai người một thời điểm.
  
• CPU có lượng cache L2 lớn hoặc có thêm cache L3: Tương đương với
  phòng chờ ở ngay cửa của phòng khám (người được yêu cầu vào khám đi vào
  nhanh hơn).
  

NguyenVanBenI12C đã viết:

Code:

#include<windows.h>
#include<stdio.h>
#include<conio.h>
#define BUFFER_SIZE 10;
int buffer[BUFFER_SIZE];
int in;
int out;
int nextproduced=1;
void Producer()
{
   while(1)//vòng lặp bất tận
   {
      while(((in+1)% BUFFER_SIZE)==out);
      buffer[in]=nextproduced ++;//khi gán xong sẽ tăng lên 1
      in=(in+1)% BUFFER_SIZE;
      SuspendThread(GetcurrenThread());//luồng trạng thái hiện hành được chuyển sang trạng thái ngủ cho đến khi được đánh thức
      //GetcurrenThread()-> trả về mục quản của luồng hiện hành
      
   }
}
void Consumed()
{
   int nextconsumed;
   while(1)
   {
      while(in==out);
      nextconsumed = buffer[out];
      out=(out+1)% BUFFER_SIZE;
      Sleep(GetTickCount()% 5000);//ngủ 1 khoảng thời gian cho trước
      //GetTickCount() -> nhận số mili giây trôi qua kể từ khi hệ điều hành khởi động cho đến thời điểm gọi hàm này

   }
}


Các bạn bổ xung tiếp nha!

Code:

#include<windows.h>
#include<stdio.h>
#include<conio.h>
#define BUFFER_SIZE 10;
int buffer[BUFFER_SIZE];
int in;
int out;
int nextproduced=1;
//nha san xuat
void Producer()
{
   while(1)//vòng lặp bất tận
   {
      while(((in+1)% BUFFER_SIZE)==out); //Busy Waiting vòng lặp quẩn tại đây cho đến khi
                                                        có 1 chỗ trống trong bộ đệm hay ngăn chứa sản phẩm
                //khi vòng lặp while kết thúc --> có 1 chỗ trống để chèn sản phẩm vô
      buffer[in]=nextproduced ++;  //chèn sản phẩm vô ngăn chứa
      in=(in+1)% BUFFER_SIZE;  //tìm vị trí khác để Producer chèn thêm sản phầm vào
      SuspendThread(GetcurrenThread()); //luồng trạng thái hiện hành được chuyển sang trạng thái ngủ cho đến khi được đánh thức
      //GetcurrenThread()-> trả về mục quản của luồng hiện hành
   }
}

//nha tieu thu
void Consumed()
{
   int nextconsumed;
   while(1)
   {
      while(in==out);  //vòng lặp quẩn tại đây khi các ngăn chứa sản phầm đều trống
                //vòng lặp while thoát khi có 1 ngăn chứa sản phầm
      nextconsumed = buffer[out]; //lấy sản phẩm ra khỏi ngăn
      out=(out+1)% BUFFER_SIZE;  //tìm vị trí khác để Consumer lấy sản phẩm
      Sleep(GetTickCount()% 5000);
                //Sleep()  ngủ 1 khoảng thời gian cho trước
      //GetTickCount() -> nhận số mili giây trôi qua kể từ khi hệ điều hành khởi động
                    cho đến thời điểm gọi hàm này
   }
}
//ham MAIN
int main()
{
        HANDLE ProducerHandle1; //biến Handle chứa mục quản NSX
        HANDLE ConsumerHandle1; // biến Handle chứa mục quản NTT

        DWORD ProducerID1, ProducerID2; //chứa ID NSX
        DWORD ConsumerID1, ConsumerID2; //chứa ID NTT
        ProducerHandle1=CreateThread(0,0,(LPTHREAD_START_ROUTINE)Producer,0,4,
                                                                                                      &ProducerID1);
        //khởi tạo NSX với các thông tin: Producer, ID, số 4 biểu thị trạng thái của Producer lúc khởi tạo:trạng thái ngủ

        ConsumerHandle1=CreateThread(0,0,(LPTHREAD_START_ROUTINE)Consumer,0,0,
                                                                                                      &ConsumerID1);
        //khởi tạo NTT với các thông tin: Consumer, ID, số 0 biểu thị trạng thái của Producer lúc khởi tạo: trạng thái thức
        while(1)
        {
                printf("\n- Nhan phim P/p de san xuat, nhan 0 de ket thuc:");
                switch (getch())
                {
                      case 'P': //nhấn phím P=Producing
                                ResumeThread(ProducerHandle1);
                                // đánh thức Producer lúc này đang ở trạng thái ngủ
                                break;
                      case 'p':
                                ResumeThread(ProducerHandle2); // tương tự như trên
                                break;
                      case '0': //giải phóng Producer và Consumer khỏi bộ nhớ
                                CloseHandle(ProducerHandle1);
                                CloseHandle(ConsumerHandle1);
                                return 0;
                }
                Sleep(1); //ngừng 1 khoảng thời gian nhất định
                ShowBuffer(); //show kết quả sau khi sản xuất tiêu thụ
        }
}


• Windows sử dụng các hàm trong thư viện Win32 API.

• Ứng dụng Windows vận hành như một tiến trình với 1 hoặc nhiều luồng.

• Bài toán Sản xuất - Tiêu thụ có thể được thực thi bằng Ứng dụng đa luồng (Visual C++ 6.0).

• Nhận độ ưu tiên của luồng bằng hàm: “int GotThroadPriority (HANDLE throadHandle)".

• Thay đổi độ ưu tiên của luồng bằng hàm: “BOOLSetThroadPriority (HANDLE threadHandle, int priority)”.

HoNgocTuan142(I12A) đã viết:

NguyenVanBenI12C đã viết:

Code:

#include<windows.h>
#include<stdio.h>
#include<conio.h>
#define BUFFER_SIZE 10;
int buffer[BUFFER_SIZE];
int in;
int out;
int nextproduced=1;
void Producer()
{
   while(1)//vòng lặp bất tận
   {
      while(((in+1)% BUFFER_SIZE)==out);
      buffer[in]=nextproduced ++;//khi gán xong sẽ tăng lên 1
      in=(in+1)% BUFFER_SIZE;
      SuspendThread(GetcurrenThread());//luồng hiện hành được chuyển sang trạng thái ngủ cho đến khi được đánh thức
      //GetcurrenThread()-> trả về mục quản của luồng hiện hành
      
   }
}
void Consumed()
{
   int nextconsumed;
   while(1)
   {
      while(in==out);
      nextconsumed = buffer[out];
      out=(out+1)% BUFFER_SIZE;
      Sleep(GetTickCount()% 5000);//ngủ 1 khoảng thời gian cho trước
      //GetTickCount() -> nhận số milli giây trôi qua kể từ khi hệ điều hành khởi động cho đến thời điểm gọi hàm này

   }
}


Các bạn bổ xung tiếp nha!

mình bổ sung và chỉnh sửa lại một tí

Code:

#include<windows.h>
#include<stdio.h>
#include<conio.h>
#define BUFFER_SIZE 10;
int buffer[BUFFER_SIZE];
int in;
int out;
int nextproduced=1;
//nha san xuat
void Producer()
{
   while(1)//vòng lặp bất tận
   {
      while(((in+1)% BUFFER_SIZE)==out); //Busy-Waiting vòng lặp chờ bận quẩn tại đây cho đến khi có 1 chỗ trống trong bộ đệm hay ngăn chứa sản phẩm
                //khi vòng lặp while kết thúc --> có 1 chỗ trống để chèn sản phẩm vô
      buffer[in]=nextproduced ++;  //chèn sản phẩm vô ngăn chứa
      in=(in+1)% BUFFER_SIZE;  //tìm vị trí khác để Producer chèn thêm sản phầm vào
      SuspendThread(GetcurrenThread()); //luồng hiện hành được chuyển sang trạng thái ngủ cho đến khi được đánh thức
      //GetcurrenThread()-> trả về mục quản của luồng hiện hành
   }
}

//nha tieu thu
void Consumed()
{
   int nextconsumed;
   while(1)
   {
      while(in==out);  //vòng lặp Busy-Waiting quẩn tại đây khi các ngăn chứa sản phầm đều trống
                //vòng lặp while thoát khi có 1 ngăn chứa sản phầm
      nextconsumed = buffer[out]; //lấy sản phẩm ra khỏi ngăn
      out=(out+1)% BUFFER_SIZE;  //tìm vị trí khác để Consumer lấy sản phẩm
      Sleep(GetTickCount()% 5000);
                //Sleep()  ngủ 1 khoảng thời gian cho trước
      //GetTickCount() -> nhận số milli giây trôi qua kể từ khi hệ điều hành khởi động
                    cho đến thời điểm gọi hàm này
   }
}
//ham MAIN
int main()
{
        HANDLE ProducerHandle1; //biến Handle chứa mục quản NSX
        HANDLE ConsumerHandle1; // biến Handle chứa mục quản NTT

        DWORD ProducerID1; //chứa ID NSX
        DWORD ConsumerID1; //chứa ID NTT
        ProducerHandle1=CreateThread(0,0,(LPTHREAD_START_ROUTINE)Producer,0,4,
                                                                                                      &ProducerID1);
        //khởi tạo NSX với các thông tin: Producer, ID, số 4 biểu thị trạng thái của Producer lúc khởi tạo:trạng thái ngủ

        ConsumerHandle1=CreateThread(0,0,(LPTHREAD_START_ROUTINE)Consumer,0,0,
                                                                                                      &ConsumerID1);
        //khởi tạo NTT với các thông tin: Consumer, ID, số 0 biểu thị trạng thái của Producer lúc khởi tạo: trạng thái thức
        while(1)
        {
                printf("\n- Nhan phim P/p de san xuat, nhan 0 de ket thuc:");
                switch (getch())
                {
                      case 'P': //nhấn phím P=Producing
                                ResumeThread(ProducerHandle1);
                                // đánh thức Producer lúc này đang ở trạng thái ngủ
                                break;
                      case 'p':
                                ResumeThread(ProducerHandle2); // tương tự như trên
                                break;
                      case '0': //giải phóng Producer và Consumer khỏi bộ nhớ
                                CloseHandle(ProducerHandle1);
                                CloseHandle(ConsumerHandle1);
                                return 0;
                }
                Sleep(1); //ngừng 1 khoảng thời gian nhất định trước khi ShowBuffer
                ShowBuffer(); //show kết quả sau khi sản xuất tiêu thụ
        }
}


còn hàm ShowBuffer() mình sẽ bổ sung sau

ví dụ: