Thảo luận Bài 5

*Giống nhau:
- Đều có thông tin trạng thái
- Luồng còn được gọi là tiến trình nhẹ
- Nhiều luồng hoặc nhiều tiến trình có thể liên quan đến một chu 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ể

*Khác nhau:
- 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
- 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
- Lập trình đa luồng thì dễ hơn lập trình đa tiến trình

- Đa luồng đảm bảo khả năng đáp ứng của tiến trình tốt hơn,nếu như một luồng có sự cố thí một luồng khác sẽ thay thế tiếp tục làm việc.
- Đa luồng giúp chia sẻ tài nguyên tốt hơn, vì các luồng ở cùng một tiến trình nên sẽ dễ dàng chia sẻ tài nguyên hơn.
- 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 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 cũng nhanh hơn.
- Tận dụng được ưu thế của kiến trúc đa xử lý, mỗi luồng có thể được xử lý bởi 1 luồng.
- Lập trình đa luồng dễ hơn lập trình đa tiến trình.
- Đảm bảo khả năng tính đáp ứng của hệ thông tốt hơn
- Chia sẽ tài nguyên tốt hơn
- Tiết kiệm (Economy) Tạo mới luồng thì sẽ tiết kiệm hơn là tạo mới tiến trình

-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.

Nguyên lý 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.

CÂU 1: phân biệt khái niệm luồng với tiến trình và trình bày lợi ích của công nghệ đa luồng.
PHÂN BIỆT KHÁI NIỆM LUỒNG VỚI TIẾN TRÌNH
Luồng là tiến trình nhẹ một đơn vị cơ bản sử dụng CPU .Luồng cũng có thông tin trạng thái như của tiến trình hệ hống
ví dụ: lớp học là một tiến trình .Trong lớp sẽ có một giáo viên(đơn luồng) và các học viên(đa luồng)
Tiến trình là chương trình trong thời gian thực hiện(đặt dưới sự quản lý của hệ điều hành). Có sự phân biệt tiến trình hệ thống ( của hệ điều hành) với tiến trình người dùng.
ví dụ Lớp I12c đang học là một tiến trình
Những lợi ích của công nghệ đa luồng
- Khả năng đáp ứng tốt hơn: Trong khi một luồng bị ách hoặc quá bận luồng khác vẫn vận hành bình thường
ví dụ: các cô tổng đài 1080 là các luồng. khi khách hàng điện thoại hỏi 1080 thì một trong các cô(cô thứ 1) sẽ trả lời.Nếu trong thời điểm đó khách hàng thứ 2 gọi 1080 tì một trong các cô(cô thứ 2) còn lại sẽ trả lời cho khách hàng.
- chia sẻ tài nguyên: theo mặc định các luồng có thể dùng chung bộ nhớ và tài nguyên của luồng cha. vài luồng cùng vận hành trong 1 vùng địa chỉ do đó dễ dùng chung tài nguyên hơn so với trường hợp đa tiến trình
ví dụ: trong nhà ta có kệ sách tivi xe gắn máy ....... thì mọi người trong nhà có thể dùng chung sách tivi xe máy
- 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 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 cũng nhanh hơn
ví dụ : các bạn trong lớp đang dùng chung một cái bảng ai cần ghi thì ghi cần thì chụp hình về xem
- 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 lâu hơntạo mới 1 luồng liên lạc giữa các luồng dễ hơn tiến trình

Câu 2: TRÌNH BÀY NGUYÊB LÝ TẬP LUỒNG VÀ CHO VÍ DỤ MINH HỌA
TẬP LUỒNG:
- 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 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 trong tập tiến trình cha chờ đến khi có luồng được giải phóng
ví dụ: trong doanh trại 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ỹ một đi bắt tên địch
trong khi đó lại có thêm 1 tên địch khác đột nhập tưỡng lĩnh sẽ điều binh sỹ 2 đi bắt địch .sau khi bắt địch xong binh sĩ sẽ trở về doanh trại

Đa luồng
Java hổ trợ đa luồng, nó có khả năng làm việc với nhiều luồng. Một ứng dụng có thể bao hàm nhiều luồng. Mỗi luồng được gán một công việc cụ thể, chúng được thực thi đồng thời với các luồng khác.

Đa luồng làm giảm tối đa thời gian nhàn rỗi của hệ thống. Điều này cho phép bạn viết các chương trình có hiệu quả cao với sự tận dụng tối đa CPU. Mỗi phần của chương trình được gọi một luồng, mỗi luồng định nghĩa một cấch thực hiện. Đây là một trường hợp đặc biệt của đa nhiệm.

Trong đa nhiệm, nhiều chương chương trình chạy đồng thời, mỗi chương trình có ít nhất một luồng trong nó. Một bộ vi xử lý thực thi tất cả các chương trình này. Qua đó chương trình được thực thi như là đồng thời, trên thực tế bộ vi xử lý chuyển qua chuyển lại giữa các chương trình.

Tạo và quản lý luồng
Khi các chương trình Java được thực thi, luồng chính đã đang được thực hiện. Hai yếu tố quan trong luồng chính (main) là:

♦ Các luồng con sẽ được tạo ra từ nó.

♦ Nó là luồng cuối cùng kết thúc việc thực hiện. Ngay khi luồng chính ngừng thực thi, chương trình bị chấm dứt.

Cho dù luồng chính được tạo ra một cách tự động với chương trình thực thi, nó có thể được điều khiển thông qua một đối tượng luồng.

Các luồng có thể được tạo ra từ hai cách:

