Bỏ qua tới nội dung chính

Trước khi có hệ điều hành

Hệ điều hành: người quản gia vô hình của máy tính

Hệ điều hành làm gì giữa phần cứng và ứng dụng: tiến trình, bộ nhớ ảo, đồng thời, hệ thống file — và nên bắt đầu học môn này từ đâu.

Trần Ngọc Tây

Cập nhật 31/10/2026 · 14 phút đọc · CC BY 4.0

Bạn đang mở trình duyệt để đọc bài này. Cùng lúc đó, máy của bạn có thể đang phát nhạc, đồng bộ ảnh lên mạng, tải bản cập nhật và chạy hàng chục chương trình nền mà bạn không hề để ý. Bộ xử lý thì chỉ có vài nhân, bộ nhớ có hạn, ổ đĩa chỉ có một. Vậy mà không chương trình nào giẫm lên chương trình nào, nhạc không bị vấp, và nếu trình duyệt bị treo thì bạn chỉ cần tắt nó — cả máy vẫn chạy bình thường.

Thứ làm được điều đó là hệ điều hành (operating system — OS): Windows, macOS, Linux, Android, iOS. Ta dùng nó mỗi ngày nhưng hiếm khi nhìn thấy nó, giống một người quản gia giỏi — chỉ khi vắng họ, ta mới biết mọi thứ hỗn loạn đến mức nào.

Trước khi có hệ điều hành

Máy tính không sinh ra cùng hệ điều hành. Những máy đầu tiên, như ENIAC (1945), thậm chí không lưu chương trình trong bộ nhớ: muốn đổi bài toán, người ta cắm lại dây và gạt lại công tắc bằng tay, có khi mất nhiều ngày.

Khi máy đã lưu được chương trình, cách dùng vẫn rất thủ công. Lập trình viên đăng ký giờ dùng máy — chẳng hạn từ 2 đến 3 giờ chiều — rồi mang chồng bìa đục lỗ tới, tự nạp vào máy, chạy, và chờ kết quả in ra. Mỗi lúc chỉ một người, một chương trình. Nếu chương trình lỗi ở phút thứ năm, năm mươi lăm phút còn lại máy nằm không, trong khi mỗi giờ máy chạy đắt hơn nhiều tháng lương của người dùng nó.

Tệ hơn, mỗi chương trình phải tự lo hết mọi thứ. Không có ai đứng giữa chương trình và phần cứng, nên chương trình phải tự chứa code để đọc bìa đục lỗ, điều khiển máy in, ghi băng từ. Cùng một đoạn code điều khiển máy in được chép đi chép lại vào hàng trăm chương trình.

Hệ điều hành ra đời từng bước, mỗi bước để bớt một kiểu lãng phí:

  1. Xử lý theo lô (batch processing) — giữa thập niên 1950. Một chương trình nhỏ luôn nằm sẵn trong máy, tự động nạp và chạy lần lượt từng việc, thay cho người vận hành ngồi nạp tay. Code điều khiển thiết bị chuyển vào đó, chương trình không phải tự mang theo nữa. GM-NAA I/O (1956), do General Motors viết cho máy IBM 704, thường được nhắc tới như một trong những hệ điều hành đầu tiên.
  2. Đa chương trình (multiprogramming) — đầu thập niên 1960. Khi một việc đang chờ băng từ quay, máy chạy tạm việc khác. Lúc này mới phải có bảo vệ bộ nhớ, để việc này không ghi đè lên việc kia.
  3. Chia sẻ thời gian (time-sharing). Nhiều người ngồi ở nhiều màn hình cùng dùng một máy, ai cũng có cảm giác máy là của riêng mình. CTSS của MIT, trình diễn năm 1961, là một hệ thống tiêu biểu. Tiếp theo là Multics, rồi Unix (1969) của Ken Thompson và Dennis Ritchie ở Bell Labs — ông tổ trực tiếp của Linux, macOS và Android.

Đặt cạnh nhau, khác biệt rất rõ:

