Thảo luận Bài 5 (Đa luồng)

Luồng - Thread: Một dòng các lệnh mà CPU phải thực thi.
Các hệ điều hành mới cho phép nhiều luồng được thực thi đồng thời. Chúng ta đã quen với việc mở nhiều ứng dụng trong một lần làm việc với máy tính.
- Một luồng là một chuỗi các lệnh nằm trong bộ nhớ (chương trình đã được nạp).
- 1 application thông thường khi thực thi là một luồng.
- Trong 1 application có thể có nhiều luồng. Thí dụ chuyển động của 10 đối tượng hiện hành trong 1 trò chơi là một luồng.

Lợi ích của đa luồng:
- Tăng hiệu suất sử dụng CPU: Phần lớn thời gian thực thi của 1 ứng dụng là chờ đợi nhập liệu từ user -> hiệu suất sử dụng CPU chưa hiệu quả.
- Tạo được sự đồng bộ giữa các đối tượng: thí dụ như trong 1 trò chơi, các nhân vật cùng nhau chuyển động.
- Quản lý được thời gian trong các ứng dụng nhu thi online, thời gian chơi một trò chơi.

NguyenDinhHop (I11C) đã viết:Giới thiệu Luồng Java
Như chúng ta đã thấy, hỗ trợ cho luồng có thể được cung cấp tại cấp người dùng với một thư viện như Pthread. Hơn nữa, hầu hết hệ điều hành cung cấp sự hỗ trợ cho luồng tại cấp nhân. 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.

Cách tạo luồng trong Java
Một cách để tạo một luồng rõ ràng là tạo một lớp mới được phát sinh từ lớp Thread và viết đè phương thức run của lớp Thread. Tiếp cận này được hiển thị trong hình sau, ấn bản Java của chương trình đa luồng xác định tổng các số nguyên không âm. Một đối tượng của lớp phát sinh sẽ chạy như một luồng điều khiển đơn trong máy ảo Java. Tuy nhiên, tạo một đối tượng được phát sinh từ lớp Thread không tạo một luồng mới, trái lại phương thức start mới thật sự tạo luồng mới. Gọi phương thức start cho đối tượng mới thực hiện hai thứ:
1) Nó cấp phát bộ nhớ và khởi tạo một luồng mới trong máy ảo Java.
2) Nó gọi phương thức run, thực hiện luồng thích hợp để được chạy bởi máy ảoJava. (Chú ý, không thể gọi phương thức run trực tiếp, gọi phương thức start sẽ gọi phương thức run).
Để hiếu rõ hơn về cách tạo luồng trong Java mình xin giởi thiệu ví dụ hàm tính tổng các số nguyên không âm
Class Summation extends Thread
{
public Summation (int n){
upper = n;
}
public void run(){
int sum = 0;

if (upper>0){
for(int i = 1; i<= upper; i++){
sum+=i;
}
System.out.println(“The sum of ”+upper+ “ is “ + sum);
}
private int upper;
}

public class ThreadTester
{
public static void main(String args[]){
if(args.length>0){
if(Integer.parseInt(args[0])<0)
System.err.println(args[0] + “ must be >= 0.”);
else{
Summation thrd = new Summation
(Integer.parseInt(args[0]));
Thrd.start();
}
}
Else
System.out.println(“Usage: summation < integer value”);
}
}
Khi chương trình tính tổng thực thi, hai luồng được tạo bởi JVM. Luồng đầu tiên là luồng được nối kết với ứng dụng-luồng này bắt đầu thực thi tại phương thức main. Luồng thứ hai là luồng Summation được tạo rõ ràng với phương thức start.Luồng Summation bắt đầu thực thi trong phương thức run của nó. Luồng kết thúc khi nó thoát khỏi phương thức run của nó.

Chào các bạn!
Bạn nào quan tâm đến lập trình đa luồng trong java thì vào trang http://news.congdongjava.com/index.php/java-se-desktop/35-da-luong-trong-java.html tham khảo nhé ! Nó giới thiệu cách tạo và quản lý luồng, những lớp tiện ích trong lập trình đa luồng... và có cả code minh họa luôn đó.

minhgiangbc đã viết:Y nghĩa 1 vai ham trong bài toán
#include <stdio.h> -->khai báo
#include <conio.h>
#include <windows.h>
#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; i<BUFFER_SIZE-1; i++)
printf("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ụ
}
}

