[[likely]] 与 [[unlikely]] 分支提示 ​

什么是 likely 和 unlikely ​

[[likely]] 和 [[unlikely]] 是 C++20 引入的属性(attribute),用于告诉编译器某个分支路径更可能或更不可能被执行。编译器可以利用这个提示来优化代码布局,把更可能执行的代码放在连续的位置,减少指令缓存未命中和跳转开销。

cpp
if (error_code != 0) [[unlikely]] {
    handle_error();  // 错误处理很少执行
} else [[likely]] {
    process();       // 正常路径频繁执行
}

这两个属性只是提示,不会改变程序的逻辑行为。编译器可以选择忽略它们。

基本示例 ​

cpp
#include <iostream>
#include <vector>
#include <string>
#include <chrono>
#include <random>
#include <stdexcept>

// ============================
// 示例1:if-else 中使用
// ============================

int process_value(int value) {
    if (value < 0) [[unlikely]] {
        // 负值是异常情况,很少出现
        throw std::invalid_argument("负值不允许");
    } else [[likely]] {
        // 正常情况,大部分时间走这条路径
        return value * 2;
    }
}

void if_else_demo() {
    try {
        std::cout << "process(42): " << process_value(42) << std::endl;
        std::cout << "process(10): " << process_value(10) << std::endl;
        process_value(-1);
    } catch (const std::exception& e) {
        std::cout << "异常: " << e.what() << std::endl;
    }
}

// ============================
// 示例2:switch-case 中使用
// ============================

enum class RequestType { Normal, Priority, Admin, Error };

std::string handle_request(RequestType type) {
    switch (type) {
        [[likely]] case RequestType::Normal:
            return "处理普通请求";

        case RequestType::Priority:
            return "处理优先请求";

        [[unlikely]] case RequestType::Admin:
            return "处理管理员请求";

        [[unlikely]] case RequestType::Error:
            return "处理错误请求";
    }
    return "未知";
}

void switch_demo() {
    std::cout << handle_request(RequestType::Normal) << std::endl;
    std::cout << handle_request(RequestType::Admin) << std::endl;
}

// ============================
// 示例3:循环中使用
// ============================

int find_negative(const std::vector<int>& data) {
    for (size_t i = 0; i < data.size(); i++) {
        if (data[i] < 0) [[unlikely]] {
            // 负数很少出现
            return static_cast<int>(i);
        }
    }
    return -1;
}

void loop_demo() {
    std::vector<int> data(1000, 1);
    data[999] = -1;  // 只有最后一个是负数

    int pos = find_negative(data);
    std::cout << "负数位置: " << pos << std::endl;
}

// ============================
// 示例4:错误检查模式
// ============================

struct Result {
    bool success;
    int value;
    std::string error;
};

Result divide(int a, int b) {
    if (b == 0) [[unlikely]] {
        return {false, 0, "除数为零"};
    }

    if (a < 0 || b < 0) [[unlikely]] {
        return {false, 0, "不支持负数"};
    }

    return {true, a / b, ""};
}

void error_check_demo() {
    auto r1 = divide(100, 5);
    if (r1.success) [[likely]] {
        std::cout << "100/5 = " << r1.value << std::endl;
    }

    auto r2 = divide(10, 0);
    if (!r2.success) [[likely]] {
        std::cout << "错误: " << r2.error << std::endl;
    }
}

// ============================
// 示例5:递归中使用
// ============================

constexpr double power(double x, long long n) noexcept {
    if (n > 0) [[likely]] {
        return x * power(x, n - 1);
    } else [[unlikely]] {
        return 1.0;  // 基础情况只执行一次
    }
}

void recursion_demo() {
    std::cout << "2^10 = " << power(2.0, 10) << std::endl;
    std::cout << "3^5 = " << power(3.0, 5) << std::endl;
}

// ============================
// 示例6:缓存命中优化
// ============================

int lookup_cache(int key,
                 const std::vector<std::pair<int, int>>& cache,
                 const std::vector<std::pair<int, int>>& database) {
    // 先查缓存——大部分时候能命中
    for (const auto& [k, v] : cache) {
        if (k == key) [[likely]] {
            return v;  // 缓存命中
        }
    }

    // 缓存未命中——回退到数据库
    for (const auto& [k, v] : database) {
        if (k == key) [[unlikely]] {
            return v;
        }
    }

    return -1;
}

void cache_demo() {
    std::vector<std::pair<int, int>> cache = {{1, 100}, {2, 200}, {3, 300}};
    std::vector<std::pair<int, int>> db = {{4, 400}, {5, 500}};

    std::cout << "查找 key=2: " << lookup_cache(2, cache, db) << std::endl;
    std::cout << "查找 key=5: " << lookup_cache(5, cache, db) << std::endl;
}

// ============================
// 示例7:性能对比测试
// ============================

