Thảo luận Bài 5

1/Khái niệm luồng:
- Luồng là một dòng điều khiển trong phạm vi một quá trình, một luồng thường được gọi là tiến trình nhẹ, là một đơn vị cơ bản cho việc sử dụng CPU, thành phần luồng: định danh luồng, một bộ đếm chương trình, tập thanh ghi, ngăn xếp và được chia sẻ với các luồng khác qua phần mã, phần dữ liệu và tài nguyên .
- Vd: 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)
2/Khái niệm đa luồng:
- Là sự tồn tại song song nhiều dòng điều khiển khác nhau trong cùng không gian địa chỉ.
Lợi ích của đa luồng:
- Đáp ứng yêu cầu tốt hơn vì có nhiều luồng trả lời. Giả sử một luồng đang bận thì sẽ có những luồng khác trả lời.
Vd: Khi gọi đến tổng đài cần tư vấn. Giả sử có nhiều người đang gọi cùng một lúc mà chỉ có một nhân viên trực máy thì sẽ gây ra tình trạng bận máy liên tục => Chưa đáp ứng tốt nhu cầu của khách hàng. Nhưng nếu có nhiều nhân viên trực => phục vụ được nhiều khách hàng đồng thời.
- Chia sẽ tài nguyên tốt hơn so với đa tiến trình. Vì các luồng cùng nằm trong một tiến trình, nên việc chia sẽ nội dung trong một tiến trình sẽ dễ dàng hơn.
Vd: Khi cần mượn xe thì mượn người trong gia đình lúc nào cũng dễ dàng hơn mượn người ngoài.
- Tiết kiệm hơn vì việc cấp phát bộ nhớ từ tiến trình cho luồng nhanh hơn.
Vd: Khi có ai đó trong nhà lập gia đình, thì họ sẽ cần một nơi để ở. Nếu ngăn vách để tạo thêm một phòng sẽ tiết kiệm hơn so với việc mua nhà riêng.
- Tận dụng được đa xử lý (nhiều CPU, thường là các máy server). HĐH sẽ cấp cho mỗi một luồng chính nguyên cả CPU => tốc độ sẽ nhanh hơn gấp nhiều lần so với sử dụng chỉ một CPU
Vd: Gia đình có một máy tính, nếu hai người cần sử dụng thì chỉ mỗi người có thể sử dụng ở một thời điểm => tốn thời gian. Nhưng nếu có 2 máy thì thì công việc sẽ hoàn tất nhanh hơn.
- Lập trình đa luồng dễ hơn đa tiến trình vì việc tương tác, truyền thông, liên lạc, dùng chung tài nguyên dễ hơn rất nhiều so với đa tiến trình.

Mô hình đa luồng
Nhiều hệ thống cung cấp sự hỗ trợ cả hai luồng nhân và luồng người dùng nên
tạo ra nhiều mô hình đa luồng khác nhau. Chúng ta sẽ xem xét ba loại cài đặt luồng
thông thường
Mô hình nhiều-một
Mô hình nhiều-một (như hình IV.2) á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.
Mô hình một-một
Mô hình một-một (hình IV.3) á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.
Mô hình nhiều-nhiều
Mô hình nhiều-nhiều (như hình VI.4) đ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ộ
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.