♦ Khai báo lớp là lớp con của lớp Thread, và phương thức run() của lớp Thread cần được định nghĩa đè.
Vòng đời của Luồng
[/URL]
Trạng thái của luồng và các phương thức của lớp Thread
Một luồng vừa được tạo ra có trạng thái 'born'. Luồng không bắt đầu chạy ngay lập tức sau khi nó được tạo ra. Nó đợi phương thức start() của chính nó được gọi. từ đó nó ở trạng thái "sẵn sàng để chạy". Luồng đi vào trạng thái "đang chay" khi hệ thống cấp quyền sử dụng bộ vi xử lý cho nó.

Bạn có thể sử dụng phương thức sleep() để tạm thời dừng sự thực thi của luồng. Luồng trở thành sẵn sàng sau khi phương thức sleep() kết thúc. Luồng khi roi vào trạng thái 'ngủ' (sleeping) không sử dụng bộ vi xử lý. Luồng đi vào trạng thái "đợi" (waiting) khi một luồng gọi phương thức wait().

Khi các luồng khác sử dụng xong đối tượng, gọi phương thức notify(), luồng trở lại trạng thái "sẵn sàng" (ready). Luồng đi vào trạng thái "blocked" khi nó đang thực thi các phép toán vào/ra (Input/output). Nó đi vào trạng thái "sẵn sàng" khi các phương thức vào/ra nó đang đợi được hoàn thành. Luồng đi vào trạng thái "chết" (dead) sau khi phương thức run() đã được thực thi xong, hoặc khi phương thức stop() của nó được gọi.

Khái niệm đa luồng. So sánh luồng với tiến trình (giống và khác nhau ở chỗ nào?)
* Khái niệm đa luồng: Luồng còn gọi là tiến trình nhẹ (LWP-Light Weight Process), cũng là một đơn vị cơ bản sử dụng CPU.
* So sánh:
- Tiến trình (Process) là chuơng trình trong thời gian thực hiện (đặt dưới sự quản lý của HĐH).
- Luồng (Thread) còn gọi là tiến trình nhẹ (LWP-Light Weight Process), một đơn vị cơ bản sử dụng CPU.
- Luồng cũng có thông tin trạng thái như của tiến trình truyền thống (HWP- Heavy Weight Process).
- 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 với các luồng khác trong tiến trình.
- Nhiều luồng có thể cùng chung một mã chương trình
- Khả năng đáp ứng (Responsiveness) tốt hơn: Trong khi một luồng bị ách hoặc quá bận, luồng khác vẫn vận hành bình thường (ví dụ, luồng chính của trình duyệt vẫn tương tác với người dùng trong khi dữ liệu được lấy về).
- Chia sẽ tài nguyên (Resource Sharing): Theo mặc định, các luồng có thể dùng chung bộ nhớ và tài nguyên của luồng cha. Vài luồng cùng vận hành trong một vùng địa chỉ, do đó dễ chia sẻ tài nguyên hơn so với trường hợp đa tiến trình.
- Tiết kiệm (Economy): Cấp phát bộ nhớ và tài nguyên cho tiến trình là một công việc tốn kém. Do luồ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 cũng nhanh hơn (Solaris 2: Tạo tiến trình chậm hơn 30 lần, chuyển ngữ cảnh chậm hơn 5 lầ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ể được chạy bởi CPU riêng.
- Lập trình đa luồng dễ hơn (chia sẻ tài nguyên và tạo mới luồng dễ hơn).

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ý.

Một số hàm được sử dụng trong Chương trình thực thi Bài toán SX-TT:
- SuspendThread(): tạm ngừng luồng với mục quản cho trước.
- ProductID1 và ProductID2: là mã số định danh của các luồng SX.
- Tham số 0 trong CreateThread(): luồng đi vào vận hành ngay sau khi được tạo lập.
- Tham số 4 trong CreateThread(): luồng ngủ luôn sau khi vừa được tạo lập.
- CloseHandle: Đóng luồng với mục quản cho trước.
- Sleep(1): Dừng lại 1milli giây để trễ một chút (cho luồng SX kịp hoàn tất 1 chu trình công việc) trước khi thực hiện lệnh ShowBuffer() kế tiếp.

*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
}

Admin
Đây chính là mẫu đề thi hay ra. Cần chú ý !

giống nhau: luồng cũng là 1 tiến trình là 1 đơn vị được cấp phát cpu bỡi hdh
khác nhau: là một bộ phận của tiến trình truyền thống, luồng nằm bên trong tiến trình,luồng có thông tinh về trạng thái của nó, các luồng trong một tiến trình có thể rất giống nhau, có thể chung 1 mã chương trình
vd: về đa tiến trình: mỗi lớp là một tiến trình, lớp i12a là 1 tiến trình. trong lớp có nhiều luồng thầy là luồng chính , học sinh là luồng phụ

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.

Nguyen Doan Linh051(I11c) đã viết:Câu 2: TRÌNH BÀY NGUYÊB LÝ TẬP LUỒNG VÀ CHO VÍ DỤ MINH HỌA
TẬP LUỒNG:
- 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 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 trong tập tiến trình cha chờ đến khi có luồng được giải phóng
ví dụ: trong doanh trại 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ỹ một đi bắt tên địch
trong khi đó lại có thêm 1 tên địch khác đột nhập tưỡng lĩnh sẽ điều binh sỹ 2 đi bắt địch .sau khi bắt địch xong binh sĩ sẽ trở về doanh trại

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.

Các bạn tham khảo bổ sung thêm

Trong chương trình java luôn có một thread chính được thực thi, các thread khác sẽ được tạo ra như các thread con, việc mở đầu và kết thúc một ứng dụng được thực hiện bởi thread chính đó.
Hình dưới minh họa vòng đời của một thread:

Để tạo và quản lý thread trong java, chúng ta dựa vào lớp Thread và Runnable interface
Runnable là một interface dùng để các lớp khác implement để sử dụng thread. Trong lớp implement đó bắt buộc phải định nghĩa một phương thức là void run().
Ví dụ ta có 2 lớp StringThread implement Runnable, và một lớp TestClass để tạo ra thread và run nó.
public class StringThread implements Runnable
{
private String str;
private int num;

StringThread(String s, int n)
{
str = new String(s);
num = n;
}

/* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
@Override
public void run()
{
for (int i = 1; i <= num; i++)
System.out.print(str + " ");

}
}
public class TestClass {

/**
* @param args
*/
public static void main(String[] args) {
StringThread t = new StringThread("Thread", 10);
new Thread(t).start();
}

}
Kết quả in ra màn hình sẽ là: Thread Thread Thread Thread Thread Thread Thread Thread Thread Thread
Thread là một lớp viết sẵn trong java, nó implement Runnable interface. Nếu chúng ta muốn sử dụng thread chỉ cần viết một lớp và kế thừa (extends) từ lớp Thread này.
Một số hàm thông dụng của Thread
• start bắt đầu thực thi thread
• sleep đưa trạng thái về trạng thái đợi (không thực thi nữa)
• resume thực thi lại thread từ trạng thái đợi hoặc dead-lock
• join đợi để cho đến khi thread này chết
• isAlive kiểm tra thread còn đang sống hay đã bị kill
• getName lấy tên của thread
• getPriority trả về độ ưu tiên của thread
• setName đặt tên cho thread
• setPriority đặt độ ưu tiên cho thread
• …
Ví dụ tương tự việc sử dụng thread với Runnable interface, chúng ta cũng có thể kế thừa tự lớp có sẵn là Thread như sau:
class StringThread extends Thread {

public void run() {
System.out.println("Inherit successfully from Thread class!");
}
}

public class TestClass {
public static void main(String[] args) {
StringThread t = new StringThread();
new Thread(t).start();
}

}
Kết quả in ra sẽ là: Inherit successfully from Thread class!

1.3 Các lớp Timer, TimerTask và SchedulingTask
Timer là một lớp tiện ích giúp cho việc lập lịch và kiểm soát việc thực thi một task vụ nào đó. Ví dụ bạn muốn dùng việc cập nhật thông trong 5 phút tới, hay thông tin chỉ được tồn tại 10h sau đó sẽ tự động bị xóa đi,… Một số hàm thông dụng trong Timer như:
• schedule lên lịch để thực thi task khi nào bắt đầu, kết thúc hay lặp lại, …
• cancel dừng timer và hủy tất cả các task đã lên lịch trong timer
• purge xóa tất cả các task đã dùng trong hàng đợi timer
TimerTask là một lớp trừu tượng implement Runnable interface, nó giúp cho việc lập lịch thực thi các thread
Ví dụ ta có một lớp MyTimerTask kế thừa từ TimerTask như bên dưới
class MyTimerTask extends TimerTask {
public void run() {
System.out.println("Running the scheduled task by Timer");
System.gc();
}
}

public class TestClass {
public static void main(String[] args) {
Timer timer = new Timer();
MyTimerTask task = new MyTimerTask();

timer.schedule(task, 3000, 2000);//Execute task after 3 senconds and then repeat in 2 seconds period
}
}
Kết quả in ra màn hình sau 5 giây sẽ là: Running the scheduled task by Timer
Running the scheduled task by Timer

1.4 Xử lý các vấn đề chúng trong multithread như synchronized, lock, dead lock, wait, notify …
Đồng bộ (Synchronization) là cơ chế giúp cho đồng bộ việc truy cập cùng tài nguyên của nhiều thread khác nhau. Như chúng ta biết vì cơ chế thread là cơ chế làm việc đồng thời do đó có khả năng một tài nguyên sẽ bị truy cập bởi nhiều thread khác nhau.
Ví dụ ta xây dựng 3 lớp Socola, Producer, Consumer. Lớp Socola chứa thông tin, lớp Producer tạo thông tin và gán vào cho Socola, Lớp Consumer sẽ ăn (tiêu thụ) thông tin đó.
public class TestClass {
public class Socola {
private int contents = 0;
public boolean isRemainingContents;

public synchronized int get() {
//print onto screen
System.out.println("\tConsumer get " + this.contents);
return contents;
}

public synchronized void set(int piContents) {
this.contents = piContents;

//print onto screen
System.out.println("Producer set " + this.contents);
}
}

public class Producer extends Thread {
private Socola socola;

Producer(Socola pSocola) {
socola = pSocola;
}

public void run() {
for(int i = 0; i < 10; i++) {
socola.set(i);

try {
Thread.sleep(100);
} catch (InterruptedException e) {

}
}
}
}

public class Consumer extends Thread {
private Socola socola;

Consumer(Socola pSocola) {
socola = pSocola;
}

public void run() {
for(int i = 0; i < 10; i++) {
socola.get();

try {
Thread.sleep(100);
} catch (InterruptedException e) {

}
}
}
}

public static void main(String[] args)
{
TestClass t = new TestClass();
Socola s = t.new Socola();

Producer p = t.new Producer(s);
Consumer c = t.new Consumer(s);
p.start();
c.start();
}
}
Kết quả in ra màn hinh sẽ không giống nhau tại các lần chạy, ví dụ 1 lần chạy:
Producer set 0
Consumer get 0
Producer set 1
Consumer get 1
Producer set 2
Consumer get 2
Producer set 3
Consumer get 3
Producer set 4
Consumer get 4
Consumer get 4
Producer set 5
Producer set 6
Consumer get 6
Producer set 7
Consumer get 7
Consumer get 7
Producer set 8
Consumer get 8
Producer set 9
Từ ví dụ trên ta thấy có chung một tài nguyên là Socola mà có 2 đối tượng cùng truy cập  có thể sinh ra mâu thuẫn khi truy cập đồng thời. Bây giờ ta muốn là chỉ khi Producer tạo ra thông tin thì Consumer mới ăn thông tin đó, không muốn Consumer ăn nhiều lần cùng một thông tin, khi Producer đang tạo ra thông tin thì Consumer đứng chờ, khi nào Producer tạo ra thông tin xong thì Consumer mới vào ăn thông tin. vậy thì ta phải dùng cơ chế đồng bộ trong java với các từ khóa synchronized, wait(), notify(), notifyAll() và chỉnh lại 2 hàm get và set trong lớp Socola như sau:
public synchronized int get() {
while(isRemainingContents == false) {
try {
wait();
} catch (InterruptedException e) {

}
}

isRemainingContents = false;

//print onto screen
System.out.println("\tConsumer get " + this.contents);

//Notify Producer to produce new contents
notifyAll();

return contents;
}

