企业官网建设流程全解析

1. 项目概述：实时统计的挑战与价值

在数据处理领域，尤其是物联网、金融交易、工业监控等场景，我们常常面临一个核心需求：如何对源源不断、实时涌入的数据流，进行快速、准确且低延迟的统计计算？比如，一个传感器每秒上报1000次温度读数，我们需要实时知道过去一分钟的平均温度、最大值、最小值以及标准差，以便及时触发预警或调整控制策略。这就是“实时输入数据的统计信息”计算所要解决的核心问题。

传统的做法是维护一个固定大小的数组或列表，每次新数据到来时，将其存入，然后遍历整个数据集重新计算统计量。这种方法简单直观，但当数据流速度极快或时间窗口很长时，其计算复杂度为 O(N)，内存占用也与窗口大小线性相关，很快就会成为性能瓶颈。想象一下，一个高频交易系统每微秒处理一笔交易，要求计算过去100毫秒内的成交均价，如果每次都重新遍历，CPU立刻就会被拖垮。

因此，我们需要更聪明的算法。本项目要探讨的，正是在C/C++环境下，如何设计并实现一套高效的算法，来实时计算数据流的常用统计信息，包括但不限于：和（Sum）、平均值（Mean）、方差（Variance）、标准差（Standard Deviation）、最大值（Max）、最小值（Min）。这些算法不仅要快，还要稳，要能处理海量数据，同时保证计算精度，避免浮点数累加带来的误差累积问题。对于C/C++开发者而言，深入理解这些算法，意味着能在系统底层构建出高性能的数据处理核心，这是优化系统响应时间、提升吞吐量的关键技能。

2. 核心算法原理与设计思路拆解

实时统计的核心在于“增量更新”和“滑动窗口”。我们不应该每次都从头计算，而是利用上一次的计算结果，结合新到来的数据和可能滑出的旧数据，以 O(1) 的时间复杂度更新统计量。下面我们来逐一拆解各个统计量的增量计算原理。

2.1 基础统计量：和、平均值、最大值、最小值

对于和（Sum）与平均值（Mean），在固定大小的滑动窗口下，增量计算非常直观。我们维护一个窗口内所有数据的和current_sum。当新数据x_new到来，旧数据x_old滑出窗口时，更新公式为：new_sum = current_sum + x_new - x_old平均值便是new_sum / window_size。关键在于，我们需要一个数据结构（如环形队列）来高效地记录窗口内的所有数据，以便在数据滑出时能知道x_old的值。

对于最大值（Max）和最小值（Min），问题变得复杂。你不能简单地用新值和当前最值比较，因为滑出的数据可能就是当前的最大值或最小值。一旦它被移走，你需要知道窗口中剩余数据的次大值或次小值。这就需要更高级的数据结构来辅助。

一种经典且高效的解决方案是使用单调队列。维护两个双端队列（Deque），一个用于最大值，一个用于最小值。以最大值为例，队列中存储的是数据的索引（或包含值和索引的结构）。当新数据到来时，从队列尾部开始，将所有小于新数据的元素弹出，然后将新数据的索引压入队尾。这样，队列头部始终是当前窗口最大值的索引。同时，每次滑动窗口时，检查队列头部的索引是否已经滑出窗口，如果是，则将其从队头弹出。这个操作的平均时间复杂度是 O(1)。最小值队列的原理与之对称。

2.2 进阶统计量：方差与标准差

方差和标准差是衡量数据离散程度的关键指标，其计算涉及平方和，增量更新需要一些技巧。总体方差公式为：Variance = (sum_of_squares - sum * sum / N) / N其中sum_of_squares是每个数据点的平方和。

为了增量计算，我们需要维护三个状态变量：

1. current_sum: 当前窗口内数据的和。
2. current_sum_of_squares: 当前窗口内数据的平方和。
3. window_size: 窗口大小（固定）。

当窗口滑动，新数据x_new进入，旧数据x_old离开时，更新步骤如下：

new_sum = current_sum + x_new - x_old new_sum_of_squares = current_sum_of_squares + x_new*x_new - x_old*x_old new_variance = (new_sum_of_squares - new_sum*new_sum/window_size) / window_size new_std_dev = sqrt(new_variance)