Không có hệ điều hành
Có hệ điều hành
Số chương trình
Một chương trình chiếm cả máy
Hàng trăm chương trình chạy xen kẽ
Điều khiển thiết bị
Mỗi chương trình tự viết code cho ổ đĩa, màn hình, bàn phím
Gọi read, write; hệ điều hành lo phần còn lại
Khi chương trình lỗi
Có thể kéo cả máy theo, phải khởi động lại
Chỉ chương trình đó bị dừng
Bảo mật
Chương trình nào cũng đọc được mọi thứ
Mỗi chương trình bị giới hạn trong vùng của nó
Đổi phần cứng
Phải sửa lại chương trình
Thường chạy được ngay, nhờ driver

Máy không có hệ điều hành vẫn tồn tại tới hôm nay. Một bo mạch Arduino chạy đúng một chương trình: hàm setup() chạy một lần khi bật nguồn, rồi hàm loop() lặp mãi mãi.

cpp
void setup() {
  pinMode(13, OUTPUT);       // chân 13 nối với đèn LED
}

void loop() {
  digitalWrite(13, HIGH);    // bật đèn
  delay(1000);               // chờ 1 giây — trong lúc này bo mạch không làm gì khác
  digitalWrite(13, LOW);     // tắt đèn
  delay(1000);
}

Chương trình tự điều khiển chân điện, không có ai chia thời gian hay bảo vệ bộ nhớ — và cũng không cần, vì nó chỉ làm một việc. Nhưng hãy thử bắt bo mạch đó vừa nháy đèn, vừa đọc cảm biến, vừa gửi dữ liệu qua Wi-Fi, vừa ghi thẻ nhớ: chỉ một lệnh delay là mọi việc khác phải đứng chờ. Đến lúc đó, người ta bắt đầu cài một hệ điều hành nhỏ — hệ điều hành thời gian thực (real-time OS) như FreeRTOS. Lịch sử hệ điều hành, thu nhỏ trong một bo mạch.

Môn này trả lời câu hỏi gì

Môn Hệ điều hành trả lời một câu hỏi: làm sao để nhiều chương trình cùng dùng chung một bộ phần cứng một cách an toàn, công bằng và hiệu quả?

Câu hỏi đó tách ra thành ba việc lớn, cũng là ba phần của cuốn sách giáo khoa miễn phí nổi tiếng Operating Systems: Three Easy Pieces (OSTEP):

  1. Ảo hóa (virtualization) — làm cho mỗi chương trình tưởng rằng nó có riêng một bộ xử lý và một vùng bộ nhớ.
  2. Đồng thời (concurrency) — cho nhiều việc chạy xen kẽ hoặc song song mà không làm hỏng dữ liệu của nhau.
  3. Lưu trữ bền (persistence) — giữ dữ liệu an toàn trên ổ đĩa, kể cả khi mất điện giữa chừng.

Vì sao cần học, khi phần lớn chúng ta sẽ không bao giờ tự viết một hệ điều hành? Vì gần như mọi vấn đề khó của phần mềm hiện đại — chương trình chậm không rõ lý do, lỗi chỉ xuất hiện "thỉnh thoảng", máy chủ sập khi đông người dùng, lỗ hổng bảo mật — đều có gốc ở những gì môn này dạy. Người hiểu hệ điều hành nhìn một chương trình và thấy được nó thực sự làm gì với máy.

Năm ý tưởng cốt lõi

1. Tiến trình: một chương trình đang chạy

Chương trình (program) là một file nằm im trên ổ đĩa. Khi bạn mở nó, hệ điều hành tạo ra một tiến trình (process): chương trình đó cộng với mọi thứ nó cần để chạy — vùng bộ nhớ riêng, các file đang mở, và "trạng thái" của bộ xử lý (đang chạy tới lệnh nào, các thanh ghi chứa gì).

Mở hai cửa sổ của cùng một trình soạn thảo là có hai tiến trình từ cùng một chương trình. Trong các hệ thống kiểu Unix, một tiến trình tạo tiến trình mới bằng lời gọi fork():

