告别锁竞争:Linux 内核 Seqlock顺序锁机制解析

在 Linux 内核高并发场景中，锁竞争始终是制约性能的核心瓶颈——互斥锁、读写锁虽能保证数据一致性，却会导致线程阻塞、上下文切换，大幅损耗系统吞吐量，尤其在高频读写、数据更新频繁的场景下，这种性能损耗更为明显。如何在保证数据安全的前提下，摆脱锁竞争的束缚，实现高效的并发读写，成为内核开发中亟待解决的关键问题。

Seqlock（顺序锁）作为 Linux 内核中一种轻量级无锁同步机制，恰好为这一痛点提供了最优解。它摒弃了传统锁的阻塞机制，通过“序列号+数据”的核心设计，实现了读写操作的并行执行，既保证了读操作的无阻塞性，又能高效完成数据更新，在时钟同步、网络协议栈、内核统计等高频读写场景中广泛应用。本文将从底层原理出发，拆解 Seqlock 的工作机制，带你读懂它如何彻底告别锁竞争，解锁内核并发性能新高度。

一、什么是 Seqlock （顺序锁）？

面试题写作模版

在并发编程的广袤世界里，锁机制始终占据着举足轻重的地位，堪称保障数据一致性与程序正确性的中流砥柱。当多个线程或进程如汹涌浪潮般同时访问共享资源时，若缺乏有效的协调与管控，数据混乱、竞态条件等问题便会接踵而至，程序的稳定性与可靠性也将遭受严重威胁 。为了化解这一难题，众多类型的锁应运而生，各自施展独特 “本领”，在不同场景下大显身手，Seqlock 顺序锁便是其中别具一格的一员。

Seqlock 顺序锁主要致力于攻克经典的读者 - 写者问题。在该问题中，存在两类对共享资源有着不同访问需求的线程：读者线程，它们仅对资源进行读取操作，不会对其进行修改；写者线程，则肩负着修改资源的重任。传统的读写锁虽然能够在一定程度上解决读写冲突，但在某些极端情况下，性能表现仍不尽如人意。比如，当写操作发生时，读操作往往会被阻塞，直至写操作完成，这在高并发且读多写少的场景中，无疑会成为性能瓶颈，极大地限制了系统的吞吐量。

Seqlock 顺序锁的横空出世，巧妙地打破了这一困境。它的设计理念独树一帜，允许读操作在写操作进行的同时继续执行，读操作不会被写操作阻塞。这就好比在一场热闹的集市中，卖家（写者）在摊位上忙碌地整理货物（修改数据），买家（读者）却依然能够在一旁自由地挑选商品（读取数据），双方互不干扰，极大地提高了并发效率。 

不过，这种高效的并发访问并非毫无代价，由于读操作和写操作可能同时进行，读者读到的数据有可能是不完整或者陈旧的。为了应对这一挑战，Seqlock 顺序锁引入了版本号机制，如同给数据贴上了时间标签，以此来帮助读者判断所读取的数据是否有效 。

二、Seqlock 顺序锁工作原理

面试题写作模版

2.1 Seqlock 结构剖析

Seqlock 在 Linux 内核中是通过一个结构体来实现的，其核心组件主要包括一个序列号（sequence number）和一个自旋锁（spinlock） 。

typedef struct {    unsigned sequence;    spinlock_t lock;} seqlock_t;

在这个结构体中，sequence 成员变量犹如一位忠实的记录者，以无符号整数的形式，精准地记录着写操作的 “足迹”。当 sequence 的值为偶数时，它仿佛在轻声诉说：当前没有写操作正在进行，数据处于稳定的 “宁静状态”，读者可以放心地读取；而当它的值变为奇数时，则如同拉响了警报，明确地告知读者：此刻有写操作正在火热进行中，数据可能处于不稳定的 “变动状态”，读取时需格外谨慎 。