这种方法清晰直接，但存在一个潜在的数值稳定性问题：当数据值非常大时，计算平方和可能导致浮点数溢出；此外，在sum_of_squares和sum*sum/N两个大数相减时，可能因精度损失导致结果不准确，甚至出现负的方差（理论上不可能）。

为了解决这个问题，我们可以采用Welford 在线算法的滑动窗口变体。标准的Welford算法用于计算整个数据流的方差，无需存储所有历史数据。其核心是维护一个中间量M2，表示平方的偏差累积和。对于滑动窗口，我们需要同时维护“进入”和“离开”对M2的增量影响。算法稍复杂，但数值稳定性极高。我们会在后续的源码实现中，提供一个基于此思想的稳健实现。

2.3 数据结构选型：环形队列与单调队列

算法的高效离不开底层数据结构的支持。

• 环形队列：是存储滑动窗口原始数据的理想选择。它用一个固定大小的数组和两个指针（头、尾）模拟队列，当数据填满数组后，新的数据会覆盖旧的数据，实现了O(1)的入队和出队操作，且内存连续，缓存友好。我们将用它来保存窗口内的历史数据，以便在计算方差等需要旧数据值时进行回溯。
• 双端队列：用于实现单调队列，以支持O(1)时间获取滑动窗口的最大最小值。C++标准库中的std::deque是一个现成的选择。在C语言中，可能需要自己实现一个基于数组或链表的双端队列。

设计思路总结：我们将构建一个类（C++）或结构体（C），内部封装一个环形队列用于存储数据，两个双端队列用于维护最大值和最小值索引，并实时更新sum、sum_of_squares等聚合变量。对外提供push(value)接口添加新数据，并自动滑出旧数据，同时提供getMean(),getVariance(),getMax(),getMin()等接口以常数时间获取各项统计指标。

3. 核心数据结构与类设计详解

我们将用C++来实现这个实时统计计算器，充分利用其面向对象和标准库容器的便利。当然，核心算法思想同样适用于C语言，只是需要手动管理更多底层细节。

3.1 类定义与成员变量

我们把这个计算器命名为RollingStatistics。它的核心职责是：给定一个窗口大小，在数据不断推入时，实时返回该窗口内的统计信息。

#include <deque> #include <cmath> #include <vector> #include <stdexcept> class RollingStatistics { private: size_t window_size_; // 滑动窗口的大小 std::vector<double> buffer_; // 环形缓冲区，存储窗口内的原始数据 size_t count_; // 当前已推入的数据总量（用于处理未满窗口的情况） size_t head_; // 环形缓冲区头部索引（指向最老的数据） size_t tail_; // 环形缓冲区尾部索引（指向下一个写入位置） double sum_; // 当前窗口内数据的和 double sum_of_squares_; // 当前窗口内数据的平方和（用于基础方差计算） // 用于最大值/最小值的单调队列（存储的是在buffer_中的索引） std::deque<size_t> max_deque_; std::deque<size_t> min_deque_; // 辅助函数：获取环形缓冲区中给定逻辑索引处的值 inline double getValueAt(size_t logical_index) const { return buffer_[logical_index % window_size_]; } public: // 构造函数，初始化窗口大小 explicit RollingStatistics(size_t window_size); // 推入一个新数据点 void push(double value); // 获取当前窗口的统计信息 double getMean() const; double getVariance() const; // 样本方差 (除以 N-1) double getPopulationVariance() const; // 总体方差 (除以 N) double getStdDev() const; // 样本标准差 double getPopulationStdDev() const; // 总体标准差 double getMax() const; double getMin() const; double getSum() const; size_t getCurrentCount() const; // 当前窗口内实际数据量（未满窗口时小于window_size_） bool isWindowFull() const; };

成员变量解析：

• buffer_: 一个std::vector<double>，大小固定为window_size_，用作环形队列。head_和tail_指针管理其读写位置。
• count_: 记录总共push了多少次。当count_ <= window_size_时，窗口未满，计算平均值等操作的分母是count_而不是window_size_。
• sum_和sum_of_squares_: 核心聚合变量，用于增量计算均值、方差。
• max_deque_和min_deque_: 单调队列，存储的是数据在buffer_中的索引。比较时依据的是索引对应的数据值。存储索引可以方便地判断队列头部的元素是否已滑出窗口。

3.2 构造函数与初始化

