使用原子 TAS 指令实现自旋锁

使用原子 TAS 指令实现自旋锁 Implementing a Spinlock Using the Atomic TAS Instruction 从零实现自旋锁：基于 TAS 的最小同步原语 Building a Spinlock from Scratch with Atomic TAS 用 test-and-set 实现最简单的互斥锁 Implementing a Minimal Mutex Using Test-and-Set 自旋锁的底层原理：TAS、原子性与忙等待 Inside Spinlocks: TAS, Atomicity, and Busy Waiting 原子操作与自旋锁：用 C 语言实现线程同步 Atomic Operations and Spinlocks: Thread Synchronization in C 从原子指令到锁：全面理解 TAS 和自旋锁 From Atomic Instructions to Locks: A Complete Guide to TAS and Spinlocks 动手写一个自旋锁：tryLock / lockAcquire / lockRelease 全实现 Hands-On Spinlock Implementation: tryLock, lockAcquire, and lockRelease 你的第一个自旋锁：基于 C 语言的 TAS 实现 Your First Spinlock: A TAS-Based Implementation in C 原子交换与线程互斥：自旋锁实现指南 Atomic Exchange and Thread Mutual Exclusion: A Guide to Implementing Spinlocks

假设我们有一个 TAS（Take-And-Set）函数。该操作返回内存中原来的值，并以原子方式将其替换为新值。原子性（atomicity）意味着没有其他线程能够观察到中间状态；整个读-写操作是一体不可分的。 在 C++ 中，标准库函数 std::exchange 在逻辑上表现相同，但它不是原子操作。同步原语需要硬件级别的原子性。

int TAS(int* memory, int newVal) {
    int old = *memory;
    *memory = newVal;
    return old;
}

我们想使用这个原语来实现一个简单的自旋锁，包括：

• lockAcquire()
• lockRelease()

线程将调用这些函数来保护对共享变量的访问：

typedef struct {
    int lock;
} lockType;

typedef struct {
    int val;
} threadArgType;

void threadFunc(void* arg) {
    lockAcquire((static_cast<lockType*>arg)->lock);
    (static_cast<threadArgType*>arg)->val++;
    lockRelease((static_cast<lockType*>arg)->lock);
}

实现 tryLock

tryLock 函数尝试获取锁一次。如果锁为空（值为 0），TAS 将其设置为 1 并返回原值（0）。如果锁已被占用，TAS 返回 1。tryLock 函数是非阻塞的——它会立即返回。 因此 tryLock() 只有在 TAS 返回 0 时才会成功：

enum {
    UNLOCKED = 0,
    LOCKED = 1
}

int tryLock(lockType* lock) {
    // 如果之前已锁定返回 1，如果之前未锁定返回 0
    int old = TAS(lock->lock, LOCKED);
    return (old == UNLOCKED);   // true (1) = 成功获取锁
}

实现 lockAcquire()

普通的锁获取应当“自旋”直到 tryLock() 成功。这称为 自旋锁，因为 CPU 会忙等待。必要时可以加入短暂的 sleep。例如，sleep(0) 并不会真正暂停执行，而是让出 CPU，允许其他线程运行。 它通常用于实现跨线程的互斥自旋锁。

void lockAcquire(lockType* lock) {
    while (!tryLock(lockType* lock)) {
        // 自旋直到锁可用
    }
}

另一种实现：

void lockAcquire(lockType* lock) {
    do {
       if (tryLock(lockType* lock)) {
          break;
       }
    } while (1);
}

展开 tryLock：

void lockAcquire(lockType* lock) {
    do {
       int old = TAS(lock->lock, LOCKED);
       // 无论锁是否已被获取，锁都已设置为 LOCKED
       if (old == UNLOCKED) {
           break;
       }
    } while (1);
}

这是使用 TAS 实现的最简单方法。在实际系统中，我们可能会加入 pause 指令或退避策略，但基本思路是相同的。

实现 lockRelease()

释放锁时，持有者只需将锁变量写为 0。由于 TAS 是“设置新值并返回旧值”，它同样适用于释放锁：

void lockRelease(lockType* lock) {
    TAS(lock->lock, UNLOCKED);
}

或者使用简单的原子存储也足够，但由于 TAS 是我们唯一的工具，我们重用它。请注意，在这里重复释放锁是安全的，因为再次将其设置为 UNLOCKED=0 不会产生副作用。

总结

仅使用原子 TAS 指令，我们实现了：

• 一个 tryLock() 尝试
• 一个 lockAcquire() 自旋锁
• 一个 lockRelease() 解锁操作

这种锁的实现方式对于理解低级并发、内存顺序以及高层互斥锁库的构建方式非常基础。 [show_file file="/var/www/wp-post-common/justyy.com/cpp.php"] 英文：Implement a Lock Acquire and Release in C++

C++ 一直在不断增加新特性，以便程序员能够区分在编译时运行的代码和在运行时执行的代码。其中两个重要工具是函数 std::is_constant_evaluated()（C++20）和语言级别的 if consteval（C++23）。本文将解释这两者，展示实际示例，比较它们的保证和权衡，并建议在何时使用各自的方法。 这两种技术都允许你编写分支，根据当前的求值是在常量求值（编译时）上下文中还是运行时上下文中而表现不同。差异虽然细微，但非常重要：一个是返回布尔值的函数，另一个是编译器视为仅在编译时检查的特殊 if 语句，编译器会进行特殊处理。

