Linux 与 Windows 10 操作系统对比

Linux 与 Windows 是设计哲学截然不同的两套操作系统。本文对比这两套操作系统的内核架构、进程管理、内存管理、文件系统等方面，并介绍 Windows Subsystem for Linux（WSL）。

1. Linux 系统概述

Linux 内核架构

Linux 以单体（monolithic）内核为基础，同时借助模块（module）系统获得灵活性。

┌───────────────────────────────────────────────┐
│                   用户空间                     │
│  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐         │
│  │ bash │ │ nginx│ │ gcc  │ │ java │         │
│  └──┬───┘ └──┬───┘ └──┬───┘ └──┬───┘         │
│     │        │        │        │              │
│     └────────┴────────┴────────┘              │
│              │ 系统调用接口                    │
├──────────────┴────────────────────────────────┤
│                   内核空间                     │
│                                               │
│  ┌─────────────────────────────────────────┐  │
│  │               进程管理                  │  │
│  │  调度器 │ 进程创建 │ 信号               │  │
│  ├─────────────────────────────────────────┤  │
│  │               内存管理                  │  │
│  │  虚拟内存 │ 页缓存 │ slab               │  │
│  ├─────────────────────────────────────────┤  │
│  │          VFS（虚拟文件系统）            │  │
│  │  ext4 │ XFS │ Btrfs │ NFS │ tmpfs      │  │
│  ├─────────────────────────────────────────┤  │
│  │                网络栈                   │  │
│  │  TCP/IP │ 套接字 │ Netfilter │ eBPF    │  │
│  ├─────────────────────────────────────────┤  │
│  │               设备驱动                  │  │
│  │  块 │ 字符 │ 网络 │ USB                │  │
│  └─────────────────────────────────────────┘  │
│                                               │
│  ┌─────────────────────────────────────────┐  │
│  │              硬件抽象                   │  │
│  └─────────────────────────────────────────┘  │
├───────────────────────────────────────────────┤
│                    硬件                       │
└───────────────────────────────────────────────┘

Linux 进程管理

// Linux 的进程结构（task_struct 主要字段）
struct task_struct {
    volatile long state;          // 进程状态
    int prio;                     // 优先级
    struct mm_struct *mm;         // 内存信息
    struct fs_struct *fs;         // 文件系统信息
    struct files_struct *files;   // 已打开文件表
    struct signal_struct *signal; // 信号信息
    pid_t pid;                    // 进程 ID
    pid_t tgid;                   // 线程组 ID
    struct task_struct *parent;   // 父进程
    struct list_head children;    // 子进程列表
    // ...
};

Linux 进程状态：
┌─────────┐  fork()  ┌─────────┐
│ 尚未    │────────→ │ READY   │
│ 存在    │          │ （可    │
└─────────┘          │  运行） │
                     └────┬────┘
                    调度  │  抢占
                     ┌────┴────┐
                     │ RUNNING │
                     │ 运行中  │
                     └────┬────┘
              I/O 等待│   │exit()
                 ┌────┴──┐│
                 │SLEEPING││
                 │（等待）││
                 └────────┘│
                     ┌─────┴───┐
                     │ ZOMBIE  │
                     │ 已终止  │ → wait() → 移除
                     └─────────┘

Linux 进程调度器（CFS）

CFS（Completely Fair Scheduler）以虚拟运行时间为依据公平地分配 CPU 时间。

CFS 红黑树：
          （按 vruntime 排序）

              B (vruntime=50)
             ╱ ╲
     A (30) ╱   ╲ D (80)
           ╱     ╲
      C (45)   E (100)

→ 最左侧节点（A, vruntime=30）是下一个执行对象
→ 执行后 A 的 vruntime 增大 → 树重新排列
→ O(log n) 插入/删除

Linux 内存管理

Linux 进程虚拟地址空间（64 位）：

高地址
┌──────────────────────┐ 0xFFFFFFFF...
│      内核空间        │
│   （所有进程共享）   │
├──────────────────────┤ 0x7FFF...
│      栈（↓ 增长）    │
│                      │
│      （空闲区）      │
│                      │
│      mmap 区域       │ ← 共享库、mmap
│                      │
│      （空闲区）      │
│                      │
│      堆（↑ 增长）    │ ← malloc/brk
├──────────────────────┤
│      BSS（未初始化） │
├──────────────────────┤
│      数据（已初始化）│
├──────────────────────┤
│      文本（代码）    │
└──────────────────────┘ 0x0000...
低地址