另一个成员变量 lock，则是一把坚固的 “守护锁”，它的类型为 spinlock_t，即自旋锁。在写操作的过程中，自旋锁发挥着至关重要的互斥作用，它如同一位严格的门卫，确保在同一时刻，只有一个写者能够进入临界区，对数据进行修改，从而避免了多个写者同时操作数据导致的混乱局面 。

Seqlock 顺序锁的初始化过程，就像是为一场精彩的演出搭建舞台，为后续的并发操作奠定坚实的基础。它主要有两种初始化方式，每种方式都有着独特的 “魅力” 和适用场景 。

（1）静态初始化：使用 SEQLOCK_UNLOCKED 宏进行静态初始化，就像是在演出前提前布置好固定的舞台场景。这种方式简单直接，一步到位 。代码示例如下：

seqlock_t my_seqlock = SEQLOCK_UNLOCKED;

在这个示例中，my_seqlock 被初始化为一个 seqlock_t 类型的顺序锁，其 sequence 成员变量被初始化为 0，呈现出偶数状态，这意味着初始时没有写操作在进行，数据处于稳定的初始状态；lock 成员变量则被初始化为 SPIN_LOCK_UNLOCKED，表示自旋锁处于解锁状态，随时准备为写操作提供互斥保护 。

（2）动态初始化：通过 seqlock_init 函数进行动态初始化，就像是在演出过程中根据实际需求灵活调整舞台布置。这种方式更加灵活，能够适应不同的运行时情况 。函数定义如下：

#define seqlock_init(x) \do{ \    (x)->sequence = 0; \    spin_lock_init(&(x)->lock); \} while (0)

在这段代码中，首先将 sequence 成员变量赋值为 0，让顺序锁处于初始的稳定状态；然后调用 spin_lock_init 函数对自旋锁 lock 进行初始化，使其处于可用状态 。使用时，只需传入指向 seqlock_t 结构体的指针，即可完成动态初始化，例如：

