Web Locks API 实战:用 navigator.locks 解决多标签页资源竞争(排他锁与共享锁)

#WebLocksAPI实战:用navigator.locks解决多标签页资源竞争(排他锁与共享锁)去年做一个在线配置台,我被一个bug折磨了整整两天。现象特别玄学:用户在A标签页改完一项配置,切到B标签页又改了…

Web Locks API 实战:用 navigator.locks 解决多标签页资源竞争(排他锁与共享锁)

去年做一个在线配置台,我被一个 bug 折磨了整整两天。现象特别玄学:用户在 A 标签页改完一项配置,切到 B 标签页又改了另一项,两边前后脚点保存,最后 localStorage 里只剩下后点那边的旧快照。用户反馈的原话是"我明明改了,一刷新就回去了"。我第一反应是接口写错了,把 Network 面板翻了个底朝天,后端日志干干净净——请求确实发了两次,问题出在两个标签页各自拿着一份过期数据互相覆盖。

那时候我用的是最土的办法:BroadcastChannel 广播加 localStorage 时间戳,谁的时间戳新谁赢。跑起来好像没事,直到测试同学开了五个标签页同时点保存,页面直接表演了一段电子斗殴。我盯着控制台里那一堆乱序消息,第一次意识到:跨标签页的临界区管理,靠"打补丁式"的消息通知根本兜不住。后来翻 MDN 文档 才看到 Web Locks API——一个早在 2021 年前后就被主流浏览器原生支持的 W3C 标准,我居然一直以为它还关在实验室里。下面就把我踩过的坑和它的正确打开方式完整捋一遍。

一、先把"锁"这件事说人话

锁不是前端的发明,它是操作系统和数据库里的老概念。多个线程同时访问同一份资源时,如果没有任何约束,最后写进去的值取决于谁跑得快——这就是典型的数据竞争。锁的作用就是给这段临界区立个规矩:同一时刻只允许符合条件的一方进去。

锁有两种基本形态,理解它们是用好 navigator.locks 的前提:

  • 排他锁(Exclusive Lock):也叫互斥锁。同一时间,整个同源范围内有且只有一个持有者,其他申请同名锁的请求统统排队。写入、删除、状态变更这类操作必须用它。
  • 共享锁(Shared Lock):允许多个持有者同时进入,但排他锁申请者必须等所有共享锁释放。读取类操作用它,并发性能会好很多。

这里有个容易被忽略的点:Web Locks API 里的"资源"是一个抽象名字,不是某个具体的 DOM 节点或存储对象。你调用 navigator.locks.request('config_write', ...),其中的config_write 仅仅是一个字符串标识,它背后代表什么由你自己定义——可以是一份 localStorage 数据、一个 IndexedDB 仓库,甚至是一段只允许单页执行的业务逻辑。浏览器只负责按名字调度,名字之外的语义完全交给开发者。

我当年就是没转过这个弯,以为传个 key 浏览器就会自动帮我锁住 localStorage,结果锁了个寂寞。名字一致才互斥,名字写错就等于没锁,这类 bug 还特别难查。

有人会问:浏览器里不是早就有 BroadcastChannel、postMessage、localStorage 事件、unload 钩子甚至 SharedWorker 了吗,为什么还要专门造一把锁?我的答案是:这些手段都能做"通知",但没有一个能原生保证"同一时刻只有一个人进临界区"。BroadcastChannel 只管把消息发出去,不管对面收到时你的写操作是否已经结束;localStorage 事件在同源页面间有触发延迟,而且写入本身不是原子的;unload 钩子在移动端和异常关闭场景下更是靠不住。我曾用 postMessage 手写过一套"请求-应答-释放"的协议,代码写了两百多行,最后还是被页面崩溃时的僵尸锁教做人。Web Locks API 的价值就在于把这套协议下沉到浏览器内核,用标准接口替代各家自造的轮子。对复杂应用来说,少一段自造的同步协议,就少一 class 只能在凌晨两点的生产环境里复现的诡异 bug。

二、Web Locks API 到底提供了什么

它把操作系统那套锁机制搬到了浏览器里,核心入口就是navigator.locks,也就是规范里的LockManager 对象。这套 API 的执行流程可以拆成四步:

  1. 脚本向锁管理器申请一把具名锁(named lock);
  2. 申请成功后,在异步回调里完成临界区工作;
  3. 回调结束(resolve 或 reject),锁由浏览器自动释放;
  4. 队列中下一个申请者获得锁。