Linux 文件系统管理

# Linux 支持的主要文件系统
# ext4    : 通用（使用最广泛）
# XFS     : 大容量文件/高性能
# Btrfs   : CoW、快照、压缩
# tmpfs   : 基于内存的临时文件系统
# procfs  : 进程信息 (/proc)
# sysfs   : 设备/驱动信息 (/sys)

# 查看已挂载的文件系统
df -hT
# Filesystem  Type  Size  Used  Avail  Use%  Mounted on
# /dev/sda1   ext4  100G   45G    50G   48%  /
# tmpfs       tmpfs  16G    0     16G    0%  /dev/shm

Linux 内核模块

可以在运行时动态添加或移除内核功能。

// 简单的内核模块示例
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Example");
MODULE_DESCRIPTION("Hello World Module");

static int __init hello_init(void) {
    printk(KERN_INFO "Hello, Kernel Module!\n");
    return 0;
}

static void __exit hello_exit(void) {
    printk(KERN_INFO "Goodbye, Kernel Module!\n");
}

module_init(hello_init);
module_exit(hello_exit);

# 内核模块管理命令
# 已加载模块列表
lsmod

# 加载模块
sudo insmod hello.ko

# 卸载模块
sudo rmmod hello

# 自动解析依赖后加载
sudo modprobe module_name

# 查看模块信息
modinfo module_name

2. Windows 10 系统概述

Windows 架构

Windows 采用混合内核结构。

┌───────────────────────────────────────────────┐
│                  用户模式                      │
│                                               │
│  ┌────────────────────────────────────────┐   │
│  │              系统进程                  │   │
│  │  服务管理器    │ LSA │ Session Manager │   │
│  └────────────────────────────────────────┘   │
│                                               │
│  ┌────────────────────────────────────────┐   │
│  │               子系统                   │   │
│  │  Windows (Win32) │ POSIX │ WSL        │   │
│  └────────────────────────────────────────┘   │
│                                               │
│  ┌────────────────────────────────────────┐   │
│  │          环境子系统 DLL                │   │
│  │  ntdll.dll │ kernel32.dll │ user32.dll │   │
│  └────────────────────────────────────────┘   │
├───────────────────────────────────────────────┤
│                  内核模式                      │
│                                               │
│  ┌────────────────────────────────────────┐   │
│  │         执行体（Executive）            │   │
│  │  Object Mgr │ Process Mgr │ Memory Mgr│   │
│  │  I/O Mgr    │ Cache Mgr   │ Security  │   │
│  │  Config Mgr │ PnP Mgr     │ Power Mgr │   │
│  ├────────────────────────────────────────┤   │
│  │           内核（Kernel）               │   │
│  │  调度 │ 同步 │ 中断处理                │   │
│  ├────────────────────────────────────────┤   │
│  │       HAL（硬件抽象层）                │   │
│  └────────────────────────────────────────┘   │
│                                               │
│  ┌────────────────────────────────────────┐   │
│  │              设备驱动                  │   │
│  └────────────────────────────────────────┘   │
├───────────────────────────────────────────────┤
│                    硬件                       │
└───────────────────────────────────────────────┘

Windows 对象管理器（Object Manager）

Windows 内核几乎把所有资源都当作对象来管理。

对象管理器命名空间：
\
├── Device
│   ├── HarddiskVolume1
│   ├── Tcp
│   └── Null
├── ObjectTypes
│   ├── Process
│   ├── Thread
│   ├── File
│   ├── Mutex
│   └── Semaphore
├── Sessions
│   └── 1
│       └── BaseNamedObjects
│           └── MyMutex
└── GLOBAL??
    ├── C:  → Device\HarddiskVolume1
    └── D:  → Device\CdRom0

Windows 对象结构：
┌─────────────────────────────────┐
│ 对象头                          │
│ - 名称                          │
│ - 目录                          │
│ - 安全描述符                    │
│ - 引用计数                      │
│ - 句柄计数                      │
│ - 对象类型指针                  │
├─────────────────────────────────┤
│ 对象体                          │
│ - 按类型划分的数据              │
│   （进程、线程、文件等）        │
└─────────────────────────────────┘

Windows 进程与线程管理

