顺序锁

顺序锁 的协作图:

结构体
class	xwos::lock::Seqlock
	顺序锁 更多...

详细描述

顺序锁的结构体非常小，因此不分别提供静态初始化与动态创建的方法。

共享读

• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    xwsq_t seq = gLock.readBegin();
    do {
        共享读临界区
    } while (gLock.readRetry(seq));
}

顺序锁的RAII机制守卫

顺序锁不同的锁模式具有不同的RAII机制守卫：

Seqlock::RdexLkGrd : 独占读普通上锁模式

• 构造函数关闭当前CPU调度器的抢占，然后上锁顺序锁。 上锁失败会自旋等待，直到上锁成功为止。
• 析构函数解锁顺序锁，开启当前CPU调度器的抢占。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时会自动对顺序锁上锁
        xwos::lock::Seqlock::RdexLkGrd grd(gSlock);
        进入临界区
    } // grd析构时会自动解锁顺序锁
}

Seqlock::TryRdexLkGrd : 独占读普通尝试上锁模式

• 构造函数关闭并保存本地CPU的中断，关闭当前CPU调度器的抢占，上锁顺序锁。 上锁失败会自旋等待，直到上锁成功为止。
• 析构函数解锁顺序锁，开启当前CPU调度器的抢占， 用保存的中断标志恢复本地CPU的中断。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时尝试进入临界区
        xwos::lock::Seqlock::TryRdexLkGrd grd(gLock);
        if (XWOK == grd.getRc()) {
            // 上锁成功，进入临界区
        } else {
            // 上锁失败
        }
    } // 如果上锁成功，析构 `grd` 时退出临界区
}

Seqlock::RdexLkThGrd : 独占读CPU中断上锁模式

• 构造函数关闭并保存本地CPU的中断，关闭当前CPU调度器的抢占，上锁顺序锁。 上锁失败会自旋等待，直到上锁成功为止。
• 析构函数解锁顺序锁，开启当前CPU调度器的抢占， 用保存的中断标志恢复本地CPU的中断。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时进入临界区
        xwos::lock::Seqlock::RdexLkThGrd grd(gSlock);
        进入临界区
    } // 析构 `grd` 时退出临界区
}

Seqlock::TryRdexLkThGrd : 独占读CPU中断尝试上锁模式

• 构造函数关闭并保存本地CPU的中断，关闭当前CPU调度器的抢占，上锁顺序锁。 上锁失败不会自旋等待，会开启当前CPU调度器的抢占， 用保存的中断标志恢复本地CPU的中断，并在 mRc 中返回 -EAGAIN
• 析构函数解锁顺序锁，开启当前CPU调度器的抢占， 用保存的中断标志恢复本地CPU的中断。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时尝试进入临界区
        xwos::lock::Seqlock::TryRdexLkThGrd grd(gLock);
        if (XWOK == grd.getRc()) {
            // 上锁成功，进入临界区
        } else {
            // 上锁失败
        }
    } // 如果上锁成功，析构 `grd` 时退出临界区
}

Seqlock::RdexLkBhGrd : 独占读中断底半部上锁模式

• 构造函数关闭当前CPU调度器的抢占，关闭本地CPU的中断底半部，然后上锁顺序锁。 上锁失败会自旋等待，直到上锁成功为止。
• 析构函数解锁顺序锁，开启本地CPU的中断底半部，开启当前CPU调度器的抢占。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时进入临界区
        xwos::lock::Seqlock::RdexLkBhGrd grd(gSlock);
        进入临界区
    } // 析构 `grd` 时退出临界区
}

Seqlock::TryRdexLkBhGrd : 独占读中断底半部尝试上锁模式

• 构造函数关闭当前CPU调度器的抢占，关闭本地CPU的中断底半部， 然后尝试上锁顺序锁。 上锁失败不会自旋等待，会开启当前CPU调度器的抢占，开启本地CPU的中断底半部， 并在 mRc 中返回 -EAGAIN 。
• 析构函数解锁顺序锁，开启本地CPU的中断底半部，开启当前CPU调度器的抢占。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时尝试进入临界区
        xwos::lock::Seqlock::RdexLkBhGrd(gLock);
        if (XWOK == grd.getRc()) {
            // 上锁成功，进入临界区
        } else {
            // 上锁失败
        }
    } // 如果上锁成功，析构 `grd` 时退出临界区
}