第三步是整个 API 最省心也最容易被低估的设计。传统锁要手动 unlock,一旦中间抛异常或者开发者忘了写释放,就是一场死锁事故。Web Locks 把锁的生命周期和 Promise 绑死,回调退出即释放,原子级完成,不用你操心 try/finally。我第一次读到这句规范描述时,感觉像是有人替我把最容易写错的那几行代码直接删掉了。

先看一个最基础的申请模板,我按自己的习惯重写并加了注释:

javascript
复制
// 特性检测:不是所有浏览器环境都有 navigator.locks(如部分 WebView)if (!navigator.locks) { console.warn('当前环境不支持 Web Locks API,需要走降级方案');}async function safeSave(payload) { try { // request 返回 Promise;回调执行完,锁自动释放,无需手动 unlock const result = await navigator.locks.request( 'config_write_lock', // 资源名:同源下同名锁才会互相排队 async (lock) => { // lock 对象含 name / mode 两个只读属性 console.log('拿到锁了:', lock.name, lock.mode); await writeToStorage(payload); // 临界区:真正需要串行化的操作 return 'saved'; // 返回值会沿 Promise 传给外层 } ); console.log('本次保存结果:', result); } catch (err) { // 队列等待期间被 AbortSignal 中断时会在这里捕获 AbortError console.error('保存失败:', err); }}

这段代码里有两个细节值得强调。第一,request()的第一个参数必须是字符串资源名;最后一个参数是回调,建议写成async,这样临界区里的异步操作会被正确等待。第二,中间的第二个参数是可选配置对象,后面讲到的mode、signal、ifAvailable、steal全都塞在这里。回调的返回值会顺着request() 返回的 Promise 传出来,这一点在做"抢到锁后把最新数据带回去"时特别好用。

三、作用域:为什么我的锁好像没锁住

我踩过的第二个坑跟作用域有关,而且特别隐蔽。当时我在localhost:5173开了一个标签页,又在127.0.0.1:5173 开了一个,代码里都写了同一把锁,结果两边照常并发覆盖数据。我一度怀疑浏览器实现有 bug,后来才明白:锁的作用域是同源(scheme + host + port),localhost 和 127.0.0.1 根本不是同一个源,两把锁分属不同的锁管理器,互不干涉。

规范里对作用域还有几条更细的规定,排查问题时很容易栽跟头:

  • 来自example.com的锁,对来自example.org的锁没有任何影响,不同源各管各的;
  • 浏览器里的单个用户配置被视为独立的用户代理,作用域之外。同一台机器上两个不同 Chrome 用户配置,即便访问同源页面,也不共享锁管理器;
  • 隐身 / 无痕模式的会话被当作独立用户代理,同样在作用域之外。想靠"只允许一个标签页"来防重复操作,用户开个无痕窗口就绕过去了;
  • 同源且同一上下文里的脚本(比如同一个页面里的两个函数)共享锁管理器;
  • 同一个用户代理下、同源的页面与各类 Worker(Web Worker、SharedWorker、Service Worker)共享锁管理器,哪怕它们之间没有直接关联。

换句话说,只要处在同一个锁管理器里,同名锁就会乖乖排队;不在同一个管理器里,各自为政。我把这个规则记成一句话:锁管的是"同源同环境",不是"同一台电脑"。想清楚这一点,能省掉大半天的无效调试。

四、排他锁与共享锁:读写分离才是性能关键

如果所有操作都无脑用默认模式,功能上没错,但性能上等于把并发读也串成了一条队。我做过一个多标签页的配置预览面板,三个标签页同时读同一份配置,本来可以并行,结果因为用了排他锁,硬生生排队等了三次网络往返。

正确姿势是读写分离:mode: 'shared'用于读取,mode: 'exclusive'(默认值)用于写入。兼容性矩阵如下:

  • 持有排他锁时,同名的排他锁和共享锁都必须排队;
  • 持有共享锁时,同名的其他共享锁可以并行进入;
  • 持有共享锁时,同名的排他锁必须等所有共享锁释放。

这就是经典的读写锁模型。下面是我按这个思路重写的读写分离代码,注释里标了每一步的意图:

