定时器高频总结一

发表于 2025/01/15 更新于 2025/01/15

作者 匆匆那年 37 分钟阅读

什么是定时器？请简要描述定时器的作用和原理

定时器是一种硬件或软件功能，用于根据预设的时间间隔触发特定操作。它广泛应用于嵌入式系统、实时操作系统以及应用程序中，以实现周期性任务或延时操作。

定时器的作用

周期性任务： 定时器可以周期性地触发中断，用于执行定时任务，如数据采集、刷新显示或心跳信号。
延时功能： 用于延时操作，例如等待某个事件完成或设定超时时间。
计数功能： 计数外部事件的发生次数，例如脉冲计数。
时间基准： 提供精准的时间基准，用于时间戳记录或同步多个系统组件。

定时器的工作原理

时钟源： 定时器依赖一个时钟信号（通常来自系统时钟或外部晶振）作为输入。
计数器： 定时器包含一个计数器，用于根据输入时钟信号递增或递减计数值。
预分频器： 通过预分频器可以降低输入时钟的频率，从而控制计数器的计数速度。
匹配和中断： 定时器可以设置一个匹配值（也称为比较值）。当计数器达到该值时，会触发一个事件（如中断）。
重装载（可选）： 定时器可以配置为自动重装载模式，计数器会在达到匹配值后自动复位并重新开始计数。

定时器类型

硬件定时器： 嵌入式微控制器或处理器芯片上集成的专用模块，提供高精度的时间控制。
软件定时器： 由操作系统或应用程序通过软件实现，依赖系统时钟进行计时，精度通常较硬件定时器低。

应用场景

嵌入式系统中实现PWM（脉宽调制）控制
操作系统中实现任务调度
通信协议中的超时检测
实时数据采集系统中的周期性触发

定时器在时间敏感的系统中至关重要，可以实现精准的时序控制与事件调度。

在多线程环境下，如何实现一个线程安全的定时器？

在多线程环境下实现一个线程安全的定时器需要考虑线程同步和数据共享的问题，确保多个线程能够安全地访问和操作定时器资源，同时避免竞争条件和数据不一致性。

以下是实现线程安全定时器的关键步骤和常用方法：

实现方法

使用互斥锁（Mutex）保护共享数据
- 定时器通常需要访问共享资源（如计数器、时间间隔、状态等）。
- 通过互斥锁（如 C++ 的 std::mutex）保护这些共享数据，确保只有一个线程可以访问它们。
使用条件变量（Condition Variable）实现等待和通知
- 定时器线程可以使用条件变量等待下一个超时时间。
- 当外部线程需要重新配置定时器（例如更改时间间隔或取消定时器）时，可以通过条件变量通知定时器线程。
独立线程或线程池
- 为定时器分配独立线程，专门负责等待和触发定时事件。
- 也可以将定时器逻辑集成到线程池中，通过任务调度实现定时功能。
时间管理
- 使用高精度时间源（如 std::chrono）记录定时器启动时间和目标时间，避免因线程切换导致时间不准。
- 支持动态调整定时器的时间间隔。

示例代码

以下是一个使用 C++ 实现线程安全定时器的简单示例：

  
#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <atomic>

class Timer {
public:
    Timer() : stop_flag(false) {}

    void start(int interval_ms, std::function<void()> callback) {
        stop();
        stop_flag = false;
        timer_thread = std::thread([this, interval_ms, callback]() {
            std::unique_lock<std::mutex> lock(timer_mutex);
            while (!stop_flag) {
                if (cv.wait_for(lock, std::chrono::milliseconds(interval_ms), [this]() { return stop_flag; })) {
                    break; // Exit if stop_flag is set
                }
                callback(); // Trigger the callback
            }
        });
    }

    void stop() {
        {
            std::lock_guard<std::mutex> lock(timer_mutex);
            stop_flag = true;
        }
        cv.notify_all(); // Wake up the timer thread
        if (timer_thread.joinable()) {
            timer_thread.join(); // Wait for the thread to finish
        }
    }

    ~Timer() {
        stop();
    }

private:
    std::thread timer_thread;
    std::mutex timer_mutex;
    std::condition_variable cv;
    std::atomic<bool> stop_flag;
};

