Tiến trình & PCB — chương trình đang chạy khác gì file đĩa

TL;DR: Một chương trình là file thực thi nằm trên đĩa — dữ liệu tĩnh, chết. Một tiến trình là chương trình đó đang chạy: có bộ nhớ riêng, register, program counter chỉ tới lệnh kế tiếp, và các tài nguyên OS cấp (file đang mở, PID). Cùng một chương trình chạy ba lần tạo ra ba tiến trình độc lập. Để có thể tạm dừng một tiến trình giữa chừng (khi hết lượt CPU) rồi chạy tiếp đúng chỗ sau đó, OS lưu toàn bộ trạng thái của nó trong một cấu trúc gọi là PCB (Process Control Block): register, PC, trạng thái, con trỏ tới không gian địa chỉ, bảng file mở. Mỗi tiến trình có một PCB; đây là "hồ sơ" OS dùng để quản lý sự sống của tiến trình.

Bạn mở ba tab terminal, mỗi tab chạy python. Đó là một chương trình (/usr/bin/python3 trên đĩa) nhưng ba tiến trình — mỗi cái có biến riêng, không thấy nhau. Bạn đang chạy một vòng lặp nặng thì hệ thống vẫn mượt, chuột vẫn nhích: OS liên tục tạm dừng tiến trình của bạn, cho tiến trình khác chạy vài mili-giây, rồi quay lại — mà vòng lặp của bạn không hề "biết" mình từng bị ngắt. Làm sao OS dừng một chương trình giữa chừng rồi chạy tiếp đúng chỗ, như thể chưa từng gián đoạn?

Xong bài, bạn explain được tiến trình khác chương trình ở đâu, và OS dùng cấu trúc PCB nào để chụp lại toàn bộ trạng thái một tiến trình — nền tảng để hiểu mọi thứ còn lại của module.

1. Analogy — công thức nấu ăn và bữa đang nấu

Một công thức trong sách là các bước tĩnh: nằm im, ai đọc cũng ra cùng nội dung, không tự làm gì. Khi bạn thật sự vào bếp nấu theo nó, bạn tạo ra một bữa đang nấu: có nồi cụ thể đang sôi, đang ở bước 3, tay cầm muỗng, nguyên liệu đã dùng một phần. Hai người bạn cùng nấu một công thức tạo ra hai bữa riêng — nồi riêng, tiến độ riêng, không ai đụng nồi ai.

Chương trình là công thức; tiến trình là bữa đang nấu. Và nếu có điện thoại reo, bạn ghi lại "đang ở bước 3, nồi đang sôi lửa nhỏ" để nghe xong quay lại đúng chỗ — mẩu giấy ghi đó chính là PCB.

2. Chương trình và tiến trình khác nhau ở đâu?

Chương trình là một file thực thi trên đĩa — chuỗi byte gồm mã máy (đoạn .text), dữ liệu khởi tạo (.data), và metadata (định dạng ELF trên Linux). Nó tĩnh: copy đi đâu vẫn thế, không có "trạng thái đang chạy".

Tiến trình là một lần thực thi của chương trình đó. Khi bạn gõ ./app, OS nạp file vào bộ nhớ, dựng không gian địa chỉ, cấp một PID (Process ID — số định danh duy nhất), rồi cho CPU bắt đầu chạy. Từ giây phút đó, nó có những thứ mà file trên đĩa không có:

• Không gian địa chỉ riêng: vùng code, dữ liệu, heap, stack — thay đổi liên tục khi chạy.
• Register và program counter: giá trị đang tính, lệnh kế tiếp sẽ thực thi.
• Tài nguyên OS cấp: file descriptor (số nguyên nhỏ OS cấp làm "tay cầm" tới một file/socket/pipe đang mở) đang mở, socket, PID, thông tin user sở hữu.
• Trạng thái: đang chạy, sẵn sàng chạy, hay đang chờ (chi tiết ở bài Trạng thái & context switch).

Điểm mấu chốt: một chương trình sinh ra nhiều tiến trình. Mỗi python trong ví dụ đầu bài là một tiến trình riêng với PID riêng và bộ nhớ riêng.

// process-identity.c -- in ra PID de thay moi lan chay la mot tien trinh khac
#include <stdio.h>
#include <unistd.h>

int main(void) {
    printf("Chuong trinh giong nhau, PID khac nhau: %d\n", getpid());
    return 0;
}

Chạy hai lần in ra hai PID khác nhau: cùng một file app (một chương trình) nhưng mỗi lần gõ ./app là OS tạo một tiến trình mới, cấp một PID mới. File trên đĩa không đổi; hai tiến trình là hai thực thể sống độc lập.

3. PCB — hồ sơ OS giữ về mỗi tiến trình

Để quản lý hàng trăm tiến trình cùng lúc — tạm dừng cái này, chạy cái kia, rồi quay lại — OS cần nhớ mọi thứ về từng tiến trình. Nó lưu trong một cấu trúc gọi là Process Control Block (PCB): một PCB cho mỗi tiến trình, sống trong bộ nhớ kernel (user code không đọc trực tiếp được).

PCB chứa (nhóm chính):

Trên Linux, cấu trúc thật đóng vai PCB là struct task_struct trong kernel (một struct lớn với hàng trăm field). Ta không cần nhớ tên từng field — điều cần hiểu là phân loại thông tin: định danh, CPU context, trạng thái, bộ nhớ, tài nguyên.