javascript
复制
const RESOURCE = 'app_settings';// 读操作:shared 模式,多个标签页可同时进入,互不等待async function readSettings() { return navigator.locks.request(RESOURCE, { mode: 'shared' }, async () => { const raw = localStorage.getItem(RESOURCE); return raw ? JSON.parse(raw) : {}; });}// 写操作:exclusive 模式,同一时刻全场只有一个写入者async function updateSettings(patch) { return navigator.locks.request(RESOURCE, { mode: 'exclusive' }, async () => { // 关键:拿到锁之后要重新读一次,避免覆盖排队期间别人写的结果 const current = JSON.parse(localStorage.getItem(RESOURCE) || '{}'); const next = { ...current, ...patch }; localStorage.setItem(RESOURCE, JSON.stringify(next)); return next; });}

注意写操作里那个"拿锁后重新读一次"的动作,这是我踩坑之后加上的。很多并发覆盖问题不是锁没生效,而是你在加锁之前就取好了旧值,进临界区后拿着旧值写回去。锁只保证串行,不负责帮你刷新数据快照。

顺带说一句,前端里"把规则定清楚、让各层按规则协作"的思路并不新鲜。你看CSS @layer 级联层实战:用层级掌控样式优先级(告别 !important 与权重战争)那套做法,也是用明确的层级代替到处打补丁的权重斗争——锁的命名与模式设计,本质上同样是先定规则再写代码。

五、ifAvailable:不想排队,就别傻等

有些场景你根本不能等。比如页面初始化时要不要抢一个"主标签页"的身份去建立 SSE 长连接,抢不到就让别的标签页去做,自己别卡在那儿。这时候 ifAvailable: true就派上用场了:它表示只有当锁不需要排队时才授予,否则回调收到的lock参数是null。

这里有个反直觉的细节,我第一次写就写错了:ifAvailable不会让request()同步返回false,它依然会调用你的回调,只是把null塞进去,由你自己判断。所以判断逻辑必须写在回调内部。