构造函数需要分配内存并初始化状态。窗口大小必须为正数。

RollingStatistics::RollingStatistics(size_t window_size) : window_size_(window_size > 0 ? window_size : throw std::invalid_argument("Window size must be positive")), buffer_(window_size_, 0.0), count_(0), head_(0), tail_(0), sum_(0.0), sum_of_squares_(0.0) { max_deque_.clear(); min_deque_.clear(); }

注意：这里用std::vector<double>(window_size_, 0.0)进行值初始化，确保缓冲区起始为0。在实际应用中，如果初始0值会影响你的业务逻辑（例如，0是一个有效数据点），你可能需要增加一个状态标志来区分“未初始化”的位置。

3.3 核心操作：push(double value) 的实现

push函数是算法的引擎，它需要处理以下逻辑：

1. 处理窗口滑动：如果窗口已满，则需要“踢出”最旧的数据。
2. 更新环形缓冲区。
3. 更新聚合变量sum_和sum_of_squares_。
4. 更新最大值和最小值单调队列。

void RollingStatistics::push(double value) { double old_value = 0.0; bool window_was_full = isWindowFull(); // 1. 如果窗口已满，准备移除最旧的数据 (head_ 指向的位置) if (window_was_full) { old_value = buffer_[head_]; // 更新聚合值：减去滑出的旧值 sum_ -= old_value; sum_of_squares_ -= old_value * old_value; // 维护单调队列：检查滑出的数据是否是当前最大/最小值队列的头部 if (!max_deque_.empty() && max_deque_.front() == head_) { max_deque_.pop_front(); } if (!min_deque_.empty() && min_deque_.front() == head_) { min_deque_.pop_front(); } // 移动头指针 head_ = (head_ + 1) % window_size_; } // 2. 将新值存入环形缓冲区尾部 buffer_[tail_] = value; // 3. 更新聚合值：加上新值 sum_ += value; sum_of_squares_ += value * value; // 4. 更新最大值单调队列 // 从队尾开始，移除所有小于等于新值的索引（注意：对于相等值，保留较新的索引可能更稳定） while (!max_deque_.empty() && getValueAt(max_deque_.back()) <= value) { max_deque_.pop_back(); } max_deque_.push_back(tail_); // 5. 更新最小值单调队列 while (!min_deque_.empty() && getValueAt(min_deque_.back()) >= value) { min_deque_.pop_back(); } min_deque_.push_back(tail_); // 6. 移动尾指针，更新计数 tail_ = (tail_ + 1) % window_size_; if (!window_was_full) { count_++; } // 如果窗口已满，count_ 保持为 window_size_， head_ 和 tail_ 的移动已经体现了滑动 }

关键点解析：

• 单调队列的维护：在插入新值value时，我们从双端队列的尾部开始，弹出所有对应值小于（或等于）value的索引。这一步保证了队列从队头到队尾，对应的数据值是单调递减的（对于最大队列）。然后压入新索引。这样，队头索引对应的永远是当前窗口的最大值。
• 相等值的处理：上述代码在比较时使用了<=和>=。这意味着当新值等于队列尾部值时，旧索引也会被弹出，新索引被放入。这保证了在值相等的情况下，队列中存储的是更新（更晚）的索引，这对于判断元素是否滑出窗口是安全的。你也可以选择只弹出“小于”的值，保留旧的相等值索引，两种方式在功能上都正确，但可能影响在数据平台期时最大值变化的频率。
• 索引的比较：getValueAt(max_deque_.back())通过存储的索引从buffer_中取出实际的值进行比较。

4. 统计信息获取接口的实现

有了正确维护的内部状态，获取统计信息就变成了简单的公式计算。

4.1 均值、和与数量

size_t RollingStatistics::getCurrentCount() const { // 如果计数小于窗口大小，说明窗口未满，实际数量就是count_ // 如果窗口已满，实际数量就是window_size_ return (count_ < window_size_) ? count_ : window_size_; } double RollingStatistics::getSum() const { return sum_; } double RollingStatistics::getMean() const { size_t current_count = getCurrentCount(); if (current_count == 0) { return std::numeric_limits<double>::quiet_NaN(); // 或返回0，或抛出异常 } return sum_ / static_cast<double>(current_count); }

注意：getCurrentCount()非常重要。在窗口未填满时（即数据流刚开始），统计计算的分母应该是实际接收到的数据个数，而不是预设的窗口大小。这符合大多数实时监控场景的直觉。

4.2 方差与标准差的实现

这里提供两种方差计算：样本方差（除以 N-1，无偏估计）和总体方差（除以 N）。

double RollingStatistics::getPopulationVariance() const { size_t current_count = getCurrentCount(); if (current_count < 2) { // 至少需要两个点才能计算方差 return std::numeric_limits<double>::quiet_NaN(); } double mean = getMean(); // 使用公式：方差 = (平方和 - 和*均值) / N // 这个公式在数值上可能不稳定，但对于演示和一般情况可行。 // 更稳定的方法是维护额外的聚合量，如Welford算法中的M2。 double variance = (sum_of_squares_ - sum_ * mean) / static_cast<double>(current_count); // 防止由于浮点误差导致极小的负数 return variance >= 0.0 ? variance : 0.0; } double RollingStatistics::getVariance() const { size_t current_count = getCurrentCount(); if (current_count < 2) { return std::numeric_limits<double>::quiet_NaN(); } double pop_var = getPopulationVariance(); // 样本方差 = 总体方差 * (N / (N-1)) return pop_var * static_cast<double>(current_count) / static_cast<double>(current_count - 1); } double RollingStatistics::getPopulationStdDev() const { double var = getPopulationVariance(); return std::sqrt(var); } double RollingStatistics::getStdDev() const { double var = getVariance(); return std::sqrt(var); }

数值稳定性警告：sum_of_squares_ - sum_ * mean这个计算在sum_of_squares_和sum_ * mean都非常大且接近时，会因浮点数精度损失产生巨大误差，甚至得到负数。在生产环境中，对于高精度要求或数据范围很大的场景，强烈建议实现基于Welford算法的滑动窗口版本。下面提供一个思路：

我们可以维护mean_和M2_（平方偏差的加权和）两个状态量。

• push时：
  • 如果窗口未满，采用标准Welford算法更新mean_和M2_。
  • 如果窗口已满，需要模拟“移除”一个旧数据点并“添加”一个新数据点。这需要用到“配对更新”公式，计算上比简单加减更复杂，但稳定性极高。
• 方差 =M2_ / current_count(总体) 或M2_ / (current_count - 1)(样本)。

由于实现较为复杂，本文基础版本暂不展开，但读者必须意识到这个问题的存在。

4.3 最大值与最小值的获取

直接从单调队列的头部索引获取对应的值即可。

double RollingStatistics::getMax() const { if (max_deque_.empty()) { return std::numeric_limits<double>::quiet_NaN(); } return getValueAt(max_deque_.front()); } double RollingStatistics::getMin() const { if (min_deque_.empty()) { return std::numeric_limits<double>::quiet_NaN(); } return getValueAt(min_deque_.front()); }

5. 性能分析与优化实践

我们设计的这个RollingStatistics类，每个push操作的时间复杂度是摊销 O(1)。虽然单调队列的while循环看似是 O(N)，但每个数据索引最多被压入和弹出队列各一次，在整个数据流的生命周期中，总操作次数与数据量成线性关系，因此平均到每次push是常数时间。

内存占用是 O(window_size)，主要用于存储原始数据的环形缓冲区buffer_。单调队列在最坏情况下（严格单调递增或递减的数据流）会存储所有索引，因此也是 O(window_size)。

5.1 实测性能对比

为了验证其效率，我们可以设计一个简单的性能测试，对比“增量算法”和“朴素重算算法”。

#include <chrono> #include <iostream> #include <random> void test_performance(size_t window_size, size_t total_data_points) { RollingStatistics rs_incremental(window_size); std::vector<double> naive_buffer; naive_buffer.reserve(window_size); std::random_device rd; std::mt19937 gen(rd()); std::uniform_real_distribution<> dis(0.0, 100.0); // 测试增量算法 auto start = std::chrono::high_resolution_clock::now(); for (size_t i = 0; i < total_data_points; ++i) { double val = dis(gen); rs_incremental.push(val); // 模拟获取一次统计值，确保计算被执行 volatile double dummy = rs_incremental.getMean(); // volatile防止被优化掉 } auto end = std::chrono::high_resolution_clock::now(); auto incremental_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start); // 测试朴素算法（每次重新计算） start = std::chrono::high_resolution_clock::now(); for (size_t i = 0; i < total_data_points; ++i) { double val = dis(gen); naive_buffer.push_back(val); if (naive_buffer.size() > window_size) { naive_buffer.erase(naive_buffer.begin()); } // 朴素计算均值 double sum = 0.0; for (double v : naive_buffer) { sum += v; } volatile double dummy = sum / naive_buffer.size(); } end = std::chrono::high_resolution_clock::now(); auto naive_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start); std::cout << "窗口大小: " << window_size << ", 数据总量: " << total_data_points << "\n"; std::cout << "增量算法耗时: " << incremental_time.count() << " us\n"; std::cout << "朴素算法耗时: " << naive_time.count() << " us\n"; std::cout << "速度提升倍数: " << static_cast<double>(naive_time.count()) / incremental_time.count() << "x\n\n"; } int main() { test_performance(100, 1000000); // 小窗口，大数据量 test_performance(10000, 1000000); // 大窗口，大数据量 return 0; }

在我的测试环境（普通桌面CPU）下，结果可能显示增量算法比朴素算法快几十到上百倍，尤其是当窗口较大时，优势极其明显。因为朴素算法的复杂度是 O(N*window_size)，而增量算法是 O(N)。

5.2 优化技巧与注意事项

1. 内存预分配与缓存友好性：使用std::vector作为环形缓冲区，内存是连续的，这对CPU缓存非常友好。确保在构造函数中一次性分配好所需内存，避免运行时动态扩容。
2. 内联函数：将getValueAt这类简单的辅助函数声明为inline，鼓励编译器进行内联优化，减少函数调用开销。
3. 浮点数精度：如之前强调，对于方差计算，基础方法存在数值风险。如果业务数据范围已知且不大，可以接受。否则，必须实现更稳定的算法（如Welford滑动窗口版）。另一种折中方案是使用long double或高精度库来存储sum_和sum_of_squares_，但这会增加内存和计算开销。
4. 线程安全：当前的类不是线程安全的。如果需要在多线程环境中使用，需要对push和各个get方法加锁（例如使用std::mutex），但这会成为性能瓶颈。在高并发场景下，可以考虑无锁环形队列或为每个线程分配独立的统计器，最后再合并结果。
5. 异常处理：在getMean(),getVariance()等方法中，当数据量不足时，我们返回了NaN。在实际应用中，你可能需要根据业务需求决定是抛出异常、返回特定值（如0）还是返回一个std::optional。

6. 扩展应用与高级话题

掌握了基础的实时统计计算后，我们可以将其扩展到更复杂的场景。

6.1 多维度统计与滚动相关系数

有时我们需要计算两个实时数据流之间的滚动相关系数。例如，实时计算股价与大盘指数之间的滚动相关性。这需要同时维护两个数据流的和、平方和以及它们的乘积和。

扩展我们的类，使其能接收一对数据(x, y)。我们需要新增状态变量：

• sum_x_,sum_y_
• sum_xx_,sum_yy_,sum_xy_

在push(x, y)时，同时更新这些变量。滚动相关系数r的计算公式为：r = (N*sum_xy - sum_x*sum_y) / sqrt( (N*sum_xx - sum_x*sum_x) * (N*sum_yy - sum_y*sum_y) )同样，需要注意数值稳定性问题。

6.2 指数加权移动平均与方差

滑动窗口是一个“硬”窗口，数据在窗口内权重相同，一出窗口权重立刻为零。另一种常见的实时统计是指数加权移动平均，它给近期数据更高的权重，旧数据的权重呈指数衰减。EWMA的更新公式非常简单：new_ema = alpha * new_value + (1 - alpha) * old_ema其中alpha是平滑因子（0 < alpha <= 1）。alpha 越大，对近期数据越敏感。 指数加权移动方差也有相应的增量算法。这种模型特别适合对最新趋势更敏感的场景，如金融中的技术指标计算。

6.3 分位数与直方图近似

计算实时数据流的中位数、百分位数比计算均值方差更难，因为需要数据的完整排序信息。精确计算需要维护一个有序窗口，每次更新复杂度为 O(log N)。对于大规模数据流，通常采用近似算法，如T-Digest或GK摘要。这些算法通过压缩数据分布为一系列质心（centroid），以可控的内存和精度损失为代价，提供近似的分位数查询。如果你的业务需要实时监控数据的分布（如API响应时间的P99线），研究这些算法是必要的。

6.4 与流处理框架集成

在大型系统中，实时统计往往是流处理管道中的一个环节。你可以将我们实现的RollingStatistics类封装成一个算子，集成到 Apache Flink、Apache Kafka Streams 或简单的自定义事件循环中。关键在于保证算子的状态可管理和容错性。在分布式流处理中，窗口状态可能需要定期做检查点（Checkpoint）保存到持久化存储中，以便在任务失败时恢复。

7. 常见问题排查与调试心得

在实际使用和调试这类实时统计组件时，我踩过不少坑，这里分享几个典型的排查思路。

问题一：方差计算偶尔出现极小的负数。

• 现象：在长时间运行后，getVariance()返回一个绝对值非常小的负数（如 -1e-15）。
• 根因：浮点数精度误差。sum_of_squares_ - sum_ * mean中，两个大数非常接近，它们的差可能落在浮点数表示的误差范围内，结果为负。
• 解决：在返回方差前，加一个保护性判断：return variance >= 0.0 ? variance : 0.0;。更根本的解决方案是采用数值稳定的Welford算法。

问题二：在数据流刚开始时，最大值/最小值返回异常。

• 现象：窗口未满时，getMax()可能返回一个不属于当前窗口的值，或者队列为空导致崩溃。
• 根因：单调队列的维护逻辑没有正确处理窗口未满和变满的过渡期。在push函数中，当窗口未满时，我们并没有一个“滑出”的数据x_old，因此不应从单调队列头部移除索引。但我们的代码中，移除头部索引的判断只依赖于max_deque_.front() == head_，而head_在窗口未满时始终为0。如果最早的数据恰好是最大值并被新数据覆盖，队列头部的索引可能已经无效。
• 排查与修复：确保单调队列中存储的索引始终是有效的（即在当前窗口内）。在push中，只有当window_was_full为真时，才执行检查并移除可能滑出的索引。同时，在getMax/Min中，可以增加一个安全检查：如果队列头部的索引不在当前有效窗口范围内（通过比较索引与head_、tail_的关系判断），则将其弹出，直到找到有效的头部索引。这增加了鲁棒性。

问题三：性能在高频数据输入时下降。

• 现象：每秒处理几十万条数据时，CPU占用率过高。
• 排查：
  1. 使用性能分析工具：如perf(Linux) 或 VTune，找到热点函数。很可能是push中的while循环或sqrt计算。
  2. 检查编译器优化：确保编译时开启了优化标志（如-O2或-O3）。inline函数是否真的被内联了？
  3. 数据结构开销：std::deque虽然支持两端O(1)操作，但其内存布局可能不是连续的，缓存不友好。对于极端性能场景，可以尝试用定长数组和头尾指针自己实现一个更轻量的双端队列。
  4. 计算频率：是否每个数据点push后都需要获取全部统计信息？也许可以降低查询频率，或者改为按需计算、缓存结果。

问题四：多线程下数据错乱。

• 现象：并发调用push和get时，偶尔读到奇怪的值或程序崩溃。
• 根因：经典的竞态条件。一个线程正在修改buffer_、sum_等状态，另一个线程同时在读取它们。
• 解决：
  • 粗粒度锁：最简单的办法是在整个RollingStatistics对象外加一个互斥锁。这会影响性能。
  • 读写锁：如果读多写少，可以使用std::shared_mutex，允许多个线程同时读，但写时独占。
  • 无锁设计：挑战极大。可以考虑为每个生产者线程分配独立的统计器，然后由一个消费者线程定期合并（适用于统计场景允许一定延迟）。或者使用原子操作和精心设计的内存顺序来实现无锁环形队列，但这非常复杂且容易出错。

调试小技巧：在开发初期，可以增加一个debugPrint()方法，打印出内部缓冲区、队列和聚合变量的状态。与一个简单的、基于完整数组重新计算的“参考实现”进行结果对比，确保在每一步滑动窗口后，两个实现计算出的统计量都完全一致（在浮点误差允许范围内）。这是验证算法正确性的有效方法。