Seqlock::RdexLkIrqsGrd : 独占读部分中断上锁模式

• 构造函数关闭并保存模板参数列表内的中断，关闭当前CPU调度器的抢占，上锁顺序锁。 上锁失败会自旋等待，直到上锁成功为止。
• 析构函数解锁顺序锁，开启当前CPU调度器的抢占， 用保存的中断标志恢复模板参数列表内的中断。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时进入临界区，同时关闭编号为1, 3, 5, 8的四个中断。
        xwos::lock::Seqlock::RdexLkIrqsGrd<1, 3, 5, 8> grd(gSlock);
        进入临界区
    } // 析构 `grd` 时退出临界区，并恢复编号为1, 3, 5, 8的四个中断。
}

Seqlock::TryRdexLkIrqsGrd : 独占读部分中断尝试上锁模式

• 构造函数关闭并保存模板参数列表内的中断，关闭当前CPU调度器的抢占，上锁顺序锁。 上锁失败不会自旋等待，会开启当前CPU调度器的抢占， 用保存的中断标志恢复模板参数列表内的中断， 并在 mRc 中返回 -EAGAIN 。
• 析构函数解锁顺序锁，开启当前CPU调度器的抢占， 用保存的中断标志恢复模板参数列表内的中断。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时尝试进入临界区，同时关闭编号为1, 3, 5, 8的四个中断。
        xwos::lock::Seqlock::TryRdexLkIrqsGrd<1, 3, 5, 8> grd(gLock);
        if (XWOK == grd.getRc()) {
            // 上锁成功，进入临界区
        } else {
            // 上锁失败
        }
    } // 如果上锁成功，析构 `grd` 时退出临界区，并恢复编号为1, 3, 5, 8的四个中断。
}

Seqlock::WrLkGrd : 独占写普通上锁模式

• 构造函数关闭当前CPU调度器的抢占，然后上锁顺序锁。 上锁失败会自旋等待，直到上锁成功为止。
• 析构函数解锁顺序锁，开启当前CPU调度器的抢占。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时会自动对顺序锁上锁
        xwos::lock::Seqlock::WrLkGrd grd(gSlock);
        进入临界区
    } // grd析构时会自动解锁顺序锁
}

Seqlock::TryWrLkGrd : 独占写普通尝试上锁模式

• 构造函数关闭并保存本地CPU的中断，关闭当前CPU调度器的抢占，上锁顺序锁。 上锁失败会自旋等待，直到上锁成功为止。
• 析构函数解锁顺序锁，开启当前CPU调度器的抢占， 用保存的中断标志恢复本地CPU的中断。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时尝试进入临界区
        xwos::lock::Seqlock::TryWrLkGrd grd(gLock);
        if (XWOK == grd.getRc()) {
            // 上锁成功，进入临界区
        } else {
            // 上锁失败
        }
    } // 如果上锁成功，析构 `grd` 时退出临界区
}

Seqlock::WrLkThGrd : 独占写CPU中断上锁模式

• 构造函数关闭并保存本地CPU的中断，关闭当前CPU调度器的抢占，上锁顺序锁。 上锁失败会自旋等待，直到上锁成功为止。
• 析构函数解锁顺序锁，开启当前CPU调度器的抢占， 用保存的中断标志恢复本地CPU的中断。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时进入临界区
        xwos::lock::Seqlock::WrLkThGrd grd(gSlock);
        进入临界区
    } // 析构 `grd` 时退出临界区
}

Seqlock::TryWrLkThGrd : 独占写CPU中断尝试上锁模式

• 构造函数关闭并保存本地CPU的中断，关闭当前CPU调度器的抢占，上锁顺序锁。 上锁失败不会自旋等待，会开启当前CPU调度器的抢占， 用保存的中断标志恢复本地CPU的中断，并在 mRc 中返回 -EAGAIN
• 析构函数解锁顺序锁，开启当前CPU调度器的抢占， 用保存的中断标志恢复本地CPU的中断。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时尝试进入临界区
        xwos::lock::Seqlock::TryWrLkThGrd grd(gLock);
        if (XWOK == grd.getRc()) {
            // 上锁成功，进入临界区
        } else {
            // 上锁失败
        }
    } // 如果上锁成功，析构 `grd` 时退出临界区
}