- 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 (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 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.
- 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 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ể chạy bởi CPU riêng. Việc chuyển từ luồng này sang luồng kia là rất nhanh.
- Lập trình đa luồng dể hơn là lập trình đa tiến trình.

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

* Phân biệt khái niệm luồng với tiến trình :
- Luồ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ó thông tin trạng thái như của tiến trình hệ thống (HWP - Heavy Weight Process). 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...

- 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. Tiến trình có thể có 1 luồng chính với nhiều luồng phụ.


* Những ích lợi của công nghệ đa luồng :
- 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 (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 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.

- 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 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ể chạy bởi CPU riêng.

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

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

1. Một số thông tin về đa luồng

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

2. Các trạng thái của luồng

- Running : đang chạy – được hiểu là khi hệ thống định rõ vị trí luồng trong CPU
- Ready to run : đã chạy ( nhưng chưa được định vị trí trong CPU )
- Resumed : luồng ở trạng thái “ready to run” sau khi suspended/ blocked
- Suspended : luồng tự nguyện dừng lại để cho 1 luồng khác chạy
- 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

Luồng thường được gọi là tiến trình nhẹ (lightweight proces-LWP), nằm trong lòng một tiến trình khác, 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 với nó phần mã (dùng chung mã chương trình), 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.
Luồng cũng có thông tin trạng thái như tiến trình truyền thống.
Tạo mới 1 luồng nhanh hơn tạo mới một tiến trình.
Ví dụ: 1 lớp học và một tiến trình. Trong lớp học sẽ có giáo viên và sinh viên, mỗi người là một luồng. giáo viên là đơn luồng, các sinh viên là đa luồng.

Ví dụ về lợi ích của vấn đề chung mã chương trình: một công ty có một danh sách các công việc cần giao cho các công nhân của mình làm, do đó, công ty đã photo danh sách và phát cho mỗi người công nhân của mình một bản (danh sách công việc có thể coi là mã chương trình). Tuy nhiên, sau 1 thời gian thì công ty lại muốn bổ sung vào danh sách đó một số công việc mới, lúc này công ty gặp khó khăn là phải phát lại danh sách công việc cho từng công nhân, mỗi lần thay đổi là phải làm lại công việc này, gây ra việc tốn thời gian và tốn tài nguyên, nhưng vấn đề quan trọng hơn đó là nếu có một công nhân nào đó vì một lý do gì nó mà không nhận được bản danh sách công việc mới mà vẫn cứ làm theo danh sách cũ thì sẽ dẫn đến làm sai công việc. Nếu không được phát hiện sớm thì có thể gây ra những hậu quả nghiêm trọng. Do đó vấn đề dùng chung bản danh sách được thực hiện, đó là một bản danh sách duy nhất được dán trước cửa, mỗi khi công nhân thực hiện công việc của mình, thì sẽ nhìn vào bản đó và thực hiện theo, vừa đảm bảo thực hiện đúng mà lại đơn giản, không tốn tài nguyên.

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 (tiến trình đơn luồng). 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 (tiến trình đa luồng).


Tiến trình đơn luồng và tiến trình đa luồng
Đặc điểm:
Mỗi luồng có một stack riêng, có trạng thái riêng.
Việc chuyển giữa các trạng thái nhanh hơn nhiều so với giữa các tiến trình.
Các luồng trong cùng một tiến trình dùng chung tài nguyên.
Các luồng thực thi đồng thời trên các hệ thống SMP, siêu phân luồng, đa lõi.
Giữa các luồng không có sự bảo vệ.

Giải pháp khắc phục sự cố mạng Phương Nam của thầy:
Vào khoảng những năm 1997-1998, công ty mạng Phương Nam có một ứng dụng web cho phép người dùng đăng ký việc làm trực tuyến. tuy nhiên, có một sự cố là khi có 5 người dùng cùng quay số sử dụng dịch vụ để nhập thông tin cá nhân vào thì server bị treo, phải khởi động lại. Nguyên nhân của vấn đề này được xác định là do sử dụng công nghệ CGI, CGI xử lý theo đa tiến trình nên khi có một yêu cầu được gởi lên server thì cũng đồng nghĩa với việc tạo ra một tiến trình mới trên server, quá nhiều tiến trình nên gây ra việc treo hệ thống. Nên thầy gợi ý sử dụng nền tảng ASP để thay thế, do ASP xử lý theo công nghệ đa luồng nên sẽ tạo ra các luồng đối với mỗi yêu cầu, mà luồng nhẹ hơn tiến trình rất nhiều và việc tạo mới một luồng cũng nhanh hơn tiến trình nên vấn đề được khắc phục mà vẫn tiết kiệm được chi phí nâng cấp phần cứng.

Chuẩn 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.

Ví dụ: Chương trình C đa luồng dùng Pthread API:

#include
#include
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]);

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

Chương trình trên thực hiện tạo một luồng riêng để 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 đoạn code trên, đâ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 sẽ bắt đầu trong main. Sau khi khởi tạo, hàm main tạo ra luồng thứ hai bắt đầu điều khiển trong hàm runner.

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 (stack) 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. Ta sẽ thiết lập các thuộc tính trong gọi hàm pthread_attr_init(&attr). Vì không thiết lập rõ thuộc tính, nên 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 hàm 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.

Chứa các thông tin ứng với mỗi process.

- Process ID, parent process ID

- Credentials (user ID, group ID, effective ID,...)

- Trạng thái process : new, ready, running, waiting…

- Program counter: địa chỉ của lệnh kế tiếp sẽ thực thi Các thanh ghi CPU

-Thông tin dùng để định thời CPU: priority,...