Cảm ơn bạn, mình đang tìm cái này, hôm trước thầy giảng, ngồi dưới bàn chót, nên nghe ko rõ lắm

Hẳn các bạn có từng nghe cái tên HyperThreading (siêu phân luồng) khi đi mua PC thời Pentimum 4 và ngay cả bây giờ cũng vậy . Bài viết dưới đây sẽ cho cho các bạn biết Hyperthreading là gì và nó ảnh hưởng gì đến hiệu năng của CPU .

HyperThreading (HT) là khái niệm được Intel giới thiệu trong thời kỳ giữa của Pentium 4. Công nghệ này ngay khi được giới thiệu trên thị trường đã đạt được những thành công vang dội về khía cạnh… marketing. Chúng tôi không hề nói đùa! Công nghệ HyperThreading áp dụng trong Pentium 4 đã làm rất nhiều người dùng thỏa mãn với 2 biểu đồ hoạt động của CPU hiện lên trong cửa sổ Task Manager. Trong khi với các thử nghiệm thực tế, đôi khi bật tính năng này lên còn làm cho CPU xử lý kém hiệu quả hơn trong một vài công việc. Tất nhiên, HT cũng làm cho một vài ứng dụng nhanh hơn nếu ứng dụng đó yêu cầu CPU làm việc theo cái cách mà HT có thể phát huy khả năng của mình. Thành thực mà nói là như vậy, nhưng nhìn chung, việc hy vọng vào HT để tăng tốc độ xử lý của CPU phần nhiều là… hên xui. Và như vậy HyperThreading đã nói lời chia tay với người dùng khi Core ra đời. Lý do gây ra hiệu quả nghèo nàn này của HyperThreading không phải nằm ở bản chất của HyperThreading, mà là nằm ở kiến trúc của Pentium 4, không phù hợp cho Hyper Threading trổ tài.

HyperThreading là gì?

Về bản chất, một nhân xử lý không thể xử lý hai luồng thông tin vào cùng một thời điểm. Nếu chúng ta muốn cùng một lúc có được nhiều ứng dụng (hay thực chất là rất nhiều các process con, hoặc rất nhiều thread) chạy song song, hệ điều hành của chúng ta phải ra lệnh cho nhân xử lý liên tục và chuyển qua chuyển lại tác vụ xử lý cho từng thread. Quá trình này diễn ra rất-rất nhanh và hoàn toàn không thể nhận biết bằng mắt thường, tạo cảm giác như CPU của chúng ta xử lý tất cả các khối lượng công việc đó song song cùng một thời điểm.



Minh họa cho cách SMT (Hyper Threading) làm tăng hiệu quả xử lý của CPU

HyperThreading là tên của Intel đặt cho công nghệ SMT (Simultaneous Multi-Threading). Công nghệ này cho phép một nhân xử lý có thể thực sự xử lý song song các thread do các ứng dụng tạo ra, bằng cách trang bị thêm một số thành phần của nhân xử lý, khiến hệ điều hành nghĩ rằng nó đang làm việc với nhiều nhân xử lý. Như vậy, với một hệ điều hành tương thích bộ xử lý nhiều nhân hay nhiều bộ xử lý, nó sẽ sắp xếp để nhiều thread cùng được gửi đến các bộ xử lý “ảo” đó. Về mặt lý thuyết, khi chúng ta chỉ có một nhân xử lý thì nó có xử lý song song được bao nhiêu thread cũng không thể tăng tốc độ xử lý chúng lên được. Tuy nhiên trong thực tế, không phải bất kỳ lúc nào mọi thành phần của nhân xử lý cũng được sử dụng đến, và những thành phần không được sử dụng đến này có thể dùng để xử lý thread thứ hai (hoặc thứ ba, thứ tư…). Công nghệ SMT còn giúp bộ xử lý làm việc hiệu quả hơn bằng cách giảm bớt số lần nhân xử lý phải chuyển qua chuyển lại giữa các thread ‘’song song”. Quá trình chuyển này, như đã nói ở trên, diễn ra rất nhanh và liên tục, nhưng không có nghĩa là không mất thời gian, và bằng việc giảm bớt lượng công việc này, bộ xử lý có thể được rảnh rang để tập trung vào chuyên môn hơn.