public synchronized void set(int piContents) {
while(isRemainingContents == true) {
try {
wait();
} catch (InterruptedException e) {

}
}

this.contents = piContents;
isRemainingContents = true;

//print onto screen
System.out.println("Producer set " + this.contents);

//Notify Consumer to eat this contents
notifyAll();
}
}

Kết quả in ra luôn luôn như sau:
Producer set 0
Consumer get 0
Producer set 1
Consumer get 1
Producer set 2
Consumer get 2
Producer set 3
Consumer get 3
Producer set 4
Consumer get 4
Producer set 5
Consumer get 5
Producer set 6
Consumer get 6
Producer set 7
Consumer get 7
Producer set 8
Consumer get 8
Producer set 9
Consumer get 9
Có 3 hàm cần để ý:
• wait() đưa thread vào trạng thái chờ khi nào được notify() hoặc notifyAll() thì sẽ thực hiện tiếp
• notify() đánh thức thread đang đợi, nếu có nhiều thread đang đợi, thì một trong những thread đó được đánh thức thôi.
• notifyAll() đánh thức tất cả các thread đang đợi
Note: Nhiều khi chúng ta không cần hoặc không thể đồng bộ nguyên hàm (dùng synchronized) mà chỉ cần đồng bộ một vài dòng code truy cập tài nguyên, ta có thể dùng khối đồng bộ như sau:
synchronized(object) {
// Các cấu lệnh cần đồng bộ
}
Ví dụ: Khi bạn sử dụng lớp Socola là của khách hàng bạn đưa cho, bạn không thể chỉnh sửa định nghĩa hàm get và set trong Socola được vậy thì bạn có thể dùng khối đồng bộ bên trên cũng sẽ cho kết quả tương tự.
Deadlock (khóa chết) trong xử lý đa luồng xảy là khi mà một thread được đưa vào trạng thái chờ tài nguyên và không bao giờ được đánh thức lại vì tại nguyên đó không bao giờ được giải phóng. Để rõ hơn ta ví dụ A, B, C là thread trong trạng thái chờ; rA, rB, rC là tài nguyên dùng chung và chỉ duy nhất một thread sử dụng trong một thời điểm, tài nguyên chỉ được giải phóng khi thread làm xong và không sử dụng nữa.
• A giữ rA, chờ rB
• B giữ rB, chờ rC
• C giữ rC, chờ rA
Từ ví dụ trên ta thấy A, B, C là những thread đang ở trong trạng thái chờ tài nguyên, tuy nhiên tài nguyên của chúng không bao giờ được giải phóng, và mãi mãi chúng cứ chờ thôi. Để hạn chế deadlock thì chúng ta phải đưa ra, cải tiến việc cấp phát, thu hồi tài nguyên cho các thread và hiện này có khá nhiều thuật toán cải tiến việc này, tuy nhiên không có cái nào giúp tránh hoàn toàn deadlock.
1.5 Những lớp tiện ích trong lập trình đa luồng (multithread)
Trong java đã xây dựng một vài lớp giúp hỗ trợ lập trình đa luồng, chúng được đặt trong gói Concurent như: Semaphore, Lock, Condition, ConcurrentMap, ConcurrentLinkedQueue, …
Semaphore là một lớp tiện ích đã xây dựng trong java (java 5) dùng để giới hạn số lượng thread truy cập đến tài nguyên. Đầu tiên thread cần yêu cầu sự chấp nhận truy cập tài nguyên từ semaphore bằng hàm acquire, và thread sẽ về trạng thái đợi (block) cho đến khi được chấp nhận, khi thread được chấp nhận nó thực hiện công việc của nó xong sẽ gọi hàm release để trả về cho semaphore một sự chấp nhận còn trống để semaphore cấp cho thread khác.
Lock là một interface được xây dựng nhằm mở rộng hơn việc quản lý truy cập tài nguyên trong nhiều thread hơn so với cách dùng synchronized chẳng hạn như có thể hỗ trợ nhiều điều kiện (condition object) trong lock, hoặc hỗ trợ nhiều thuật toán cho chain-lock để tránh deadlock tốt hơn, … Khi dùng Lock chúng ta nên theo một template chuẩn như sau:
Lock l = ...;
l.lock();
try {
// Các task truy cập tài nguyên bảo vệ bởi lock đặt ở đây
} finally {
l.unlock();
}