Windows 进程结构：
┌─────────────────────────────────────┐
│ 进程 (EPROCESS)                     │
│ - 虚拟地址空间                      │
│ - 句柄表（已打开对象）              │
│ - 访问令牌（安全上下文）            │
│ - PID                               │
│                                     │
│ ┌─────────┐ ┌─────────┐ ┌────────┐ │
│ │Thread 1 │ │Thread 2 │ │Thread 3│ │
│ │(ETHREAD)│ │(ETHREAD)│ │(ETHREAD│ │
│ │- TEB    │ │- TEB    │ │- TEB   │ │
│ │- 栈     │ │- 栈     │ │- 栈    │ │
│ │- 优先级 │ │- 优先级 │ │- 优先级│ │
│ └─────────┘ └─────────┘ └────────┘ │
└─────────────────────────────────────┘

Windows 调度

Windows 优先级层次：

31 ┌──────────────────┐
   │ Real-time 类     │  16-31：实时优先级
16 ├──────────────────┤
15 │ Variable 类      │  1-15：动态优先级
   │                  │  （I/O 完成时临时提升）
 1 ├──────────────────┤
 0 │ Idle             │  0：系统空闲线程
   └──────────────────┘

优先级提升：
- 交互式进程：前台提升
- I/O 完成：临时提高优先级
- 防止饥饿：长期等待的线程获得提升

Windows 内存管理器

Windows 虚拟内存结构（64 位）：

高地址
┌──────────────────────┐
│      内核空间        │  （高半部）
│  - 内核代码/数据     │
│  - 分页/非分页       │
│    内存池            │
├──────────────────────┤  0x7FFF...
│      用户空间        │  （低半部，128TB）
│  - DLL               │
│  - 堆                │
│  - 栈                │
│  - 可执行文件映像    │
└──────────────────────┘  0x0000...

特殊内存：
- Paged Pool: 可被换出的内核内存
- NonPaged Pool: 始终驻留在物理内存中
- Section Object: 内存映射文件

NTFS (NT File System)

NTFS 主要特性：
┌──────────────────────────────────────────┐
│  MFT (Master File Table):               │
│  - 保存所有文件/目录的元数据             │
│  - 每个条目约 1KB                        │
│  - 小文件直接存放在 MFT 记录中           │
│                                          │
│  MFT 记录结构：                          │
│  ┌───────────────────────────────────┐   │
│  │ 头部                              │   │
│  ├───────────────────────────────────┤   │
│  │ Standard Information 属性         │   │
│  │ （时间戳、标志等）                │   │
│  ├───────────────────────────────────┤   │
│  │ File Name 属性                    │   │
│  ├───────────────────────────────────┤   │
│  │ Data 属性                         │   │
│  │ （小文件：直接存放数据）          │   │
│  │ （大文件：运行(run)列表）         │   │
│  ├───────────────────────────────────┤   │
│  │ Security Descriptor 属性          │   │
│  └───────────────────────────────────┘   │
│                                          │
│  附加特性：                              │
│  - 日志（事务日志）                      │
│  - 文件级压缩                            │
│  - 文件级加密（EFS）                     │
│  - 备用数据流（ADS）                     │
│  - 基于 ACL 的细粒度访问控制             │
│  - 磁盘配额                              │
│  - 符号链接、联接点(junction)            │
└──────────────────────────────────────────┘

3. Linux vs Windows 对比

内核架构对比

特性	Linux	Windows
内核类型	单体（+ 模块）	混合
源代码	开源（GPL）	闭源（部分公开）
设备驱动	内核内/模块	内核/用户模式驱动
文件系统	VFS 抽象	I/O 管理器 + 过滤驱动
安全模型	DAC + MAC（SELinux）	ACL + 完整性级别

进程模型对比

Linux:                              Windows:
┌─────────────────────┐            ┌─────────────────────┐
│ 进程 (fork)         │            │ 进程                │
│ ┌────┐              │            │ (CreateProcess)     │
│ │Task│ = 进程       │            │ ┌──────┐ ┌──────┐  │
│ └────┘              │            │ │Thread│ │Thread│  │
│                     │            │ └──────┘ └──────┘  │
│ 线程 = 轻量级       │            │                     │
│ 进程 (clone)        │            │ 纤程(Fiber):        │
│ ┌────┐ ┌────┐      │            │ 用户模式线程        │
│ │Task│ │Task│      │            │ (协作式调度)        │
│ └────┘ └────┘      │            └─────────────────────┘
│ → 共享同一          │
│   mm_struct 地址空间│
└─────────────────────┘

Linux fork(): 复制进程（CoW）
Windows CreateProcess(): 直接创建新进程

文件系统对比

特性	Linux (ext4)	Windows (NTFS)
元数据	inode	MFT 记录
最大文件大小	16 TiB	256 TiB
日志	支持	支持
权限	POSIX (rwx)	ACL
大小写	区分	保留（默认不区分）
文件流	单一	多个（ADS）
加密	dm-crypt（卷级）	EFS（文件级）

IPC（进程间通信）对比

Linux IPC:                       Windows IPC:
- pipe / named pipe (FIFO)       - Named Pipes
- UNIX 域套接字                  - Mailslots
- System V IPC                   - Shared Memory (Section)
  (shmem, semaphore, msgqueue)   - COM / DCOM
- POSIX IPC                      - Windows Messages
- D-Bus                          - RPC
- netlink 套接字                 - ALPC (Advanced Local
- io_uring                         Procedure Call)

4. Windows Subsystem for Linux (WSL)

WSL 让 Windows 能够原生运行 Linux 二进制程序。

WSL 1 vs WSL 2

WSL 1:
┌──────────────────────────────────────┐
│ Linux 用户空间                       │
│ (bash, gcc, python 等)               │
├──────────────────────────────────────┤
│ LxCore.sys / Lxss.sys               │
│ (Linux 系统调用 → NT 系统调用转换)   │
├──────────────────────────────────────┤
│ Windows NT 内核                      │
└──────────────────────────────────────┘
→ 系统调用翻译方式（兼容性有限）

WSL 2:
┌──────────────────────────────────────┐
│ Linux 用户空间                       │
│ (bash, gcc, python, docker 等)       │
├──────────────────────────────────────┤
│ 真正的 Linux 内核（轻量 VM 内部）    │
├──────────────────────────────────────┤
│ 轻量实用工具 VM（基于 Hyper-V）      │
├──────────────────────────────────────┤
│ Windows NT 内核 + Hyper-V            │
└──────────────────────────────────────┘
→ 运行完整的 Linux 内核（兼容性高）

特性	WSL 1	WSL 2
架构	系统调用转换	轻量 VM（真正 Linux 内核）
系统调用兼容性	部分	完全
文件系统性能	Windows FS 更快	Linux FS 更快
网络	与宿主相同	基于 NAT
Docker 支持	不支持	支持
内存	共享	单独分配（动态）

# WSL 基本命令

# 可安装的发行版列表
wsl --list --online

# 安装 Ubuntu
wsl --install -d Ubuntu

# 查看 WSL 版本
wsl -l -v

# 将默认发行版设为 WSL 2
wsl --set-default-version 2

# 启动 Linux 发行版
wsl -d Ubuntu

# 在 Windows 中访问 Linux 文件
# \\wsl$\Ubuntu\home\user\

5. 总结

Linux

内核：单体 + 动态模块加载
进程：fork/exec 模型，基于 task_struct，CFS 调度器
内存：虚拟内存、页缓存、slab 分配器
文件系统：通过 VFS 整合多种文件系统，默认为 ext4
优势：开源、适合服务器/云环境、易于定制

Windows 10

内核：混合结构，Executive 服务层
进程：CreateProcess 模型，基于对象的管理，优先级提升
内存：Paged/NonPaged 池、Section 对象、工作集管理
文件系统：NTFS（基于 MFT，支持 ACL、ADS、EFS）
优势：桌面兼容性、企业级管理、通过 WSL 整合 Linux

小测验：Linux 与 Windows 对比

Q1. Linux 的单体内核与 Windows 的混合内核有什么区别？

A1. Linux 的单体内核把进程管理、内存管理、文件系统、驱动等所有核心功能都放在同一个内核空间中执行，性能好，但出错时会影响整个系统。 Windows 的混合内核把核心功能保留在内核模式，同时把一部分服务（如环境子系统）放到用户模式，从而在稳定性与性能之间取得平衡。

Q2. Linux 的 fork() 与 Windows 的 CreateProcess() 有什么区别？

A2. fork() 复制当前进程来创建子进程。父进程与子进程先执行相同的代码，然后通过 exec() 载入另一个程序。借助 Copy-on-Write 十分高效。 CreateProcess() 则从头创建一个新进程，并直接载入指定的可执行文件，类似于把 fork+exec 两个步骤合并为一个。

Q3. WSL 1 与 WSL 2 的核心区别是什么？

A3. WSL 1 采用把 Linux 系统调用翻译为 NT 内核系统调用的模拟方式，存在部分系统调用不受支持的兼容性局限。 WSL 2 在基于 Hyper-V 的轻量 VM 中运行真正的 Linux 内核，因此提供完整的系统调用兼容性，并且支持 Docker。