Thảo luận Bài 5

1. Sơ qua về luồng (Thread)

Bài viết này mình sẽ hướng dẫn cho các bạn mới tìm hiểu về đa luồng và ứng dụng của nó và được mô tả trên ngôn ngữ C# cho dễ hiểu. Trước tìm hiểu nó cũng vất vả vì nó khó hiểu giờ muốn giúp chút xíu gì đó cho các bạn (Bạn sẽ cảm thấy vô cùng đơn giản nếu làm việc nhiều với nó, đó chỉ là do kỹ năng của mình yếu lên cảm thấy phức tạp)
Một luồng là một chuỗi liên tiếp những sự thực thi (mã lệnh hay câu lệnh) trong chương trình (ứng dụng). Trong một chương trình C#, dễ thấy việc thực thi được bắt đầu bằng phương thức main() và tiếp tục cho đến khi kết thúc hàm main(). Cấu trúc này rất hay cho những chương trình có một chuỗi xác định những nhiệm vụ liên tiếp, nhưng thường thì trong một chương trình ứng có nhiều hơn một công việc vào cùng một lúc. Một ví dụ rất hay và khá thực tế mà mình thấy trên diễn đàn tin học của "can_qua", các bạn cùng tham khảo

Vấn đề quan trọng là bạn phải tìm ra một cách nào đó để chia một công việc lớn thành những công việc nhỏ mà trong đó có những việc có thể thực hiện một cách đồng thời. Ví dụ, mẹ giao việc cho con là "làm việc xong mới được đi coi xi-nê". "Công việc lớn" này có thể gồm 3 việc nhỏ "quét nhà", "rửa chén", và đi coi "xi-nê". Trong đó chỉ được "coi xi-nê" sau khi làm xong hai việc kia. Rõ ràng là bạn muốn làm xong việc nhà càng sớm càng tốt để vi vút, nên bạn kêu thằng em bạn quét nhà, bạn thì rửa chén, cả hai người cùng làm đồng thời. Rửa chén xong trước, bạn phải đợi thằng em bạn thông báo là quét nhà cũng xong thì bạn mới vù đi coi xi-nê được. Như vậy multithread cho "rửa chén" và "quét nhà" làm tăng hiệu suất thực hiện công việc của bạn (so với việc bạn làm tuần tự rửa chén, quét nhà, coi xi-nê).

2. Ví dụ nhỏ về đa luồng
Ví dụ này mình sẽ mô tả 2 luồng (cho đơn giản) được thực thi cùng một lúc.
Ở đây thì bạn cứ tưởng tượng ra rằng có hai thằng tên là A và B thi đếm từ 0 cho đến 100, thằng nào đếm xong trước thì báo cáo và được về chỗ. Tương ứng mình sẽ tạo ra 2 phương thức A() và B() (mỗi luồng sẽ xử lý một thằng).

Code:

void A()
      {
            for(int i=0; i<=100; i++)
            {
                Console.WriteLine(i.ToString());
            }
            Console.WriteLine("A đã đọc xong");  // Báo cáo đã đọc xong
      }

      void B()
      {
            for(int i=0; i<=100; i++)
            {
                Console.WriteLine(i.ToString());
            }
            Console.WriteLine("B đã đọc xong");  // Báo cáo đã đọc xong
      }

Bây giờ thầy giáo (hoặc là bạn) bỗng cao hứng gọi 2 thằng lên thi đọc --> 2 thằng A và B cùng đọc Đến đây trong phương thức hàm main() của chương trình bạn sẽ phải gọi 2 thằng này

Code:

static void main()
  {
  ThreadStart ts1 = new ThreadStart(A); // Chỉ định thằng A lên đọc
  ThreadStart ts2 = new ThreadStart(B); // Chỉ định thằng B lên đọc
 
  // Sẵn sàng cho cuộc đấu (thi đếm nhanh :D)
  Thread tA = new Thread(ts1);
  Thread tB = new Thread(ts2);
 
  // Bắt đầu bấm giờ
  tA.Start();
  tB.Start();
  tA.Join();
  tB.Join();
  // Hai thằng tranh nhau đếm
  Console.WriteLine("Cuộc thi kết thúc"); // Chờ đến khi 2 thằng đọc xong, không biết thằng nào sẽ thắng :D
  Console.ReadLine();
  }

// Thư viện tham chiếu nằm trong namespace System.Threading;
// Bạn cần khai báo sử dụng nó using Sytem.Threading;

Truyền tham số cho Thread
Có nhiều cách truyền tham số, tuỳ theo nhu cầu mà dùng sao cho phù hợp
Thông qua phương thức Start(object) thì bạn có thể truyền tham số theo cách này.
Ví dụ:

Code:

    using System;
      using System.Threading;
      class ThreadSample
      {
        public static void Main()
        {
        Thread newThread = new Thread(ThreadSample.DoWork);
        newThread.Start(100); // Dữ liệu truyền vào là một số nguyên
     
        // Để Start luồng sử dụng phương thức thể hiện (instance method)
        // thì trước tiên ta cần khởi tạo nó trước khi gọi
     
        ThreadSample worker = new ThreadSample();
        newThread = new Thread(worker.DoMoreWork);
        newThread.Start("Truyền đối tượng cho thread thực thi");
     
        // Nếu biết trước được đối tượng truyền vào thì ta cần ghép kiểu cho nó
        // để việc sử dụng được hiệu quả hơn
        }
     
        public static void DoWork(object data)
        {
        Console.WriteLine("Ðây là luồng tĩnh.");
        Console.WriteLine("Dữ liệu truyền vào: Data = {0}", data);
        }
     
        public void DoMoreWork(object data)
        {
        Console.WriteLine("Đây là luồng cần được khởi tạo");
        Console.WriteLine("Dữ liệu truyền vào là: Data = {0}", data);
        }

      }


Đôi khi ta cũng sử dụng ThreadPool cho việc khởi chạy một luồng mới với tham số là _Param