Nehalem và HyperThreading

Quay trở lại một vài trang trước của bài viết này, chúng tôi có nhấn mạnh rằng Intel đã không chú trọng nhiều vào việc tăng tốc độ xử lý của nhóm các đơn vị thực thi mà chú trọng vào việc nâng cao hiệu suất của chúng. Và đây chính là điểm mấu chốt của việc họ ứng dụng công nghệ HyperThreading vào Nehalem. Kiến trúc của Nehalem, giống như Core rất thân thiện với việc áp dụng HyperThreading (hay SMT), với mục đích nâng cao hiệu suất xử lý hơn là tốc độ xử lý, các thread xử lý song song được ghép chung với nhau một cách tối ưu hơn, tận dụng tốt hơn những thành phần rảnh rỗi của nhân xử lý. Kết hợp điều này với băng thông cực lớn của bus giao tiếp với bộ nhớ (sẽ được nói sâu hơn ở phần sau bài viết) và bộ nhớ cache lớn hơn nhiều lần so với Pentium 4, nhân xử lý của Nehalem luôn luôn được nhồi đủ dữ liệu để yên tâm làm việc của mình.



Biểu đồ cung cấp bởi Intel về sự gia tăng trong tốc độ xử lý các tác vụ khác nhau. Kết quả được kiểm nghiệm bởi vozLabs vui lòng xem thêm phía dưới.

Để hiểu thêm về cách Intel đã ứng dụng SMT vào Nehalem, ngoài khả năng diễn đạt của chúng tôi bằng tiếng Việt về vấn đề này thực sự gặp khó khăn thì chúng tôi cũng e rằng kiến thức của mình không đủ để diễn đạt đúng bản chất của vấn đề. Do vậy rất mong bạn đọc thông cảm. Các bạn có thể tham khảo thêm một số tài liệu rất hữu ích tại Tom’s Hardware, Be Hardware và Anandtech.

Kết quả thử nghiệm của chúng tôi

Trong một khoảng thời gian ngắn ngủi có được, nhóm thử nghiệm sản phẩm đã thử kiểm nghiệm hiệu quả của việc ứng dụng SMT với Nehalem, và có lẽ tất cả các bạn đều đang rất nóng lòng chờ đợi những kết quả này. Sử dụng công cụ Geekbench 2.0, chúng tôi tiến hành thử nghiệm và thu thập các kết quả test Multi-threaded giữa hai chế độ bật và tắt HyperThreading.



Nhanh hơn trong hầu hết tất cả các thử nghiệm, duy chỉ có LU Decomposition là việc bật HT mang lại hiệu năng thấp hơn, HT thực sự như cá gặp nước với Nehalem.

Cần phải chú thích thêm một chút, trong thử nghiệm Crafty Chess, kết quả multi-threaded còn kém hơn so với kết quả single-threaded, và tình hình còn tệ hại hơn nữa khi HT được bật. Một dấu hiệu cho thấy thử nghiệm này đặc biệt ”ghét’ mọi hình thức chạy song song nhiều thread. Ngoài ra thì, nhìn vào biểu đồ, có lẽ không cần phải phân tích thêm gì nhiều, mọi thứ đều tuyệt vời! Đây chỉ là so sánh giữa hai chế độ HyperThreading bật và tắt, vậy HT có ảnh hưởng như thế nào giữa hai chế độ single-threaded và multi-threaded?



Ngay cả khi HT không được bật, chênh lệch giữa single-threaded (chỉ sử dụng 1 core) với multi-threaded (sử dụng cả 4 core) vẫn thực sự ấn tượng, hầu hết các test đều cho kết quả nhanh hơn xấp xỉ 4 lần.