- Thông tin bộ nhớ: base/limit register, page tables…

- Thông tin thống kê: CPU time, time limits…

-Thông tin trạng thái I/O: danh sách thiết bị I/O được cấp phát, danh sách các file đang mở,...

- Con trỏ (pointer) đến PCBs khác.

Liên lạc trực tiếp (Direct Communications)

§Theo địa chỉ đối xứng (Symmetric Scheme)

Send (P, Message) - Gửi thông điệp cho P

Receive (Q, Message) - Nhận thông điệp từ Q

Đặc điểm:

× Liên kết được thiết lập tự động giữa mỗi cặp tiến trình.

× Liên kết chỉ giữa 2 tiến trình.

× Chỉ có 1 liên kết giữa mỗi cặp.

× Tính đối xứng của liên lạc (2 bên đều biết đích xác tên của nhau khi Gửi/Nhận).

§Theo địa chỉ phi đối xứng (Asymmetric Scheme)

Send (P, Message) - Gửi thông điệp cho P

Receive (id, Message) - Nhận thông điệp từ tiến trình bất kỳ, Biến id chứa số hiệu tiến trình gửi

Liên lạc gián tiếp (Indirect Communications)

§ Qua các Hộp thư (Mailboxes) hoặc Cổng (Ports).

§ Hộp thư là một thực thể qua đó thông điệp được gửi đến và lấy ra.

§ Mỗi hộp thư có định danh riêng.

§ Hai tiến trình phải chung nhau một hộp thư nào đó.

§ Hai loại hộp thư:

× Hộp thư tiến trình (Process Mailbox): Nằm trong vùng địa chỉ của một tiến trình nào đó.

× Hộp thư hệ điều hành (OS Mailbox): Nằm trong vùng địa chỉ của HĐH

Đa luồng

Trong một chương trình, những mảnh chương trình độc lập gọi là "chủ đề" (chủ đề), sử dụng nó để khái niệm lập trình được gọi là "đa luồng". Đa luồng Một ví dụ phổ biến là giao diện người dùng. Việc sử dụng các chủ đề, người dùng có thể nhấn một nút và chương trình sẽ ngay lập tức đáp ứng, chứ không phải là cho phép người dùng chờ đợi cho chương trình để hoàn thành nhiệm vụ hiện tại sau đó bắt đầu đáp ứng.

Khái niệm

Lập trình máy tính, một khái niệm cơ bản là để kiểm soát nhiều nhiệm vụ cùng một lúc. Nhiều vấn đề lập trình yêu cầu chương trình phải ngừng làm việc ở bàn tay, một số vấn đề khác để đối phó với, và sau đó trả về cho quá trình chính. Có một số cách để đạt được mục tiêu này. Đầu, những người có lập trình ngôn ngữ máy cấp thấp để viết một số "Dịch vụ thường xuyên ngắt", quá trình chính của việc đình chỉ bị gián đoạn bởi một thực hiện mức phần cứng. Trong khi đây là một phương pháp hữu ích, nhưng hàng loạt các khó khăn về thủ tục cấy ghép, do đó gây ra một vấn đề tốn kém. Gián đoạn mạnh nhiệm vụ thời gian thực là cần thiết. Nhưng đối với nhiều vấn đề khác, chỉ cần vấn đề được chia thành các mảnh riêng biệt của chương trình đang chạy, do đó, toàn bộ chương trình có thể nhanh chóng đáp ứng với yêu cầu người sử dụng.


Ban đầu, các chủ đề của một bộ xử lý được sử dụng để phân bổ thời gian xử lý của một công cụ. Tuy nhiên, nếu hệ điều hành này hỗ trợ nhiều bộ xử lý, mỗi chủ đề có thể được giao cho một bộ vi xử lý khác nhau, thực sự vào "tính toán song song" nhà nước. Từ quan điểm của ngôn ngữ lập trình, hoạt động đa luồng là một trong những tính năng có giá trị nhất các lập trình viên không quan tâm bao nhiêu bộ vi xử lý được sử dụng cuối cùng. Chương trình theo nghĩa hợp lý, được chia thành nhiều chủ đề, nếu bản thân máy có nhiều bộ xử lý cài đặt, chương trình sẽ chạy nhanh hơn, mà không cần thực hiện bất kỳ điều chỉnh đặc biệt. Theo các cuộc thảo luận trước đó, chúng ta có thể cảm thấy luồng là rất đơn giản. Nhưng phải chú ý đến một vấn đề: tài nguyên chia sẻ! Nếu có nhiều chủ đề để chạy cùng một lúc, và họ đang cố gắng truy cập vào các nguồn tài nguyên này, bạn sẽ có một vấn đề. Ví dụ, hai chủ đề cùng một lúc có thể gửi thông tin đến một máy in. Để giải quyết vấn đề này, đối với những người có thể chia sẻ tài nguyên (như máy in), họ phải đi vào trạng thái bị khóa trong khi sử dụng. Để các nguồn lực có thể là một khóa chủ đề, sau khi hoàn thành nhiệm vụ của mình, và sau đó mở khóa (phát hành) các khóa, do đó, các chủ đề khác có thể sử dụng các nguồn lực như nhau.