seqlock_t *my_seqlock_ptr = kmalloc(sizeof(seqlock_t), GFP_KERNEL);if (my_seqlock_ptr) {    seqlock_init(my_seqlock_ptr);// 后续操作} else {// 内存分配失败处理}

2.2 Seqlock 的读写工作机制

（1）写操作流程——当一个写者想要对共享资源进行写操作时，它首先会调用 write_seqlock 函数。在这个函数中，会先通过 spin_lock 函数获取自旋锁，这一步就像是在进入仓库修改账本和货物之前，先拿到仓库的钥匙，确保没有其他写者同时进入仓库。获取到自旋锁后，写者会递增 sequence 变量的值，这就相当于在账本上记录下一次货物进出（写操作）的记录。同时，为了保证内存操作的顺序性，会使用内存屏障 smp_wmb ()。内存屏障在这里的作用就像是给账本的记录加上一个时间戳，确保在递增 sequence 这个记录之后的所有写操作（修改货物）都能被正确地记录和排序，不会出现记录混乱的情况。

1. 获取写锁：当一个写者想要对被 Seqlock 保护的共享资源进行写操作时，它首先要调用 write_seqlock 函数。在这个函数内部，最关键的一步是通过 spin_lock 函数获取自旋锁 。自旋锁就像是一个 “独占令牌”，一旦被某个写者获取，其他写者就无法同时获取，只能在原地自旋等待 。获取自旋锁后，写者会将序列号 sequence 递增 1 。例如，初始时序列号为 0（偶数），递增后变为 1（奇数），这个变化就像是在 “告知” 所有读者：现在有写操作正在进行，数据可能不稳定哦。
2. 数据修改：在成功获取写锁并且序列号递增后，写者就可以放心地对共享数据进行修改了 。比如，假设共享资源是一个记录系统配置参数的结构体，写者可能会修改其中的某个参数值。在这个修改数据的过程中，由于自旋锁的保护，不会有其他写者同时进入这个临界区修改数据 ，保证了数据修改的原子性和一致性 。不过，需要注意的是，写操作应尽量简短高效，避免长时间占用自旋锁，不然会导致其他写者长时间等待，影响系统性能 。
3. 释放写锁：当写者完成数据修改后，就需要调用 write_sequnlock 函数释放写锁 。在这个函数里，首先会执行一个写内存屏障 smp_wmb() 。内存屏障的作用就像是一个 “指令顺序保护器”，它确保了在序列号再次递增之前，所有的数据修改操作都已经完成并且对其他处理器可见 。之后，写者将序列号再次递增 1 ，比如从 1（奇数）变为 2（偶数），这就向读者们发出了一个信号：写操作已经完成，数据现在处于一致状态，可以安全读取啦。最后，通过 spin_unlock 函数释放自旋锁，让其他写者有机会获取锁并进行写操作 。

   #include <linux/seqlock.h>// 定义顺序锁 + 共享数据seqlock_t seq_lock;struct sys_config config;// 写者完整流程voidupdate_config(int new_timeout, int new_maxconn){// 1. 获取写锁    write_seqlock(&seq_lock);// 2. 修改共享数据    config.timeout = new_timeout;    config.max_conn = new_maxconn;// 3. 释放写锁    write_sequnlock(&seq_lock);}

（2）读操作流程——对于读者来说，读操作的流程相对复杂一些。读者在读取共享资源之前，会调用 read_seqbegin 函数获取当前的 sequence 值，这个值就像是读者在读取货物信息之前，先记录下当前账本的状态。在读取完共享资源后，读者会调用 read_seqretry 函数，再次获取当前的 sequence 值，并与之前记录的值进行比较。如果两次获取的 sequence 值相同，说明在读取过程中没有写操作发生，读取的数据是有效的；如果不同，则说明有写操作介入，数据可能已经被修改，需要重新读取 。

这里还有一个特殊的判断条件，如果读者在获取 sequence 值时发现其为奇数，说明此时可能有写操作正在进行，因为写操作开始时会将 sequence 变为奇数。这种情况下，读者会等待一段时间，然后再次尝试获取 sequence 值，直到其变为偶数，才开始读取数据。这就好比在仓库外等待进入查看货物信息的人，如果发现账本上的记录正在被修改（sequence 为奇数），就先在外面等一会儿，直到修改完成（sequence 变为偶数），再进去查看货物信息，以保证看到的货物信息是准确的 。

1. 获取序列号：读者在读取被 Seqlock 保护的共享资源之前，会调用 read_seqbegin 函数获取当前的序列号 。这个序列号就像是一个 “版本标记”，记录了当前共享资源的状态 。同时，为了保证内存操作的顺序性，会执行一个读内存屏障 smp_rmb() 。它确保了在读取数据之前，先读取到最新的序列号，防止 CPU 或编译器对读取操作进行重排序 。例如，假设当前序列号为 2（偶数），读者获取到这个序列号后，就以这个 “版本” 为基准去读取数据 。此外，在获取序列号时，还会对序列号进行掩码检查（通常是检查最低位），如果发现序列号为奇数，说明此时可能有写操作正在进行，数据不稳定，读者可能会选择等待或者直接重试读取操作 。
2. 数据读取：在获取了序列号并且通过掩码检查后（如果需要），读者就可以开始读取共享数据了 。因为 Seqlock 允许读写并发，所以读者在读取数据时不需要获取锁，这大大提高了读操作的效率 。多个读者可以同时进行读取操作，不会相互阻塞 。在读内存屏障的保证下，读者能先获取到正确的序列号，再读取数据，从而保证读取到的数据和序列号对应的版本是一致的 。比如，共享资源是一个存储系统性能指标的数组，读者可以直接读取数组中的数据，用于后续的分析或展示 。
3. 验证与重试：读者读取完数据后，需要调用 read_seqretry 函数来验证读取的数据是否有效 。这个函数会再次读取当前的序列号，并与之前在 read_seqbegin 函数中获取的初始序列号进行对比 。如果两个序列号相同，说明在读取数据的过程中没有发生写操作，数据是一致的，读取成功；如果序列号不同，那就意味着在读取期间有写者对数据进行了修改，此时读者需要重新进行读取操作 。例如，初始序列号为 2，再次读取时序列号变为 4，说明有写操作发生，读者就会重新执行整个读操作流程，包括获取序列号、读取数据和再次验证，直到验证通过为止 。这种重试机制保证了读者最终能读取到一致的数据 ，虽然可能会增加一些读操作的开销，但在高并发读多写少的场景下，整体性能依然比传统锁机制更优 。

   #include <linux/seqlock.h>#include <linux/module.h>// 定义顺序锁与共享数据seqlock_t seq_lock;struct sys_config {int timeout;int max_conn;} config;// 读者完整读取逻辑voidread_config(int *out_timeout, int *out_maxconn){    unsigned int seq;// 重试循环：直到读取到一致的数据do {// 1. 获取起始序列号        seq = read_seqbegin(&seq_lock);// 2. 无锁读取数据        *out_timeout = config.timeout;        *out_maxconn = config.max_conn;// 3. 验证是否需要重试    } while (read_seqretry(&seq_lock, seq));}EXPORT_SYMBOL(read_config);

2.3 Seqlock 与锁竞争优势

（1）减少读锁阻塞：在传统的读写锁机制中，当写者持有写锁对共享资源进行写操作时，所有读操作都必须等待写操作完成并释放锁后才能进行 。这就好比一条道路，写操作是一辆大型货车，它占据道路时，其他小型的读操作 “车辆” 都得停下来等待，哪怕读操作只是快速通过取个东西就走 。例如，在一个多线程的数据库查询系统中，如果使用传统读写锁，当数据库管理员进行数据更新（写操作）时，所有用户的查询（读操作）都得暂停，这会导致大量用户请求堆积，响应时间大幅增加 。

而 Seqlock 的出现改变了这一局面 。在 Seqlock 机制下，读锁不会被写锁阻塞 。这意味着，即使写者正在对共享资源进行写操作，读者也可以继续读取数据 。就像在一个繁忙的图书馆中，管理员在整理书架（写操作）时，读者仍然可以在书架间穿梭挑选书籍（读操作） 。读者在读取数据前获取序列号，读取完成后验证序列号，如果序列号没有变化，说明读取过程中没有写操作发生，数据有效；如果序列号变化了，读者只需重新读取即可 。

这种方式大大提高了读操作的并发性能，在高并发读场景下，能显著减少读操作的等待时间，提高系统的整体响应速度 。比如在一个实时监控系统中，大量的监控数据需要被读取展示，偶尔会有数据更新（写操作），使用 Seqlock 可以让读操作不受写操作的影响，实时获取监控数据，保证系统的高效运行 。

（2）提高写操作优先级：Seqlock 具有写操作优先的特点，这在写操作频繁的场景下具有明显优势 。在传统的读写锁中，当有大量读操作正在进行时，写操作可能会被长时间阻塞，因为它需要等待所有读操作完成后才能获取锁进行写操作 。例如，在一个文件系统中，如果有众多用户同时读取文件（读操作），此时系统管理员想要更新文件的某些权限信息（写操作），可能会因为读操作的持续进行而长时间无法执行，影响系统的管理和维护 。

但 Seqlock 不同，它允许写操作在有读操作进行时也能立即开始 。写者在获取自旋锁后就可以进行写操作，无需等待读者完成读操作 。这就像是在一个交通枢纽，虽然有很多车辆在正常行驶（读操作），但紧急救援车辆（写操作）可以凭借特殊权限优先通过 。写操作的优先级提高，使得写操作能够及时完成，避免了写操作被读操作长时间阻塞的情况，提高了系统在写操作频繁场景下的效率 。在一个日志记录系统中，日志数据需要不断更新（写操作），同时也可能会被其他模块读取用于分析，使用 Seqlock 能让日志更新操作及时进行，保证日志数据的实时性和准确性 。

三、Seqlock 与其他同步机制的比较

面试题写作模版

3.1 Seqlock 与自旋锁对比

在 Linux 内核的同步机制中，自旋锁是一种基础且重要的同步原语，它与 seqlock 顺序锁在很多方面都存在着差异 。

从使用场景来看，自旋锁适用于临界区非常短的情况 。这是因为自旋锁在获取不到锁时，线程会进入忙等待状态，不断地循环检查锁的状态，直到获取到锁为止 。这种忙等待的方式会消耗 CPU 资源，如果临界区长时间占用锁，那么其他等待获取锁的线程就会一直自旋，浪费大量的 CPU 时间 。而 seqlock 顺序锁则更适合读操作频繁且读操作时间较短、写操作较少的场景 。在这种场景下，seqlock 顺序锁允许读操作在写操作进行时也能继续进行，大大提高了系统的并发性能 。例如，在一个监控系统中，需要频繁读取传感器的实时数据（读操作），而偶尔才会对传感器的配置进行修改（写操作），这种情况下，使用 seqlock 顺序锁就比自旋锁更合适 。

在性能方面，自旋锁在锁竞争不激烈且临界区很短时，由于避免了线程上下文切换的开销，性能表现较好 。但是，当锁竞争激烈时，自旋锁的忙等待会导致 CPU 使用率急剧上升，性能大幅下降 。而 seqlock 顺序锁在读多写少的场景下，读操作几乎没有锁开销，性能优势明显 。不过，如果写操作过于频繁，seqlock 顺序锁的读操作可能需要多次重试，这也会对性能产生一定的影响 。比如，在一个高并发的数据库查询系统中，如果使用自旋锁来保护共享数据，当大量线程同时请求查询时，锁竞争会非常激烈，导致 CPU 资源被大量消耗；而使用 seqlock 顺序锁，由于读操作不受写操作的阻塞，能够快速地返回查询结果，大大提高了系统的响应速度 。

适用条件上，自旋锁要求临界区代码执行时间短，并且不能包含可能导致睡眠的操作，否则会导致死锁 。而 seqlock 顺序锁要求被保护的共享数据结构不能包含指针，因为写操作可能会使指针失效，而读操作在不知情的情况下访问失效指针会导致程序崩溃 。例如，在一个简单的计数器共享资源中，如果使用自旋锁，只要计数器的更新操作非常快，自旋锁就能很好地工作；但如果使用 seqlock 顺序锁，就需要确保计数器的相关数据结构中不包含指针 。

3.2 Seqlock 与读写锁对比

读写锁也是一种常用的同步机制，它与 seqlock 顺序锁在读写并发控制、写操作优先级、实现复杂度等方面有着不同的特点 。

在读写并发控制上，读写锁允许多个读操作同时进行，但当有写操作时，读操作和其他写操作都会被阻塞，直到写操作完成 。而 seqlock 顺序锁则更加灵活，它允许读操作在写操作进行时继续进行，只要读操作在读取数据前后检查顺序号没有变化，就可以认为读取的数据是有效的 。

这就使得 seqlock 顺序锁在读写并发性能上更有优势 。例如，在一个文件系统的缓存机制中，大量的读操作需要频繁读取缓存中的文件数据，而偶尔会有写操作更新缓存 。如果使用读写锁，当有写操作时，所有的读操作都要等待，这会降低系统的响应速度；而使用 seqlock 顺序锁，读操作可以在写操作进行时继续进行，提高了系统的并发性能 。

写操作优先级方面，读写锁中读锁和写锁的优先级是相同的，写操作需要等待所有读操作完成后才能进行 。而 seqlock 顺序锁中写操作具有更高的优先级，写操作可以在有读操作进行时立即执行，读操作可能需要多次重试才能获取到正确的数据 。这种写操作优先级的差异，使得 seqlock 顺序锁更适合那些对写操作及时性要求较高的场景 。比如，在一个实时数据采集系统中，新的数据不断写入（写操作），同时也有其他模块需要读取这些数据（读操作），使用 seqlock 顺序锁可以保证新数据能够及时写入，而读操作即使需要重试，也不会影响写操作的及时性 。

实现复杂度上，读写锁的实现相对简单，它主要通过对读锁和写锁的状态进行管理来实现读写并发控制 。而 seqlock 顺序锁的实现则相对复杂一些，它需要引入顺序号来检测读写冲突，并且在写操作时还需要结合自旋锁来保证写操作的原子性 。这种实现复杂度的差异，也会影响到开发者在选择同步机制时的决策 。如果系统对性能要求极高，且读写场景符合 seqlock 顺序锁的适用条件，那么即使其实现复杂度较高，也可能会选择使用它；而如果系统对性能要求不是特别高，且读写场景相对简单，那么读写锁可能是更好的选择 。

四、Seqlock 顺序锁的应用场景

4.1 内核中的应用

在 Linux 内核这个庞大而复杂的系统中，seqlock 顺序锁就像是一位默默守护的 “幕后英雄”，在许多关键场景中发挥着重要作用 。

系统时间的维护是操作系统的一项基础而重要的任务。系统时间就像是整个系统的 “时钟”，它的准确性和及时性对于许多系统功能的正常运行至关重要 。在 Linux 内核中，xtime 变量用于记录系统的当前时间 。由于系统时间会被频繁读取，以提供给各种系统调用和内核函数使用，同时也会被周期性地更新，所以这个场景非常适合使用 seqlock 顺序锁 。

当内核中的某个线程需要读取系统时间时，它可以通过 read_seqbegin 函数获取当前的顺序号，然后读取 xtime 变量的值 。在读取完成后，再通过 read_seqretry 函数检查顺序号是否发生变化 。如果顺序号没有变化，说明在读取期间系统时间没有被更新，读取的结果是准确的；如果顺序号发生了变化，那就意味着系统时间在读取过程中被更新了，线程需要重新读取 。而当有线程需要更新系统时间时，它会先调用 write_seqlock 函数获取顺序锁，然后更新 xtime 变量的值，最后调用 write_sequnlock 函数释放顺序锁 。通过这种方式，seqlock 顺序锁保证了系统时间在高并发读写情况下的一致性和准确性 。

性能计数器的更新也是内核中的一个常见场景。性能计数器就像是系统的 “健康监测仪”，它用于记录系统的各种性能指标，如 CPU 使用率、内存使用率、磁盘 I/O 速率等 。这些性能指标对于系统的性能分析和调优非常重要 。由于性能计数器会被频繁读取，以提供给系统管理员和性能分析工具使用，同时也会被内核中的各种模块周期性地更新，所以这个场景也非常适合使用 seqlock 顺序锁 。

例如，在统计 CPU 使用率时，内核中的某个模块会定期读取 CPU 的时间戳和其他相关信息，然后计算出 CPU 的使用率 。在这个过程中，为了保证读取的数据的一致性，就可以使用 seqlock 顺序锁 。当读取模块需要读取相关数据时，它会先获取顺序号，然后读取数据，最后检查顺序号是否变化 。而当更新模块需要更新数据时，它会先获取顺序锁，然后更新数据，最后释放顺序锁 。这样，seqlock 顺序锁就有效地保证了性能计数器在高并发读写情况下的准确性和可靠性 。

4.2 用户态应用

在用户态多线程编程的世界里，seqlock 顺序锁同样有着广阔的应用前景，它就像是一把神奇的 “钥匙”，能够帮助开发者解决许多并发控制的难题 。

假设我们正在开发一个实时数据分析系统，这个系统需要处理大量的传感器数据 。在这个系统中，有多个线程负责从不同的传感器读取数据（读操作），同时还有一个线程负责对这些数据进行汇总和分析（写操作） 。为了保证数据的一致性和完整性，我们可以使用 seqlock 顺序锁来实现高效的并发控制 。

下面是一个简单的 C++ 代码示例，展示了如何在用户态程序中使用 seqlock 顺序锁：

#include <iostream>#include <thread>#include <atomic>#include <chrono>#include <vector>// 定义 seqlock 结构体struct Seqlock {    std::atomic<unsigned> sequence;    std::atomic<bool> lock;    Seqlock() : sequence(0), lock(false) {}voidwrite_lock(){while (lock.exchange(true)) {// 自旋等待，直到获取锁        }        sequence++;    }voidwrite_unlock(){        sequence++;        lock.store(false);    }unsigned read_begin(){        unsigned seq;do {            seq = sequence.load();        } while (seq & 1); // 如果 sequence 为奇数，说明有写操作正在进行，继续循环return seq;    }bool read_retry(unsigned seq){return (seq & 1) || (seq != sequence.load());    }};// 共享数据结构struct SensorData {int value;};Seqlock seqlock;SensorData shared_data = {0};// 读线程函数voidread_thread(){while (true) {        unsigned seq = seqlock.read_begin();int data = shared_data.value;if (!seqlock.read_retry(seq)) {            std::cout << "Read data: " << data << std::endl;        }        std::this_thread::sleep_for(std::chrono::milliseconds(100));    }}// 写线程函数voidwrite_thread(){while (true) {        seqlock.write_lock();        shared_data.value++;        std::cout << "Write data: " << shared_data.value << std::endl;        seqlock.write_unlock();        std::this_thread::sleep_for(std::chrono::seconds(1));    }}intmain(){    std::vector<std::thread> read_threads;for (int i = 0; i < 5; ++i) {        read_threads.emplace_back(read_thread);    }    std::thread write_thread_obj(write_thread);for (auto& thread : read_threads) {        thread.join();    }    write_thread_obj.join();return0;}

在这个示例中，我们定义了一个 Seqlock 结构体，它包含一个 sequence 变量和一个 lock 变量，用于实现 seqlock 顺序锁的功能 。write_lock 函数用于获取写锁，它会先尝试获取自旋锁，如果获取成功，则将 sequence 变量加 1；write_unlock 函数用于释放写锁，它会将 sequence 变量再加 1，并释放自旋锁 。read_begin 函数用于获取读操作的起始顺序号，它会循环检查 sequence 变量的值，直到其为偶数，表示没有写操作正在进行；read_retry 函数用于检查读操作是否需要重试，它会检查 sequence 变量的值是否为奇数或者是否与起始顺序号不同 。

在 main 函数中，我们创建了 5 个读线程和 1 个写线程 。读线程会不断读取共享数据，并在读取完成后检查是否需要重试；写线程会每隔 1 秒对共享数据进行一次更新 。通过这种方式，seqlock 顺序锁有效地保证了多线程环境下数据的一致性和并发性能 。

五、Linux 内核中的应用实例

面试题写作模版

在 Linux 内核的时间管理模块中，jiffies_64 变量记录了系统启动以来的时钟滴答数，对系统的时间相关操作至关重要 。为了保证在高并发环境下对 jiffies_64 变量的安全访问，Linux 内核采用了顺序锁机制。以下是相关的代码片段：

// 定义顺序锁static seqlock_t jiffies_lock = __SEQLOCK_UNLOCKED(jiffies_lock);// 写操作：更新 jiffies_64 变量voidtick_do_update_jiffies64(void){    write_seqlock(&jiffies_lock);// 更新 jiffies_64 的具体操作    jiffies_64++;    write_sequnlock(&jiffies_lock);}// 读操作：读取 jiffies_64 变量u64 get_jiffies_64(void){    unsigned int seq;    u64 ret;do {        seq = read_seqbegin(&jiffies_lock);        ret = jiffies_64;    } while (read_seqretry(&jiffies_lock, seq));return ret;}

在上述代码中，当需要更新 jiffies_64 变量时，会调用 tick_do_update_jiffies64 函数，该函数首先通过 write_seqlock 获取顺序锁，确保在更新过程中不会有其他写操作干扰，更新完成后再通过 write_sequnlock 释放锁 。而在读取 jiffies_64 变量时，get_jiffies_64 函数会先调用 read_seqbegin 获取当前的顺序号，然后读取 jiffies_64 的值，最后通过 read_seqretry 检查顺序号是否发生变化，以确定读取的数据是否有效。通过这种方式，顺序锁有效地保护了 jiffies_64 变量在高并发环境下的读写操作，确保了系统时间管理的准确性和稳定性 。