Hãy nhìn vào biểu đồ, ngoại trừ LU Decomposition có vấn đề với HT như các bạn có thể thấy ở biểu đồ trước và Crafty Chess qua biểu đồ thứ hai này, một lần nữa xác nhận rằng test này rất kỵ chạy multi-threaded. Ngoài ra thì sao? Chúng tôi chưa muốn nói tới khả năng tăng tốc giữa 1 nhân và 4 nhân của Nehalem tốt tới mức nào, hầu hết là ở khoảng xấp xỉ gần 4 lần, một vài trường hợp còn hơn, thì trong tất cả các test HT khi bật đều nâng mức tăng tốc lên rất nhiều, một vài test gần đạt tới con số 7. Khá là tuyệt!

Theo Voz.vn

Ví dụ về luồng và và đa luồng:
+ Nhiều gói phần mềm chạy trên các máy để bàn PC là đa luồng
* Một trình duyệt Web có thể có một luồng hiển thị hình ảnh, văn bản trong khi một luồng khác
lấy dữ liệu từ mạng
* Một trình soạn thảo văn bản có thể có một luồng hiển thị đồ họa, luồng thứ hai đọc sự bấm phím trên bàn phím từ người dùng, một luồng thứ ba thực hiện việc kiểm tra chính tả và từ vựng chạy trong chế độ nền.

Trong những trường hợp cụ thể một ứng dụng đơn có thể được yêu cầu thực hiện nhiều tác vụ đơn.
* Thí dụ, một trình phục vụ web chấp nhận các yêu cầu khách hàng như trang web, hình ảnh, âm thanh
=> Một trình phục vụ web có thể có nhiều (hàng trăm) khách hàng truy xuất đồng thời nó. Nếu trình phục vụ web chạy như một quá trình đơn luồng truyền thống thì nó sẽ có thể chỉ phục vụ một khách hàng tại cùng thời điểm. Lượng thời gian mà khách hàng phải chờ yêu cầu của nó được phục vụ là
rất lớn.

*Luồng là gì?
Luồng là một dòng điều khiển trong phạm vi một quá trình. Quá trình đa luồng
gồm nhiều dòng điều khiển khác nhau trong cùng không gian địa chỉ. Những lợi điểm
của đa luồng gồm đáp ứng nhanh đối với người dùng, chia sẻ tài nguyên trong quá
trình, tính kinh tế, và khả năng thuận lợi trong kiến trúc đa xử lý.
Luồng cấp người dùng là các luồng được nhìn thấy bởi người lập trình và không
được biết bởi nhân. Thư viện luồng trong không gian người dùng điển hình quản lý
luồng cấp người dùng. Nhân của hệ điều hành hỗ trợ và quản lý các luồng cấp nhân.
Thông thường, luồng cấp người dùng nhanh hơn luồng cấp nhân trong việc tạo và
quản lý. Có ba loại mô hình khác nhau liên quan đến luồng cấp người dùng và luồng
cấp nhân. Mô hình nhiều-một ánh xạ nhiều luồng người dùng tới một luồng nhân. Mô
hình một-một ánh xạ mỗi luồng người dùng tới một luồng nhân tương ứng. Mô hình
nhiều-nhiều đa hợp nhiều luồng người dùng tới một số lượng nhỏ hơn hay bằng luồng
nhân.
Những chương trình đa luồng giới thiệu nhiều thử thách cho việc lập trình, gồm
ngữ nghĩa của lời gọi hệ thống fork và exec. Những vấn đề khác gồm huỷ bỏ luồng,
quản lý tín hiệu, và dữ liệu đặc tả luồng. Nhiều hệ điều hành hiện đại cung cấp nhân
hỗ trợ luồng như Windows NT, Windows 2000, Solaris 2 và Linux. Pthread API cung
cấp tập hợp các hàm để tạo và quản lý luồng tại cấp người dùng. Java cung cấp một
API tương tự cho việc hỗ trợ luồng. Tuy nhiên, vì các luồng Java được quản lý bởi
JVM và không phải thư viện luồng cấp người dùng hay nhân, chúng không rơi vào
loại luồng người dùng hay nhân.