// Example usage
int main() {
    Timer timer;
    timer.start(1000, []() {
        std::cout << "Timer tick: " << std::chrono::system_clock::now().time_since_epoch().count() << std::endl;
    });

    std::this_thread::sleep_for(std::chrono::seconds(5));
    timer.stop();
    return 0;
}

关键点解析

互斥保护共享资源：
- std::mutex 用于保护定时器的状态（如 stop_flag）。
条件变量同步：
- std::condition_variable 确保线程可以高效等待和唤醒，而不是忙等待。
可安全停止：
- 使用 std::atomic 确保线程之间对 stop_flag 的修改是线程安全的。
支持动态调整：
- 可以通过扩展 start 方法，使其支持动态更改时间间隔或重新启动。

扩展与优化

支持多个定时器：
- 使用优先队列（如 std::priority_queue）管理多个定时器，根据超时时间排序并逐一触发。
精度优化：
- 使用高分辨率定时器（如 std::chrono::steady_clock 或 std::chrono::high_resolution_clock）。
减少线程开销：
- 通过线程池或事件循环管理多个定时器，避免为每个定时器创建独立线程。

通过上述方法，可以实现高效且线程安全的定时器，在多线程环境中可靠运行。

解释定时器的精度和分辨率之间的区别

定时器的精度和分辨率是衡量其性能的重要指标，但两者的含义不同，且常被混淆。以下是它们的区别：

1. 定时器的精度（Accuracy）

定义： 定时器触发的时间与实际期望时间之间的偏差，称为精度。
衡量标准： 偏差的大小通常以时间误差的形式表示，例如 ±10微秒。
影响因素：
1. 硬件精度： 时钟源（如晶振）的质量会直接影响定时器的精度。
2. 软件延迟： 系统调度、线程切换或中断处理导致的延迟可能降低精度。
3. 系统负载： 高负载情况下，定时器可能无法在准确时间触发。
目标： 精度越高，定时器触发时间越接近期望时间。

示例： 如果设置一个定时器在1000毫秒后触发，但实际触发时间是1002毫秒或998毫秒，则精度误差为 ±2毫秒。

2. 定时器的分辨率（Resolution）

定义： 定时器能够区分的最小时间单位，称为分辨率。
衡量标准： 分辨率通常以最小时间间隔表示，例如 1微秒、10毫秒。
影响因素：
1. 时钟频率： 分辨率与定时器使用的时钟频率相关，频率越高，分辨率越小。
2. 硬件支持： 定时器硬件是否支持更小的时间间隔。
3. 软件实现： 软件是否能有效利用硬件提供的分辨率。
目标： 分辨率越高，定时器能够支持更细粒度的时间间隔。

示例： 一个分辨率为1毫秒的定时器无法设置时间间隔为0.5毫秒，但一个分辨率为1微秒的定时器可以支持更精细的时间设置。

两者的关系与差异

特性	精度（Accuracy）	分辨率（Resolution）
定义	定时器触发时间与目标时间的误差	定时器可支持的最小时间单位
依赖因素	硬件、系统负载、软件调度等	时钟频率、硬件能力
目标	减少误差，提高时间准确性	支持更小的时间间隔，提高时间粒度
举例	定时器设定为100ms，实际触发在102ms，则误差为2ms	最小时间间隔为1ms，则无法设置0.5ms定时

结合使用

分辨率设定了定时器能够设置的最小时间间隔，但即使分辨率很高，系统可能因为各种因素无法精确触发，导致精度不足。
在实际应用中，选择分辨率和精度的权衡取决于任务需求。例如：
- 实时系统： 需要高精度（如医疗设备）。
- 一般任务： 更关注分辨率即可满足需求（如普通延时操作）。

通过了解和优化精度与分辨率，可以更好地满足不同应用场景的时间要求。

如何处理在定时器回调函数中发生阻塞的情况？

在定时器回调函数中发生阻塞可能导致系统性能下降或功能失效，特别是在实时或高并发环境中。因此，设计一个能够安全处理阻塞的定时器回调机制非常重要。

以下是一些有效的处理策略：

1. 将阻塞操作移出回调函数

方法： 定时器回调函数仅负责触发事件，将需要执行的阻塞操作提交到一个独立线程或线程池中进行处理。
实现方式：
- 使用任务队列：回调函数将任务加入线程安全的队列中，由消费者线程处理。
- 使用线程池：通过线程池执行阻塞操作，避免占用定时器的资源。