c
#include <stdio.h>
#include <unistd.h>

int main(void) {
    pid_t pid = fork();          // từ đây có hai tiến trình chạy cùng một đoạn code
    if (pid == 0) {
        printf("Tôi là tiến trình con\n");
    } else {
        printf("Tôi là tiến trình cha, con của tôi có mã %d\n", pid);
    }
    return 0;
}

Chạy đoạn này, bạn sẽ thấy cả hai dòng được in ra — và thứ tự giữa chúng có thể đổi giữa các lần chạy. Ai được chạy trước là do hệ điều hành quyết định, không phải do bạn. Đó là cánh cửa dẫn vào ý tưởng tiếp theo.

2. Lập lịch: chia thời gian bộ xử lý

Máy có 8 nhân nhưng có 300 tiến trình. Hệ điều hành giải quyết bằng cách chia thời gian: cho mỗi tiến trình chạy một lát rất ngắn, rồi tạm dừng nó, lưu lại trạng thái, nạp trạng thái của tiến trình khác và cho tiến trình đó chạy. Việc đổi này gọi là chuyển ngữ cảnh (context switch), diễn ra hàng nghìn lần mỗi giây — đủ nhanh để mắt người thấy mọi thứ chạy cùng lúc.

Phần thú vị là chọn ai chạy tiếp. Đó là việc của bộ lập lịch (scheduler), và không có câu trả lời hoàn hảo:

  • Ưu tiên việc ngắn trước thì tổng thời gian chờ thấp, nhưng việc dài có thể chờ mãi.
  • Chia đều cho mọi người thì công bằng, nhưng chương trình cần phản hồi nhanh (như ứng dụng bạn đang gõ phím) có thể thấy giật.
  • Cho ưu tiên cao thì nhanh, nhưng ưu tiên sai có thể gây thảm họa.

Câu chuyện nổi tiếng về điểm cuối: năm 1997, tàu thăm dò Mars Pathfinder trên sao Hỏa liên tục tự khởi động lại. Nguyên nhân là đảo ngược ưu tiên (priority inversion): một tác vụ ưu tiên thấp giữ một tài nguyên dùng chung, tác vụ ưu tiên cao phải chờ nó, trong khi các tác vụ ưu tiên trung bình liên tục chen vào làm tác vụ thấp không chạy được. Các kỹ sư sửa lỗi từ Trái Đất bằng cách bật một cơ chế có sẵn trong hệ điều hành của tàu — kế thừa ưu tiên (priority inheritance). Một khái niệm trong giáo trình đã cứu cả một sứ mệnh.

3. Bộ nhớ ảo: mỗi chương trình một thế giới riêng

Nếu mọi chương trình cùng ghi vào bộ nhớ thật (RAM), một lỗi nhỏ ở chương trình này có thể xóa dữ liệu của chương trình khác — hoặc của chính hệ điều hành. Lời giải là bộ nhớ ảo (virtual memory).

Mỗi tiến trình thấy một không gian địa chỉ (address space) riêng, bắt đầu từ 0 và rất lớn. Địa chỉ mà chương trình dùng chỉ là địa chỉ "ảo". Mỗi lần chương trình đọc hay ghi, phần cứng (bộ quản lý bộ nhớ — MMU) cùng với hệ điều hành dịch nó sang địa chỉ thật trong RAM, theo từng khối gọi là trang (page), thường 4 KB.

Nhờ vậy:

  • Cách ly: tiến trình A không thể nhìn thấy bộ nhớ của tiến trình B — không có địa chỉ ảo nào của A trỏ tới đó. Khi một chương trình truy cập sai chỗ, chỉ nó bị dừng (lỗi "segmentation fault" quen thuộc), máy vẫn chạy.
  • Dùng nhiều hơn RAM thật: trang ít dùng có thể được tạm đẩy ra ổ đĩa và nạp lại khi cần.
  • Chia sẻ tiết kiệm: mười tiến trình cùng dùng một thư viện thì thư viện chỉ cần nằm trong RAM một lần.