Đa luồng là để đồng bộ nhiều nhiệm vụ, không để cải thiện hiệu quả hoạt động, nhưng để nâng cao hiệu quả sử dụng nguồn lực để nâng cao hiệu quả hệ thống. Chủ đề cùng một lúc khi bạn cần phải hoàn thành một số nhiệm vụ để đạt được.

Sự tương tự đơn giản nhất là như đa luồng mỗi phần của toa xe lửa, và quá trình này là đào tạo. Tàu vận chuyển không chạy đi, và sự đồng cảm có thể không chỉ có một tàu vận chuyển. Sự xuất hiện của đa luồng là để nâng cao hiệu quả. Đồng thời nó dường như đã gây ra một số vấn đề.

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

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).
PHP 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
PHP 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 )
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
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ụ:
PHP 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
PHP 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ó
PHP 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ụ
PHP Code:
t.Join(10000);

+ Đả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 đó gia tăng sự đáp ứng đối với người dùng.
Ví 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 vẫn nạp bằng một luồng khác.

+ 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. 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 nhà có kệ sách, xe máy, máy vi tính … mọi người có thể dùng chung và sử dụng chung kệ sách, xe máy, máy vi tính. Trong khi không thể dùng chung những đồ dùng trên với nhà khác được
Trong lớp chúng ta có thể dùng bảng của 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 không 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

Giống nhau:

- Điề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 1 chương trình.

- Dùng chung tài nguyên từ tiến trình(hoạc luồng) cha.

- Cùng có chức năng xử lý song song.

- 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 các luồng cùng vận hành trong cùng 1 địa chỉ vì vậy dễ dùng chung tài nguyên hơn đa tiến trình

- Do các luồng chung tài nguyên với cha và các luồng khác nên việc tạo lập và chuyển ngữ cảnh cũng nhanh hơn và ít chiếm tài nguyên hơn tiến trình.

- Cấp phát bộ nhớ và tài nguyên cho tiến trình thì tốn kém hơn luồng.

- Lập trình đa luồng thì dễ hơn lập trình đa tiến trình. Bởi vì trao đổi dữ liệu của lập trình đa luồng dễ hơn việc trao dữ liệu của lập trình đa tiến trình

- Đa tiến trình tốn resources hơn đa luồng.

Những thuận lợi của đ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.
• 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.

Trước tiên, để giải quyết câu hỏi này, theo mình nên so sánh hai vấn đề cần đặt ra: đó là đa luồng với đơn luồng và luồng - tiến trình để nhận thấy đa luồng (Multi Thread) làm việc hiệu quả hơn so với đơn luồng (Single Thread) và tiến trình truyền thống (Heavy Weight Process)


1. So sánh Đa luồng và Đơn luồng: (để thấy được đa luồng tích cực hơn đơn luồng)
- Giải quyết được bài toán về thời gian.
- Giải quyết được độ trễ (delay) khi thực hiện công việc xử lý.
- Giải quyết được tình trạng tăng tốc và đồng bộ khi xử lý dữ liệu.
- Tài nguyên được trả về rỗng khi thực hiện xong công việc (đa luồng) so với từng đợt, từng đợt trả trả về (đơn luồng) -> Đỡ chiếm nguồn tài nguyên trong khoảng thời gian

2. So sánh luồng với tiến trình
- Khi hoạt động, luồng chiếm dụng tài nguyên (CPU) ít hơn so với tiến trình
- Vấn đề chia sẽ tài nguyên, thông tin giữa các luồng linh động hơn, truy xuất được nhanh hơn (do có nhiều luồng phụ hoạt động song song và đồng thời).
- Khi tiến trình bị ngắt trong quá trình vận hành, do lỗi của hệ thống, tiến trình có thể bị gián đoạn. Trong khi đó, nếu luồng trong trạng thái bận, chưa kịp phản hồi thì những luồng phụ được hoạt động -> đảm bảo hoàn thành công việc.