Condition là một interface dùng để nhóm cách xử lý trong các phương thức (wait, notify, notifyAll) của lớp Object vào thành một đối tượng nhằm đưa ra nhiều chọn lựa hơn trong việc đồng bộ, ví dụ chúng ta có thể dùng nhiều condition và khi nào chúng ta muốn đánh thức chính xác điều kiện nào được sử dụng tài nguyên.
Ví dụ ta dùng lại ví dụ Consumer-Producer ở trên, thêm vào 2 biến lock, condition và chỉnh sửa hai làm get và put thế là ta cũng được kết quả như dùng với từ khóa synchronized:
final Lock lock = new ReentrantLock();
final Condition condition = lock.newCondition();
public int get() {
int result;

lock.lock();
try {
while(isRemainingContents == false) {
try {
condition.await();
} catch (InterruptedException e) {

}
}

isRemainingContents = false;

//print onto screen
System.out.println("\tConsumer get " + this.contents);

//get value
result = contents;

//Notify Producer to produce new contents
condition.signalAll();
} finally {
lock.unlock();
}

return result;
}

public void set(int piContents) {
lock.lock();
try {
while(isRemainingContents == true) {
try {
condition.await();
} catch (InterruptedException e) {

}
}

this.contents = piContents;
isRemainingContents = true;

//print onto screen
System.out.println("Producer set " + this.contents);

//Notify Consumer to eat this contents
condition.signalAll();
} finally {
lock.unlock();
}
}
Kết quả luôn luôn là thế này:
Producer set 0
Consumer get 0
Producer set 1
Consumer get 1
Producer set 2
Consumer get 2
Producer set 3
Consumer get 3
Producer set 4
Consumer get 4
Producer set 5
Consumer get 5
Producer set 6
Consumer get 6
Producer set 7
Consumer get 7
Producer set 8
Consumer get 8
Producer set 9
Consumer get 9
ConcurrentMap là một interface kế thừa từ Map dùng để cải tiến, tối ưu hơn khi chạy Map trong ứng dụng đa luồng (multithread)
Ví dụ cách dùng ConcurrentHashMap tương tự dùng Map, tuy nhiên người ta đã thống kê là nếu chương trình có càng nhiều thread truy cập vào cMap này thì dùng ConcurrentMap sẽ cho performance tốt hơn rất nhiều so với dùng Map với đồng bộ kiểu synchronized
public static ConcurrentMap cMap =
new ConcurrentHashMap(1000);

public static void main(String[] args) {
cMap.putIfAbsent("id", "1");
cMap.putIfAbsent("name", "kien");
cMap.putIfAbsent("email", "nakien2a@yahoo.com");

System.out.println(cMap); //Print to screen
}
Kết quả: {name=kien, email=nakien2a@yahoo.com, id=1}
Các bạn tham khảo và đóng góp thêm ý kiến để mình cố gắng lập trình tốt hơn

1.Sự đáp ứng: đa luồng một ứng dụng giao tiếp cho phép một chương trình tiếp tục chạy thậm chí nếu một phần của nó bị khóa hay đang thực hiện một thao tác dài, do đó gia tăng sự đáp ứng đối với người dùng. Thí dụ, một trình duyệt web vẫn có thể đáp ứng người dùng bằng một luồng trong khi một ảnh đang được nạp bằng một luồng khác.
2.Chia sẻ tài nguyên: Mặc định, các luồng chia sẻ bộ nhớ và các tài nguyên của các quá trình mà chúng thuộc về. Thuận lợi của việc chia sẽ mã là nó cho phép một ứng dụng có nhiều hoạt động của các luồng khác nhau nằm trong cùng không gian địa chỉ.
3.Kinh tế: cấp phát bộ nhớ và các tài nguyên cho việc tạo các quá trình là rất
đắt. Vì các luồng chia sẻ tài nguyên của quá trình mà chúng thuộc về nên nó kinh tế hơn để tạo và chuyển ngữ cảnh giữa các luồng. Khó để đánh giá theo kinh nghiệm sự khác biệt chi phí cho việc tạo và duy trì một quá trình hơn một luồng, nhưng thường nó sẽ mất nhiều thời gian để tạo và quản lý một quá trình hơn một luồng. Trong Solaris 2, tạo một quá trình chậm hơn khoảng 30 lần tạo một luồng và chuyển đổi ngữ cảnh chậm hơn 5 lần.
4.Sử dụng kiến trúc đa xử lý: các lợi điểm của đa luồng có thể phát huy trong
kiến trúc đa xử lý, ở đó mỗi luồng thực thi song song trên một bộ xử lý khác nhau. Một quá trình đơn luồng chỉ có thể chạy trên một CPU. Đa luồng trên một máy nhiều CPU gia tăng tính đồng hành. Trong kiến trúc đơn xử lý, CPU thường chuyển đổi qua lại giữa mỗi luồng quá nhanh để tạo ra hình ảnh của sự song song nhưng trong thực tế chỉ một luồng đang chạy tại một thời điểm..