Code:

 ThreadPool.QueueUserWorkItem(new WaitCallback(_ThreadProc), _Param);

Bạn hãy tham khảo về nó tại đây: http://dotnetperls.com/threadpool

Chờ đợi một luồng khác
Bằng việc sử dụng phương thức Join(); ta có thể cho phép chờ đợi một luồng khác thực hiện xong (để thu thập dữ liệu chẳng hạn - do chia nhỏ công việc mà), thì luồng đã gọi nó mới tiếp tục được công việc của nó

Code:


        static void Main(string[] args)
        {
            Console.WriteLine("Main thread: Gọi luồng thứ 2 ThreadProc()...");

            Thread t = new Thread(new ThreadStart(ThreadProc));
            t.Start();

            for (int i = 0; i < 50; i++)
            {
                Console.WriteLine("Main thread: Do Some Work.");
                Thread.Sleep(0);
            }

            Console.WriteLine("Main thread finished: And call t.Join()");
            Console.WriteLine("Main thread tạm thời đang được dừng lại");
            t.Join(); // Dừng tại đây

            // Sau khi ThreadProc hoàn tất Main thread tiếp tục công việc của nó
            // Tiếp tục thực thi 3 dòng lệnh tiếp theo
            Console.WriteLine("Thread.Join() has returned.");
            Console.WriteLine("Main đã làm xong việc");
            Console.ReadLine();
        }

        public static void ThreadProc()
        {
            for (int i = 0; i < 100; i++)
            {
                Console.WriteLine("ThreadProc: {0}", i);
                Thread.Sleep(0);
            }
        }

Đối số cho Join() có thể là int hoặc TimeSpan, khoảng thời gian giới hạn mà Main thread có thể chờ được, ví dụ

Code:

t.Join(10000);

nghĩa là, sau 10s mà ThreadProc chưa làm xong việc của nó thì Main thread không chờ nữa, tiếp tục công việc khác

- Luồng: là tiến trình nhẹ ( LWP - Light Weight Process), một đơn vị cơ bản sử dụng CPU.
- Tiến trình: là 1 tập hợp các luồng.
- Lợi ích của đa luồng:
+ Khả năng đáp ứng tốt hơn trong khi một luồng bị ách hay quá bận, luồng khác vẫn hoạt động bình thường.
+ Chia sẻ tài nguyên : theo mặc định các luồng có thể dùng chung tài nguyên và bộ nhớ của luồng cha.
+ Tiết kiệm: cấp phát bộ nhớ và tài nguyên cho tiến trình là công việc tốn kém. Do luồng dùng chung tài nguyên với cha và các luồng khác, việc tạo lập và chuyển ngữ cảnh nhanh hơn.
+ Tận dụng được thế mạnh của kiến trúc đa xử lý: đa luồng làm tăng tính song song trên hệ máy nhiều CPU. Mỗi luồng có thể chạy bởi CPU riêng.
+ Lập trình đa luồng dễ dàng hơn lập trình đa tiến trình: tạo mới luồng dễ, gửi nhận thông điệp giữa các luồng dễ hơn.

- Tiến trình truyền thống là tiến trình nặng vì: khi tạo tiến trình mới sẽ phức tạp, khó khăn hơn..
- Luồng là tiến trình nhẹ vì: khi tạo luồng sẽ dễ dàng và nhanh hơn..
ví dụ: trong một lớp học A có 50 sinh viên, có thêm 10 sinh viên đăng kí vào học. Thay vì mở thêm lớp học mới, ta nên đưa 10 bạn đó vào danh sách lớp học A sẽ tiết kiệm được khoảng chi phí mở lớp học mới.

#include -->khai báo
#include
#include
#define BUFFER_SIZE 10
int buffer[BUFFER_SIZE];
int in=0;
int out=0;
int nextProduced=1;
void Producer(){
while (1){
// ... (nextProduced) quá trình tạo ra 1 sản phẩm
while(((in+1)%BUFFER_SIZE)==out); ---> 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(GetCurrentThread());lấy luồng hiện hành, SuspendThread hàm API dùng để tạo ngưng 1 luồng.
}
}
void Consumer(){
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 nếu out đang nằm ở cuối mảng thì out sẽ trở về đầu mảng
// ... (nextConsumed) ----quá trình tiêu thụ sàn phẩm-----
Sleep(GetTickCount()%5000); --> hàm API đưa luồng vào trạng thái ngủ trong khi chờ Producer sản xuất thêm sản phầm,thời gian tính bằng ms trôi qua kể từ khi hệ thống khởi động tới thời điểm hiện tại, chia lấy số dư cho 5000 sẽ ra được 1 con số từ 0-4999, cho luồng tiêu thụ này tạm dừng trong khoảng thời gian đó.
}
}
void ShowBuffer(){ // In nộii dung Buffer
const char * LeftMargin="\n\t";
int i;
printf(LeftMargin);
for(i=0; i<(in*5);i++) putchar(' '); printf("!in");
printf(LeftMargin);
for (i=0; iprintf("S%2d, ",buffer[i]);
printf("S%2d",buffer[BUFFER_SIZE-1]);
printf(LeftMargin);
for(i=0; i<(out*5); i++) putchar(' ');printf("^out");
printf("\n");
}
int main(){
HANDLE ProducerHandle1, ProducerHandle2; --> biến Handle chứa mục quản NSX
HANDLE ConsumerHandle1, ConsumerHandle2; --> biến Handle chứa mục quản NTT

DWORD ProducerID1, ProducerID2; --> chứa ID NSX
DWORD ConsumerID1, ConsumerID2; --> chứa ID NTT

// 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); //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 là trạng thái luôn luôn ngủ

ProducerHandle2=CreateThread(0,0,
(LPTHREAD_START_ROUTINE)Producer,0, 4, &ProducerID2); // tuong tu
// tao 2 luồng tiêu thụ trong trang thái ngay
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 luôn luôn thức.

ConsumerHandle2=CreateThread(0,0,(LPTHREAD_START_ROUTINE)Consumer,0, 0, &ConsumerID2); //tuong tu
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 Producer lúc này đang ở trạng thái ngủ
break;
case 'p':
ResumeThread(ProducerHandle2); ///đánh thức Producer lúc này đang ở trạng thái ngủ
break;
case '0': /// giải phóng Producer và Consumer khỏi bộ nhớ
CloseHandle(ProducerHandle1);
CloseHandle(ProducerHandle2);
CloseHandle(ConsumerHandle1);
CloseHandle(ConsumerHandle2);
return 0;
}
Sleep(1); --> ngủ trong khoảng 1mns
ShowBuffer(); -->kết quả sau khi sản xuất tiêu thụ, khi đang show thì không sx, không tiêu thụ
}
}