Từ hai kết quả so sánh trên theo ý của mình, để nhận thấy luồng (thread) hoạt động tích cực, hiệu quả hơn so với tiến trình truyền thống (Process).

- 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ĐH .
- Luồng: là một tiến trình, nhưng đặc biệt ở chỗ là nhẹ hơn tiến trình truyền thống nên còn được gọi là tiểu tiến trình. Luồng nhẹ hơn tiến trình vì nó nằm trong lòng của một tiến trình.
- Một tiến trình có ít nhất một luồng (luồng chính) hoặc có thể có nhiều luồng (một luồng chính và nhiều luồng phụ)
- Luồng chính quản lý, điều phối các luồng phụ.
- Các luồng có thể chạy chung một mã code để đảm bảo tính nhất quán trong công việc.

giống nhau:
- Bản chất đều là tiến trình, nên đều có thông tin trạng thái.
- Đều được hệ điều hành quản lý và cấp phát CPU.
- Chia sẻ tài nguyên cho nhau.

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

=> ích lợi của đa luồng:
1. Đáp ứng yêu cầu tốt hơn vì có nhiều luồng trả lời. Giả sử một luồng đang bận thì sẽ có những luồng khác trả lời.
VD: Một cửa hàng có 1 nhân viên phục vụ thì khi có nhiều khách hàng đến mua hàng thì nhân viên đó tại 1 thời điểm chỉ đáp ứng được yêu cầu của một khách hàng

2. Chia sẽ tài nguyên tốt hơn so với đa tiến trình. Vì các luồng cùng nằm trong một tiến trình, nên việc chia sẽ nội dung trong một tiến trình sẽ dễ đang hơn.
VD: khi ta cần vay mượn tiền thì vay tiền người nhà bao giờ cũng dễ dàng hơn vay người ngoài

3. Tiết kiệm hơn vì việc cấp phát bộ nhớ từ tiến trình cho luồng nhanh hơn.
VD: Trong 1 gia đình có thêm 1 thành viên thì việc sắp xếp chỗ ở nhanh hơn vì không phải xây thêm 1 nhà mới cho thành viên đó

4. Tận dụng được đa xử lý (nhiều CPU, thường là các máy server). HĐH sẽ cấp cho mỗi một luồng chính nguyên cả CPU => tốc độ sẽ nhanh hơn gấp nhiều lần so với sử dụng chỉ một CPU
VD:một công việc có nhiều người làm bao giờ cũng nhanh hơn làm một người.

5. Lập trình đa luồng dễ hơn đa tiến trình vì việc tương tác, truyền thông, liên lạc, dùng chung tài nguyên dễ hơn rất nhiều so với đ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 or nhiều 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ể

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
VD : Mượn đồ dùng trong gia đình thì dể hơn mượn của hàng xóm
+ 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ộ
+ Cấp phát bộ nhớ & tài nguyên cho tiến trình thì tốn kém hơn luồng
+ Lập trình đa luồng thì dể hơn đa 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 đó gia tăng sự đáp ứng đối với người dùng, Ví 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 vẫn nạp bằng một luồng khác.
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à tài 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 nhà có kệ sách, xe máy, máy vi tính … mọi người có thể dùng chung và sử dụng chung kệ sách, xe máy, máy vi tính. Trong khi không thể dùng chung những đồ dùng trên với nhà khác được
Trong lớp chúng ta có thể dùng bảng của 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 không 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

Rất chi tiết và dễ hiểu. Thanks, bạn.

NguyenVietLong08(HLT3) đã viết:Nhận xét:
• Tổ chức buffer có dạng xoay vòng (circular buffer)
• Producer nhanh hơn: mất dữ liệu
• Consumer nhanh hơn: trùng dữ liệu
Giải quyết:

#define N 100                          /* kích thước buffer */
typedef int semaphore;                 /* kiểu semaphore */
semaphore mutex = 1;                   /* mutex loại trừ tương hỗ */
semaphore empty = N;                   /* số phần tử trống */
semaphore full = 0;                    /* số phần tử có dữ liệu */

