TIẾN TRÌNH VÀ TIỂU T RÌNH
Mục tiêu
Sinh viên làm quen với lập trình trên Hệ điều hành Ubuntu thông qua trình soạn thảo vim, trình biên dịch gcc và trình gỡ lỗi gdb
Thực hành với tiến trình
Thực hành với tiểu trình thông qua thư viện pthread Giới thiệu về cơ chế truyền thông: signal
Nội dung thực hành
Sử dụng trình soạn thảo vim để soạn thảo mã nguồn
Sử dụng trình biên dịch gcc để biên dịch từ tệp tin mã nguồn sang tệp tin có thể thực thi
Sử dụng trình gỡ lỗi gdb để gỡ lỗi chương trình
Tạo, dừng, hợp và gỡ tiểu trình với thư viện pthread Truyền thông giữa các tiến trình bằng cơ chế signal
Sinh viên chuẩn bị
3.3.1 Trình soạn thảo văn bản vim
Trình soạn thảo văn bản thuần túy không sử dụng các định dạng văn bản để trình bày, giúp tạo ra các tài liệu nhẹ và dễ đọc, hạn chế xử lý phức tạp Trong bài thực hành này, chúng ta sử dụng Vim (Visual Improved) như một công cụ giúp thao tác văn bản hiệu quả Sinh viên có thể cài đặt Vim cùng các gói liên quan bằng câu lệnh đơn giản: `apt-get install vim`, đảm bảo quá trình học tập diễn ra thuận lợi và dễ dàng hơn.
Sau khi cài đặt, Vim thường được đặt tại đường dẫn /usr/bin/vim, bạn có thể kiểm tra chính xác vị trí của Vim trên máy bằng lệnh `which vim` Ngoài ra, chương trình hướng dẫn đi kèm là vimtutor sẽ tự động được cài đặt, giúp người dùng làm quen và học các thao tác cơ bản với Vim qua các bài hướng dẫn dễ hiểu.
Trình biên dịch (compiler) là phần mềm chuyển đổi mã nguồn viết bằng ngôn ngữ lập trình cao thành các chuỗi bit có thể thực thi trên máy tính Trong bài thực hành này, gcc (GNU C Compiler) được sử dụng làm công cụ chính để biên dịch các chương trình Để cài đặt gcc và các gói liên quan, sinh viên có thể sử dụng lệnh: apt-get install build-essential, giúp thiết lập môi trường lập trình C hiệu quả.
Sau khi cài đặt, GCC thường được đặt tại đường dẫn /usr/bin/gcc; người dùng có thể sử dụng lệnh which gcc để xác định vị trí chính xác của gcc trên từng máy tính Quá trình biên dịch một chương trình từ mã nguồn thành một chương trình có thể thực thi được trên máy tính được trình bày rõ ràng trong Hình 3-1, giúp người học hiểu rõ các bước chuyển đổi mã nguồn thành phần mềm chạy đúng cách.
Hình 3-1 Quá trình biên dịch Quá trình từ tệp mã nguồn tới tệp đối tượng có thể trình bày chi tiết hơn trong Hình 3-2
Hình 3-2 Quá trình biên dịch chi tiết
Bộ tiền xử lý (Preprocessor) sẽ sao chép nội dung các tệp mã nguồn (*.c) trong thư mục dự án và các tệp tiêu đề (*.h) tại /usr/include vào bản sao, biến nó thành một chương trình hoàn chỉnh ở cấp độ ngôn ngữ lập trình cao Tiếp theo, trình biên dịch chuyển đổi bản sao này thành mã hợp ngữ (*.asm) phù hợp với kiến trúc của máy tính Sau đó, assembler sẽ dịch mã hợp ngữ thành các tệp đối tượng (*.o) Cuối cùng, linker liên kết các tệp đối tượng và thư viện (*.a, *.so, *.sa) trong /usr/lib hoặc /lib để tạo ra một chương trình nhị phân có thể chạy trực tiếp trên máy tính.
Các tệp mã nguồn (*.c) là các tệp tin do lập trình viên tạo ra để phục vụ các mục đích chuyên biệt trong quá trình phát triển phần mềm Chúng chứa mã lập trình thúc đẩy chức năng của ứng dụng và thường xuyên được cập nhật để nâng cao hiệu suất, sửa lỗi và bổ sung tính năng mới Việc quản lý và duy trì các tệp mã nguồn này đóng vai trò quan trọng trong quy trình phát triển phần mềm chuyên nghiệp.
Các tệp tiêu đề (*.h) là phần quan trọng trong lập trình C/C++, dùng để định nghĩa hàm và khai báo các biến, cấu trúc dữ liệu cần thiết Chúng giúp trình biên dịch kiểm tra lỗi cú pháp và kiểu dữ liệu, đồng thời tạo ra các tệp đối tượng (*.o) trong quá trình biên dịch Việc sử dụng đúng tệp tiêu đề đảm bảo quá trình biên dịch diễn ra suôn sẻ, tối ưu hóa hiệu suất của chương trình.
Các tệp đối tượng (*.o) là các tệp tin chứa cáckhối mã nhị phân thuần túy
Các tệp tin thư viện như lib*.a, lib*.sa, và lib*.so là các thành phần thiết yếu giúp biên dịch chương trình thành công Trên môi trường Linux, có hai loại thư viện liên kết chính là thư viện liên kết tĩnh và thư viện liên kết động, đóng vai trò quan trọng trong quá trình xây dựng và thực thi ứng dụng.
Thư viện liên kết tĩnh là loại thư viện mà trình biên dịch lấy toàn bộ mã thực thi của hàm và đưa vào chương trình chính khi biên dịch Sau khi biên dịch, chương trình sử dụng thư viện này hoạt động độc lập mà không phụ thuộc vào thư viện gốc Tuy nhiên, khi cần nâng cấp hoặc sửa đổi để tận dụng chức năng mới của thư viện, buộc phải biên dịch lại toàn bộ chương trình Ngoài ra, sử dụng thư viện liên kết tĩnh tiêu tốn nhiều không gian bộ nhớ và gây khó khăn trong việc nâng cấp chương trình.
Thư viện liên kết động (lib*.so) là các thư viện không được tích hợp trực tiếp vào chương trình trong quá trình biên dịch và liên kết Thay vào đó, liên kết động lưu trữ thông tin tham chiếu đến các hàm trong thư viện này Khi chương trình chạy, hệ điều hành sẽ nạp các thư viện cần thiết vào bộ nhớ, cho phép nhiều chương trình cùng chia sẻ các hàm trong một thư viện liên kết động duy nhất, tối ưu hóa tài nguyên hệ thống.
Sử dụng vim để soạn chương trình hello.c như sau:
# , #
{ printf("Hello, I am ,\n"); printf("Welcome to IT007!\n"); return 0;
Biên dịch và chạy chương trình bằng 2 dòng lệnh sau:
Lệnh gcc được sử dụng để biên dịch tệp tin hello.c thành chương trình thực thi có tên là hello Để chạy chương trình sau khi biên dịch, bạn dùng lệnh /hello Kết quả hiển thị trên màn hình sẽ xác nhận rằng chương trình đã hoạt động chính xác.
Nếu muốn quan sát rõ hơn quá trình biên dịch thì có thể sử dụng các lệnh tương ứng sau:
Xem tệp tin tạm (sau
Preprocessor) gcc -E hello.c -o hello_tmp.c
Xem tệp tin hợp ngữ (sau
Xem tệp tin đối tượng (Sau
Tạo tệp tin thực thi từ tệp tin đối tượng gcc hello.o -o hello
Hãy quay lại với chương trình hello của chúng ta và trình bày cách các lập trình viên áp dụng trong thực tế bằng cách thêm hàm main.c Đồng thời, chuyển chương trình hello.c thành một thư viện để tối ưu hóa quá trình phát triển phần mềm Việc này giúp tổ chức mã nguồn rõ ràng và dễ bảo trì hơn, đồng thời nâng cao khả năng tái sử dụng các thành phần trong các dự án khác nhau Áp dụng kỹ thuật này là một bước quan trọng trong lập trình chuyên nghiệp, giúp tối ưu hóa quá trình xây dựng và quản lý phần mềm hiệu quả hơn.
# , #
# , #
{ printf("Hello, I am ,\n"); printf("Welcome to IT007!\n");
# , #
Trong tệp hello.c ở trên, có một sự khác biệt nhỏ tại chỉ thị
#include, sự khác nhau giữa #include và #include
“filename” nằm ở khâu tìm kiếm tệp tiêu đề của bộ tiền xử lý trước quá trình biên dịch:
Trong lập trình C, chỉ thị #include được sử dụng để yêu cầu bộ tiền xử lý tìm kiếm và chèn nội dung của các tệp tiêu đề (.h) vào chương trình hiện tại Bộ tiền xử lý sẽ chỉ tìm kiếm các tệp tiêu đề trong thư mục chứa tệp tiêu đề của thư viện ngôn ngữ C, giúp quản lý và truy cập các thư viện một cách dễ dàng và hiệu quả Nếu bạn cần sử dụng thư viện đi kèm sẵn của ngôn ngữ C, nên sử dụng cú pháp #include để đảm bảo quá trình biên dịch diễn ra suôn sẻ.
#include để cải thiện tốc độ biên dịch chương trình
Trong quá trình lập trình, việc sử dụng câu lệnh #include "filename" giúp thực hiện xử lý tiền xử lý tìm kiếm tệp tiêu đề (.h) trong thư mục dự án Nếu không tìm thấy tệp tiêu đề trong thư mục dự án, quá trình này sẽ tiếp tục tìm kiếm trong thư mục chứa các tệp tiêu đề của thư viện ngôn ngữ C Do đó, nếu bạn muốn sử dụng thư viện tự viết, cần đảm bảo đã sử dụng đúng cú pháp #include để hướng dẫn trình biên dịch khai thác các tệp tiêu đề phù hợp.
Biên dịch và chạy chương trình bằng 2 dòng lệnh sau:
Hãy kiểm chứng lại là kết quả hiển thị trên màn hình vẫn giống như lần trước:
Khi thường xuyên chèn tệp vào dự án hoặc cần thay đổi tham số biên dịch, việc sử dụng hai câu lệnh để biên dịch và chạy chương trình trở nên dài dòng, dễ gây lỗi và khó chỉnh sửa thủ công Để khắc phục vấn đề này, chương trình Make ra đời nhằm tự động hóa các thao tác lặp đi lặp lại trong quá trình xây dựng dự án May mắn thay, Make đi kèm tự động cùng với gói build-essential khi bạn cài đặt gcc, giúp quá trình xây dựng dự án trở nên dễ dàng và hiệu quả hơn.
Hướng dẫn thực hành
Hệ thống chỉ quản lý các tiến trình đang thực thi trên ổ đĩa, không quản lý toàn bộ các chương trình đã lưu trữ Một chương trình muốn thực thi trên bất kỳ hệ điều hành nào cần ở dạng mã máy, chứa nhiều đoạn mã nhị phân giúp máy tính xác định hoạt động của chương trình Khi chạy, các đoạn mã này được nạp vào bộ nhớ, với vùng hoạt động và thời gian thực thi được cấp phát rõ ràng Mỗi tiến trình sẽ có một mã định danh duy nhất (PID) là biến nguyên 32-bit, được hệ điều hành cấp phát tài nguyên và sở hữu các tài nguyên đó cho đến khi bị thu hồi hoặc kết thúc.
Chương trình được nạp vào bộ nhớ khi thực thi, cho phép chạy nhiều lần cùng một lúc, tạo ra nhiều tiến trình đồng thời Ví dụ, khi sử dụng chương trình MS Office Word, mặc dù chỉ có một phiên bản Word được cài đặt trên máy tính, người dùng có thể mở nhiều cửa sổ Word để đọc và chỉnh sửa nhiều tệp tin cùng lúc Điều này minh họa rõ ràng cách hệ điều hành cho phép chạy nhiều tiến trình của cùng một chương trình đồng thời, nâng cao hiệu quả làm việc và quản lý tác vụ.
3.4.1.2 Tiến trình trong môi trường Linux
Trên môi trường Linux, tiến trình có các trạng thái quan trọng như "Đang chạy" (running), nghĩa là khi tiến trình chiếm quyền xử lý CPU để thực hiện các tác vụ tính toán hoặc công việc của mình Trạng thái này xác định tiến trình đang hoạt động và thực thi nhiệm vụ trong hệ thống Hiểu rõ trạng thái "Đang chạy" giúp quản lý tiến trình hiệu quả hơn và tối ưu hóa hiệu suất hệ thống Linux.
Chờ (waiting): tiến trình bị Hệ điều hành tước quyền xử lý CPU và chờ đến lượt cấp phát khác
Trong hệ điều hành, quá trình có thể tạm dừng (suspend) hoặc chuyển sang trạng thái ngủ (sleep), giúp hệ thống quản lý tài nguyên hiệu quả hơn Khi cần thiết, hệ điều hành sẽ đánh thức (wake up) tiến trình, nạp lại mã lệnh vào bộ nhớ và cấp phát CPU để tiến trình tiếp tục hoạt động Tuy nhiên, không thể dừng hẳn (zombie) một tiến trình hoàn toàn, vì tiến trình đã bị kết thúc nhưng vẫn còn sót lại một số thông tin cần thiết cho tiến trình cha tham khảo, đảm bảo quá trình quản lý hệ thống ổn định và an toàn.
Trên môi trường Linux, lệnh top giúp người dùng dễ dàng theo dõi các tiến trình đang hoạt động trên hệ thống một cách nhanh chóng Kết quả hiển thị sau khi chạy lệnh top, như minh họa trong Hình 3-3, cung cấp thông tin chi tiết về các tiến trình đang chạy, mức tiêu thụ CPU, bộ nhớ và nhiều dữ liệu quan trọng khác Sử dụng lệnh top là cách hiệu quả để quản lý và tối ưu hiệu suất hệ thống Linux của bạn.
Hình 3-3: Kết quả sau khi sử dụng lệnh top
Lệnh top cho ta biết khá nhiều thông tin của các tiến trình:
Dòng thứ nhất cho biết thời gian uptime (từ lúc khởi động) cũng như số người dùng thực tế đang hoạt động
Bản tóm tắt này cung cấp các thống kê quan trọng về tiến trình hệ thống, bao gồm tổng số tiến trình đang chạy, số tiến trình đang hoạt động (running), các tiến trình ở trạng thái ngủ (sleeping), các tiến trình đã bị dừng (stopped), và những tiến trình không thể dừng hẳn (zombie) Thông tin này giúp người dùng dễ dàng theo dõi hoạt động và hiệu suất của hệ thống máy tính.
Dòng thứ 3 5 lần lượt cho biết thông tin về CPU, RAM và - bộ nhớ Swap
Các dòng còn lại trong danh sách bao gồm các thông tin quan trọng như quá trình định danh (PID), người dùng thực thi (USER), mức độ ưu tiên (PR) và lệnh thực thi (COMMAND), giúp quản lý và giám sát các tiến trình một cách hiệu quả.
Một lệnh khác là ps cũng giúp ta liệt kê được chi tiết của tiến trình, tuy nhiên có một vài điểm khác với top:
Hiện thị ít thông tin hơn lệnh top
Nếu top hiển thị thời gian thực các tiến trình thì ps chỉ hiển thị thông tin tại thời điểm khởi chạy lệnh
Dưới đây là sự mô tả các thông hiển thị bởi lệnh ps -f:
UID ID người sử dụng mà tiến trình này thuộc sở hữu
PID ID của tiến trình
PPID ID của tiến trình cha
C CPU sử dụng của tiến trình
STIME Thời gian bắt đầu tiến trình
TTY Kiểu terminal liên kết với tiến trình
TIME Thời gian CPU bị sử dụng bởi tiến trình
CMD Lệnh bắt đầu tiến trình này
Những tùy chọn khác có thể được sử dụng song song với lệnh ps:
-a Chỉ thông tin về tất cả người sử dụng
-x Chỉ thông tin về các tiến trình mà không có terminal -u Chỉ thông tin thêm vào như chức năng -f
-e Hiển thị thông tin được mở rộng
Có 2 cách để chạy một tiến trình, đó là foreground và background Theo mặc định, mọi tiến trình mà chúng ta bắt đầu chạy là tiến trình foreground, nó nhận đầu vào từ bàn phím và gửi đầu ra tới màn hình Khi một chương trình đang chạy trong foreground và cần một khoảng thời gian dài, chúng ta không thể chạy bất kỳ lệnh nào khác (bắt đầu một tiến trình khác) bởi vì dòng nhắc không có sẵn tới khi chương trình đang chạy kết thúc tiến trình và thoát ra Ngược lại, tiến trình background chạy mà không được kết nối với bàn phím Nếu tiến trình background yêu cầu bất cứ đầu vào nào từ bàn phím, nó sẽ đợi cho đến khi được chuyển thành foreground và nhận đầu vào từ bàn phím Lợi thế của chạy một chương trình trong background là bạn có thể chạy các lệnh khác; bạn không phải đợi tới khi nó kết thúc để bắt đầu một tiến trình mới! Cách đơn giản nhất để bắt đầu một tiến trình background là thêm dấu và (&) tại phần cuối của lệnh.
Trong hầu hết các công việc thực tế với hệ thống Linux, người dùng không cần quá quan tâm đến các tiến trình foreground và background Tuy nhiên, có những trường hợp đặc biệt yêu cầu sử dụng tính năng này để quản lý và tối ưu hóa các tiến trình hiệu quả hơn trên hệ thống Linux.
Một chương trình cần mất nhiều thời gian để sử dụng, nhưng bạn lại muốn ngay lập tức được chạy một chương trình khác
Bạn đang chạy một chương trình nhưng lại muốn tạm dừng nó lại để chạy một chương trình khác rồi quay lại với cái ban đầu
Khi xử lý các tệp có dung lượng lớn hoặc biên dịch chương trình, việc tiết kiệm thời gian bằng cách tránh bắt đầu lại từ đầu sau mỗi lần thực hiện là điều quan trọng Đảm bảo quá trình xử lý hoặc biên dịch được tiến hành một cách hiệu quả và nhanh chóng giúp nâng cao năng suất làm việc Các công cụ hỗ trợ lưu trữ trạng thái hoặc tiếp tục dự án sẽ giúp bạn duy trì tiến trình mà không mất công sức lặp lại từ đầu.
Một số lệnh hữu dụng giúp ta xử lý các trường hợp này là: jobs: liệt kê danh sách các công việc đang chạy
Sử dụng từ khóa "&" khi kết thúc câu lệnh cho phép chương trình bắt đầu hoạt động ở chế độ nền (background) thay vì chế độ ưu tiên (foreground) như mặc định Ngoài ra, lệnh "fg " giúp đưa một chương trình đang chạy trong nền trở lại chế độ ưu tiên (foreground) để người dùng có thể tiếp tục thao tác Đây là các lệnh hữu ích trong quản lý tiến trình và tối ưu hóa hiệu suất làm việc trên hệ thống.
Ctrl+z: ngược lại với fg, đưa một chương trình foreground trở thành chương trình background
Trong hệ thống, mỗi tiến trình đều được gán hai ID quan trọng: ID của tiến trình (pid) và ID của tiến trình cha (ppid) Hầu hết các tiến trình đều có một tiến trình cha, ngoại trừ tiến trình init Khi chạy các lệnh trong shell, shell thường đóng vai trò làm tiến trình cha của các tiến trình mới Ví dụ, lệnh "ps f" giúp liệt kê rõ ràng các ID tiến trình và ID của tiến trình cha để kiểm tra cấu trúc quá trình trong hệ thống.
Khi một tiến trình con bị khử, tiến trình cha được thông báo qua tín hiệu SIGCHLD và có thể bắt đầu lại hoặc thực hiện công việc khác Tuy nhiên, trong một số trường hợp, tiến trình cha bị khử trước tiến trình con, khiến tiến trình init trở thành PPID mới, gọi là tiến trình orphan Khi đó, danh sách ps có thể vẫn hiển thị các tiến trình ở trạng thái Zombie (Z), là các tiến trình đã kết thúc nhưng vẫn còn trong bảng tiến trình do chưa bị thu dọn Khác với tiến trình orphan, các tiến trình Zombie đã hoàn thành công việc nhưng vẫn còn tồn tại trong hệ thống do chưa giải phóng, gây ra tình trạng không còn hoạt động nhưng vẫn còn trong danh sách tiến trình.
Hàm fork() được sử dụng để tạo tiến trình mới bằng cách sao chép tiến trình hiện tại Khi gọi hàm fork(), tiến trình cha tiếp tục thực thi trong khi tiến trình con bắt đầu từ cùng một điểm sau hàm gọi Kết quả trả về của fork() giúp phân biệt giữa tiến trình cha và con: nếu trả về 0, đó là tiến trình con; nếu trả về giá trị > 0, đó là tiến trình cha và giá trị đó chính là PID của tiến trình con; còn nếu trả về 1, quá trình tạo tiến trình thất bại PID của tiến trình cha được gán vào PPID của tiến trình con để xác định mối quan hệ cha-con rõ ràng, giúp quản lý tiến trình hiệu quả.
# , #
#include int main(){ pid_t pid; pid=fork(); if(pid==0) printf("Child Process, pid=%d\n",pid); else printf("Parent Process, pid=%d\n",pid); exit(0);
Họ hàm exec() được sử dụng để thay thế tiến trình hiện tại bằng cách nạp chương trình được chỉ định vào không gian địa chỉ của tiến trình đó, sau đó tiến trình gọi hàm exec() sẽ tự hủy, giữ nguyên số lượng tiến trình ban đầu Khi sử dụng họ hàm exec(), tiến trình mới sẽ thay thế tiến trình cũ tại không gian địa chỉ đã cấp phát mà không thay đổi PID Các hàm trong họ exec() gồm có execl(), execlp(), execle(), exect(), execv(), và execvp(), giúp linh hoạt trong việc thực thi các chương trình khác nhau.
Bài tập ôn tập
1 Mối quan hệ cha-con giữa các tiến trình a Vẽ cây quan hệ parent child của các tiến trình bên - dưới:
Lệnh `ps` có thể được sử dụng để tìm tiến trình cha của một tiến trình dựa trên PID của nó bằng cách sử dụng các tùy chọn phù hợp như `ps -fp `, giúp hiển thị thông tin chi tiết về tiến trình và cha của nó Ngoài ra, bạn cần cài đặt lệnh `pstree` (nếu chưa có), để trực quan hóa cấu trúc cây tiến trình và dễ dàng xác định tiến trình cha của một tiến trình dựa trên PID bằng cách chạy lệnh `pstree -p ` Việc làm quen với cả hai lệnh này sẽ giúp quản lý và giám sát tiến trình trên hệ thống Linux một cách hiệu quả hơn.
2 Chương trình bên dưới in ra kết quả gì? Giải thích tại sao? /*######################################
# , #
#include int main(){ pid_t pid; int num_coconuts = 17; pid = fork(); if(pid == 0) { num_coconuts = 42; exit(0);
} else { wait(NULL); /*wait until the child terminates */
} printf("I see %d coconuts!\n", num_coconuts); exit(0);
3 Trong phần thực hành, các ví dụ chỉ sử dụng thuộc tính mặc định của pthread, hãy tìm hiểu POSIX thread và trình bày tất cả các hàm được sử dụng để làm thay đổi thuộc tính của pthread, sau đó viết các chương trình minh họa tác động của các thuộc tính này và chú thích đầy đủ cách sử dụng hàm này trong chương trình (Gợi ý các hàm liên quan đến thuộc tính của pthread đều bắt đầu bởi: pthread_attr_*)
4 Viết chương trình làm các công việc sau theo thứ tự: a In ra dòng chữ: “Welcome to IT007, I am
To open the file abcd.txt using the vim editor, simply launch vim and load the desired file When the user presses CTRL+C, the vim editor will be terminated gracefully, and a message will be displayed Specifically, pressing CTRL+C triggers a custom response where the system prints "You are pressed CTRL+C! Goodbye!" before closing the program This process ensures an interactive and user-friendly experience when working with text files in vim, highlighting the importance of handling keyboard interrupts effectively.