javascript
复制
async function tryBeLeader(onBecomeLeader) { let acquired = false; await navigator.locks.request( 'sse_leader_lock', { ifAvailable: true }, // 不排队:能拿就拿,拿不到立即回调 null async (lock) => { if (!lock) { // 锁已被别的标签页占用,安静退出,不做任何事 return; } acquired = true; onBecomeLeader(); // 只有真正的 leader 才建立连接 // 这里刻意不结束回调:保持锁,直到页面关闭才由浏览器释放 await new Promise((resolve) => { window.addEventListener('pagehide', resolve, { once: true }); }); } ); return acquired;}

我把这段逻辑用在了 SSE 连接上:只有抢到锁的标签页建立连接,其他标签页通过 BroadcastChannel 接收它广播的消息。用户关掉主标签页时锁自动释放,排队中的下一个标签页立刻上位。整套切换过程没有任何服务端参与,比我自己写的心跳选举干净太多。类似"多个上下文抢一个独占资源"的需求,在 File System Access API 实战:让网页直接读写本地文件(showOpenFilePicker 与 createWritable)里也会遇到——网页拿到本地文件句柄后,如果不加协调,两个标签页同时写入同一个文件照样会互相覆盖。

六、signal 与超时:排队不能没有尽头

死锁和长时间挂起是锁不可避免的副作用。最典型的场景:某个标签页在临界区里发起一个没有超时设置的 fetch,服务端卡住了,锁就一直不释放,后面所有标签页集体陪葬。我在生产环境见过一次,用户投诉"页面点了没反应",最后发现是队列里排了十几把锁,罪魁祸首是一个忘加超时的接口。

从原理上说,死锁指的是参与各方都在等待对方释放资源,谁也无法继续推进。锁本身没有错,错的是使用锁的方式。我的经验是遵循三条朴素规则:第一,避免嵌套锁,一个临界区里再去申请另一把锁,是死锁最爱待的地方;第二,固定加锁顺序,如果确实要拿多把锁,所有代码路径都按同样的顺序申请,别这里先 A 后 B、那里先 B 后 A;第三,给等待设上限,也就是马上要讲的 signal。规范文档里也把"精心设计的 API 结构"列为预防死锁的根本手段——说穿了就是别把自己绕进环里。

给锁请求加超时是最直接的防御手段。signal参数接收一个AbortSignal,队列中等待的请求被中止后会抛出AbortError:

javascript
复制
async function requestWithTimeout() { const controller = new AbortController(); // 最多等 500ms,超时后中止排队中的锁请求 const timer = setTimeout(() => controller.abort(), 500); try { await navigator.locks.request( 'resource_with_timeout', { signal: controller.signal }, async () => { await doSomethingQuick(); // 临界区逻辑 } ); } catch (err) { // 超时触发时为 DOMException,name 为 'AbortError' if (err.name === 'AbortError') { console.warn('等锁超时了,本次操作放弃'); } else { throw err; } } finally { clearTimeout(timer); // 别忘了清掉定时器 }}// 现代浏览器也可以直接用静态 timeout,代码更短async function requestWithTimeout2() { try { await navigator.locks.request( 'resource_with_timeout', { signal: AbortSignal.timeout(500) }, // 500ms 后自动 abort async () => { await doSomethingQuick(); } ); } catch (err) { console.warn('抢锁失败:', err.name); }}

这里再吐槽一句:AbortSignal 的行为在不同版本浏览器里经历过调整,早期版本"锁已经拿到之后 signal 才 abort"并不会中断回调。所以超时是排队阶段的保险,不是临界区的看门狗。真要限制临界区执行时间,得给里面的每个异步操作单独设超时。别指望一个 signal 解决所有问题,我在这上面栽过跟头。

七、steal:应急通道,千万别当常规武器

规范还提供了一个霸道参数steal: true。它的语义是:不管当前锁被谁持有、队列里排了多少请求,直接把现有锁释放,并把锁授予这次请求。

javascript
复制
async function emergencyTakeover() { // 应急抢占:仅在确认原持有者已经"僵死"时使用 await navigator.locks.request( 'stuck_resource_lock', { steal: true }, // 抢占同名锁,插到队首 async () => { await recoverDirtyState(); // 清理被卡住的流程遗留的脏数据 } );}

听起来很解气,但它的代价必须说清楚:原来持有锁的那段代码并不会被强制终止,它会继续跑。也就是说,抢占之后可能出现两段代码同时在操作同一份资源的局面,正好违背了我们用锁的初衷。我在排查一个"数据偶发错乱"的问题时才发现,同事在业务代码里常态化使用 steal,导致临界区里出现了两个写入者,那场面比不用锁还热闹。

所以我的建议是:steal 只留给你确信原持有者已经失去响应、且你能自行处理脏数据的极端场景,比如页面崩溃恢复后的自救流程。日常业务里,老老实实排队或者通过 signal超时退出才是正解。关于这个参数,社区从规范制定阶段就有激烈讨论,可以看看WICG 的 steal 讨论帖了解来龙去脉。

八、query:把锁管理器的黑盒子打开

锁是隐藏状态,出问题时最难的是"根本看不见"。navigator.locks.query()返回锁管理器在当前瞬间的状态快照,包含held(已持有)和pending(等待中)两个数组,每一项都有资源名、模式以及发起请求的clientId。

javascript
复制
async function dumpLockState() { const state = await navigator.locks.query(); console.table(state.held); // 当前谁拿着锁:name / mode / clientId console.table(state.pending); // 谁还在排队 // 排查示例:统计同名锁的等待数量 const counts = state.pending.reduce((acc, item) => { acc[item.name] = (acc[item.name] || 0) + 1; return acc; }, {}); console.log('各资源的等待队列长度:', counts);}

有一次线上出现大面积卡顿,我就是靠query() 看到某个锁的 pending 队列里排了二十多个请求,顺藤摸瓜找到了那个忘记释放的临界区。不过要记住:这是快照,不是实时订阅。规范明确警告不要拿它做业务判断——你看到锁空闲的下一毫秒,它可能就被别的标签页抢走了。它只适合调试和观测,不适合当业务逻辑的分支依据。

九、落到真实工程里的几个用法

把 API 会用了,还得知道什么时候该掏出来。我目前用得最多的有三类场景。

第一类是Token 刷新去重。多个标签页同时发现 token 过期,如果各自去调刷新接口,后到的 refresh token 可能已经失效,直接把用户踢下线。正确做法是把刷新逻辑包进一把排他锁,进锁后二次校验 token 是否已被别的标签页刷新,是的话直接复用。这类"后端协作式调度"的思路,和 PHP 8.1 Fibers 纤程实战:用原生协程实现协作式多任务(Fiber 与调度器)里讲的协作式多任务有异曲同工之妙:关键不是在代码里硬排队,而是让调度权回到一个明确的规则手里。

第二类是共享数据的读写协调。比如一个语音笔记应用,多个标签页都要读同一份转写结果,同时只允许一个标签页调用识别服务。读走 shared 锁,写走 exclusive 锁,识别服务那一侧配一把 ifAvailable 的主标签页锁——正好能和 Web Speech API 实战:用浏览器原生能力做语音识别与语音合成(SpeechRecognition 与 speechSynthesis)组合起来用。

第三类是临界区的职责边界。锁解决的是"同一时刻谁能进",不解决"进来之后做什么"。我习惯把临界区压到最小:只做读-改-写那一小段,网络请求、复杂计算尽量挪到锁外。锁粒度太大,并发就退化成串行;粒度太小,又要防止读到脏快照。这个平衡没有标准答案,只能结合业务压测出来。

还有一类容易忽略的场景是多 Worker 协作。主线程把大块计算扔给几个 Web Worker,几个 Worker 又要把结果写回同一个 IndexedDB 仓库。很多人以为 Worker 之间天然隔离就不会打架,其实只要它们同源于同一个用户代理,就共享同一个锁管理器,照样会互相覆盖。我的做法是在每个 Worker 的写回入口统一包一层同名的排他锁,让调度规则集中在一处定义,而不是散落在每个 Worker 的代码里。顺带提醒:从 Worker 里调用 navigator.locks 的方式和主线程完全一样,不需要额外的通信桥接,这也是这套 API 比 SharedWorker 方案省心的原因。集中定义规则、分散执行,这个思路在任何并发系统里都成立。

十、兼容性与降级:别指望它 everywhere

Web Locks API 的兼容性曾经是它最大的短板,虽然现在主流现代浏览器基本都支持了,但一些定制化 WebView、内嵌浏览器环境仍然缺席。上线前建议先查一下 caniuse 的支持情况,并准备降级路径。社区曾经有过 polyfill,但后来被移除了,原因是这类跨上下文锁很难在不依赖浏览器内核调度的前提下正确模拟——这一点我很理解,毕竟靠 localStorage 轮询模拟出来的"锁",竞态窗口还是摆在那儿。

我的降级策略分三档:

  1. 有navigator.locks就用原生实现,这是最优路径;
  2. 没有锁但支持 IndexedDB,把写操作塞进 readwrite 事务,借用事务的排他性兜底;
  3. 兜底到 BroadcastChannel 加 localStorage 时间戳,接受它不完美,但至少比裸奔强。

顺带提一句,配套的规范文档在WICG Web Locks Explainer,想理解设计动机和边界情况,比看二手教程靠谱得多。

小结

回头看,Web Locks API 最打动我的不是它多新奇,而是它把一件本来很容易写错的事——跨标签页、跨 Worker 的临界区管理——变成了一个标准、可观测、且由浏览器内核保证正确性的能力。几点实战心得收个尾:

  • 同名才互斥:资源名是抽象标识,命名要统一,拼错等于没锁;
  • 读写要分离:读用shared,写用exclusive,别让只读操作陪着排队;
  • 进锁再取值:拿锁后重新读取数据快照,避免拿旧值覆盖新值;
  • 排队要有上限:用signal加超时,别让一个卡死的标签页拖垮全场;
  • steal 是保险丝:只用于恢复场景,常态使用等于自找数据错乱;
  • query 只做观测:它是瞬时快照,不能当业务判断依据。

如果你也在维护一个会被用户开一堆标签页的应用,别再用时间戳和广播去硬扛并发覆盖了。把临界区找出来,用navigator.locks包一层,很多时候十几行代码就能解决一个折磨你两天的问题——别问我怎么知道的。

标签:javascript, 前端, html5描述:基于真实踩坑经历讲透 navigator.locks 的排他锁与共享锁、作用域、ifAvailable、signal 超时、steal 抢占与 query 调试,附可运行代码与降级方案,帮你用浏览器原生能力解决多标签页与 Worker 的资源竞争。

6m0adrmkfe6m0adrmkfe
评论

评论列表共有0条评论

发表评论发布评论后审核成功,即可显示在列表中...

文章4
粉丝0
获赞0
私信