void producer(void)
{
    int item;                         /* phần tử dữ liệu */

    while (TRUE){                    
         produce_item(&item);         /* tạo dữ liệu */
         down(&empty);                /* giảm số phần tử trống */
         down(&mutex);                /* vào vùng tranh chấp */
         enter_item(item);            /* ghi dữ liệu */
         up(&mutex);                  /* rời vùng tranh chấp */
         up(&full);                   /* tăng số phần tử có dữ liệu */
    }
}

void consumer(void)
{
    int item;

    while (TRUE){                    
         down(&full);                 /* giảm số phần tử có dữ liệu */
         down(&mutex);                /* vào vùng tranh chấp */
         remove_item(&item);           /* loại bỏ dữ liệu */
         up(&mutex);                  /* rời vùng tranh chấp */
         up(&empty);                  /* tăng số phần tử trống */
         consume_item(item);          /* dùng item */
    }
}

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 lol! lol! lol!   

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

Thread

Có một định nghĩa về thread như sau :

Thread là một dòng các điều khiển trong một process hay một ứng dụng. Nguyên văn là : Threads are multiple flows of control within a single program or process.

Với cơ chế multithreading ứng dụng của bạn có thể thực thi đồng thời nhiều dòng lệnh cùng lúc. Có nghĩa là bạn có thể làm nhiều công việc đồng thời trong cùng một ứng dụng của bạn. Có thể hiểu một cách hết sức đơn giản : hệ điều hành với cơ chế đa nhiệm cho phép nhiều ứng dụng chạy cùng lúc. Thì với cơ chế đa luồng, mỗi ứng dụng của bạn có thể thực hiện được nhiều công việc đồng thời.

Bạn sẽ hỏi tại sao không dùng nhiều processes , sao không là multiprocessing mà lại cần đến multithreading ?

Câu trả lời đơn giản nhất là: Việc tạo ra và quản lý các process đòi hỏi nhiều tài nguyên của hệ thống (cả ram và CPU) nhiều hơn rất nhiều so với việc tạo ra một thread. Trong khi đó bạn có thể chỉ cần tạo ra một thread để thực hiện song song một công việc hết sức đơn giản cùng với một công việc chính.

Bạn viết một ứng dụng Java trên bất kỳ nền tảng nào. Khi ứng dụng bạn chạy thì thực sự đã có một bản sao của JVM khởi động và ứng dụng của bạn là một thread nếu bạn không dùng multithreading hoặc là nhiều threads nếu bạn dùng multithreading.
Tạo một thread

Như đã nói, mỗi khi chạy một ứng dụng trong java thì bạn đã có một thread. Đây là thread chính, nó thực thi các dóng lệnh trong method : public static void main . Đây là một điểm nhập bắt buộc cho mọi ứng dụng độc lập.

Để tạo ra một thread khác ngoài thread chính trên, Java cung cấp cho chúng ta hai cách :

- Tạo ra một lớp con của lớp Thread (java.lang.Thread)
- Tạo ra một lớp hiện thực interface Runnable

Chúng ta sẽ tìm hiểu lần lược hai cách trên.

Tạo một lớp con của lớp java.lang.Thread
class A extends Thread {

public void run() {

... // code for the new thread to execute

}

}

...

A a = new A(); // create the thread object

a.start(); // start the new thread executing

...
Với cách này các dòng lệnh của bạn sẽ được đặt trong method run. Method này được override method nguyên thuỷ của lớp Thread.

Sau đó bạn sẽ tạo ra một đối tượng từ lớp của bạn.

Bạn gọi phương thức start từ đối tượng đó. Lúc này thread của bạn chính thức được tạo ra và phương thức start sẽ tự gọi method run của bạn và thực thi các dòng lệnh mà bạn đã đặt tả.

Chú ý rằng: method start là method của hệ thống, nó có nhiệu vụ cấp phát bộ nhớ, tạo ra một thread và gọi hàm run của bạn. Vì thế bạn không nên override phương thức này. Điều này có thể dẫn đến ko tạo được thread.
Hiện thực interface Runnable
class B extends … implements Runnable {

public void run() {

... // code for the new thread to execute

}

}

...

B b = new B(); // create the Runnable object

Thread t = new Thread(b); // create a thread object

t.start(); // start the new thread
Cũng giống như cách trên, dòng lệnh của bạn đặt trong method run (có thể gọi đến các phương thức khác, nhưng phải bắt đầu trong phương thức này)

Sau đó bạn tạo một đối tượng B từ lớp đã hiện thực interface Runnable, tạo thêm một đối tượng t của lớp Thread với thông số cho constructor là đối tượng B.