Chuẩn Pthreads
Pthreads tham chiếu tới chuẩn POSIX (IEEE 1003.1c) định nghĩa API cho việc tạo và đồng bộ luồng. Đây là một đặc tả cho hành vi luồng không là một cài đặt.
Người thiết kế hệ điều hành có thể cài đặt đặc tả trong cách mà họ muốn. Thông thường, các thư viện cài đặt đặc tả Pthread bị giới hạn đối với các hệ thống dựa trên cơ sở của UNIX như Solaris 2. Hệ điều hành Windows thường không hỗ trợ Pthreads mặc dù các ấn bản shareware là sẳn dùng trong phạm vi công cộng.
Trong phần này chúng ta giới thiệu một số Pthread API như một thí dụ cho thư viện luồng cấp người dùng. Chúng ta sẽ xem nó như thư viện cấp người dùng vì không có mối quan hệ khác biệt giữa một luồng được tạo dùng Pthread và luồng được gắn với nhân. Chương trình C hiển thị trong hình dưới đây, mô tả một Pthread API cơ bản để xây dựng một chương trình đa luồng.
Chương trình hiển thị trong hình tạo một luồng riêng xác định tính tổng của một số nguyên không âm. Trong chương trình Pthread, các luồng riêng bắt đầu thực thi trong một hàm xác định. Trong hình, đây là một hàm runner. Khi chương trình này bắt đầu, một luồng riêng điều khiển bắt đầu trong main. Sau khi khởi tạo, main tạo ra luồng thứ hai bắt đầu điều khiển trong hàm runner.
Bây giờ chúng ta sẽ cung cấp tổng quan của chương trình này chi tiết hơn. Tất cả chương trình Pthread phải chứa tập tin tiêu đề pthread.h. pthread_t tid khai báo danh biểu cho luồng sẽ được tạo. Mỗi luồng có một tập các thuộc tính gồm kích thước ngăn xếp và thông tin định thời. Khai báo pthread_attr_t attr hiện diện các thuộc tính cho luồng. Chúng ta sẽ thiết lập các thuộc tính trong gọi hàm pthread_attr_init(&attr). Vì chúng ta không thiết lập rõ thuộc tính, chúng ta sẽ dùng thuộc tính mặc định được cung cấp. Một luồng riêng được tạo với lời gọi hàm pthread_create. Ngoài ra, để truyền định danh của luồng và các thuộc tính cho luồng, chúng ta cũng truyền tên của hàm, nơi một luồng mới sẽ bắt đầu thực thi, trong trường hợp này là hàm runner. Cuối cùng chúng ta sẽ truyền số nguyên được cung cấp tại dòng lệnh, argv[1].
Tại điểm này, chương trình có hai luồng: luồng khởi tạo trong main và luồng thực hiện việc tính tổng trong hàm runner. Sau khi tạo luồng thứ hai, luồng main sẽ chờ cho luồng runner hoàn thành bằng cách gọi hàm pthread_join. Luồng runner sẽ hoàn thành khi nó gọi hàm pthread_exit.

#include pthread
#include stdio.h

