本章深入探讨 ROS2 的实时性能优化技术，涵盖从内核配置到 DDS 调优的全栈优化策略。我们将学习如何构建满足硬实时要求的机器人控制系统，实现微秒级延迟和确定性行为。对于需要高频控制循环的应用（如手术机器人、高速机械臂），这些技术至关重要。
标准 Linux 内核采用分时调度策略，无法保证任务的确定性执行时间。实时性要求系统能够在规定的时间约束内响应外部事件，这对机器人控制至关重要。
实时系统分为两类：
实时性的关键指标：
PREEMPT-RT 是 Linux 内核的实时补丁，将标准内核转换为完全可抢占的实时内核。
主要特性：
安装配置步骤：
# 下载内核源码和 RT 补丁
wget https://kernel.org/pub/linux/kernel/v5.x/linux-5.15.tar.xz
wget https://kernel.org/pub/linux/kernel/projects/rt/5.15/patch-5.15-rt.patch.xz
# 应用补丁
cd linux-5.15
xzcat ../patch-5.15-rt.patch.xz | patch -p1
# 配置内核
make menuconfig
# 启用: Processor type -> Preemption Model -> Fully Preemptible Kernel (RT)
# 禁用: Processor type -> CPU Frequency scaling
# 禁用: Power management options
Linux 提供多种调度策略，ROS2 节点可以根据需求选择：
#include <pthread.h>
#include <sched.h>
class RealtimeNode : public rclcpp::Node {
public:
RealtimeNode() : Node("realtime_node") {
// 设置实时调度策略
struct sched_param param;
param.sched_priority = 80; // 优先级范围 1-99
// SCHED_FIFO: 先进先出实时调度
if (pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m) != 0) {
RCLCPP_WARN(get_logger(), "Failed to set realtime priority");
}
// 锁定内存，防止页面交换
if (mlockall(MCL_CURRENT | MCL_FUTURE) != 0) {
RCLCPP_WARN(get_logger(), "Failed to lock memory");
}
}
};
调度策略对比：
将特定 CPU 核心专门用于实时任务，避免系统任务干扰：
# 内核启动参数，隔离 CPU 2-3
isolcpus=2,3 nohz_full=2,3 rcu_nocbs=2,3
# 设置 CPU 亲和性
taskset -c 2 ros2 run my_package realtime_node
C++ 代码中设置 CPU 亲和性：
void setCPUAffinity(int cpu_id) {
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(cpu_id, &cpuset);
pthread_t thread = pthread_self();
if (pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset) != 0) {
std::cerr << "Error setting CPU affinity" << std::endl;
}
}
动态内存分配是实时系统的主要延迟源。ROS2 提供多种策略避免运行时分配：
预分配内存池：
#include <rclcpp/strategies/allocator_memory_strategy.hpp>
class PreallocatedNode : public rclcpp::Node {
private:
// 预分配消息池
using MessageAllocator = std::allocator<sensor_msgs::msg::PointCloud2>;
using MessageDeleter = rclcpp::allocator::Deleter<MessageAllocator, sensor_msgs::msg::PointCloud2>;
using MessageUniquePtr = std::unique_ptr<sensor_msgs::msg::PointCloud2, MessageDeleter>;
MessageAllocator message_allocator_;
rclcpp::LoanedMessage<sensor_msgs::msg::PointCloud2> loaned_msg_;
public:
PreallocatedNode() : Node("preallocated_node") {
// 使用自定义内存策略
auto allocator = std::make_shared<CustomAllocator<void>>();
auto memory_strategy = std::make_shared<rclcpp::memory_strategies::allocator_memory_strategy::AllocatorMemoryStrategy<>>(allocator);
rclcpp::ExecutorOptions options;
options.memory_strategy = memory_strategy;
}
};
自定义分配器：
template<typename T>
class PoolAllocator {
private:
std::vector<T> pool_;
std::queue<T*> available_;
std::mutex mutex_;
public:
PoolAllocator(size_t pool_size) {
pool_.reserve(pool_size);
for (size_t i = 0; i < pool_size; ++i) {
pool_.emplace_back();
available_.push(&pool_[i]);
}
}
T* allocate(size_t n) {
std::lock_guard<std::mutex> lock(mutex_);
if (available_.empty() || n != 1) {
throw std::bad_alloc();
}
T* ptr = available_.front();
available_.pop();
return ptr;
}
void deallocate(T* ptr, size_t) {
std::lock_guard<std::mutex> lock(mutex_);
available_.push(ptr);
}
};
零拷贝通信避免了消息在发布者和订阅者之间的内存复制，显著降低延迟和 CPU 使用。
Loaned Messages（借用消息）：
class ZeroCopyPublisher : public rclcpp::Node {
private:
rclcpp::Publisher<sensor_msgs::msg::Image>::SharedPtr publisher_;
public:
ZeroCopyPublisher() : Node("zero_copy_publisher") {
// 启用零拷贝
auto qos = rclcpp::QoS(10);
publisher_ = create_publisher<sensor_msgs::msg::Image>("image", qos);
}
void publishImage() {
// 从 DDS 层借用消息缓冲区
auto loaned_msg = publisher_->borrow_loaned_message();
// 直接在借用的内存中填充数据
auto& msg = loaned_msg.get();
msg.width = 1920;
msg.height = 1080;
msg.encoding = "rgb8";
msg.data.resize(1920 * 1080 * 3);
// 填充图像数据...
// 发布时不需要拷贝
publisher_->publish(std::move(loaned_msg));
}
};
使用共享内存在同一主机上的节点间传输大数据：
// 配置 Cyclone DDS 使用共享内存
// cyclone_dds.xml
<Domain id="any">
<SharedMemory>
<Enable>true</Enable>
<LogLevel>info</LogLevel>
</SharedMemory>
</Domain>
Iceoryx 集成：
// 使用 rmw_iceoryx_cpp 实现真正的零拷贝
export RMW_IMPLEMENTATION=rmw_iceoryx_cpp
// 启动 RouDi (Iceoryx 守护进程)
iox-roudi
// 运行节点
ros2 run my_package zero_copy_node
优化数据结构以提高缓存命中率：
// 缓存友好的数据结构
struct alignas(64) CacheAlignedData { // 64 字节缓存行对齐
std::array<float, 16> values; // 热数据放在一起
// 填充以避免伪共享
char padding[64 - sizeof(values)];
};
// Structure of Arrays (SoA) vs Array of Structures (AoS)
// SoA 更适合 SIMD 优化
struct PointCloudSoA {
std::vector<float> x;
std::vector<float> y;
std::vector<float> z;
std::vector<uint8_t> intensity;
void processPoints() {
// SIMD 友好的内存访问模式
#pragma omp simd
for (size_t i = 0; i < x.size(); ++i) {
x[i] *= 2.0f;
y[i] *= 2.0f;
z[i] *= 2.0f;
}
}
};
Quality of Service (QoS) 配置直接影响通信性能：
class OptimizedNode : public rclcpp::Node {
public:
OptimizedNode() : Node("optimized_node") {
// 实时性优化的 QoS 配置
auto qos = rclcpp::QoS(rclcpp::KeepLast(1))
.reliability(RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT) // 低延迟
.durability(RMW_QOS_POLICY_DURABILITY_VOLATILE) // 不持久化
.deadline(std::chrono::milliseconds(10)) // 截止时间
.lifespan(std::chrono::milliseconds(100)); // 消息生存期
// 历史深度为 1，减少内存使用
qos.keep_last(1);
// 创建发布者
publisher_ = create_publisher<std_msgs::msg::Float64>("data", qos);
}
};
QoS 策略选择指南：
不同 DDS 实现有不同的性能特点：
Fast DDS (默认)：
<!-- fastrtps.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<profiles xmlns="http://www.eprosima.com/XMLSchemas/fastRTPS_Profiles">
<participant profile_name="participant_profile" is_default_profile="true">
<rtps>
<builtin>
<discovery_config>
<leaseDuration>
<sec>1</sec>
<nanosec>0</nanosec>
</leaseDuration>
</discovery_config>
<metatrafficUnicastLocatorList>
<locator>
<udpv4>
<address>127.0.0.1</address>
</udpv4>
</locator>
</metatrafficUnicastLocatorList>
</builtin>
<sendSocketBufferSize>1048576</sendSocketBufferSize>
<receiveSocketBufferSize>4194304</receiveSocketBufferSize>
</rtps>
</participant>
<data_writer profile_name="datawriter_profile">
<historyMemoryPolicy>PREALLOCATED_WITH_REALLOC</historyMemoryPolicy>
<qos>
<publishMode>
<kind>ASYNCHRONOUS</kind>
</publishMode>
</qos>
</data_writer>
</profiles>
Cyclone DDS (低延迟优化)：
<!-- cyclonedds.xml -->
<CycloneDDS>
<Domain id="any">
<General>
<NetworkInterfaceAddress>auto</NetworkInterfaceAddress>
<MaxMessageSize>65500B</MaxMessageSize>
<FragmentSize>4000B</FragmentSize>
</General>
<Tracing>
<Verbosity>warning</Verbosity>
<OutputFile>stdout</OutputFile>
</Tracing>
<Internal>
<SocketReceiveBufferSize>4MB</SocketReceiveBufferSize>
<SocketSendBufferSize>1MB</SocketSendBufferSize>
<MaxQueuedMessages>500</MaxQueuedMessages>
</Internal>
</Domain>
</CycloneDDS>
性能对比测试：
# 测试不同 DDS 实现
export RMW_IMPLEMENTATION=rmw_fastrtps_cpp
ros2 run performance_test perf_test -c ROS2 -t Array1k
export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp
ros2 run performance_test perf_test -c ROS2 -t Array1k
UDP 缓冲区调优：
# 增加系统 UDP 缓冲区大小
sudo sysctl -w net.core.rmem_max=134217728
sudo sysctl -w net.core.wmem_max=134217728
sudo sysctl -w net.ipv4.udp_mem="102400 873800 16777216"
sudo sysctl -w net.core.netdev_max_backlog=30000
# 永久生效
echo "net.core.rmem_max=134217728" >> /etc/sysctl.conf
多播配置优化：
// 禁用多播发现，使用单播
export ROS_DISCOVERY_SERVER=127.0.0.1:11811
// 或配置静态节点
<participant>
<rtps>
<builtin>
<initialPeersList>
<locator>
<udpv4>
<address>192.168.1.100</address>
</udpv4>
</locator>
</initialPeersList>
</builtin>
</rtps>
</participant>
使用分区隔离不同子系统的通信：
class PartitionedNode : public rclcpp::Node {
public:
PartitionedNode() : Node("partitioned_node") {
// 设置分区
auto qos = rclcpp::QoS(10);
// 使用 rmw 特定的 QoS 设置分区
rmw_qos_profile_t rmw_qos = qos.get_rmw_qos_profile();
// 控制系统分区
auto control_pub = create_publisher<std_msgs::msg::Float64>(
"control_command", qos);
// 感知系统分区
auto sensor_sub = create_subscription<sensor_msgs::msg::LaserScan>(
"scan", qos,
[](const sensor_msgs::msg::LaserScan::SharedPtr msg) {
// 处理激光数据
});
}
};
perf 工具：
# CPU 性能分析
sudo perf record -g ros2 run my_package my_node
sudo perf report
# 缓存命中率分析
sudo perf stat -e cache-references,cache-misses ros2 run my_package my_node
# 调度延迟分析
sudo perf sched record ros2 run my_package my_node
sudo perf sched latency
ftrace 内核跟踪：
# 启用函数跟踪
echo function > /sys/kernel/debug/tracing/current_tracer
echo 1 > /sys/kernel/debug/tracing/tracing_on
# 运行节点
ros2 run my_package my_node
# 查看跟踪结果
cat /sys/kernel/debug/tracing/trace
ros2_tracing (LTTng)：
// 在代码中添加跟踪点
#include <tracetools/tracetools.h>
void myCallback() {
TRACEPOINT(callback_start, (const void *)this);
// 处理逻辑
TRACEPOINT(callback_end, (const void *)this);
}
# 启动跟踪会话
ros2 trace start my_session
# 运行节点
ros2 run my_package my_node
# 停止跟踪
ros2 trace stop
# 分析结果
babeltrace ~/ros2_tracing/my_session
ros2 topic延迟测量：
# 测量话题延迟
ros2 topic delay /scan
# 带宽测量
ros2 topic bw /image
# 频率测量
ros2 topic hz /cmd_vel
#include <chrono>
#include <rclcpp/rclcpp.hpp>
class PerformanceMonitor {
private:
struct Metrics {
std::atomic<uint64_t> message_count{0};
std::atomic<uint64_t> total_latency_us{0};
std::atomic<uint64_t> max_latency_us{0};
std::atomic<uint64_t> min_latency_us{UINT64_MAX};
};
std::unordered_map<std::string, Metrics> metrics_;
rclcpp::TimerBase::SharedPtr report_timer_;
public:
void recordLatency(const std::string& name, uint64_t latency_us) {
auto& m = metrics_[name];
m.message_count++;
m.total_latency_us += latency_us;
uint64_t old_max = m.max_latency_us.load();
while (latency_us > old_max &&
!m.max_latency_us.compare_exchange_weak(old_max, latency_us));
uint64_t old_min = m.min_latency_us.load();
while (latency_us < old_min &&
!m.min_latency_us.compare_exchange_weak(old_min, latency_us));
}
void printReport() {
for (const auto& [name, m] : metrics_) {
uint64_t count = m.message_count.load();
if (count > 0) {
double avg = m.total_latency_us.load() / (double)count;
RCLCPP_INFO(rclcpp::get_logger("performance"),
"%s: avg=%.2fus, max=%ldus, min=%ldus, count=%ld",
name.c_str(), avg,
m.max_latency_us.load(),
m.min_latency_us.load(),
count);
}
}
}
};
PlotJuggler 实时绘图：
# 安装
sudo apt install ros-humble-plotjuggler-ros
# 启动
ros2 run plotjuggler plotjuggler
# 发布性能数据
ros2 topic pub /performance std_msgs/Float64MultiArray "{data: [1.2, 3.4, 5.6]}"
Trace Compass 分析：
# 导入 LTTng 跟踪数据到 Trace Compass
# 可视化时间线、延迟分布、CPU 使用率等
某医疗科技公司开发的神经外科手术机器人系统需要实现 1kHz 的控制频率，以确保手术器械的精确定位和稳定控制。系统要求：
┌─────────────────┐
│ 主控制器节点 │
│ (1kHz Loop) │
└────────┬────────┘
│
┌───────────┼───────────┐
│ │ │
┌───────▼──────┐ ┌─▼──┐ ┌──────▼──────┐
│ 运动规划节点 │ │力控│ │ 安全监控节点 │
│ (100Hz) │ │节点│ │ (1kHz) │
└──────────────┘ └────┘ └─────────────┘
│
┌────────▼────────┐
│ EtherCAT 总线 │
│ (<100μs) │
└────────┬────────┘
│
┌───────────┼───────────┐
│ │ │
┌────▼───┐ ┌────▼───┐ ┌────▼───┐
│电机驱动│ │电机驱动│ │力传感器│
└────────┘ └────────┘ └────────┘
1. 实时内核配置
# 使用 Ubuntu 22.04 + PREEMPT-RT
uname -a
# Linux surgical-robot 5.15.0-rt17 #1 SMP PREEMPT_RT
# CPU 隔离配置
# /etc/default/grub
GRUB_CMDLINE_LINUX="isolcpus=2,3,4,5 nohz_full=2,3,4,5 rcu_nocbs=2,3,4,5"
# IRQ 亲和性设置
echo 2 > /proc/irq/24/smp_affinity # EtherCAT 中断绑定到 CPU2
2. 控制节点实现
class SurgicalRobotController : public rclcpp::Node {
private:
// EtherCAT 主站
std::unique_ptr<EthercatMaster> ethercat_master_;
// 实时缓冲区
struct RealtimeBuffer {
std::array<double, 7> joint_positions;
std::array<double, 7> joint_velocities;
std::array<double, 6> wrench;
uint64_t timestamp;
};
RealtimeBuffer rt_buffer_;
std::atomic<bool> emergency_stop_{false};
public:
SurgicalRobotController() : Node("surgical_controller") {
// 设置实时优先级
struct sched_param param;
param.sched_priority = 95;
pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m);
// 锁定所有内存页
mlockall(MCL_CURRENT | MCL_FUTURE);
// 预分配内存
rt_buffer_ = {};
// 初始化 EtherCAT
ethercat_master_ = std::make_unique<EthercatMaster>();
ethercat_master_->init();
// 创建 1kHz 定时器
auto timer_callback = [this]() { this->controlLoop(); };
timer_ = create_wall_timer(
std::chrono::microseconds(1000),
timer_callback);
}
void controlLoop() {
auto start = std::chrono::high_resolution_clock::now();
// 1. 读取传感器数据 (< 50μs)
ethercat_master_->readInputs(rt_buffer_);
// 2. 安全检查 (< 10μs)
if (checkSafetyLimits()) {
emergency_stop_ = true;
stopAllMotors();
return;
}
// 3. 控制计算 (< 200μs)
std::array<double, 7> torques = computeControl(rt_buffer_);
// 4. 发送控制命令 (< 50μs)
ethercat_master_->writeOutputs(torques);
// 5. 性能监控
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(
end - start).count();
if (duration > 1100) { // 超过 1.1ms 警告
RCLCPP_WARN_THROTTLE(get_logger(), *get_clock(), 1000,
"Control loop took %ld us", duration);
}
}
};
3. 零拷贝数据传输
// 使用 Iceoryx 实现进程间零拷贝
class ZeroCopyDataExchange {
private:
iox::popo::Publisher<SensorData> sensor_publisher_;
iox::popo::Subscriber<ControlCommand> command_subscriber_;
public:
void publishSensorData(const SensorData& data) {
sensor_publisher_.loan()
.and_then([&](auto& sample) {
*sample = data;
sample.publish();
});
}
void receiveCommand() {
command_subscriber_.take()
.and_then([this](const auto& sample) {
processCommand(*sample);
});
}
};
性能指标测试结果：
┌─────────────────────┬──────────┬──────────┬──────────┐
│ 指标 │ 要求 │ 实测平均 │ 最差情况 │
├─────────────────────┼──────────┼──────────┼──────────┤
│ 控制周期 │ 1ms±50μs │ 1.002ms │ 1.048ms │
│ 端到端延迟 │ <500μs │ 380μs │ 495μs │
│ 抖动 (Jitter) │ <50μs │ 12μs │ 48μs │
│ CPU 使用率 │ <50% │ 35% │ 42% │
│ 内存使用 │ <2GB │ 1.2GB │ 1.2GB │
└─────────────────────┴──────────┴──────────┴──────────┘
测试环境：
测试方法：
// 性能测试节点
class DdsPerformanceTest : public rclcpp::Node {
public:
DdsPerformanceTest() : Node("dds_test") {
// 配置 QoS
auto qos = rclcpp::QoS(1)
.reliability(RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT)
.durability(RMW_QOS_POLICY_DURABILITY_VOLATILE);
// 创建发布者和订阅者
publisher_ = create_publisher<std_msgs::msg::Header>("test", qos);
subscription_ = create_subscription<std_msgs::msg::Header>(
"test", qos,
[this](const std_msgs::msg::Header::SharedPtr msg) {
auto now = this->now();
auto latency = (now - msg->stamp).nanoseconds() / 1000.0;
latencies_.push_back(latency);
});
// 1kHz 发布定时器
timer_ = create_wall_timer(
std::chrono::milliseconds(1),
[this]() {
auto msg = std_msgs::msg::Header();
msg.stamp = this->now();
publisher_->publish(msg);
});
}
};
测试结果：
| 指标 | Cyclone DDS | Fast DDS | Connext DDS |
|---|---|---|---|
| 平均延迟 | 45μs | 62μs | 38μs |
| P99 延迟 | 89μs | 145μs | 72μs |
| 最大延迟 | 210μs | 520μs | 180μs |
| CPU 使用率 | 8% | 12% | 10% |
| 内存占用 | 45MB | 78MB | 95MB |
| 启动时间 | 0.8s | 1.2s | 2.1s |
不同消息大小的对比：
消息大小: 1KB
├─ Cyclone DDS: 48μs (avg), 12Mbps
├─ Fast DDS: 65μs (avg), 11Mbps
└─ Connext DDS: 41μs (avg), 13Mbps
消息大小: 1MB
├─ Cyclone DDS: 820μs (avg), 980Mbps
├─ Fast DDS: 1100μs (avg), 890Mbps
└─ Connext DDS: 750μs (avg), 1050Mbps
消息大小: 10MB
├─ Cyclone DDS: 12ms (avg), 820Mbps
├─ Fast DDS: 18ms (avg), 680Mbps
└─ Connext DDS: 10ms (avg), 920Mbps
DPDK (Data Plane Development Kit) 集成：
// 使用 DPDK 加速网络通信
class DpdkAcceleratedNode {
private:
struct rte_mempool* mbuf_pool_;
uint16_t port_id_ = 0;
public:
DpdkAcceleratedNode() {
// 初始化 DPDK
rte_eal_init(argc, argv);
// 创建内存池
mbuf_pool_ = rte_pktmbuf_pool_create(
"MBUF_POOL", 8192,
MBUF_CACHE_SIZE, 0,
RTE_MBUF_DEFAULT_BUF_SIZE,
rte_socket_id());
// 配置端口
struct rte_eth_conf port_conf = {};
rte_eth_dev_configure(port_id_, 1, 1, &port_conf);
}
void sendPacket(const uint8_t* data, size_t len) {
struct rte_mbuf* mbuf = rte_pktmbuf_alloc(mbuf_pool_);
// 零拷贝数据传输
rte_pktmbuf_attach_extbuf(mbuf, (void*)data,
rte_malloc_virt2iova(data), len, nullptr);
// 发送数据包
rte_eth_tx_burst(port_id_, 0, &mbuf, 1);
}
};
必读论文：
git clone https://github.com/ros-controls/realtime_tools
git clone https://github.com/ros-controls/ros2_control
git clone https://github.com/ApexAI/performance_test
本章深入探讨了 ROS2 实时系统优化的关键技术：
核心概念：
关键公式：
延迟计算： \(L_{total} = L_{kernel} + L_{scheduler} + L_{network} + L_{application}\)
抖动（Jitter）： \(J = \max(T_i) - \min(T_i), \quad i \in [1, n]\)
CPU 利用率界限（Rate Monotonic）： \(U = \sum_{i=1}^{n} \frac{C_i}{T_i} \leq n(2^{1/n} - 1)\)
其中 $C_i$ 是任务执行时间，$T_i$ 是任务周期
内存带宽需求： \(BW = \frac{Message\_Size \times Frequency}{Zero\_Copy\_Factor}\)
性能优化要点：
练习 15.1：配置实时内核 设计一个 bash 脚本，自动检测系统是否安装了 PREEMPT-RT 内核，并报告当前的实时性配置状态。
练习 15.2：QoS 策略选择 给定以下场景，选择合适的 QoS 配置： a) 机械臂力控制（1kHz） b) 视觉数据流（30Hz，每帧 2MB） c) 状态监控（1Hz）
练习 15.3：延迟测量 编写一个 ROS2 节点，测量话题通信的往返延迟（RTT），并计算平均值、最大值、最小值和标准差。
练习 15.4：内存池设计 设计一个固定大小的内存池分配器，支持 O(1) 的分配和释放操作。
练习 15.5：多核优化 设计一个多生产者-多消费者系统，使用无锁队列在 4 个 CPU 核心间传递数据，实现最小延迟。
提示：考虑 SPSC 队列组合、缓存行对齐、NUMA 亲和性
练习 15.6：实时性能诊断 某机器人系统偶尔出现控制延迟峰值（从平均 200μs 突增到 5ms）。设计一个诊断方案找出原因。
提示：考虑内核跟踪、中断统计、内存分配
练习 15.7：端到端优化 优化一个视觉伺服系统，将”相机采集→处理→控制输出”的端到端延迟从 50ms 降低到 10ms。
提示：分析每个阶段的耗时，识别瓶颈
练习 15.8：DDS 实现选型 为以下应用场景选择最适合的 DDS 实现并说明理由： a) 低延迟交易机器人 b) 大规模传感器网络 c) 嵌入式实时控制
问题：低优先级任务持有高优先级任务需要的资源，导致高优先级任务被阻塞。
解决方案：
// 使用优先级继承互斥锁
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
pthread_mutex_init(&mutex, &attr);
问题：首次访问未映射的内存页面导致延迟峰值。
解决方案：
// 预触摸所有内存页面
void prefaultStack() {
unsigned char dummy[8192];
memset(dummy, 0, sizeof(dummy));
}
// 锁定内存防止交换
mlockall(MCL_CURRENT | MCL_FUTURE);
问题：大量节点同时启动导致网络拥塞。
解决方案：
问题：分布式系统中时钟偏差导致时序错误。
解决方案：
问题：CPU 动态调频导致性能不稳定。
解决方案：
# 设置 CPU 为性能模式
cpupower frequency-set -g performance
# 禁用 Intel Turbo Boost
echo 1 > /sys/devices/system/cpu/intel_pstate/no_turbo