- SuspendThread : luồng sản xuất hiện hành được chuyển sang trạng thái ngủ cho đến khi được đánh thức
vd; một người công nhân đến làm việc ở bến cảng khi chưa được phân công thì anh ta tạm rơi vào trạng thái ngủ, chờ khi tàu đến thì anh ta dậy và vác đồ vào kho, làm xong anh ta lại tiếp tục rơi vào trạng thái ngủ.
- GetCurrentThread: trả về mục quản cuả luồng hiện hành.
- Sleep: ngủ 1 khoảng thời gian cho trước.
- Sleep(0): làm cho luồng chính trễ đi 1mili giây trước khi thực hiện đưa nội dung bộ đệm ra màn hình.
- GetTickCount: Nhận số mili giây trôi qua kể từ khi HĐH khởi động cho đến thời điểm gọi hàm này.
- ShowBuffer(): Đưa kết quả ra màn hình.

Hàm GetCurrentThread: dùng để lấy về mục quản của luồng sản xuất hiện hành(mục quản: là con số do hệ điều hành cấp ho luồng hiện hành)
Hàm SuspendThread: dùng để tạm ngưng công việc của hàm với mục quản cho trước
Hàm Sleep: dùng để ngủ 1 số miligiay cho trước,hết khoảng thời gian đó nhà tiêu thụ lại làm việc tiếp
Hàm GetTickCount(): dùng để lấy số miligiay 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
HÀm ResumeThread: dùng để tiếp tục công việc của luồng với mục quản cho trước
Hàm CloseHandle: dùng để hủy đối tượng cho trước với mục quản cho trước. vd: CLoseHandle (45) :luồng 45 không làm việc nữa,bị đóng lại

Luồng Windows 2000

Windows 2000 cài đặt Win32 API. Win32 API là một API chủ yếu cho họ hệ điều hành Windows (Windows 95/98/NT và Windows 2000). Thực vậy, những gì được đề cập trong phần phần này áp dụng tới họ hệ điều hành nàyỨng dụng Windows chạy như một tiến trình riêng rẻ nơi mỗi tiến trình có thể chứa một hay nhiều luồng. Windows 2000 dùng ánh xạ một-một nơi mà mỗi luồng cấp người dùng ánh xạ tới luồng nhân được liên kết tới.Tuy nhiên, Windows cũng cung cấp sự hỗ trợ cho một thư viện có cấu trúc (fiber library) cung cấp chức năng của mô hình nhiều-nhiều. Mỗi luồng thuộc về một tiến trình có thể truy xuất một không gian địa chỉ ảo của tiến trình.Những thành phần thông thường của một luồng gồm:ID của luồng định danh duy nhất luồng Tập thanh ghi biểu diễn trạng thái của bộ xử lý Ngăn xếp người dùng khi luồng đang chạy ở chế độ người dùng. Tương tự, mỗi luồng cũng có một ngăn xếp nhân được dùng khi luồng đang chạy trong chế độ nhân Một vùng lưu trữ riêng được dùng bởi nhiều thư viện thời gian thực và thự viện liên kết động (DLLs).Tập thanh ghi, ngăn xếp và vùng lưu trữ riêng được xem như ngữ cảnh của luồng và được đặc tả kiến trúc tới phần cứng mà hệ điều hành chạy trên đó. Cấu trúc dữ liệu chủ yếu của luồng gồm:RTHREAD (executive thread block-khối luồng thực thi). KTHREAD (kernel thread-khối luồng nhân) TEB (thread environment block-khối môi trường luồng)Các thành phần chủ yếu của RTHREAD gồm một con trỏ chỉ tới tiến trình nào luồng thuộc về và địa chỉ của thủ tục mà luồng bắt đầu điều khiển trong đó. ETHREAD cũng chứa một con trỏ chỉ tới KTHREAD tương ứng.KTHREAD gồm thông tin định thời và đồng bộ hóa cho luồng. Ngoài ra, KTHREAD chứa ngăn xếp nhân (được dùng khi luồng đang chạy trong chế độ nhân) và con trỏ chỉ tới TEB.ETHREAD và KTHREAD tồn tại hoàn toàn ở không gian nhân; điều này có nghĩa chỉ nhân có thể truy xuất chúng. TEB là cấu trúc dữ liệu trong không gian người dùng được truy xuất khi luồng đang chạy ở chế độ người dùng. Giữa những trường khác nhau, TEB chứa ngăn xếp người dùng và một mảng cho dữ liệu đặc tả luồng (mà Windows gọi là lưu trữ cục bộ luồng)

Luồng Linux