Seqlock::WrLkBhGrd : 独占写中断底半部上锁模式

• 构造函数关闭当前CPU调度器的抢占，关闭本地CPU的中断底半部，然后上锁顺序锁。 上锁失败会自旋等待，直到上锁成功为止。
• 析构函数解锁顺序锁，开启本地CPU的中断底半部，开启当前CPU调度器的抢占。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时进入临界区
        xwos::lock::Seqlock::WrLkBhGrd grd(gSlock);
        进入临界区
    } // 析构 `grd` 时退出临界区
}

Seqlock::TryWrLkBhGrd : 独占写中断底半部尝试上锁模式

• 构造函数关闭当前CPU调度器的抢占，关闭本地CPU的中断底半部， 然后尝试上锁顺序锁。 上锁失败不会自旋等待，会开启当前CPU调度器的抢占，开启本地CPU的中断底半部， 并在 mRc 中返回 -EAGAIN 。
• 析构函数解锁顺序锁，开启本地CPU的中断底半部，开启当前CPU调度器的抢占。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时尝试进入临界区
        xwos::lock::Seqlock::WrLkBhGrd(gLock);
        if (XWOK == grd.getRc()) {
            // 上锁成功，进入临界区
        } else {
            // 上锁失败
        }
    } // 如果上锁成功，析构 `grd` 时退出临界区
}

Seqlock::WrLkIrqsGrd : 独占写部分中断上锁模式

• 构造函数关闭并保存模板参数列表内的中断，关闭当前CPU调度器的抢占，上锁顺序锁。 上锁失败会自旋等待，直到上锁成功为止。
• 析构函数解锁顺序锁，开启当前CPU调度器的抢占， 用保存的中断标志恢复模板参数列表内的中断。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时进入临界区，同时关闭编号为1, 3, 5, 8的四个中断。
        xwos::lock::Seqlock::WrLkIrqsGrd<1, 3, 5, 8> grd(gSlock);
        进入临界区
    } // 析构 `grd` 时退出临界区，并恢复编号为1, 3, 5, 8的四个中断。
}

Seqlock::TryWrLkIrqsGrd : 独占写部分中断尝试上锁模式

• 构造函数关闭并保存模板参数列表内的中断，关闭当前CPU调度器的抢占，上锁顺序锁。 上锁失败不会自旋等待，会开启当前CPU调度器的抢占， 用保存的中断标志恢复模板参数列表内的中断， 并在 mRc 中返回 -EAGAIN 。
• 析构函数解锁顺序锁，开启当前CPU调度器的抢占， 用保存的中断标志恢复模板参数列表内的中断。
• 示例

#include <xwos/cxx/lock/Seqlock.hxx>
 
xwos::lock::Seqlock gLock;
 
void foo()
{
    { // 构造 `grd` 时尝试进入临界区，同时关闭编号为1, 3, 5, 8的四个中断。
        xwos::lock::Seqlock::TryWrLkIrqsGrd<1, 3, 5, 8> grd(gLock);
        if (XWOK == grd.getRc()) {
            // 上锁成功，进入临界区
        } else {
            // 上锁失败
        }
    } // 如果上锁成功，析构 `grd` 时退出临界区，并恢复编号为1, 3, 5, 8的四个中断。
}

等待条件量并解锁

• Seqlock::RdexLkGrd::wait()
• Seqlock::TryRdexLkGrd::wait()
• Seqlock::RdexLkThGrd::wait()
• Seqlock::TryRdexLkThGrd::wait()
• Seqlock::RdexLkBhGrd::wait()
• Seqlock::TryRdexLkBhGrd::wait()
• Seqlock::RdexLkIrqsGrd::wait()
• Seqlock::TryRdexLkIrqsGrd::wait()
• Seqlock::WrLkGrd::wait()
• Seqlock::TryWrLkGrd::wait()
• Seqlock::WrLkThGrd::wait()
• Seqlock::TryWrLkThGrd::wait()
• Seqlock::WrLkBhGrd::wait()
• Seqlock::TryWrLkBhGrd::wait()
• Seqlock::WrLkIrqsGrd::wait()
• Seqlock::TryWrLkIrqsGrd::wait()

头文件

xwos/cxx/lock/Seqlock.hxx