Sau đó khi bạn gọi phương thức t.start() thì chính thức thread được tạo ra và phương thức run của bạn sẽ được triệu gọi một cách tự động.
Bản thân ngôn ngữ Java không hỗ trợ đa thừa kế . Bạn chỉ có thể extends từ một lớp duy nhất. Nhưng bạn lại có thể implements cùng lúc nhiều interface. Khi mà lớp của bạn đã [extends] một lớp nào đó rồi (vd : Applet), thì bạn chỉ có thể implements Runnable để tạo ra Thread.

- Việc extends lớp Thread có thể dẫn đến rủi ro là bạn override các method start, stop, ... thì có thể làm cho việc tạo thread là không thể.

Một lời khuyên là: bạn nên tạo ra một lớp hiện thực interface Runnable (cách thứ hai) khi muốn tạo ra một Thread. Chương trình của bạn sẽ trong sáng và dễ tìm lỗi hơn.

Các constructor cho lớp Thread
public Thread ()
- Tạo ra một đối tượng lớp Thread.

- Constructor này có tác dụng giống như Thread(null, null, gname) với gname là một tên được phát sinh tự động bởi JVM (máy ảo java) ở dạng Thread-n , với n là một số nguyên.
public Thread(Runnable target)
Tạo ra một đối tượng lớp Thread.

- Constructor này có tác dụng giống như Thread(null, target, gname) với gname là tên được phát sinh tự động bởi JVM (máy ảo java) ở dạng Thread-n , với n là một số nguyên.


public Thread(ThreadGroup group, Runnable target)
- Tạo ra một đối tượng lớp Thread.

- Constructor này có tác dụng giống như Thread(group, target, gname) với gname là tên được phát sinh tự động bởi JVM (máy ảo java) ở dạng Thread-n , với n là một số nguyên.

- Constructor này có thể phát sinh một ngoại lệ SecurityException nếu như thread hiện tại không có quyền tạo một thread mới trong nhóm group.

PHP Code:
public Thread(String name)
- Tạo ra một đối tượng lớp Thread.

- Constructor này có tác dụng giống như Thread(null, null, name).


public Thread(ThreadGroup group, String name)
- Tạo ra một đối tượng lớp Thread.

- Constructor này có tác dụng giống như Thread(group, null, name).

- Constructor này có thể phát sinh một ngoại lệ SecurityException nếu như thread hiện tại không có quyền tạo một thread mới trong nhóm group.


public Thread(Runnable target, String name)
- Tạo ra một đối tượng lớp Thread.

- Constructor này có tác dụng giống như Thread(null, target, name).


public Thread(ThreadGroup group, Runnable target, String name)
- Tạo ra một đối tượng lớp Thread.

- group là nhóm các thread mà thread được tạo mới này sẽ được thêm vào.

- target là đối tượng cần chạy. Tức là trong đối tượng này có method run, chứa các dòng lệnh cần thực thi của chúng ta.

- name là tên của thread.

- Nếu group là null và có một bộ quản lý bảo mật security manager(ta thiết lập cho JVM, mặc định thì không có) thì gruop được xác định bởi method getThreadGroup của security manager. Nếu group null và không có security manager hay phương thức getThreadGroup trả về null thì group là nhóm mà thread đang hoạt động thuộc về.

- Nếu target là null thì sau khi được khởi hoạt, method run của lớp Thread sẽ được gọi. Nếu target không null thì sau khi được khởi hoạt thì method run của target sẽ được gọi.

- Độ ưu tiên (priority) của thread mới sẽ được thiết lập bằng với độ ưu tiên của thread tạo ra nó.

- Constructor này có thể phát sinh một ngoại lệ SecurityException nếu như thread hiện tại không có quyền tạo một thread mới trong nhóm group.

Chi tiết hơn bạn có thể xem ở Java API của bộ JDK

Một số phương thức chính của lớp Thread


public static Thread currentThread()
- Phương thức này là một phương thức tĩnh. Có nghĩa là bạn có thể gọi nó ở bất đâu mà không cần phải tạo một đối tượng của lớp Thread.

- Cú pháp để gọi phương thức này là : Thread.currentThread()

- Phương thức này trả về một đối tượng của lớp Thread. Đối tượng này thể hiện cho thread mà đang thực thi dòng lệnh này.


public long getId()
- Phương thức này trả về một số nguyên là định danh của thread.