Nhân Linux được giới thiệu trong ấn bản 2.2. Linux cung cấp một lời gọi hệ thống fork với chức năng truyền thống là tạo bản sao một tiến trình . Linux cũng cung cấp lời gọi hệ thống clone mà nó tương tự như tạo một luồng. clone có hành vi rất giống như fork, ngoại trừ thay vì tạo một bản sao của tiến trình gọi, nó tạo một tiến trình riêng chia sẻ không gian địa chỉ của tiến trình gọi. Nó chấm dứt việc chia sẻ không gian địa chỉ của tiến trình cha mà một tác vụ được nhân bản đối xử giống rất nhiều một luồng riêng rẻ.Chia sẻ không gian địa chỉ được cho phép vì việc biểu diễn của một tiến trình trong nhân Linux. Một cấu trúc dữ liệu nhân duy nhất tồn tại cho mỗi tiến trình trong hệ thống. Một cấu trúc dữ liệu nhân duy nhất tồn tại cho mỗi tiến trình trong hệ thống. Tuy nhiên, tốt hơn lưu trữ dữ liệu cho mỗi tiến trình trong cấu trúc dữ liệu là nó chứa các con trỏ chỉ tới các cấu trúc dữ liệu khác nơi dữ liệu này được được lưu. Ví dụ, cấu trúc dữ liệu trên tiến trình chứa các con trỏ chỉ tới các cấu trúc dữ liệu khác hiện diện danh sách tập tin đang mở, thông tin quản lý tín hiệu, và bộ nhớ ảo. Khi fork được gọi, một tiến trình mới được tạo cùng với một bản sao của tất cả cấu trúc dữ liệu của tiến trình cha được liên kết tới. Khi lời gọi hệ thống clone được thực hiện, một tiến trình mới chỉ tới cấu trúc dữ liệu của tiến trình cha, do đó cho phép tiến trình con chia sẻ bộ nhớ và tài nguyên của tiến trình cha. Một tập hợp cờ được truyền như một tham số tới lời gọi hệ thống clone. Tập hợp cờ này được dùng để hiển thị bao nhiêu tiến trình cha được chia sẻ với tiến trình con. Nếu không có cờ nào được đặt, không có chia sẻ xảy ra và clone hoạt động giống như fork. Nếu tất cả năm cờ được đặt, tiến trình con chia sẻ mọi thứ với tiến trình cha. Sự kết hợp khác của cờ cho phép các cấp độ chia sẻ khác nhau giữa hai mức độ cao nhất này. Điều thú vị là Linux không phân biệt giữa tiến trình và luồng. Thật vậy, Linux thường sử dụng thuật ngữ tác vụ-hơn là tiến trình hay luồng-khi tham chiếu tới dòng điều khiển trong chương trình. Ngoài tiến trình được nhân bản, Linux không hỗ trợ đa luồng, cấu trúc dữ liệu riêng hay thủ tục nhân. Tuy nhiên, những cài đặt Pthreads là sẳn dùng cho đa luồng cấp người dùng.

Luồng Java

Java là một trong số nhỏ ngôn ngữ cung cấp sự hỗ trợ tại cấp ngôn ngữ cho việc tạo và quản lý luồng. Tuy nhiên, vì các luồng được quản lý bởi máy ảo Java, không bởi một thư viện cấp người dùng hay nhân, rất khó để phân cấp luồng Java như cấp độ người dùng hay cấp độ nhân. Trong phần này chúng ta trình bày các luồng Java như một thay đổi đối với mô hình người dùng nghiêm ngặt hay mô hình cấp nhân.Tất cả chương trình tạo ít nhất một luồng điều khiển đơn. Thậm chí một chương trình Java chứa chỉ một phương thức main chạy như một luồng đơn trong máy ảo Java. Ngoài ra, Java cung cấp các lệnh cho phép người phát triển tạo và thao tác các luồng điều khiển bổ sung trong chương trình.

Tiến trình cha yêu cầu hệ điều hành tạo lập sẵn một tập luồng gồm các luồng giống nhau nhưng khi chưa có việc làm thì ở trạng thái sleeping chờ công việc.Khi có yêu cầu công việc, một luồng được đánh thức và đưa nhanh vào vận hành, xong việc lại trở về tập luồng.Nếu số yêu cầu vượt quá số luồng trong tập luồng, tiến trình cha chờ đến khi có luồng được giải phóng.

Ví dụ: Trang bị sẵn sàng cho cả nhóm lính mặc áo giáp cầm súng nằm ngủ, nhưng nếu 1 tên địch tiến đến thì người lính bắt đầu dậy tiến hành công việc một cách nhanh chóng. Và khi đã chiến đấu xong thì lính lại trở về trạng thái nằm ngủ để đợi công việc tiếp theo.

Ví dụ : Thực hành 1 môn học
* Mỗi nhóm 2 sinh viên là 1 tiến trình:
* Mỗi sinh viên là 1 luồng:
------> Cùng làm bài => Hoạt động đồng hành
------> Có bài thực hành chung => Tài nguyên chung
------> Trao đổi với nhau

Phân biệt giữa luồng và tiến trình
Luồng : 1 dòng xử lý
Tiến trình : 1 không gian địa chỉ hoặc nhiều luồng.
=> Các tiến trình là độc lập, trong mỗi tiến trình có thể có nhiều luồng

MultiProcess và MultiThread

- MultiProcess và MultiThread đều là khái niệm dùng để chỉ khả năng hoạt động song song cùng một lúc.

MultiProcess là liên quan tới chương trình :

Ví dụ Paint, Word, Excel, IE, nói chung là một chương trình chạy cụ thể.
-> Vì sao lại gọi là MultiProcess là để chỉ hệ điều hàng có khả năng chạy nhiều chương trình cùng lúc. Bạn có thể mở IE, Word, Window Media .... hay thậm chí mở 3, 4 chương trình IE cùng lúc. Chỉ những hệ điều hành hỗ trợ MultiProcess thì mới chạy nhiều chương trình cùng lúc như vậy được
-> Những hệ điều hành cũ như Dos(Microsoft), OS/2 (IBM) thì bạn chỉ có thể chạy tại 1 thời điểm 1 chương trình
Không tin bạn cứ khởi động máy ra Dos rồi chạy NC, PartionMagic, Norton Ghost hay đại loại coi làm sao chạy 2,3 thằng cùnglúc được