*Tạo 1 luồng
Một cách để tạo một luồng rõ ràng là tạo một lớp mới được phát sinh từ lớp Thread và viết đè phương thức run của lớp Thread.
Một đối tượng của lớp phát sinh sẽ chạy như một luồng điều khiển đơn trong máy ảo
Java. Tuy nhiên, tạo một đối tượng được phát sinh từ lớp Thread không tạo một luồng
mới, trái lại phương thức start mới thật sự tạo luồng mới. Gọi phương thức start cho
đối tượng mới thực hiện hai thứ:
1) Nó cấp phát bộ nhớ và khởi tạo một luồng mới trong máy ảo Java.
2) Nó gọi phương thức run, thực hiện luồng thích hợp để được chạy bởi máy ảo
Java. (Chú ý, không thể gọi phương thức run trực tiếp, gọi phương thức start
sẽ gọi phương thức run)

Luồng:về cơ bản thì vẫn lá tiến trình nhưng 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ó các thông tin trạng thái như của tiến trình (HWP - Heavy Weight Process)
Ví dụ: mỗi làn xe trên đường phố là 1 tiến trình .Bên trong mỗi làn xe lại có rất nhiều xe đang di chuyển .Ở đây các xe được xem như là các luồng.
Tiến trình:là chương trình trong thời gian thực .
Điểm giống nhau giữa luồng và tiến trình :
Đều là tiến trình. Vì vậy cưng có đầy đủ các tính chất của 1 tiến trình .
Khác nhau:
Luồng là tiến trình nhẹ. Còn tiến trình là tiến trình nặng.
Tiến trình bao gồm nhiều luồng bên trong .Còn bên trong luồng không bao gồm luồng khác

Đa luồng đảm bảo khả năng đáp ứng của tiến trình tốt hơn.Nếu như 1 luồng có sự cố thí 1 luồng khác sẽ thay thế tiếp tục làm việc. Ví dụ như tổng đài 1080 trong đó thì mỗi tổng đài viên là 1 luồng .Nếu 1 người nào bận thì lập tức sẽ có 1 người khác giải đáp thắt mắc.
Đa luồng giúp chia sẻ tài nguyên tốt hơn .Thật vậy vì các luồng ở cùng 1 tiến trình nên sẽ dễ dàng chia sẻ tài nguyên hơn. Ví dụ các sinh viên trong cùng 1 lớp sẽ chia sẽ tài nguyên (ví dụ như bảng) dễ hơn so với việc các sinh viên khác lớp nhau chia sẻ tài nguyê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.

Tập luồng (Thread Pools):
- Tiến trình cha yêu cầu tạo lập sẵn một tập luồng chờ (ở trạng thái waiting). Khi tiến trình cha nhận một yêu cầu thì một luồng được đánh thức để xử lý yêu cầu đó. Sau khi thực hiện xong, luồng được đưa trả về tập luồng tiếp tục chờ .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ụ:Lớp học là một tiến trình .Trong đó giáo viên là luồng chính. Khi có 1 bài tập nào đó thì giáo viên sẽ yêu cầu 1 học sinh lên bảng thực hiện bài tập này. Đôi khi bài tập này quá lớn thì giáo viên có thể chia bài tập này ra nhiều phần và cho các học sinh khác nhau giải quyết từng phần .

1. Kha nang dap ung(Responsiveness) tot hon: trong khi mot luong bi ach hoac qua ban, luong khac van van hanh binh thuong(luong chinh cua trinh duyet van tuong tac voi nguoi dung trong khi du lieu duoc lay ve).
2.Chia se tai nguyen(Resource Sharing): theo mac dinh,cac luong co the dung chung bo nho va tai nguyen cua luong cha. Vai luong cung van hanh trong 1 vung dia chi,do do de dung chung tai nguyen hon so voi truong hop da tien trinh.
3.Tiet kiem(Economy): cap phat bo nho va tai nguyen cho tien trinh la cong viec ton kem. Do luong chung tai nguyen voi cha va cac luong khac, viec tao lap va chuyen ngu canh cung nhanh hon(Solaris 2: tao tien trinh cham hon 30 lan,chuyen ngu canh cham hon 5 lan).
4. Tan dung duoc the manh cua kien truc da xu ly: da luong lam tanh tinh song song tren he may nhieu CPU. Moi luong co the chay boi CPU rieng.
5. Lap trinh da luong de hon lap trinh da tien trinh.

Phân biệt đa luồng và đa tiến trình?

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 ví dụ mượn đồ trong gia đình dễ mượn đồ hơn của hàng xóm
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 riêng ra một phòng trong nhà thì dễ hơn được nhà nước cấp cho một căn hộ
Cấp phát tài nguyên cho bộ nhớ thì tốn kém
Lập trình đa luồng thì dễ hơn lập trình đa tiến trình

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();
}
}