flowchart LR
  P1["Tien trinh A dang chay"] -->|"het luot CPU"| S["Cat register + PC vao PCB cua A"]
  S --> L["Nap register + PC tu PCB cua B"]
  L --> P2["Tien trinh B chay tiep dung cho"]
  P2 -.->|"sau nay den luot A"| R["Nap lai context tu PCB cua A"]
  R -.-> P1

4. Vì sao mỗi tiến trình có không gian địa chỉ riêng?

Một tính chất quan trọng của tiến trình: không gian địa chỉ tách biệt. Địa chỉ 0x5000 trong tiến trình A và 0x5000 trong tiến trình B trỏ tới hai ô nhớ vật lý khác nhau. OS + MMU (Memory Management Unit) dịch địa chỉ ảo của mỗi tiến trình sang địa chỉ vật lý riêng thông qua page table riêng của nó — cơ chế bộ nhớ ảo bạn đã học ở khoá Bộ nhớ.

Hệ quả:

• Cô lập lỗi: tiến trình A ghi bậy vào con trỏ của nó không làm hỏng bộ nhớ tiến trình B. Một tab python crash không kéo theo tab khác.
• Bảo mật: A không đọc lén được mật khẩu B đang giữ trong RAM (trừ khi qua kênh IPC hợp lệ — xem Module 4).
• Đơn giản hoá lập trình: mỗi chương trình viết như thể sở hữu toàn bộ bộ nhớ, không phải né địa chỉ của chương trình khác.

Tien trinh A                 Tien trinh B
+-----------------+          +-----------------+
| dia chi ao 0x5000|         | dia chi ao 0x5000|
+--------+--------+          +--------+--------+
         |  page table A              |  page table B
         v                            v
   RAM vat ly 0x9A00            RAM vat ly 0x1C00
   (hai o nho KHAC nhau -- khong dung cham)

Đây là điểm phân biệt cốt lõi giữa tiến trình (không gian địa chỉ riêng) và thread (chia sẻ không gian địa chỉ) — trục chính của bài Thread vs process.

5. Pitfall tổng hợp

❌ Nhầm 1 — "chạy chương trình 2 lần thì chúng chia sẻ biến":

// Chay ./counter hai lan cung luc, moi ban tang bien 'count' rieng
static int count = 0;   // moi tien trinh co ban sao RIENG cua count

✅ Mỗi lần chạy là một tiến trình với không gian địa chỉ riêng. Biến count của tiến trình này và tiến trình kia là hai ô nhớ khác nhau; tăng cái này không ảnh hưởng cái kia. Muốn hai tiến trình chia sẻ dữ liệu, phải dùng IPC (shared memory, pipe, socket — Module 4), không phải biến thường.

❌ Nhầm 2 — "PID gắn liền với chương trình":

✅ PID gắn với tiến trình, không với chương trình. Cùng file app chạy 3 lần có 3 PID khác nhau. Sau khi tiến trình chết và được cha wait (reap), PID của nó mới được OS thu hồi và có thể cấp lại cho tiến trình mới sau này — nên đừng giả định "PID 1234 luôn là app của tôi".

❌ Nhầm 3 — "PCB nằm trong bộ nhớ của tiến trình":

✅ PCB sống trong bộ nhớ kernel, không trong không gian địa chỉ user của tiến trình. Nếu PCB nằm trong vùng nhớ user, một tiến trình lỗi có thể tự sửa trạng thái/priority của mình — phá cô lập và bảo mật. User code chỉ truy cập thông tin PCB gián tiếp qua system call (getpid, getppid, đọc /proc/<pid>/).

6. 📚 Deep Dive

7. Liên hệ các bài khác

• fork, exec, wait — vòng đời một tiến trình: bài kế dùng chính khái niệm tiến trình + PCB ở đây để giải thích fork nhân đôi một tiến trình (chép PCB + không gian địa chỉ) như thế nào.
• System call là gì: getpid, fork, exec đều là system call — cách duy nhất user code nhờ kernel thao tác trên tiến trình.
• Thread vs process: thread dùng chung không gian địa chỉ của tiến trình — đối lập trực tiếp với "mỗi tiến trình một không gian riêng" ở section 4.
• Trạng thái & context switch: đào sâu thao tác cất-nạp CPU context vào/ra PCB và chi phí thật của nó.

8. Tóm tắt

• Chương trình là file tĩnh trên đĩa; tiến trình là một lần chạy của nó — có bộ nhớ, register, PC, tài nguyên riêng.
• Một chương trình sinh nhiều tiến trình độc lập; mỗi tiến trình có một PID duy nhất (được thu hồi và tái sử dụng sau khi tiến trình chết).
• PCB (Process Control Block) là cấu trúc kernel lưu toàn bộ trạng thái tiến trình: định danh, CPU context (register + PC), trạng thái, bộ nhớ, tài nguyên, kế toán.
• Nhờ cất/nạp CPU context vào/ra PCB, OS tạm dừng rồi chạy tiếp một tiến trình đúng chỗ mà nó không nhận ra.
• Mỗi tiến trình có không gian địa chỉ ảo riêng → cô lập lỗi, bảo mật, và lập trình đơn giản. Đây là ranh giới phân biệt tiến trình với thread.
• PCB nằm trong bộ nhớ kernel; user code chỉ đọc gián tiếp qua system call (getpid) hoặc /proc/<pid>/.

9. Tự kiểm tra

Bài tiếp theo: fork, exec, wait — vòng đời một tiến trình