int sum: /*Dữ liệu này được chia sẻ bởi thread(s)*/
void *runner(void *param); /*luồng*/
main(int argc, char *argv[])
{
pthread_t tid; /*định danh của luồng*/
pthread_attr_t attr; /*tập hợp các thuộc tính*/
if(argc !=2){
fprintf(stderr, “usage: a.out ”);
exit();
}
if (atoi(argv[1] < 0))
{
fprintf(stderr,”%d must be >= 0 \n”, atoi(argv[1]));
exit();
}
/*lấy các thuộc tính mặc định*/
pthread_attr_init(&attr);
/*tạo một luồng*/
pthread_create(&tid,&attr,runner, argv[1]);
/*bây giờ chờ luồng kết thúc*/
pthread_join(tid,NULL);
printf(“sum = %d\n”,sum);
/*Luồng sẽ bắt đầu điều khiển trong hàm này*/
void *runner(void *param)
{
int upper = atoi(param);
int i;
sum = 0;
if (upper > 0){
sum+= i;
}
pthread_exit(0);
}
[b]

Hàm GetCurrentThread(): Dùng để lấy về mục quản của luồng hiện hành.
Hàm SuspendThread(): Dùng để tạm ngừng công việc của luồng với mục quản cho trước.
Hàm Sleep(): Dùng để ngủ 1 số mili(s) cho trước, hết khoảng thời gian đó luồng hiện hành làm việc tiếp (có thời hạn).
Hàm GetTickCount(): Dùng để lấy số milli(s) trôi qua kể từ khi HĐH khởi động cho đến khi thời điểm gọi hàm này.
Hàm ResumeThread(): 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 (luồng) với mục quản cho trước.
Hàm Sleep(1): Ngủ 1 milli(s) trước khi gọi hàm ShowBuffer(). Có tác dụng đồng bộ hóa công việc của luồng chính với công việc các luồng SX.

Giống nhau:

+Luồng thực ra cũng là một tiến trình hay nó còn được gọi là tiến trình nhẹ
+Luồng là một bộ phân của tiến trình hệ thống
+Nhiều luồng hoặc nhiều tiến trình thì sẽ ảnh hưởng tới toàn chương trình
+Luồng và tiến trình đều có thông tin trạng thái

Khác nhau:

+Tạo mới luồng nhanh hơn tạo mới tiến trình
Ví dụ: Việc ngăn một phong mới trong nhà để ở thì sẽ dễ dàng hơn nhiều so với việc xây một ngôi nhà mới.
+Việc chuyển ngữ cảnh của tiến trình này sang tiến trình khác chậm hơn 5 lần việc chuyển ngữ cảnh từ luồng sang luồng
+Lập trình đa luồng thì dễ hơn lâp trình đa tiến trình
+Cấp phát bộ nhớ cho luồng thì nhanh hơn cho tiến trình.

+ Đảm bảo được khả năng đáp ứng của tiến trình tốt hơn.
Khi lập trình đa luồng thì một khi 1 luồng có sự cố thì luồng khác vẫn làm việc, vẫn phản hồi ,trong trường hợp lập trình đơn luồng khi gặp sự cố thì luồng đó sẽ chậm và làm chậm luôn cả tiến trình, đa luồng một ứng dụng giao tiếp cho phép một chương trình tiếp tục chạy thậm chí nếu một phần của nó bị khóa hay đang thực hiện một thao tác dài, do đó gai tăng sự đáp ứng đối với người dùng.
Ví dụ : Các cô ở tổng đài 108 là các luồng , khi khách hàng điện thoại hỏi 108, thì một trong các cô (người thứ nhất) sẽ trả lời, nếu trong thời điểm đó khách hàng thứ hai gọi 108,thì một trong các cô (cô thứ 2) còn lại sẽ trả lời
+ Theo mặc định các luồng có thể dùng chung bộ nhớ và tai nguyên của luồng cha.
Thuận lợi của việc chia sẻ mã là nó cho phép một ứng dụng có nhiều hoạt động của các luồng khác nằm trong cùng không gian, địa chỉ,vài luồng cùng vận hành trong một vùng địa chỉ dễ dùng chung tài nguyên hơn so với trường hợp đa tiến trình.
Ví dụ :Trong lớp chúng ta có thể dùng bảng củ lớp mình, chúng ta có thể chia sẻ các thông tin cần thiết cho tất cả các thành viên ở trong lớp biết,trong khi chúng ta khong thể dùng chung bảng của lớp khác để chia sẻ thông tin cho lớp mình được.
+ Tiết kiệm (Economy) :
Cấp phát bộ nhớ và tài nguyên cho tiến trình là công việc rất tốn kém. Do luồng có thể dùng chung tài nguyên với luồng cha và các luồng khác, việc tạo lập ngữ cảnh cũng nhanh hơn (Solaris2, tạo tiến trình chậm hơn 30 lần, chuyển ngữ cảnh chậm hơn 5 lần
Ví dụ : Các bạn trong lớp là các luồng đang dùng chung một cái bảng của lớp, ai cần ghi thì ghi, ai cần thì chụp hình về xem
Có thể bố trí một chỗ ngồi ở trong lớp cho một bạn đến sau dễ dàng hơn việc làm một chiếc ghế khác cho bạn đó.
+ Chuyển ngữ cảnh từ luồng này sang luồng khác thì nhanh hơn chuyển ngữ cảnh từ tiến trình này sang tiến trình khác.
+ Tận dụng được ưu thế kiến trúc đa xử lý (nhiều CPU). Khi đa luồng thì 1 luồng dùng CPU này và 1 luồng dùng CPU khác sẽ nhanh hơn và các luồng có thể làm việc song song , mỗi luồng có thể chạy bởi CPU riêng. Tiến trình đa luồng sẽ làm việc nhanh hơn tiến trình đơn luồng.
+ Lập trình đa luồng dễ dàng hơn lập trình đa tiến trình

*vì sao phải chung code: đảm bảo được tính đồng bộ và tránh hao tốn tài nguyên bộ nhớ
*ích lợi đa luồng:
-khả năng đáp ứng tốt hơn vì có 1 luồng gặp sự cố thì các luồng khác vẫn hoạt động bình thường
vd: tổng đài 1080 có 100 nhân viên trực(100 luồng) , tổng đài 108 có 1 nv trực(1 luồng)
1080 khi có 1 nv ko thể trực ,99 nv khác còn lại vẫn trực bình thường thì tổng đài vẫn hoạt động
108 khi có 1 nv ko thể trực , thì tổng đài ngưng hoạt động
- chia chia sẽ tài nguyên trong 1 tiến trình dễ dàng hơn
-tiết kiệm bộ nhớ và tài nguyên
- tận dụng được thế mạnh kiến trúc đa sử lý
- lập trình đa luồng dễ dàng hơn lập trình đa tiến trình

Khi bạn sử dụng thread, trong thread đang chạy bạn xử lý với các control và đôi lúc bạn gặp phải cái lỗi "Cross-thread operation not valid: ...". Cái lỗi này khi xài VS 2003 thì bạn không gặp phải, nhưng với > VS2005 thì chắc chắn là gặp. Và cách xử lý như sau:
Mô tả một đoạn mã gặp lỗi:
using System.Threading;

public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void AddItemN(int n)
{
for (int i = 0; i < n; i++)
{
lsbCross.Items.Add(i);
}
}

private void AddItem()
{
for (int i = 0; i < 10; i++)
{
lsbCross.Items.Add(i);
}
}

private void CrossThread()
{
AddItemN(20);
}

private void btnCross_Click(object sender, EventArgs e)
{
ThreadStart ths = new ThreadStart(AddItem);
Thread thd = new Thread(ths);
thd.Start();
}
}
còn đây là thông báo lỗi

Cross-thread operation not valid: Control 'lsbCross' accessed from a thread other than the thread it was created on.
Cách xử lý thì bạn chỉ cần thay các hàm AddItem (không có tham số truyền cho hàm), AddItemN(int n) (có tham số truyền cho hàm) bằng các hàm đã xử lý cross thread như sau:

#region Xử lý Cross Thread
//Xử lý cross có truyền tham số (sử dụng hàm AddItemN)
private delegate void dlgAddItemN(int n);
private void AddItemN(int n)
{
//nếu control nào đó không có properties InvokeRequired thì xài luôn this.InvokeRequired không cần phải thông qua control
if (this.lsbCross.InvokeRequired)
{
this.Invoke(new dlgAddItemN(AddItemN), n);
}
else
{
for (int i = 0; i < n; i++)
{
this.lsbCross.Items.Add(i);
}
}
}

//Xử lý cross thread không truyền tham số cho hàm (sử dụng hàm AddItem)
private delegate void dlgAddItem();
private void AddItem()
{
if (this.lsbCross.InvokeRequired)
{
this.Invoke(new dlgAddItem(AddItem));
}
else
{
for (int i = 0; i < 10; i++)
{
this.lsbCross.Items.Add(i);
}
}
}
#endregion

- bao gồm các luồng giống nhau chung chức năng chung code
- tiến trình cha tạo sẵn 1 tập luồng khi khởi động , tập luồng này ở trạng thái ngũ sẵn sàng chờ công việc
vd: năm 1999 thầy đi đến mạng phương nam: mạng phương nam là áp dụng công nghệ CGI(COMMON GATEWAY INTERFACE)(ĐA TIẾN TRÌNH) cho nhu cầu tìm kiếm việc làm qua mạng. khi đó mạng phương nam gặp sự cố , khi có nhiều người đăng nhập cùng một lúc thì server treo phải reset lại server cho nạp lại. khi đó thầy đưa ra phương án gián quyết cho sự cố trên là áp dụng công nghệ ASP(ACTIVE SERVER PAGES)(ĐA LUỒNG) VÀ đã giải quyết được sự cố và giúp mạng phương nam nâng cao hơn về tính năng quản lý và giao diện web

Ta cần phải nêu rõ 2 vấn đề:
* Thứ nhất:
KN: luồng còn gọi là tiến trình nhẹ, một đơn vị cơ bản sử dụng CPU, luồng cũng có các thông tin trạng thái giống như 1 tiến trình, một tiến trình có nhiều luồng con các luồng con trong một tiến trình có thể rất giống nhau, mỗi luồng có khả năng chia sẽ tài nguyên với các luồng khác trong 1 tiến trình.
*Thứ hai:
Điểm giống nhau:
- Luồng cũng là 1 tiến trình và cũng là đơn vị cơ bản nhất sử dụng CPU.
* Thứ ba:
Điểm khác nhau:
- Luồng là một bộ phận của tiến trình, nên mang đầy đủ tố chất, thông tin trạng thái của một tiến trình nhưng là một tiến trình nhẹ,
- Luồng còn được gọi tiểu tiến trình,
- Do được HĐH quản lý và cấp phát CPU nên nó có thông tin trạng thái của nó,
- Luồng phải có thông tin của 1 TCP.
** Tính ưu việc của công nghệ đa luồng trong các HĐH hiện đại là:
- Các hệ điều hành rất khéo léo cấp phát một các công bằng cho các luồng nằm trong 1 tiến trình, do luồng là một tiến trình nhẹ nên rất được các HĐH hiện đại sử dụng, cho phép hình thành nhiều tiến trình con(luồng) chạy song song cùng nhau trong cùng 1 tiến trình.
- Khả năng đáp ứng tốt hơn: khi có công nghệ đa luồng thì nhiều luồng sẽ được chạy cùng nhau, khi có một luồng bị bận không thể đáp ứng được thỉ các luồng khác ngay lập tức sẽ thay thế nó làm công việc đó. Vd: Gọi điện đến tổng đài Viettel luôn luôn được đáp ứng, cho dù trong cùng 1 thời điểm cũng sẽ có rất nhiều người gọi về số tổng đài đó-> chứng tỏ Viettel đã ứng dụng công nghệ đa luồng trong quản lý các cuộc gọi về tổng đài.
- Chia sẽ tài nguyên: theo mặc định thì các luồng có thể sử dụng cùng chung bộ nhớ và tài nguyên của luồng cha, các luồng vận hành trong cùng một địa chĩ sẽ dễ dàng chia sẽ tài nguyên hơn trường hơp đa tiến trình.
- Tiết kiệm: việc cấp phát bộ nhớ và tài nguyên cho các tiến trình là một công việc rất tốn kém, do các luồng dùng chung tài nguyên với luồng cha nên sẽ giảm thiểu chi phí cấp phát cho nhiều luồng khác nhau,
- Đa luồng giúp làm tăng tính song song trên trên cấu trúc máy nhiều CPU, do vậy mỗi luồng có thể chạy trên các CPU riêng,
- Việc lập trình đa luồng sẽ dễ dàng hơn việc lập trình đa tiến trình, vì luồng là một tiến trình nhẹ, là con của tiến trình nên việc lập trình từng cái nhỏ thành cái lớn sẽ dễ dàng hơn.

- Tiến trình cha tạo lập sẵn một tập luồng ngay khi vửa khởi động một công việc và chuyển nó sang trạng thái sleep(vì nếu cho xử lý liền thì sẽ tốn CPU). Phải chuyển sang trạng thái ngủ nên khi có yêu cầu xử lý thì sẽ chuyển sang trạng thái xử lý ngay, mặc dù phải tốn RAM để duy trì tập luồng trong trạng thái sleep nhưng vẫn tốt hơn, tiết kiệm hơn trong việc phải chờ hình thành một tiến trình khác.
- Các luồng trong tập luồng luôn trong trạng thái sẵn sàng chờ công việc, ngay khi có yêu cầu xử lý thì tập luồng sẽ điều phối các luồng ra thực hiện trong phạm vi số lượng luồng cho phép, nếu hết thì cần phải chờ luồng xử lý xong mới tiếp tục đáp ứng thực hiện yêu cầu sau.
- Khi tiến trình cha nhận được một yêu cầu thì một luồng con sẽ được đánh thức và đưa vào vận hành.
- Sau khi phục vụ xong yêu cầu thì luồng ngay lập tức sẽ được trả về tập luồng và chờ cho đến khi được gọi thực thị công việc kế tiếp.
- Nếu số lượng yêu cầu quá lớn, lớn hơn số lượng luồng trong tập luồng, thì tiến trình cha phải chờ cho đến khi có luồng con được giải phóng trả về mới gọi đi thực thi tiếp.

Ví dụ:
- Mỗi lớp là một tiến trình nặng, cùng nhau hoạt động trong phạm vi 1 lầu, chúng hoạt động song song, cùng lúc với nhau,
- Trong phạm vi mỗi lớp thì có nhiều tiến trình nhẹ hay tập luồng cùng hoạt động song song, đảm bảo tính nhất quán cùng nhau
- Và tiến trình cha đó chính là tiến trình thầy, sẽ là người điều phối các luồng(Sinh viên) trong tập luồng lớp thực thi các yêu cầu của bài học để đạt được kết quả học tập tốt nhất, như: việc điều phối SV lên bảng làm bài tập, kiểm tra bài tập, yêu cầu sinh viên trả lời câu hỏi, yêu cầu thảo luận nhóm,...