std::is_constant_evaluated() (C++20)

这是一个在 <type_traits> 中声明的函数：

#include <type_traits>
constexpr bool std::is_constant_evaluated() noexcept;

当当前表达式在常量表达式（编译时）上下文中求值时，该函数返回 true，否则返回 false。 示例：

#include <iostream>
#include <type_traits>

constexpr int f() {
    if (std::is_constant_evaluated()) {
        return 42; // 编译时
    } else {
        return 0; // 运行时 
    }
}

int main() {
constexpr int a = f(); // 编译时求值 -> 42
    int b = f(); // 运行时求值 -> 0
    std::cout << a << ", " << b << "\n"; // 打印 "42, 0"
}

if consteval (C++23)

if consteval 是一个语言级别的 if 条件语句，编译器用它来判断当前求值上下文是否为常量求值。它提供了更强的编译时保证：编译器知道 consteval 分支在常量求值中必须可用，并且会拒绝不能在该上下文中出现的代码。 语法：

if consteval {
    // 仅编译时代码
} else {
    // 仅运行时代码
}

示例：

#include <iostream>

constexpr int f() {
    if consteval {
        return 42; // 编译时版本
    } else {
        return 0; // 运行时版本
    }
}

int main() {
    constexpr int a = f(); // 编译时上下文 -> 返回 42
    int b = f(); // 运行时上下文 -> 返回 0
    std::cout << a << ", " << b << "\n"; // 打印 "42, 0"
}

主要区别（总结）

• 形式： std::is_constant_evaluated() 是一个函数；if consteval 是一个语言级条件语句。
• 标准： std::is_constant_evaluated() 出现在 C++20 中；if consteval 出现在 C++23 中。
• 保证： if consteval 为编译器提供编译时保证，并拒绝编译时无法使用的 consteval 分支中的代码。 std::is_constant_evaluated() 的执行环境更为宽松：它返回布尔值，但不会强制编译器拒绝其他分支中无效的编译时构造。
• 在表达式内部使用： std::is_constant_evaluated() 可以在语句形式的 if 无法使用的表达式内部使用（例如，在三元运算符内部）。if consteval 需要语句级上下文。

具体比较示例

两个函数看起来相似，但在执行方面表现不同：

// if-consteval 示例
constexpr int f() {
    if consteval {
        return 1; // 仅在编译时
    } else {
        return 2; // 仅限运行时
    }
}

// std::is_constant_evaluated() 示例
#include <type_traits>
constexpr int g() {
    if (std::is_constant_evaluated()) {
        return 1; // 可能仍会编译运行时路径
    } else {
    return 2;
    }
}

以下场景中，差异至关重要：

// 使用 if consteval 时，编译器将拒绝无效的仅限编译时构造
constexpr int bad() {
    if consteval {
        std::cout << "compile-time"; // ❌ 错误 — 常量求值中不允许 I/O
    }
    return 0;
}

// 使用 std::is_constant_evaluated() 时，编译器会更加宽容，可能会编译通过，直到代码
// 实际用于常量表达式上下文。
#include <type_traits>
constexpr int perhaps_bad() {
    if (std::is_constant_evaluated()) {
        std::cout << "compile-time"; // 可能会编译通过；只有在 const-expr 中求值时才会出现错误
    }
    return 0;
}

使用场景

• 如果您的目标是 C++23（或更高版本），并且想要清晰的、编译时强制的分支：请优先使用 if consteval。
• 如果您必须仅支持 C++20 环境：请使用 std::is_constant_evaluated()。
• 如果您需要在表达式（而非语句）中进行检查，请使用 std::is_constant_evaluated()，因为 if consteval 是语句级的。
• 如果您希望编译器拒绝编译时无法使用的代码，if consteval 可以提供更强的保证。

实际用例

• 为编译时和运行时（快速预计算 vs 较慢的运行时）编写不同的实现逻辑）。
• 保护仅运行时操作（例如 I/O、动态分配或系统调用），以免它们被意外地用于常量求值路径。
• 在编写可在 constexpr 上下文和正常运行时上下文中使用的库时，提供更清晰、更能揭示意图的代码。

简短实用的检查清单

• 需要表达式级检查？→ std::is_constant_evaluated()。
• 想要编译器强制执行的仅编译时分支？→ if consteval。
• 仅针对 C++20？→ std::is_constant_evaluated()。
• 针对 C++23+ 并更注重清晰度和安全性？ → if consteval.

TL;DR

std::is_constant_evaluated() — C++20：在编译时求值中返回 true 的函数（适用于表达式级检查）。 if consteval — C++23：

• 编译器将其视为仅编译时分支的语言级条件语句；
• 更强的编译时执行力和更清晰的意图。

结束语

这两个工具都很有用。如果您可以使用 C++23，则最好使用 if consteval 以获得更清晰的语义和更强的编译时保证，并在与 C++20 兼容或需要表达式级检查时回退到 std::is_constant_evaluated() [show_file file="/var/www/wp-post-common/justyy.com/cpp.php"] 英文：Detecting Compile-time vs Runtime in C++: if consteval vs std::is_constant_evaluated()