MultiThread là liên quan tới đa xử lý bên trong chương trình :


Ví dụ : Bạn mở IE hoặc FireFox có thể làm nhiều việc cùng lúc với nó
+ Duyệt nhiều trang web
+ Nghe nhạc online
+ Download tài liệu .....
Tất cả các thao tác trên bạn có thể làm cùng một lúc trong cùng một chương trình

Lập trình MultiProcess dễ hơn MultiThread là vì chỉ cần tạo nên chương trình đó, chạy bao nhiêu phiên bản thì hệ điều hành quản lý.

Tiến trình cha tạo lập sẵn một 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ụ như 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 trả về tập luồng.
- Nếu số yêu cầu lớn hơn số luồng có trong tập, tiến trình cha chờ đến khi có luồng được giải phóng.
VD: Trong một doanh trại quân đội có một tướng lĩnh(tiến trình cha) và 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 (Nhận một yêu cầu), tướng lĩnh sẽ điều một binh sĩ (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 đ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)

Tạm ngừng thi hành (SuspendThread) các luồng sản xuất(Producer), biết rằng mục quản (Handle) của chúng lưu trong mảng được khai báo bằng lệnh HANDLE ProducerHandle[50].

Code:
for(int i=0; i<50; i++)//khai báo biến i,i có giá trị ban đầu bằng 0,i chạy từ 0->49
SuspendThread(ProducerHandle[i]);
//gọi hàm SuspendThread để tạm ngưng thi hành sản xuất,mục quản của mỗi nhà sản xuất ứng với phần tử thứ i trong mảng ProducerHandle
}


*Đánh thức (ResumeThread) các luồng sản xuất (Producer), biết rằng mục quản (Handle) của chúng lưu trong mảng được khai báo bằng lệnh HANDLE ProducerHandle[50].

Code:
for(int i=0; i<50; i++)
{
ResumeThread(ProducerHandle[i]);
//gọi hàm ResumeThread để đánh thức thi hành sản xuất
}

TranThichThem (113A) đã viết:

Tiến trình cha yêu cầu hệ điều hành tạo lập sẵn một tập luồng gồm các luồng giống nhau nhưng khi chưa có việc làm thì ở trạng thái sleeping chờ công việc.Khi có yêu cầu công việc, một luồng được đánh thức và đưa nhanh vào vận hành, xong việc lại trở về tập luồng.Nếu số yêu cầu vượt quá số luồng trong tập luồng, tiến trình cha chờ đến khi có luồng được giải phóng.

Ví dụ: Trang bị sẵn sàng cho cả nhóm lính mặc áo giáp cầm súng nằm ngủ, nhưng nếu 1 tên địch tiến đến thì người lính bắt đầu dậy tiến hành công việc một cách nhanh chóng. Và khi đã chiến đấu xong thì lính lại trở về trạng thái nằm ngủ để đợi công việc tiếp theo.

Mình xin bổ sung thêm ví dụ về tập luồng:

Ví dụ 1: Tổng đài điện thoại 108 , có nhiều nhân viên trực điện thoại ( nhân viên là các luồng con ) , số nhân viên tương ứng với số luồng trong tập luồng , cùng làm việc trong 1 văn phòng ( cùng chung 1 bộ nhớ ) , mỗi nhân viên trực 1 điện thoại ( tức là mỗi luồng điều khiển 1 CPU ), do đó luồng có khả năng đáp ứng cao , khi không có cuộc gọi đến của khách hàng -> nhân viên không làm việc ( luồng đang ở trạng thái ngủ ), khi có cuộc gọi đến của khách hàng -> nhân viên trả lời cuộc gọi (luồng được đánh thức và đưa vào vận hành ) -> kết thúc cuộc gọi của khách hàng , nhân viên được nghỉ ( tức là luồng quay trạng thái ban đầu , trạng thái ngủ ) .

Ví dụ 2: Khách sạn A là 1 ks 3 sao, trong khách sạn có 1 bộ phận khuân vác hành lý cho khách hàng. Bộ phần này gồm: 1 nv quản lý (tiến trình cha, tạm thời gọi là Mr. B) và 5 nv khuân vác (các luồng). Lúc đầu chưa có khách nào đến, 5 nhân viên ngủ (nhưng với trang phục đầy đủ, để khi được đánh thức là ra làm việc được ngay). Khi có kh đến Mr. B sẽ lập tức điều phối công việc cho các nhân viên trong đơn vị của mình, Mr. B bắt đầu đánh thức 1 người bất kỳ dậy để khuân hành lý cho khách, sau khi khuân xong anh này sẽ trở lại đơn vị của mình để chờ được phân công tiếp công việc tiếp theo. Khi có 6 khách hàng yêu cầu khiên hành lý thì Mr. B sẽ cử cả 5 nhân viên đi khiên hành nhưng trong trường hợp này thì thiếu nhân viên nên Mr. B sẽ chờ 1 nhân viên trong 5 người làm xong công việc rồi sẽ giao công việc đang chờ nhân viên đó cho người nào làm xong trước.

Ngoài ra còn có: Web Server, Database Server cũng đều làm việc theo nguyên lý này.
Thêm 1 ví dụ nữa là sự kiện Năm 1999, thày đến mạng Phương Nam giải quyết sự cố liên quan đến ứng dụng Web động (dùng CGI) Giới thiệu việc làm qua mạng.

Một luồng thường được gọi là tiến trình nhẹ (lightweight proces-LWP), là một đơn vị cơ bản của việc sử dụng CPU; nó hình thành gồm: một định danh luồng (thread ID), một bộ đếm chương trình, tập thanh ghi và ngăn xếp. Nó chia sẻ với các luồng khác thuộc cùng một tiến trình phần mã, phần dữ liệu, và tài nguyên hệ điều hành như các tập tin đang mở và các tín hiệu.
Một tiến trình truyền thống (hay tiến trình nặng) có một luồng điều khiển đơn. Nếu tiến trình có nhiều luồng điều khiển, nó có thể thực hiện nhiều hơn một tác vụ tại một thời điểm.

