Process View: The Heartbeat of System Runtime

1. What is Process View?

Process view answers “how the system works” by describing the runtime behavior, i.e., which processes and threads are active, how they communicate, how concurrency is controlled, and what performance characteristics they exhibit.

2. Core Concepts

2.1 Process

A process is the basic unit of resource allocation in an operating system.

┌─────────────────────────────────┐
│           进程A                │
│                               │
│  ┌─────────────────────────┐ │
│  │        代码区            │ │
│  └─────────────────────────┘ │
│  ┌─────────────────────────┐ │
│  │        数据区            │ │
│  └─────────────────────────┘ │
│  ┌─────────────────────────┐ │
│  │        堆栈区            │ │
│  └─────────────────────────┘ │
│                               │
│  进程ID: 1001                │
│  内存地址: 0x7f0000000000   │
└─────────────────────────────────┘

2.2 Thread

A thread is the basic unit of CPU scheduling; a process may contain multiple threads.

┌─────────────────────────────────┐
│           进程A                │
│                               │
│  ┌───────────┐                │
│  │   主线程   │ ← 线程1      │
│  └───────────┘                │
│                               │
│  ┌───────────┐ ┌───────────┐ │
│  │  工作线程 │ │  工作线程 │ │ ← 线程2, 线程3
│  └───────────┘ └───────────┘ │
│                               │
└─────────────────────────────────┘

Process vs Thread

Resource usage: process – independent memory space; thread – shared memory.

Creation overhead: process – large; thread – small.

Communication: process – complex (IPC); thread – simple (shared memory).

Context‑switch cost: process – large; thread – small.

2.3 Inter‑Process Communication (IPC)

Common IPC mechanisms and their suitable scenarios:

Pipe – unidirectional data flow, for parent‑child processes.

Message queue – asynchronous messages, for decoupled communication.

Shared memory – high‑performance data sharing.

Socket – network communication, for cross‑machine interaction.

RPC – remote procedure calls, for distributed systems.

2.4 Concurrency Models

Three typical models:

Multi‑process : isolated processes share a database; strong isolation, a crash in one process does not affect others.

Multi‑thread : threads share data within a process; suitable for high‑concurrency workloads.

Hybrid : combination of processes and threads, e.g., each service runs in its own process with a thread pool.

2.5 Synchronization Mechanisms

Mutex – ensures exclusive access to a resource.

Read‑write lock – optimised for many reads and few writes.

Semaphore – controls the number of concurrent resources.

Condition variable – enables producer‑consumer waiting.

Atomic operation – non‑interruptible updates, useful for counters.

2.6 Asynchronous Model

Difference between synchronous and asynchronous calls, illustrated with ASCII diagrams, and a typical message‑queue flow.

同步：
请求 ──────────────────────────→ 响应
    (等待)

异步：
请求 ──→ 响应（回调）
    (继续处理其他事情)

服务A           MQ               服务B
  │             │                │
  │──发送消息──→│                │
  │             │──消费消息──→│
  │             │                │
  │             │                │

3. Performance Indicators

3.1 Process‑level metrics

CPU usage – process CPU share, target < 80%.

Memory usage – avoid OOM.

Thread count – keep active threads reasonable.

File descriptor count – respect system limits.

GC frequency – high frequency may increase latency.

3.2 System‑level metrics

System load – keep below the number of CPU cores.

CPU wait – I/O wait ratio should not be too high.

Context switches – excessive switches degrade performance.

Process count – stay within system limits.

4. Design Guidelines

4.1 Process Partitioning Principles

By function: web processes (handle HTTP), background processes (asynchronous tasks), scheduled processes (timed jobs).

By isolation: separate processes for components that require isolation.

By resource: separate CPU‑intensive, I/O‑intensive, or memory‑heavy workloads.

4.2 Thread Design Principles

Thread‑pool size = CPU cores × desired utilization × (1 + wait‑time / compute‑time). Example: CPU‑bound → cores + 1; I/O‑bound → cores × 2 or more.

Avoid excessive concurrency: thread creation and context switching have overhead.

4.3 IPC Design

Select the communication method that matches the scenario:

Same‑process multithreading – shared memory and locks.

Same‑machine processes – Unix sockets or pipes.

Cross‑machine – RPC or message queues.

High‑concurrency decoupling – message queues.

Consider reliability aspects such as persistence, acknowledgement, and retry strategies.

5. Illustrative Diagrams

Process architecture of an e‑commerce system:

┌─────────────────────────────────────────────────────┐
│          电商系统进程架构                         │
├─────────────────────────────────────────────────────┤
│                                                   │
│   ┌─────────┐                                    │
│   │ Nginx   │ ← 进程1: 负载均衡                     │
│   └────┬────┘                                    │
│        │                                          │
│   ┌────▼────┐   ┌─────────┐                       │
│   │ 网关服务 │───→│ 用户服务 │ ← 进程2‑3: 多实例      │
│   └────┬────┘   └─────────┘                       │
│        │                                          │
│        │   ┌─────────┐                           │
│        ├──→│ 商品服务 │ ← 进程4‑5: 多实例          │
│        │   └─────────┘                           │
│        │                                          │
│        │   ┌─────────┐                           │
│        └──→│ 订单服务 │ ← 进程6: 消息驱动          │
│             └────┬────┘                           │
│                  │                               │
│   ┌───────────────┼───────────────────┐           │
│   │               │                   │           │
│ ┌─▼───┐       ┌───▼───┐           ┌───▼───┐      │
│ │MySQL│       │ Redis │           │Kafka │      │
│ └─────┘       └───────┘           └───────┘      │
│                                                   │
└─────────────────────────────────────────────────────┘

Thread‑pool layout with core and maximum sizes, and a connection‑pool example:

┌─────────────────────────────────────────┐
│          Web服务器                     │
├─────────────────────────────────────────┤
│                                         │
│   ┌─────────────────────────────────┐ │
│   │      线程池 (核心:10, 最大:50)   │ │
│   │                                 │ │
│   │  ┌────┐ ┌────┐ ┌────┐ ┌────┐   │ │
│   │  │线程1│ │线程2│ │线程3│ │线程4│   │ │
│   │  └────┘ └────┘ └────┘ └────┘   │ │
│   │        ...更多线程...          │ │
│   │  ┌────┐ ┌────┐ ┌────┐ ┌────┐   │ │
│   │  │线程9│ │线程10│ │线程11│ │...│ │
│   │  └────┘ └────┘ └────┘ └────┘   │ │
│   └─────────────────────────────────┘ │
│                                         │
│   ┌─────────────────────────────────┐ │
│   │      连接池 (HikariCP)           │ │
│   │      最大连接数: 50              │ │
│   └─────────────────────────────────┘ │
│                                         │
└─────────────────────────────────────────┘

Sequence diagram of a user request flowing through gateway, user service, order service, and MySQL:

用户      网关       用户服务     订单服务     MySQL
 │        │            │            │        │
 │──请求──→│            │            │        │
 │        │──调用────→│            │        │
 │        │            │──查询────→│        │
 │        │            │←─结果─────│        │
 │        │←─返回─────│            │        │
 │        │──调用───────────────→│        │
 │        │            │            │──写入────→│
 │        │            │            │←─确认─────│
 │        │←─返回─────────────────│        │
 │←─响应───│            │            │        │

6. Takeaways

Process view focuses on runtime behavior, not static structure.

Reasonable process partition balances isolation and overhead.

Thread‑pool size should be tuned; more threads are not always better.

Choose appropriate communication mechanisms; match sync/async to the use case.