Fix format issue

02_basic_concept/2.2_container.md

@@ -14,24 +14,17 @@
 
 > 💡 **笔者认为，理解这一点是理解 Docker 的关键****容器的本质是一个特殊的进程。**
 
-```
-┌─────────────────────────────────────────────────────────────┐
-│                     普通进程                                 │
-│  • 与其他进程共享系统资源                                     │
-│  • 可以看到其他进程                                          │
-│  • 共享网络和文件系统                                         │
-└─────────────────────────────────────────────────────────────┘
-
-┌─────────────────────────────────────────────────────────────┐
-│                     容器进程                                 │
-│  ┌───────────────────────────────────────────────────────┐ │
-│  │  • 有自己的进程空间（看不到宿主机上的其他进程）           │ │
-│  │  • 有自己的网络（独立 IP、端口）                         │ │
-│  │  • 有自己的文件系统（独立的 root 目录）                  │ │
-│  │  • 有自己的用户（容器内的 root ≠ 宿主机的 root）         │ │
-│  └───────────────────────────────────────────────────────┘ │
-│     但仍然运行在宿主机的内核上                                │
-└─────────────────────────────────────────────────────────────┘
+```mermaid
+flowchart TD
+    subgraph NormalProcess ["普通进程"]
+        direction TB
+        N1["• 与其他进程共享系统资源<br/>• 可以看到其他进程<br/>• 共享网络和文件系统"]
+    end
+    
+    subgraph ContainerProcess ["容器进程 (运行在宿主机内核上)"]
+        direction TB
+        C1["• 有自己的进程空间（看不到宿主机上的其他进程）<br/>• 有自己的网络（独立 IP、端口）<br/>• 有自己的文件系统（独立的 root 目录）<br/>• 有自己的用户（容器内的 root ≠ 宿主机的 root）"]
+    end
 ```
 
 这种隔离是通过 Linux 内核的 **Namespace** 技术实现的。
@@ -40,21 +33,35 @@
 
 很多初学者会混淆容器和虚拟机。笔者用一张图来说明：
 
-```
-虚拟机                              容器
-┌───────────────────────┐          ┌───────────────────────┐
-│   App A    │   App B  │          │   App A    │   App B  │
-├────────────┼──────────┤          ├────────────┼──────────┤
-│ Guest OS   │ Guest OS │          │ Container  │ Container│
-│ (完整系统) │ (完整系统)│          │  (仅应用)   │  (仅应用) │
-├────────────┴──────────┤          └────────────┴──────────┤
-│      Hypervisor       │          │     Docker Engine     │
-├───────────────────────┤          ├───────────────────────┤
-│       Host OS         │          │       Host OS         │
-├───────────────────────┤          ├───────────────────────┤
-│      Hardware         │          │      Hardware         │
-└───────────────────────┘          └───────────────────────┘
-每个 VM 运行完整 OS                  所有容器共享宿主机内核
+```mermaid
+flowchart TD
+    subgraph VM ["虚拟机 (每个 VM 运行完整 OS)"]
+        direction TB
+        subgraph VMApp ["应用层"]
+            VA[App A] & VB[App B]
+        end
+        subgraph VMGuest ["Guest OS (完整系统)"]
+            G1[Guest OS] & G2[Guest OS]
+        end
+        V[Hypervisor]
+        VMH[Host OS]
+        VMHW[Hardware]
+        VMApp --> VMGuest --> V --> VMH --> VMHW
+    end
+    
+    subgraph Container ["容器 (所有容器共享宿主机内核)"]
+        direction TB
+        subgraph CApp ["应用层"]
+            CA[App A] & CB[App B]
+        end
+        subgraph CContainer ["隔离层"]
+            CC1[Container 仅应用] & CC2[Container 仅应用]
+        end
+        CE[Docker Engine]
+        CH[Host OS]
+        CHW[Hardware]
+        CApp --> CContainer --> CE --> CH --> CHW
+    end
 ```
 
 | 特性 | 容器 | 虚拟机 |
@@ -73,19 +80,15 @@
 
 当容器运行时，Docker 会在镜像的只读层之上创建一个**可写层**（容器存储层）：
 
-```
-┌─────────────────────────────────────────────┐
-│       容器存储层（可读写）                    │ ← 容器运行时创建
-│  运行时产生的文件变化记录在这里                │
-├─────────────────────────────────────────────┤
-│       镜像第 N 层（只读）                     │
-├─────────────────────────────────────────────┤
-│       镜像第 N-1 层（只读）                   │
-├─────────────────────────────────────────────┤
-│           ...                               │
-├─────────────────────────────────────────────┤
-│       镜像第 1 层（只读）                     │ ← 基础镜像层
-└─────────────────────────────────────────────┘
+```mermaid
+flowchart TD
+    ContainerLayer["容器存储层（可读写）<br/>容器运行时创建，记录文件变化"]
+    ImageLayerN["镜像第 N 层（只读）"]
+    ImageLayerN1["镜像第 N-1 层（只读）"]
+    Dots["..."]
+    ImageLayer1["镜像第 1 层（只读）<br/>基础镜像层"]
+    
+    ContainerLayer --> ImageLayerN --> ImageLayerN1 --> Dots --> ImageLayer1
 ```
 
 #### Copy-on-Write（写时复制）
@@ -143,34 +146,25 @@ $ docker run -v /host/path:/container/path nginx
 
 ### 容器的生命周期
 
-掌握容器的生命周期对于管理和调试 Docker 应用非常重要。下图展示了容器从创建到删除的完整状态流转。
+掌握容器的生命周期对于管理和调试 Docker 应用非常重要。如图 2-1 所示，容器会经历从创建到删除的完整状态流转。
 
+```mermaid
+stateDiagram-v2
+    direction TB
+    [*] --> Created : docker create
+    Created --> Running : docker start
+    Running --> Stopped : docker stop
+    Running --> Paused : docker pause
+    Paused --> Running : docker unpause
+    
+    Created --> Deleted : docker rm
+    Stopped --> Deleted : docker rm
+    Paused --> Deleted : docker rm
+    
+    Deleted --> [*]
 ```
-                ┌──────────────────────────────────────────────────┐
-                │                  容器生命周期                     │
-                └──────────────────────────────────────────────────┘
 
-    docker create           docker start           docker stop
-         │                       │                      │
-         ▼                       ▼                      ▼
-    ┌─────────┐            ┌─────────┐            ┌─────────┐
-    │ Created │───────────▶│ Running │───────────▶│ Stopped │
-    └─────────┘            └─────────┘            └─────────┘
-         │                       │                      │
-         │                       │ docker pause         │
-         │                       ▼                      │
-         │                 ┌─────────┐                  │
-         │                 │ Paused  │                  │
-         │                 └─────────┘                  │
-         │                       │                      │
-         │        docker rm      │     docker rm        │
-         └───────────────────────┴──────────────────────┘
-                                 │
-                                 ▼
-                           ┌──────────┐
-                           │ Deleted  │
-                           └──────────┘
-```
+图 2-1 容器生命周期状态流转图
 
 #### 常用生命周期命令