void benchmark_demo() {
    constexpr int iterations = 10'000'000;

    // 生成测试数据:99% 的值大于0,1% 小于等于0
    std::mt19937 rng(42);
    std::uniform_int_distribution<int> dist(1, 100);
    std::vector<int> data(iterations);
    for (auto& v : data) {
        v = dist(rng);
        if (v == 1) v = -1;  // 约 1% 的概率为负数
    }

    // 带 likely/unlikely
    volatile long long sum1 = 0;
    auto start = std::chrono::high_resolution_clock::now();
    for (int v : data) {
        if (v > 0) [[likely]] {
            sum1 += v;
        } else [[unlikely]] {
            sum1 -= v;
        }
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto ms1 = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // 不带属性
    volatile long long sum2 = 0;
    start = std::chrono::high_resolution_clock::now();
    for (int v : data) {
        if (v > 0) {
            sum2 += v;
        } else {
            sum2 -= v;
        }
    }
    end = std::chrono::high_resolution_clock::now();
    auto ms2 = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    std::cout << "带属性: " << ms1 << " us" << std::endl;
    std::cout << "不带属性: " << ms2 << " us" << std::endl;
    std::cout << "(效果取决于编译器和优化级别)" << std::endl;
}

int main() {
    std::cout << "=== if-else ===" << std::endl;
    if_else_demo();

    std::cout << "\n=== switch-case ===" << std::endl;
    switch_demo();

    std::cout << "\n=== 循环 ===" << std::endl;
    loop_demo();

    std::cout << "\n=== 错误检查 ===" << std::endl;
    error_check_demo();

    std::cout << "\n=== 递归 ===" << std::endl;
    recursion_demo();

    std::cout << "\n=== 缓存 ===" << std::endl;
    cache_demo();

    std::cout << "\n=== 性能测试 ===" << std::endl;
    benchmark_demo();

    return 0;
}

编译器如何利用这些提示 ​

编译器拿到 likely/unlikely 提示后,可能做以下优化:

优化策略说明
代码布局把 likely 路径放在连续位置,unlikely 路径移到远处
跳转方向likely 路径不跳转(fallthrough),unlikely 路径跳转
指令缓存likely 路径更容易留在 L1 指令缓存中
分支预测辅助 CPU 的静态分支预测(首次遇到时)

likely/unlikely vs 编译器内建 ​

方式标准语法可移植性
[[likely]] / [[unlikely]]C++20标准属性完全可移植
__builtin_expect(expr, val)GCC/Clang 扩展编译器内建不可移植
__assume(expr)MSVC 扩展编译器内建不可移植
PGO(Profile-Guided Optimization)编译器功能编译选项依赖工具链

适用场景 ​

  • 错误处理路径(错误很少发生)
  • 空指针检查(大部分时候不为空)
  • 边界检查(越界极少发生)
  • 缓存命中/未命中路径
  • 热循环中的罕见条件分支
  • 性能关键代码经过 profiling 确认的热路径

常见问题 ​

likely/unlikely 能带来多大的性能提升?

通常很小(0-5%),在大多数情况下编译器和 CPU 的分支预测已经足够好。只有在高频执行的热路径、分支比例非常不均匀时才可能有明显效果。不要期望它能解决性能问题。

可以同时在两个分支都加 likely 吗?

不可以在同一个语句同时使用 [[likely]] 和 [[unlikely]]。但可以在 if 的两个分支分别标注不同的属性。

过度使用会有害吗?

C++ 标准草案明确指出:"过度使用这两个属性可能导致性能下降。"如果标注错误(比如把不常执行的路径标为 likely),反而会误导编译器。

constexpr 函数中可以使用吗?

可以。likely/unlikely 可以在 constexpr 函数中使用。

注意事项 ​

  • 只是提示,编译器可以忽略
  • 过度使用或标注错误可能导致性能下降
  • 应该基于 profiling 数据来决定标注哪些分支
  • 不改变程序逻辑,只影响编译器优化
  • 不能同时在一个语句上使用 likely 和 unlikely
  • 大多数情况下编译器和 CPU 的自动预测就够了

编译器支持情况 ​

编译器支持最低版本
GCC支持9.0
Clang支持12.0
MSVC支持19.26 (VS 2019 16.6)

总结 ​

[[likely]] 和 [[unlikely]] 是 C++20 引入的标准化分支预测提示,取代了以前各编译器的非标准扩展(如 __builtin_expect)。它们告诉编译器某条分支路径更可能或更不可能执行,编译器据此优化代码布局和跳转方向。实际性能提升通常很小,因为现代 CPU 的动态分支预测已经很强。最佳实践是只在经过 profiling 确认的热路径上使用,避免凭直觉大量标注。典型用法包括错误处理路径标 unlikely、正常处理路径标 likely。