Mình xin giới thiệu một số ví dụ về đa luồng để các ban hiểu hơn
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.
mình sẽ tạo ra 2 phương thức A() và B()
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
}
Phương thức hàm main() của chương trình:
static void main()
{
ThreadStart ts1 = new ThreadStart(A); // Chỉ định A lên đọc
ThreadStart ts2 = new ThreadStart(B); // Chỉ định B lên đọc

// Sẵn sàng cho cuộc đấu (thi đếm nhanh )
Thread tA = new Thread(ts1);
Thread tB = new Thread(ts2);

// Bắt đầu bấm giờ
tA.Start();
tB.Start();
tA.Join();
tB.Join();
//đếm
Console.WriteLine("kết thúc");
Console.ReadLine();
}

Truyền tham số cho Thread
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);
}

}

Chờ đợi một luồng khác
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);
}
}

Đây là một số ví dụ, các bạn tham khảo rồi góp ý nha

vohongcong(I111C) đã viết:Hôm qua trên lớp thầy có hỏi 1 câu tại sao phải dùng code chung?.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.

Nhưng theo mình nói một cách dễ hiểu hơn đó chính là chạy code chung cho dễ đồng bộ.

Mình xin nêu lên một số ý kiến về dùng code chung, có thể theo ý nghĩ của mình thiên về thực tế một chút: Khi dùng code chung, chúng ta sẽ đi theo một cái chung nào đó, mỗi người sẽ phát triển theo một hướng riêng nhưng dựa trên nền tản là chung đó. Mình ví dụ đơn giản thế này, áp dụng ngay tại lớp học chúng ta, Thầy dạy môn hệ điều hành, hôm nay thầy dạy bài 5 là Đa luồng chẳng hạn, thầy sẽ cho chúng ta hiểu rõ hơn về đa luồng, nhưng với mỗi người chúng ta sẽ tiếp thu và hiểu một cách khác nhau nhưng có một cái chung là đều dựa trên bài giảng của thầy về đa luồng.

Admin đã viết:Thảo luận những vấn đề liên quan đến Bài 5 (Đa luồng).