Sự giống nhau:
- Đều có thông tin trạng thái
- Luồng cũng là tiến trình nhưng là tiến trình nhẹ (Light Weigh Process)
- Đa luồng hay đa tiến trình có thể liên quan đến một chương trình.
- Chia sẻ tài nguyên cho nhau, tăng tốc tính toán, đảm bảo tính đơn thể
- Do luồng cùng vận hành trong 1 vùng địa chỉ, vì vậy dễ dùng chung tài nguyên hơn đa tiến trình
Ví dụ: Mình cần mượn xe đi đâu đó thì mượn xe trong gia đình để đi thì dễ hơn mượn của người ngoài
- Do luồng chung tài nguyên với luồng cha nên việc tạo lập và chuyển đổi ngữ cảnh cũng nhanh hơn tiến trình
Ví dụ: Việc ngăn phòng riêng ra trong nhà thì dễ hơn việc xây thêm hay mua thêm một nhà khác.
- Cấp phát tài nguyên bộ nhớ cho tiến trình khá tốn kém.
- Lập trình đa luồng thì dễ hơn lập trình đa tiến trình.

Sự khác nhau:
- Lập trình đa luồng dễ hơn lập trình đa tiến trình.
- Tạo mới một tiến trình khó hơn tạo mới một luồng.
- Luồng không cần gởi, nhận thông điệp.
- Luồng chuyển đổi ngữ cảnh nhanh và ít chiếm tài nguyên hơn tiến trình.
- Luồng chia sẻ tài nguyên dùng chung dể hơn tiến trình.

Luồng: còn được gọi là 1 tiến trình nhẹ, nằm bên trong các tiến trình lớn. Có thể nói chúng là một đơn vị nhò sử dụng cpu. Chúng có thông tin về trạng thái như một tiến trình truyền thống.
VD1: Các bạn đi trên đường một chiều thì một chiều đó chình là một luồng hay 1 tiến trình, nhưng trong luồng đó người ta phân ra các luồng nhỏ hơn đó là các làn xe ô tô, xe tải, xe máy, và đi bộ. Các làn đó được gọi là một luồng hay 1 tiến trình nhẹ.
VD2: Trong công ty các bạn có : Sếp, thư kí, kế toán, nhân viên văn phòng...... Thì công ty là một luồng lớn hay 1 tiến trình để sản xuất là một sản phẩm gì đó vd như cơ khí, còn những cá thể trong công ty sẽ là một luồng hay một tiến trình nhẹ để xử lý các công việc khác nhau.......

Giống nhau :
1. Đều có thông tin trạng thái
2. Luồng còn được gọi là tiến trình nhẹ
3. Nhiều luồng or nhiều tiến trình có thể liên quan đến một chương trình
4. Chia sẻ tài nguyên cho nhau
5. Tăng tốc tính toán
6. Đảm bảo tính đơn thể

Khác nhau
1. Do luồng cùng vận hành trong 1 vùng địa chỉ vì vậy dể dùng chung tài nguyên hơn đa tiến trình
VD : Mượn đồ dùng trong gia đình thì dể hơn mượn của hàng xóm
2. Do luồng chung tài nguyên với cha & các luồng khác nên việc tạo lập & chuyển ngữ cảnh cũng
nhanh hơn tiến trình
VD : Việc ngăn riêng ra một phòng trong nhà thì nhanh hơn là chờ nhà nước cấp cho
một căn hộ
3. Cấp phát bộ nhớ & tài nguyên cho tiến trình thì tốn kém hơn luồng
4. Lập trình đa luồng thì dể hơn đa tiến trình

[quote="NguyenThiNgocPhuong(113A)"]Giải thích code Sản Xuất Tiêu Thụ Đa Luồng

#include < stdio . h >
#include < conio . h >
#include < windows . h > // lập trình đa luồng đồng hành, sử dụng được hàm win32 API

#define BUFFER_SIZE 10 // định nghĩa một buffer có số khoang chứa là 10

int buffer[BUFFER_SIZE];
int in=0; // biến in chứa giá trị chỉ vị trí xếp sản phẩm vào
int out=0;// biến out chứa giá trị chỉ vị trí lấy sản phẩm ra

int nextProduced=1;// biến trung gian, chứa số hiệu sản phẩm đầu tiên

void Producer(){ // nhà sản xuất
while (1){
// ... Sản xuất (nextProduced)
while(((in+1)%BUFFER_SIZE)==out);// khoang chứa đầy thì quẩn tại đây đến khi nào có chỗ trống
buffer[in]=nextProduced++; // cho sản phẩm vào mảng tại vị trí in
in=(in+1)%BUFFER_SIZE; //sau khi chèn sản phẩm vào mảng, tăng in lên 1, nếu in đang nằm ở vị trí cuối mảng sẽ nhảy về đầu mảng
SuspendThread(GetCurrentThread()); //getcureentthread: hàm của thư viện win32 API, trả về giá trị mục quản của luồng hiện hành, vd: 1700. SuspendThread(): ngừng luồng có mục quản là giá trị trong ngoặc, vd: SuspendThread(1700) ngừng luồng có mục quản 1700
}
}

void Consumer(){ // nhà tiêu thụ
int nextConsumed; // biến chứa sản phẩm được tiêu thụ
while (1){
while(in==out); //trong khoang chứa hết sản phẩm thì quẩn tại đây cho đến khi nào trong buffer có sản phẩm
nextConsumed=buffer[out]; //sản phẩm ở vị trí out được đưa vào biến netxconsumed
out=(out+1)%BUFFER_SIZE;//out tăng lên 1, nếu out đang nằm ở cuối mảng thì nhảy lên đầu mảng
// ... Tiêu thụ (nextConsumed)
Sleep(GetTickCount()%5000); // hàm gettickcount() sẽ trả về thời gian tính bằng ms trôi qua kể từ khi hệ thống khởi động tới thời điểm hiện tại, kết quả sẽ ra được con số rất lớn và chia lấy số dư cho 5000 sẽ ra được 1 con số từ 0-4999, cho luồng tiêu thụ này ngủ trong khoảng thời gian đó.
}
}