Khi máy bạn chậm hẳn đi vì mở quá nhiều tab, nhiều khả năng hệ điều hành đang phải đẩy trang qua lại giữa RAM và ổ đĩa liên tục — hiện tượng có tên thrashing.

4. Đồng thời: khi hai việc đụng nhau

Một tiến trình có thể chia thành nhiều luồng (thread) chạy song song, dùng chung bộ nhớ. Nhanh hơn, nhưng mở ra một loại lỗi khó chịu nhất trong lập trình. Hãy xem dòng code vô hại này, chạy bởi hai luồng cùng lúc:

c
count = count + 1;

Với bộ xử lý, đây là ba bước: đọc count vào thanh ghi, cộng 1, ghi lại. Nếu luồng A đọc được 5, rồi bị dừng; luồng B cũng đọc 5, cộng thành 6, ghi 6; A chạy tiếp, cộng thành 6, ghi 6 — thì hai lần cộng chỉ làm count tăng 1. Đây là điều kiện tranh chấp (race condition): kết quả phụ thuộc vào thứ tự chạy ngẫu nhiên. Lỗi kiểu này có thể không xuất hiện trong một nghìn lần thử, rồi xuất hiện đúng hôm có nhiều người dùng nhất.

Môn học dạy các công cụ để kiểm soát chuyện này — khóa (lock), semaphore, biến điều kiện (condition variable) — và các cái bẫy khi dùng chúng, như bế tắc (deadlock): hai luồng, mỗi luồng giữ một khóa và chờ khóa của luồng kia, đứng yên mãi mãi. Lịch sử có những ví dụ đắt giá: máy xạ trị Therac-25 trong thập niên 1980 đã gây tử vong cho bệnh nhân, một phần vì lỗi tranh chấp trong phần mềm điều khiển.

5. Hệ thống file: dữ liệu sống sót qua mất điện

Ổ đĩa chỉ biết các khối dữ liệu đánh số. "File", "thư mục", "đường dẫn" là những thứ hệ thống file (file system) dựng lên trên các khối đó. Phần khó không nằm ở việc lưu, mà ở việc lưu cho đúng khi có sự cố.

Thử nghĩ: để thêm một dòng vào một file, hệ thống phải ghi dữ liệu mới, cập nhật kích thước file, và đánh dấu khối đã dùng — ba lần ghi ở ba chỗ khác nhau. Mất điện sau lần ghi thứ nhất thì sao? Các hệ thống file hiện đại như ext4 trên Linux hay NTFS trên Windows dùng nhật ký (journaling): ghi trước "tôi sắp làm những việc này" vào một vùng riêng, rồi mới làm. Khởi động lại sau sự cố, hệ thống đọc nhật ký để làm nốt hoặc bỏ hẳn — không bao giờ dừng ở trạng thái nửa vời. Ý tưởng này về sau xuất hiện lại trong cơ sở dữ liệu và hệ phân tán.

Hệ điều hành nằm ở đâu trong chồng tầng

Nếu bạn đã đọc Từ electron đến ứng dụng, máy tính là một chồng tầng trừu tượng. Hệ điều hành nằm ngay trên phần cứng và tập lệnh (ISA), ngay dưới mọi ứng dụng.

Tầng dưới đưa lên

bộ xử lý với các chế độ đặc quyền (chế độ nhân và chế độ người dùng), ngắt (interrupt), bộ quản lý bộ nhớ, thiết bị vào ra.

Đưa lên

tiến trình, luồng, bộ nhớ ảo, file, socket mạng — thông qua các lời gọi hệ thống (system call) như read, write, fork.

Giấu đi

chi tiết của từng loại ổ đĩa, card mạng, cách RAM thật được chia, và việc có bao nhiêu chương trình khác đang chạy.

Vì vậy môn này nối với nhiều môn khác.

Học trước và học sau

· 8 môn

Cấu trúc tính toán

Computation Structures

Học trước sẽ dễ hơn.

Xem chủ đề trên OpenER: Computation Structures