- Con số này là do máy ảo Java (JVM) tạo ra.


public final String getName()
- Phương thức này trả về tên của thread.


public final void setName(String name)
- Thay đổi tên của thread bằng tên name.


public Thread.State getState()
- Trả về trạng thái hiện tại của thread.

- Là một hằng của lớp Thread.

- Các giá trị có thể là :

+ NEW : thread chưa được khởi hoạt.

+ RUNNABLE : thread đang hoạt động trong JVM.

+ BLOCKED : thread chờ một monitor để unlock một đối tượng mà nó cần.

+ WAITING : thread chờ không giới hạn cho đến khi một thread khác đánh thức nó.

+ TIMED_WAITING : thread chờ trong một thời gian nhất định, hoặc là có một thread khác đánh thức nó.

+ TERMINATED : thread đã kết thúc công việc của nó.


public static void yield()
- Đây là một phương thức tĩnh.

- Phương thức này sẽ làm cho thread hiện thời tạm ngưng hoạt động để nhường cho một thread khác hoạt động.


public static void sleep(long millis) throws InterruptedException

public static void sleep(long millis, int nanos) throws InterruptedException
- Đây là một phương thức tĩnh.

- Phương thức này làm cho thread hiện tại ngừng hoạt động trong một thời gian millis milliseconds.

- Phương thức này có thể phát sinh một ngoại lệ InterruptedException nếu có một thread nào đó làm ngưng hoạt động thread này. (Nhưng không hợp lệ, tức là không dùng các phương thức được cho phép).


public void start()
- Phương thức này chính thức tạo ra một đối tượng thread. Và JVM sẽ tự động gọi phương thức run của đối tượng này nếu nhưng target là null. Hoặc sẽ gọi phương thức run của target nếu như target khác null.

- Tuyến được bắt đầu hoạt động sau khi phương thức này được gọi thành công.

- Phương thức này có thể phát sinh một ngoại lệ IllegalThreadStateException nếu thread này đã được khởi hoạt.


public final boolean isAlive()
- Phương thức này kiểm tra xem thread có còn hiệu lực hay không (còn sống).

- Một thread còn sống khi mà nó đã được khởi hoạt và chưa kết thúc công việc của nó.


public final ThreadGroup getThreadGroup()
- Trả về nhóm Thread mà thread này thuộc về


public final void join(long millis) throws InterruptedException

public final void join(long millis, int nanos) throws InterruptedException

public final void join() throws InterruptedException
- Đây là phương thức được gọi bởi một thread khác.

- Phương thức này làm cho thread gọi phải ngưng hoạt động và chờ trong một khoảng thời gian millis millisecond hoặc chờ trong khoảng thời gian millis millisecond và nanos nanosseconds, hoặc chờ cho đến khi thread này kết thúc thì mới tiếp tục hoạt động.

- Phương thức này có thể phát sinh một ngoại lệ InterruptedException nếu nó bị một thread khác làm ngưng hoạt động.


public String toString()
- Trả về một thể hiện dạng String của thread này.

- Thể hiện này bao gồm tên, độ ưu tiên và nhóm.


public final void stop()

public final void stop(Throwable obj)
public void destroy()

public final void suspend()

public final void resume()
- Các methods này đều được khuyến cáo là không nên dùng. Sẽ bị bỏ trong các phiên bản sau của bộ JRE và JDK.

- Bởi vì các methods này làm cho các monitor của hệ thống (được JVM tạo ra để giám sát các đối tượng của người dùng) bị giải phóng. Làm cho các đối tượng không được thống nhất và dẫn đến các lỗi không mong muốn, không an toàn khi sử dụng.

đa luồng:
- Mỗi luồng có thể dùng chung và chia sẻ nguồn tài nguyên trong quá trình chạy, nhưng có thể thực hiện một cách độc lập.
- Ứng dụng trách nhiệm có thể được tách
+ Luồng chính chạy giao diện người dung
+ Các luồng phụ nhiệm gửi đến luồng chính.
- Luồng mang tính chất trừu tượng
- Một chương trình đa luồng hoạt động nhanh hơn trên máy tính có cấu hình tốt và mạnh
* Nhược điểm của đa luồng:
- Càng nhiều luồng thì xử lý càng phức tạp
- Cần phát hiện tránh các luồng chết, luồng chạy mà không làm gì trong ứng dụng cảận những vấn đề liên quan đến Bài 5.[/quote]