void ShowBuffer(){ // In nội dung Buffer
const char * LeftMargin="\n\t";
int i;
printf(LeftMargin);
for(i=0; i<(in*5);i++) putchar(' '); printf("!in");

printf(LeftMargin);
for (i=0; iprintf("S%2d, ",buffer[i]);
printf("S%2d",buffer[BUFFER_SIZE-1]);

printf(LeftMargin);
for(i=0; i<(out*5); i++) putchar(' ');printf("^out");
printf("\n");
}

int main(){
HANDLE ProducerHandle1, ProducerHandle2; // lưu mục quản của 2 nhà sx vào 2 biến ProducerHandle1, ProducerHandle2
HANDLE ConsumerHandle1, ConsumerHandle2; //lưu mục quản của 2 nhà tiêu thụ

DWORD ProducerID1, ProducerID2; // mã số định danh của luồng sản xuất
DWORD ConsumerID1, ConsumerID2; // mã số định danh của luồng tiêu thụ

// 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);// các đối số đầu ko quan tâm vì có mới chạy được
// số 4 chỉ ra luồng vừa tạo sẽ không chạy mà ngủ luôn, &ProducerID1 chỉ ra luồng sẽ có mã số định danh là ProducerID1
// sau khi làm lệnh này, sẽ có 2 luồng, luồng ctrinh này và luồng producer
ProducerHandle2=CreateThread(0,0,(LPTHREAD_START_ROUTINE)Producer,0, 4, &ProducerID2);
// Tạo 2 luồng tiêu thụ thi hành ngay
ConsumerHandle1=CreateThread(0,0,(LPTHREAD_START_ROUTINE)Consumer,0, 0, &ConsumerID1); //0: luồng tiêu thụ vận hành ngay, ko ngủ


ConsumerHandle2=CreateThread(0,0,
(LPTHREAD_START_ROUTINE)Consumer,
0, 0, &ConsumerID2);
while(1){
printf("\n- Nhap P/p de san xuat, 0 de ket thuc:”);
//P đánh thức nhà sx1, p sx2
switch (getch()){//biết người sử dụng bấm gì
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);// hủy đối tượng(ở đây là luồng) có mục quản
CloseHandle(ProducerHandle2);
CloseHandle(ConsumerHandle1);
CloseHandle(ConsumerHandle2);
return 0;
}
Sleep(1);// ngủ 1 ms, tức là luồng chính sẽ trễ 1 chút để sản xuất cho xong(chờ in tăng lên 1) rồi mới showbuffer ra
ShowBuffer();
}
}
Cám ơn ban nha !!!

A: So sánh Luồng và Tiến Trình:
- Luồng cũng là tiến trình bình thường, đều đc cấp phát bởi CPU và đc quản lý bởi HĐH.
- Tiến trình có thể có một luồng chính với nhiều luồng phụ, Mỗi luồng có khả năng chia sẻ tài nguyên dùng chung với các luồng khác trong tiến trình rất là tốt( như Ram,HDD). Tiến trình đc đa luồng hỗ trợ trong các HĐH hiện tại. Bao gồm 1 hoặc nhiều luồng bên trong.
VD: Lớp học là 1 tiến trình, Trong lớp có 1 Giáo Viên là Đơn luồng và toàn thể học sinh là Đa Luồng.
B: Những ưu việt của công nghệ đa luồng:
-Đảm bảo khả năng tính đáp ứng tốt hơn-> Khi 1 luồng gặp sự cố bị treo thì luồng khác vẫn làm việc.
VD: tổng đái 1080, 1 cô trực tổng đài trả lời trong tổng đài tương đương với đơn luồng, còn có nhiều cô là đa luồng ->Khi chúng ta gọi 1 lúc nếu 1 cô thì hok đáp ứng đc, còn nhiều cô thì linh động vì tính đáp ứng tốt hơn.
-Chia sẻ tài nguyên tốt hơn.
VD: Trong nhà ta có kệ sách, tivi, xe máy... mọi ng trong nhà có thể dùng chung.
-Tiết kiệm( Economy): Tạo mới luồng sẻ tiết kiệm hơn là tạo mới 1 tiến trình
VD: Trong gia đình có anh chị lập gia đình thì việc ngăn phòng ra ở dễ hơn là đi mua 1 căn hộ mới.
-Lập trình đa luồng dễ hơn lập trình đa tiến trình.
-Tận dụng đc thế mạnh của kiến trúc đa xử lý: Đa luồng làm tăng tính song song trên hệ máy nhiều CPU. Mỗi luồng có thể chạy bởi CPU riêng.

1. Phân biệt khái niệm "luồng" và "tiến trình". Cho biết những ưu việt của công nghệ đa luồng.
2. Trình bày nguyên lý tập luồng và ứng dụng. Nêu ví dụ minh hoa.
3. Cơ bản về lập trình đa luồng trong Window ( các hàm của thư viện Win32 API).
Thảo luận: + Tại sao tiến trình truyền thống thì "nặng" còn luồng thì "nhẹ" ?
+ Tại sao khi showbuffer có lúc đúng lúc sai ? Tại sao phải cần trễ 1 miligiây ?

Vì tạo luồng dễ dàng, nhanh và ít tốn kém hơn là tạo hẳn một tiến trình. Tạo một tiến trình thì khó, chậm và tốn nhiều thời gian, chi phí.
Ví dụ: thêm 1 lớp học trong trường thì khó hơn là thêm 1 chỗ ngồi cho 1 sinh viên trong lớp. Khi thêm 1 lớp học thì phải đảm bảo đủ số lượng sinh viên để mở lớp, đảm bảo có đủ các trang thiết bị phục vụ cho lớp học đó và còn phải có giờ giấc, lịch học hẳn hoi. Trong khi thêm 1 ghế cho 1 sinh viên vào lớp trễ thì quá dễ dàng.

A.Tập luồng ( Thread pool )
- Tiến trình cha tao lập sẵn 1 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 ( vd: Web Server) nhận thêm 1 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 thả về tập luồng.
-Nếu số yêu cầu lớn hơn số trong tập luồng, tiến trình cha chờ đến khi có luồng đc giải phóng.
B.Ví Dụ
VD1: Tổng đài ĐT có nhiều NV trực ĐT ( NV là các luồng con ). số NV nhiều tương ứng với số luồng nhiều, cùng làm chung 1 văn phòng( Chung 1 bộ nhớ), mỗi NV trực 1 ĐT( mỗi luồng đc diều khiển 1 CPU), do đó luồng có khả năng đáp ứng cao. Khi không có cuộc gọi-> NV hok làm gì( luồng trong trạng thái ngủ), Khi có cuộc gọi đến-> NV bắt đầu nghe máy( Luồng đc đánh thức và vận hành) -> kết thúc cuộc gọi->luồng quay về trạng thái ban đầu.
VD2: Năm 1999, Cty mang Phương Nam, Internet chưa phổ biến chỉ có 1 số ứng dụng đơn giản, có 1 ứng dụng hay đó là gt việc làm qua mạng, Server phục vụ 28 user cùng lúc quay số qua mo-dem kết nối tới máy chủ. Nhưng bị 1 hạn chế đó là nếu có hơn 5 ng cùng quay số 1 lúc, thì hệ thống web bị treo và cách giải quyết là phải khởi động lại hệ thống. Nhưng nguyên nhân chính là do khi chạy ứng dụng thì tao ra hơn 5 heavy Process, khiến máy chủ ứng dụng web bị treo, vì các nhà lập trình đã sử dụng công nghệ CGI(common gateway interface), thầy đã giải quyết bằng cách làm lại ứng dụng bằng ASP. Đây cũng đc xem là ứng dụng đầu tiên sử dụng ASP.

Admin
Không phải vậy (xem câu gạch dưới). Thực ra, 28 users cũng quay số đến một lúc vẫn được ! (họ làm nhiều việc khác nhau, không chỉ truy xuất trang "Giới thiệu việc làm").

Ví dụ về tập luồng:xây dựng một đội quân có trang bị đầy đủ vũ khí ,giáp,rồi cho đi ngủ .Nếu có một tên địch tới sẽ phái một anh lính ra tiêu diệt.Cứ thế nếu có một tên địch khác đến thì tiếp tục phái một anh lính ra tiêu diệt.

LeThanhNhan45 (113A) đã viết:Ví dụ về tập luồng:xây dựng một đội quân có trang bị đầy đủ vũ khí ,giáp,rồi cho đi ngủ .Nếu có một tên địch tới sẽ phái một anh lính ra tiêu diệt.Cứ thế nếu có một tên địch khác đến thì tiếp tục phái một anh lính ra tiêu diệt.

Mà đội quân này phải đang ở trạng thái sẳn sàng (đã tập luyện thường xuyên, mặt áo giáp, cầm vũ khí) rồi mới cho đi ngủ.

Mình xin bổ sung ví dụ về tập luồng (Mình tham khảo tự các lớp trước)
Trong một buỗi kiểm tra bài cũ thì giáo viên và những học sinh phía dưới (được gọi là 1 tập luồng) sẽ diễn ra như sau:
-Các học sinh phía dưới đã chuẩn bị bài cũ và sẵn sàng "chiến đấu",lúc này các học sinh đang trong trạng thái đợi.
-Khi các giáo viên gọi bất kỳ một học sinh nào, thì ngay tức khắc học sinh đó sẽ lên bảng trả bài hoặc làm bài tập...
-Khi các học sinh đó hoàn thành xong "công việc" của mình thì học sinh đó trở về vị trí cũ đợi tiếp và Giáo viên sẽ tiếp tục gọi học sinh tiếp theo.
*Các Luồng (học sinh) luôn trong trạng thái chờ và sẽ được đánh thức đưa vào vận hành.

Lợi ích đa luồng
- khả năng đáp ứng tốt hơn
ví dụ : ta lấy que đánh vào con chó đang ngủ. nếu nó kêu chứng tỏ tính phản hồi, trả lời của nó tốt.
- chia sẻ tài nguyên dễ dàng hơn
ví dụ : chia sẻ tài nguyên trong gia đình ví dụ như xem ti vi thì dễ dàng hơn là chia sẻ với hàng xóm.
- tiết kiệm hơn
ví dụ : cha mẹ tạo thêm phòng cho anh chị lập gia đình tốt hơn là mua một căn nhà mới
- tận dụng được thế mạnh kiến trúc đa sử lý
ví dụ : một hệ thống có nhiều động cơ mạnh mẽ hơn là một hệ thống chỉ có một động cơ
- lập trình đa luồng dễ hơn lập trình đa tiến trình
vì : tạo luồng mới dễ hơn và gửi nhận thông điệp dễ hơn giữa các luồn

NguyenVanLam(I13A) đã viết:- Mô hình Many – to – One là nhiều User level threads được ánh xạ vào một Kernel Thread. Việc quản lý được thực hiện ở User Level, khi có một thread bị block thì toàn bộ các Process cũng bị block theo.
- Mô hình One – to – One là mỗi User level thread được gắn với một Kernel thread. Khi có một user thread mới được tạo ra thì cũng cần tạo một Kernel thread tương ứng, lúc này chi phí quá lớn.
- Mô hình Many – to – Many nhiều User level thread được phân chia ánh xạ vào một số Kernel thread. Tránh được các khuyết điếm của 2 mô hình trên.

Các mô hình bổ sung , các bạn tham khảo .Thanks!!