• Sơ qua về luồng (Thread)
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.
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ụ, sếp giao việc cho bạn là "Viết chương trình quản lý cho bộ phận mình". "Công việc lớn" này giả sử có thể gồm 3 việc nhỏ "thiết kế csdl", "thiết kế giao diện", và “coding xử lý". Sau đó được lãnh thưởng sau khi làm xong ứng dụng, càng nhanh trước thời hạn càng được thưởng nhiều tiền, trễ hạn sẽ bị phạt. Rõ ràng là bạn muốn làm xong việc càng sớm càng tốt nên bạn sẽ phối hợp thêm 2 bạn nữa: bạn A thì thiết kế giao diện, bạn B thì coding xử lý còn bạn thì thiết kế csdl. Cả 3 người cùng làm đồng thời. Thiết kế giao diện xong, csdl cũng đã hoàn tất, bạn phải đợi bạn B thông báo là coding xong thì bạn mới có thể báo cáo cho sếp để mà lãnh tiền thưởng . Như vậy multithread cho "thiết kế giao diện", "coding" và “thiết kế csdl” 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ự từng việc nhỏ).
• 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 bạn tên là A và B thi đếm từ 0 cho đến 100, bạn 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 bạn).
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 bạn lên thi đọc --> 2 bạn 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 bạn này
static void main()
{
ThreadStart ts1 = new ThreadStart(A); // Chỉ định bạn A lên đọc
ThreadStart ts2 = new ThreadStart(B); // Chỉ định bạn B lên đọc

// Sẵn sàng cho cuộc đấu (thi đếm nhanh )
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 bạn tranh nhau đếm
Console.WriteLine("Cuộc thi kết thúc"); // Chờ đến khi 2 bạn đọc xong, không biết bạn nào sẽ thắng
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ụ:
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
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ó
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ụ
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.
Thân chào!

vohongcong(I111C) đã viết:Hôm qua trên lớp thầy có hỏi 1 câu tại sao phải dùng code chung?.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.

Nhưng theo mình nói một cách dễ hiểu hơn đó chính là chạy code chung cho dễ đồng bộ.

Chào bạn!
Ý bạn bổ sung thêm thực sự Thầy đã nêu ra trong lời giảng luôn rồi chứ không phải thiếu hay chưa chính xác đâu. Chắc tại bạn chưa nghe kỹ thôi à!
Thân!

Uhm thầy cũng bảo là code chung thì dễ phát triển và nếu có sửa đổi code thì những cái khác cũng ăn theo. Vì riêng biệt thì khó phát triển đồng bộ được.

Mình sưu tầm được 1 số ví dụ này, mình chia sẻ cho các bạn tham khảo nhé
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ó 2 tên là A và B thi đếm từ 0 cho đến 100, bạn 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 bạn).
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 gọi 2 bạn lên thi đọc --> 2 bạn 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 bạn này
static void main()
{
ThreadStart ts1 = new ThreadStart(A); // Chỉ định A lên đọc
ThreadStart ts2 = new ThreadStart(B); // Chỉ định B lên đọc

// Sẵn sàng cho cuộc đấu (thi đếm nhanh )
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 bạn tranh nhau đếm
Console.WriteLine("Cuộc thi kết thúc"); // Chờ đến khi 2 bạn đọc xong, không biết bạn nào sẽ thắng
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ụ:
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
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ó
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ụ
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

Những thuận lợi của lập trình đa luồng có thể được chia làm bốn loại:
• 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.
• 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ỉ.
• 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.
• 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.
Thân chào!

Chúng ta thường thảo luận là xem xét luồng như một chiều hướng chung. Tuy nhiên, hỗ trợ luồng được cung cấp hoặc ở cấp người dùng, cho các luồng người dùng hoặc ở cấp nhân, cho các luồng nhân như sau:
• Luồng người dùng: được hỗ trợ dưới nhân và được cài đặt bởi thư viện luồng tại cấp người dùng. Thư viện cung cấp hỗ trợ cho việc tạo luồng, lập thời biểu, và quản lý mà không có sự hỗ trợ từ nhân. Vì nhân không biết các luồng cấp người dùng, tất cả việc tạo luồng và lập thời biểu được thực hiện trong không gian người dùng mà không cần sự can thiệp của nhân. Do đó, các luồng cấp người dùng thường tạo và quản lý nhanh, tuy nhiên chúng cũng có những trở ngại. Thí dụ, nếu nhân là đơn luồng thì bất cứ luồng cấp người dùng thực hiện một lời gọi hệ thống nghẽn sẽ làm cho toàn bộ quá trình bị nghẽn, thậm chí nếu các luồng khác sẳn dùng để chạy trong ứng dụng. Các thư viện luồng người dùng gồm các luồng POSIX Pthreads, Mach C-threads và Solaris 2 UI-threads.
• Luồng nhân: được hỗ trợ trực tiếp bởi hệ điều hành. Nhân thực hiện việc tạo luồng, lập thời biểu, và quản lý không gian nhân. Vì quản lý luồng được thực hiện bởi hệ điều hành, luồng nhân thường tạo và quản lý chậm hơn luồng người dùng. Tuy nhiên, vì nhân được quản lý các luồng nếu một luồng thực hiện lời gọi hệ thống nghẽn, nhân có thể lập thời biểu một luồng khác trong ứng dụng thực thi. Trong môi trường đa xử lý, nhân có thể lập thời biểu luồng trên một bộ xử lý khác. Hầu hết các hệ điều hành hiện nay như Windows NT, Windows 2000, Solaris 2, BeOS và Tru64 UNIX (trước Digital UNIX)-hỗ trợ các luồng nhân.

1-Running : đang chạy – được hiểu là khi hệ thống định rõ vị trí luồng trong CPU
2-Ready to run : đã chạy ( nhưng chưa được định vị trí trong CPU )
3-Resumed : luồng ở trạng thái “ready to run” sau khi suspended/ blocked
4-Suspended : luồng tự nguyện dừng lại để cho 1 luồng khác chạy
5-Blocked : luồng đang đợi tài nguyên để tiếp tục hoặc bị 1 sự kiện của hệ thống
chặn ngang

Chào các bạn !!!
Mình học xong bài đa luồng mà cũng không hiểu rõ, ứng dụng của đa luồng vào thực tế là làm đc những gì, có thể ví dụ để mọi người rõ hơn được không ạ?
Mong các bạn khi đọc xong topic nếu nắm đc thì giải thích cho mọi người cùng học nhé
Cảm ơn rất nhiều ạ

- Đả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 la tạo mới tiến trình

- Chuyển ngữ cảnh từ luồng này sang luồng kia, tiến trình này sang tiến trình kia

- Tận Dụng được thế mạnh của kiến trúc đa xử lý

- Lập trình đa luồng dể hơn lập trình đa tiến trình

VoMinhHoang (I11C) đã 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.

Mình xin đóng góp thêm kiến thức về các loại mô hình này:
Mô hình nhiều-một
Mô hình nhiều-một ánh xạ nhiều luồng cấp người dùng tới một luồng cấp nhân. Quản lý luồng được thực hiện trong không gian người dùng vì thế nó hiệu quả nhưng toàn bộ quá trình sẽ bị khóa nếu một luồng thực hiện lời gọi hệ thống khóa. Vì chỉ một luồng có thể truy xuất nhân tại một thời điểm nên nhiều luồng không thể chạy song song trên nhiều bộ xử lý. Green threads-một thư viện luồng được cài đặt trên các hệ điều hành không hỗ trợ luồng nhân dùng mô hình nhiều-một.

Hình 1-Mô hình nhiều-một

Mô hình một-một
Mô hình một-một ánh xạ mỗi luồng người dùng tới một luồng nhân. Nó cung cấp khả năng đồng hành tốt hơn mô hình nhiều-một bằng cách cho một luồng khác chạy khi một luồng thực hiện lời gọi hệ thống nghẽn; nó cũng cho phép nhiều luồng chạy song song trên các bộ xử lý khác nhau. Chỉ có một trở ngại trong mô hình này là tạo luồng người dùng yêu cầu tạo một luồng nhân tương ứng. Vì chi phí cho việc tạo luồng nhân có thể đè nặng lên năng lực thực hiện của ứng dụng, các cài đặt cho mô hình này giới hạn số luồng được hỗ trợ bởi hệ thống. Windows NT, Windows 2000 và OS/2 cài đặt mô hình một-một này.

Hình 2-Mô hình một-một

Mô hình nhiều-nhiều
Mô hình nhiều-nhiều đa hợp nhiều luồng cấp người dùng tới số lượng nhỏ hơn hay bằng các luồng nhân. Số lượng các luồng nhân có thể được xác định hoặc một ứng dụng cụ thể hay một máy cụ thể (một ứng dụng có thể được cấp nhiều luồng nhân trên một bộ đa xử lý hơn trên một bộ đơn xử lý). Trong khi mô hình nhiều-một cho phép người phát triển tạo nhiều luồng người dùng như họ muốn, thì đồng hành thật sự là không đạt được vì nhân có thể lập thời biểu chỉ một luồng tại một thời điểm. Mô hình một-một cho phép đồng hành tốt hơn nhưng người phát triển phải cẩn thận không tạo ra quá nhiều luồng trong một ứng dụng. Mô hình nhiều-nhiều gặp phải một trong hai vấn đề khiếm khuyết: người phát triển có thể tạo nhiều luồng người dùng khi cần thiết và các luồng nhân tương ứng có thể chạy song song trên một bộ đa xử lý. Khi một luồng thực hiện một lời gọi hệ thống khóa, nhân có thể lập thời biểu một luồng khác thực thi. Solaris 2, IRIX, HP-UX, và Tru64 UNIX hỗ trợ mô hình này.

Hình 3-Mô hình nhiều-nhiều.

Thân chào!

Các bạn viết bài Đa Luồng vê Windown mình thấy gần như là đầy đủ luôn đó.Những gì mình cần coi hay tìm để đọc thêm mình đều thấy các bạn post ở đây.Mình Cảm ơn Các bạn nhiều nhé.

Sẵn đây mình post them về phần đa luồng trong java.Các bạn nào muốn xem thêm thì xem thêm nhé