Kiến trúc máy tính

Computer Architecture and Engineering

Học trước sẽ dễ hơn: cách bộ xử lý và bộ nhớ hoạt động.

Xem chủ đề trên OpenER: Computer Architecture and Engineering

Lập trình

Programming

Học trước sẽ dễ hơn, đặc biệt là C.

Xem chủ đề trên OpenER: Programming

Mạng máy tính

Computer Networks

Học sau, dùng lại môn này.

Xem chủ đề trên OpenER: Computer Networks

Hệ phân tán

Distributed Systems

Học sau, dùng lại môn này.

Xem chủ đề trên OpenER: Distributed Systems

An toàn máy tính

Computer Security

Học sau, dùng lại môn này.

Xem chủ đề trên OpenER: Computer Security

Hệ cơ sở dữ liệu

Database Systems

Học sau, dùng lại môn này.

Xem chủ đề trên OpenER: Database Systems

Tính toán song song

Parallel Computing

Học sau, dùng lại môn này.

Xem chủ đề trên OpenER: Parallel Computing

Ứng dụng thật và nghề nghiệp

Kiến thức hệ điều hành xuất hiện ở khắp nơi, kể cả khi bạn không làm "hệ điều hành":

  • Lập trình backend và hệ thống: hiểu tiến trình, luồng, bộ nhớ để viết máy chủ chịu được nhiều người dùng, tìm ra vì sao dịch vụ chậm.
  • Cloud và DevOps: máy ảo và container (Docker, Kubernetes) được xây trực tiếp trên các cơ chế cách ly của hệ điều hành.
  • Nhúng và IoT: từ máy giặt tới ô tô, thiết bị nhỏ chạy hệ điều hành thời gian thực, nơi trễ một mili giây có thể là lỗi.
  • Bảo mật: phần lớn lỗ hổng nghiêm trọng là chuyện vượt ranh giới mà hệ điều hành dựng lên.
  • Phát triển chính hệ điều hành: nhân Linux — bắt đầu năm 1991 như dự án cá nhân của sinh viên Linus Torvalds — nay chạy trong hầu hết máy chủ, mọi điện thoại Android và rất nhiều thiết bị nhúng.

Học xong làm được gì, bắt đầu từ đâu

Sau môn này bạn có thể:

  • giải thích chuyện gì xảy ra từ lúc bấm đúp một biểu tượng tới lúc cửa sổ hiện lên;
  • đọc được vì sao một chương trình chậm, treo, hay dùng quá nhiều bộ nhớ;
  • viết chương trình nhiều luồng mà không sợ lỗi "thỉnh thoảng";
  • tự viết một phần của một hệ điều hành nhỏ — điều mà các khóa học tốt nhất đều bắt bạn làm.

Nên biết trước: lập trình C ở mức đọc được con trỏ, và một chút về cách bộ xử lý chạy lệnh. Chưa vững thì đi qua các chủ đề Programming và Computation Structures trước.

Bắt đầu trên OpenER: trang chủ đề Operating Systems có các khóa học đã chọn lọc, và hướng dẫn học gợi ý thứ tự đi qua chúng. Một lộ trình phổ biến: đọc OSTEP song song với một khóa có bài lab, rồi làm các bài lab tự viết một phần nhân hệ điều hành (ví dụ xv6 — hệ điều hành dạy học của MIT).

Tài liệu tham khảo

  • Remzi H. Arpaci-Dusseau, Andrea C. Arpaci-Dusseau — Operating Systems: Three Easy Pieces, đọc miễn phí tại ostep.org.
  • MIT 6.1810 Operating System Engineering (trước đây 6.S081 / 6.828) — bài giảng và lab dùng xv6.
  • UC Berkeley CS 162 Operating Systems and System Programming.

Trần Ngọc Tây, “Hệ điều hành: người quản gia vô hình của máy tính”, OpenER, 2026. Phát hành theo CC BY 4.0: được chia sẻ, chỉnh sửa, kể cả thương mại, miễn ghi công tác giả và dẫn link bài gốc.