示例代码：

  
#include <iostream>
#include <thread>
#include <chrono>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>

class TaskQueue {
public:
    void push(const std::function<void()>& task) {
        std::lock_guard<std::mutex> lock(mutex_);
        tasks_.push(task);
        cv_.notify_one();
    }

    void processTasks() {
        while (true) {
            std::function<void()> task;
            {
                std::unique_lock<std::mutex> lock(mutex_);
                cv_.wait(lock, [this]() { return !tasks_.empty(); });
                task = tasks_.front();
                tasks_.pop();
            }
            task(); // Execute task
        }
    }

private:
    std::queue<std::function<void()>> tasks_;
    std::mutex mutex_;
    std::condition_variable cv_;
};

// Example usage
void timerCallback(TaskQueue& taskQueue) {
    taskQueue.push([]() {
        std::this_thread::sleep_for(std::chrono::seconds(2)); // Simulate blocking
        std::cout << "Task completed in worker thread.\n";
    });
}

int main() {
    TaskQueue taskQueue;
    std::thread worker(&TaskQueue::processTasks, &taskQueue);

    // Simulate a timer triggering the callback
    for (int i = 0; i < 3; ++i) {
        timerCallback(taskQueue);
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    worker.detach(); // For demonstration; handle thread lifetime properly in production
    return 0;
}

2. 设置回调函数的超时时间

方法： 在定时器回调函数中为阻塞操作设置超时时间，防止无限期等待。
实现方式：
- 使用 std::future 和 std::async 处理任务，结合 wait_for() 设置超时。

示例代码：

  
#include <iostream>
#include <future>
#include <chrono>

void timerCallbackWithTimeout() {
    auto future = std::async(std::launch::async, []() {
        std::this_thread::sleep_for(std::chrono::seconds(2)); // Simulate blocking
        std::cout << "Task completed.\n";
    });

    if (future.wait_for(std::chrono::milliseconds(500)) == std::future_status::timeout) {
        std::cout << "Task timed out.\n";
    }
}

int main() {
    timerCallbackWithTimeout();
    return 0;
}

3. 使用非阻塞操作

方法： 尽可能避免使用会阻塞线程的操作，例如长时间等待或 I/O 操作。
实现方式：
- 使用异步 I/O 或事件驱动机制。
- 设计为非阻塞算法，将大任务拆分为小任务分步执行。

4. 增加并发定时器

方法： 如果定时器回调中不可避免地包含阻塞操作，考虑为定时器分配多个线程以提高并发能力。
实现方式：
- 使用线程池处理多个回调任务。
- 确保线程池大小足够大，避免线程耗尽。

5. 使用优先级队列

方法： 如果定时器触发多个回调函数，使用优先级队列管理任务，确保重要任务优先执行，减少因阻塞导致的延迟。
实现方式：
- 定义任务优先级。
- 使用 std::priority_queue 管理回调任务。

注意事项

避免忙等待： 确保在等待条件时使用条件变量或其他高效机制，而非循环轮询。
线程安全： 在多线程环境下，保证共享资源的访问受保护（如使用互斥锁）。
资源清理： 确保定时器线程和任务线程在终止时正确清理资源。

通过合理设计，可以有效防止定时器回调函数中的阻塞问题对系统性能和稳定性造成影响。

解释定时器的触发方式：一次性触发和周期性触发。它们有何不同以及各自适用的场景

定时器的触发方式主要有一次性触发和周期性触发，两者在触发行为和应用场景上有所不同。

1. 一次性触发

定义

定时器在设定的时间间隔到达后，仅触发一次。
一旦触发，定时器自动停止，不再继续计时。

实现原理

定时器开始计时后，当内部计数器达到预设值或目标时间到达时，触发回调函数。
触发后，定时器不再重置，需要手动重新启动以再次使用。

适用场景

延时任务：
- 需要在设定的时间后执行某个操作，例如延迟初始化、网络重试。
超时控制：
- 设置一个超时时间，用于检测操作是否完成，例如 HTTP 请求超时。
一次性事件：
- 用户事件处理，如鼠标单击后延迟触发某个动画。

优点

简单易用。
避免不必要的重复触发，适合一次性逻辑。

示例

  
#include <iostream>
#include <thread>
#include <chrono>

void onceTimer() {
    std::this_thread::sleep_for(std::chrono::seconds(3)); // Simulate delay
    std::cout << "Once timer triggered!\n";
}

int main() {
    std::cout << "Starting once timer...\n";
    std::thread(onceTimer).detach(); // Run timer in a separate thread
    std::this_thread::sleep_for(std::chrono::seconds(5)); // Allow time for the timer to trigger
    return 0;
}

2. 周期性触发

定义

定时器在设定的时间间隔到达后，重复触发回调函数，直到被显式停止。
定时器会在每次触发后自动重置计时器，并继续运行。

实现原理

定时器开始计时后，每当计数器达到预设值或目标时间到达时，触发回调函数，并自动重启计时过程。

适用场景

周期性任务：
- 需要定时执行的任务，例如数据采集、日志轮询、刷新界面。
心跳信号：
- 用于网络通信中的心跳检测，周期性地发送信号包以维持连接状态。
实时控制：
- 在嵌入式系统中，周期性地控制硬件或读取传感器数据。

优点

自动重复触发，减少开发者手动重启定时器的麻烦。
适合需要稳定时间间隔的周期性任务。

示例

  
#include <iostream>
#include <thread>
#include <chrono>
#include <atomic>

void periodicTimer(std::atomic<bool>& stopFlag, int intervalMs) {
    while (!stopFlag) {
        std::this_thread::sleep_for(std::chrono::milliseconds(intervalMs));
        std::cout << "Periodic timer triggered!\n";
    }
}

int main() {
    std::atomic<bool> stopFlag(false);
    std::cout << "Starting periodic timer...\n";
    std::thread timerThread(periodicTimer, std::ref(stopFlag), 1000);

    std::this_thread::sleep_for(std::chrono::seconds(5)); // Run for 5 seconds
    stopFlag = true; // Stop the timer
    timerThread.join();
    return 0;
}

3. 二者的主要区别

特性	一次性触发	周期性触发
触发次数	仅触发一次	按设定时间间隔多次触发
计时方式	到时间后停止	到时间后自动重置并继续计时
复杂度	较低	较高，需要考虑如何终止或动态调整间隔
适用场景	一次性延时任务、超时控制等	数据采集、实时控制、心跳信号等
资源占用	触发后资源释放	需要持续占用资源

4. 如何选择

选择一次性触发：
- 当任务只需要执行一次，且不需要重复触发时。
- 适用于简单场景，减少资源占用。
选择周期性触发：
- 当任务需要持续运行，且需要在固定时间间隔内执行时。
- 适用于需要稳定、持续处理的场景。

通过正确选择触发方式，既能满足需求，又能优化资源使用，提高系统性能。

在嵌入式系统中，如何实现低功耗的定时器？

在嵌入式系统中，低功耗的定时器设计是实现节能的关键之一。通过合理利用硬件资源、优化软件逻辑，可以在满足功能需求的同时显著降低功耗。以下是一些实现低功耗定时器的关键策略：

1. 利用硬件低功耗定时器

现代嵌入式微控制器（MCU）通常内置低功耗计时模块，这些模块专为节能设计，能够在 MCU 的低功耗模式下工作。

特性：
- 运行时功耗极低。
- 通常连接到独立的低频时钟源（如 32.768 kHz 的晶振）。
- 支持唤醒 MCU 的功能。
实现方法：
1. 配置低功耗时钟源（如 RTC 或 LPTIM）。
2. 设置定时器的唤醒时间。
3. 将 MCU 切换到低功耗模式，定时器触发时唤醒系统。
应用场景：
- 实时时钟 (RTC) 定时唤醒。
- 周期性任务（如传感器采集或无线通信）。

示例（伪代码）：

  
configureLowPowerTimer(interval_ms); // 配置低功耗定时器
enterLowPowerMode();                // 进入低功耗模式
// 系统会在定时器中断触发时自动唤醒

2. 使用低频时钟源

低频时钟 (LFXO/LSI)：
- 低频晶振（如 32.768 kHz）或内部低速振荡器（LSI）。
- 耗能较低，适合定时精度要求不高的场景。
优点：
- 显著降低功耗。
- 与低功耗定时器结合使用效果更佳。
限制：
- 分辨率较低，适合大时间间隔的定时器。

3. 中断驱动设计

关键思想：
- 使用中断触发代替轮询检测，避免处理器持续运行。
实现方式：
- 定时器在预设时间触发中断，唤醒处理器执行任务。
- 任务完成后再次进入低功耗模式。
优势：
- 减少不必要的功耗。
- 提高系统响应速度。

4. 使用睡眠模式和唤醒管理

深度睡眠模式：
- 定时器工作时将 MCU 切换到深度睡眠模式，仅保留必要的外设运行（如 RTC）。
唤醒事件：
- 定时器中断可作为唤醒事件，唤醒处理器完成任务。
动态切换：
- 动态选择功耗模式（如睡眠、停止或待机）以平衡性能和功耗。

示例：

  
void timerInterruptHandler() {
    wakeUpMCU();  // 唤醒 MCU
    performTask(); // 执行定时任务
    enterLowPowerMode(); // 再次进入低功耗模式
}

5. 优化软件逻辑

减少无效操作：
- 在定时器触发后仅执行必要任务，避免多余计算。
调节定时器频率：
- 根据任务需求动态调整定时器频率，降低定时器的唤醒频率。
合并任务：
- 合并多个定时器的触发事件，减少唤醒次数。

6. 使用硬件辅助功能

一些硬件支持更高效的低功耗管理：

DMA（直接内存访问）：
- 在定时器触发时，直接通过 DMA 执行任务，避免唤醒处理器。
事件系统：
- 将定时器事件直接连接到其他外设（如 ADC、通信模块），实现低功耗任务链。

7. 利用超低功耗 MCU 特性

选择支持超低功耗功能的 MCU：

集成 RTC 和 LPTIM：
- STM32、Nordic 等 MCU 提供专用低功耗计时器。
可编程功耗模式：
- 提供多种功耗模式（RUN、SLEEP、STOP、STANDBY），按需切换。

8. 考虑时间分辨率和精度的权衡

如果不需要高精度计时，可以适当降低分辨率和精度，减少频繁中断。
在任务允许的情况下，增加时间间隔进一步降低功耗。

典型应用场景

物联网设备：
- 定时器周期性唤醒系统上传数据，其他时间保持低功耗。
传感器网络：
- 低功耗定时器控制采样周期，避免传感器持续运行。
远程控制：
- 使用 RTC 定时唤醒设备，保持低功耗待机状态。

通过结合硬件和软件的低功耗优化技术，可以实现高效、节能的定时器设计，特别适合电池供电或节能要求高的嵌入式系统。

介绍操作系统中常见的定时器机制，比如基于硬件中断、轮询等方式

操作系统中的定时器机制用于管理时间相关的任务，例如任务调度、延时操作和超时检测。定时器机制可以分为基于硬件中断和软件轮询的方式，每种方式各有特点和应用场景。

1. 基于硬件中断的定时器

原理

硬件定时器通过硬件时钟源（如晶振）计数，当计数值达到预设的阈值时，触发中断。
操作系统在中断服务程序（ISR）中处理定时事件，例如更新系统时钟、唤醒等待任务。

特点

高效： 中断只在需要时触发，避免了 CPU 的忙等待。
精确： 定时器精度由硬件时钟源决定，可实现高分辨率计时。
低功耗： 在不需要工作时，系统可以进入低功耗模式，定时器中断唤醒系统。

适用场景

实时任务调度。
系统时钟更新（如 jiffies 或 tick）。
超时检测（如网络协议的超时重传）。

操作系统中的应用

时钟中断：
- 操作系统使用硬件时钟中断更新系统的全局时间计数器，例如 Linux 内核中的 tick 机制。
高分辨率定时器：
- 现代操作系统支持高分辨率定时器（如 Linux 的 hrtimer），可以精确到微秒级甚至纳秒级。
延时任务：
- 通过定时器中断触发延时任务的执行，例如 sleep() 或 usleep()。

2. 基于软件轮询的定时器

原理

操作系统通过定期检查（轮询）当前时间是否达到定时器的触发条件来实现定时功能。
通常由一个系统线程或任务不断检查定时器队列中的到期时间。

特点

简单： 实现逻辑较硬件中断简单。
效率低： CPU 持续运行，浪费资源。
受限于轮询频率： 分辨率和触发延迟取决于轮询间隔，难以实现高精度定时。

适用场景

非实时任务。
时间分辨率要求较低的场景。
没有硬件定时器支持的系统。

操作系统中的应用

用户态定时器：
- 某些轻量级系统或库中可能使用轮询实现简单的定时功能，例如游戏引擎中的帧延时。
任务调度模拟：
- 在某些简单操作系统中，用轮询机制实现基本的定时调度。

3. 其他定时器机制

3.1 基于多级轮转队列的定时器

原理： 将定时器按到期时间分为多个时间轮（Time Wheel），每个轮代表一段时间范围。
特点：
- 高效管理大量定时器。
- 时间复杂度低，常为 $O(1)$。
应用：
- 网络协议栈的超时管理（如 TCP 重传）。
- 高性能系统中的大量定时事件管理。

3.2 事件驱动定时器

原理： 使用事件通知机制，当定时器到期时触发事件回调。
特点：
- 不需轮询，事件触发更高效。
- 常结合硬件中断实现。
应用：
- 异步任务调度（如 epoll、libevent）。

3.3 混合机制

结合硬件中断和软件轮询，轮询间隔较长，硬件中断用于处理高精度任务。
特点：
- 兼顾性能和资源利用率。
应用：
- 嵌入式系统中常用的调度策略。

对比表

机制	优点	缺点	适用场景
硬件中断	高精度、低延迟、低功耗	实现复杂，需要硬件支持	实时任务调度、系统时钟更新、超时检测
软件轮询	实现简单、无硬件依赖	低效，难以实现高精度计时	简单定时任务、时间分辨率要求不高的场景
多级轮转队列	适合管理大量定时器，效率高	实现复杂	网络协议栈的超时检测
事件驱动定时器	高效，适合异步任务	依赖事件机制	异步 I/O、事件触发的任务管理
混合机制	兼顾高精度和低功耗	实现较复杂	嵌入式系统和节能应用场景

总结

硬件中断适用于高精度、高性能需求的定时器，例如操作系统内核。
软件轮询适用于简单、低精度需求的场景，尤其是在硬件支持有限的情况下。
多级轮转队列和事件驱动机制在处理复杂定时需求或大量定时任务时表现出色。

根据具体场景选择合适的定时器机制，可以优化性能和资源使用，满足系统的需求。

定时器, 定时器面经

C++ 面经操作系统定时器

本文由作者按照 CC BY 4.0 进行授权

什么是定时器？请简要描述定时器的作用和原理

定时器的作用

定时器的工作原理

定时器类型

应用场景

在多线程环境下，如何实现一个线程安全的定时器？

实现方法

示例代码

关键点解析

扩展与优化

解释定时器的精度和分辨率之间的区别

1. 定时器的精度（Accuracy）

2. 定时器的分辨率（Resolution）

两者的关系与差异

结合使用

如何处理在定时器回调函数中发生阻塞的情况？

1. 将阻塞操作移出回调函数

2. 设置回调函数的超时时间

3. 使用非阻塞操作

4. 增加并发定时器

5. 使用优先级队列

注意事项

解释定时器的触发方式：一次性触发和周期性触发。它们有何不同以及各自适用的场景

1. 一次性触发

定义

实现原理

适用场景

优点

示例

2. 周期性触发

定义

实现原理

适用场景

优点

示例

3. 二者的主要区别

4. 如何选择

在嵌入式系统中，如何实现低功耗的定时器？

1. 利用硬件低功耗定时器

2. 使用低频时钟源

3. 中断驱动设计

4. 使用睡眠模式和唤醒管理

5. 优化软件逻辑

6. 使用硬件辅助功能

7. 利用超低功耗 MCU 特性

8. 考虑时间分辨率和精度的权衡

典型应用场景

介绍操作系统中常见的定时器机制，比如基于硬件中断、轮询等方式

1. 基于硬件中断的定时器

原理

特点

适用场景

操作系统中的应用

2. 基于软件轮询的定时器

原理

特点

适用场景

操作系统中的应用

3. 其他定时器机制

3.1 基于多级轮转队列的定时器

3.2 事件驱动定时器

3.3 混合机制

对比表

总结

热门标签