Web 锁 API

1. 介绍

本节是非规范性的。

脚本对特定的锁请求发起操作，请求特定的资源名称和模式。调度算法查看当前和之前请求的状态，最终授予锁请求。锁是一个已授予的请求；它有一个资源名称和模式。它作为一个返回给脚本的对象表示。只要锁被持有，它可能阻止其他锁请求被授予（取决于名称和模式）。脚本可以释放锁，此时它可能允许其他锁请求被授予。

该 API 提供了一些可按需使用的可选功能，包括：

从异步任务中返回值，
共享和独占锁模式，
条件获取，
查询锁状态的诊断功能，
防止死锁的应急措施。

合作协调在共享代理的存储桶的范围内进行；这可能跨越多个代理集群。

1.1. 使用概述

该 API 的使用步骤如下：

请求锁。
在异步任务中持有锁时执行工作。
任务完成时自动释放锁。

以下是 API 使用的基本示例：

navigator.locks.request('my_resource', async lock => {
   // 锁已获取。
   await do_something();
   await do_something_else();
   // 锁现在将被释放。
});

在异步函数中，请求本身可以使用 await 等待：

// 在请求锁之前。
await navigator.locks.request('my_resource', async lock => {
   // 锁已获取。
   await do_something();
   // 锁现在将被释放。
});
// 在锁被释放之后

1.2. 动机和使用案例

基于 Web 的文档编辑器将状态存储在内存中以便快速访问，并将更改（作为一系列记录）持久化到存储 API，例如 Indexed Database API，以提高弹性和离线使用能力，同时同步到服务器以支持跨设备使用。当同一文档在两个标签页中打开进行编辑时，必须在这些标签页之间进行协调，例如确保一次只能有一个标签页对文档进行修改或同步。需要在活动标签页离开（导航、关闭、崩溃）时使其他标签页可以变为活动状态。

在数据同步服务中，会指定一个“主标签页”。这个标签页是唯一执行某些操作的页面（例如网络同步、清理排队数据等）。它持有一个锁并且从不释放。其他标签页可以尝试获取该锁，所有尝试将排队进行。如果“主标签页”崩溃或关闭，则其他标签页中的一个将获得该锁并成为新的主标签页。

Indexed Database API 定义了一个事务模型，允许在原点内的多个命名存储分区之间进行共享读取和独占写入访问。将此概念作为一个原语公开，可以基于资源的可用性调度任何 Web 平台活动，例如允许为其他存储类型（例如 Caches [Service-Workers]）、跨存储类型，甚至跨非存储 API（例如网络获取）组合事务。

2. 概念

本规范的目的如下：

浏览器中的不同用户配置文件被视为不同的用户代理。
每个隐私模式浏览会话被视为一个单独的用户代理。

一个用户代理具有一个锁任务队列，它是启动新的并行队列的结果。

任务来源对于下面排队的步骤是Web 锁任务来源。

2.1. 资源名称

资源名称是由 web 应用程序选择的表示抽象资源的 JavaScript 字符串。

资源名称在调度算法之外没有外部含义，但在共享代理的存储桶中是全局的。 Web 应用程序可以自由使用任何资源命名方案。

要在命名数据库中模拟对命名存储的事务锁定，可以这样写脚本，组合资源名称：

encodeURIComponent(db_name) + '/' + encodeURIComponent(store_name)

以 U+002D HYPHEN-MINUS（-）开头的资源名称是保留的；请求这些资源名称将引发异常。

2.2. 锁管理器

锁管理器封装了锁和锁请求的状态。每个存储桶都通过与 Web 锁 API 相关联的存储瓶包含一个锁管理器。

注意：页面和 worker（代理）共享一个存储桶，即使它们处于不相关的浏览上下文中，但它们仍共享同一个锁管理器。

要获取一个锁管理器，给定一个环境设置对象 environment，运行以下步骤：

令map为通过environment和"web-locks"获取本地存储瓶映射的结果。
如果map为失败，则返回失败。
令bottle为map相关联的存储瓶。
返回bottle的相关联锁管理器。

这里需要完善与 [存储]的集成，包括如何从给定环境中正确获取锁管理器。

2.3. 模式和调度

模式可以是 "exclusive" 或 "shared"。模式可以用于模拟常见的读写锁模式。如果持有 "exclusive" 锁，则无法授予该名称的其他锁。如果持有 "shared" 锁，则可以授予其他具有相同名称的 "shared" 锁，但不能授予任何 "exclusive" 锁。 API 中的默认模式是 "exclusive"。

其他属性可能会影响调度，例如超时、公平性等。

2.4. 锁

锁表示对共享资源的独占访问。

一个锁具有一个代理，它是一个代理。

一个锁具有一个clientId，它是一个不透明的字符串。

一个锁具有一个管理器，它是一个锁管理器。

一个锁具有一个名称，它是一个资源名称。

一个锁具有一个模式，它是"exclusive" 或 "shared"中的一个。

一个锁具有一个等待的 promise，它是一个 Promise。

一个锁具有一个释放的 promise，它是一个 Promise。

锁的生命周期中有两个相关的 Promise：

由回调函数在锁被授予时隐式或显式提供的 Promise，用于确定锁持有的时间。当这个 Promise 完成时，锁被释放。这被称为锁的等待的 promise。
由LockManager的 request()方法返回的 Promise，它在锁被释放或请求被中止时完成。这被称为锁的释放的 promise。

const p1 = navigator.locks.request('resource', lock => {
  const p2 = new Promise(r => {
    // 使用锁的逻辑并解决 promise...
  });
  return p2;
});

在上面的示例中，p1 是释放的 promise，而p2 是等待的 promise。请注意，大多数代码中的回调函数会实现为async函数，返回的 Promise 是隐式的，如下例所示：

const p1 = navigator.locks.request('resource', async lock => {
  // 使用锁的逻辑...
});

在上述代码中，等待的 promise未命名，但仍然作为匿名async回调的返回值存在。进一步注意，如果回调函数不是async，并返回一个非 promise，返回值将被包装在一个立即解决的 Promise 中；锁将在接下来的微任务中释放，而释放的 promise也将在后续的微任务中解决。

每个锁管理器具有一个持有的锁集合，它是锁的有序集合。

当锁 lock的等待的 promise 完成（成功或失败）时，排队以下步骤到锁任务队列中：

释放锁 lock。
解决 lock的释放的 promise，使用lock的等待的 promise。

2.5. 锁请求

锁请求表示一个待处理的锁请求。

一个锁请求是一个结构体，具有以下项：代理、clientId、管理器、名称、模式、回调函数、promise，以及信号。

锁请求队列是一个队列，其中包含锁请求。

每个锁管理器都有一个锁请求队列映射，它是一个有序映射，将资源名称映射到锁请求队列。

要从锁请求队列映射 queueMap中获取资源名称 name的锁请求队列，运行以下步骤：

如果queueMap[name] 不存在，则设置queueMap[name]为一个新的空锁请求队列。
返回queueMap[name]。

当以下步骤返回 true 时，表示锁请求 request是可授予的：

设manager为request的管理器。
设queueMap为manager的锁请求队列映射。
设name为request的名称。
设queue为从queueMap中获取name的结果锁请求队列。
设held为manager的持有的锁集合。
设mode为request的模式。
如果queue不为空，且request不是queue中的第一个项，则返回 false。
如果mode是"exclusive"，则当held中没有锁的名称等于name时返回 true，否则返回 false。
否则，mode是"shared"；当held中没有锁的模式为"exclusive"，且其名称等于name时，返回 true，否则返回 false。

2.6. 锁的终止

每当运行卸载文档清理步骤时，对其文档使用终止剩余锁和请求的过程，其对应的代理。

当代理终止时，终止剩余锁和请求。

目前这仅适用于工作线程，并且定义得较为模糊，因为没有规范的方法来在工作线程终止时运行步骤。

为了终止剩余锁和请求，使用代理，在锁任务队列中排入以下步骤：

对于每个锁请求 request，其代理等于代理：
1. 中止请求 request。
对于每个锁 lock，其代理等于代理：
1. 释放锁 lock。

3. API

3.1. Navigator 混入

[SecureContext]
interface mixin NavigatorLocks {
  readonly attribute LockManager locks;
};
Navigator includes NavigatorLocks;
WorkerNavigator includes NavigatorLocks;

每个环境设置对象都有一个 LockManager 对象。

Navigator/locks

在所有当前的引擎中可用。

Firefox96+Safari15.4+Chrome69+

Opera?Edge79+

Edge (旧版)?IE无

Firefox for Android?iOS Safari?Chrome for Android?Android WebView?三星 Internet?Opera Mobile?

locks 获取器的步骤是返回此对象的相关设置对象的 LockManager 对象。

3.2. `LockManager` 类

LockManager

在所有当前的引擎中可用。

Firefox96+Safari15.4+Chrome69+

Opera?Edge79+

Edge (旧版)?IE无

Firefox for Android?iOS Safari?Chrome for Android?Android WebView?三星 Internet?Opera Mobile?

[SecureContext, Exposed=(Window,Worker)]
interface LockManager {
  Promise<any> request(DOMString name,
                       LockGrantedCallback callback);
  Promise<any> request(DOMString name,
                       LockOptions options,
                       LockGrantedCallback callback);

  Promise<LockManagerSnapshot> query();
};

callback LockGrantedCallback = Promise<any> (Lock? lock);

enum LockMode { "shared", "exclusive" };

dictionary LockOptions {
  LockMode mode = "exclusive";
  boolean ifAvailable = false;
  boolean steal = false;
  AbortSignal signal;
};

dictionary LockManagerSnapshot {
  sequence<LockInfo> held;
  sequence<LockInfo> pending;
};

dictionary LockInfo {
  DOMString name;
  LockMode mode;
  DOMString clientId;
};

一个 LockManager 实例允许脚本发起锁请求并查询锁管理器的状态。

3.2.1. 方法 `request()`

LockManager/request

在所有当前的引擎中可用。

Firefox96+Safari15.4+Chrome69+

Opera?Edge79+

Edge (旧版)?IE无

Firefox for Android?iOS Safari?Chrome for Android?Android WebView?三星 Internet?Opera Mobile?

promise = navigator.locks.request(name, callback)

promise = navigator.locks.request(name, options, callback)

调用 request() 方法来请求一个锁。

name（初始参数）是一个资源名称字符串。

callback（最后一个参数）是一个当锁被授予时调用的回调函数。这是由脚本指定的，通常是一个 async 函数。锁在回调函数完成之前一直被持有。如果传递了一个非异步的回调函数，它将自动包裹在一个立即解析的 Promise 中，因此锁只会在同步回调的持续时间内持有。

返回的 promise 在锁释放后解析（或拒绝）回调的结果，如果请求被中止则拒绝。

示例：

try {
  const result = await navigator.locks.request('resource', async lock => {
    // 此处持有锁。
    await do_something();
    await do_something_else();
    return "ok";
    // 现在锁将被释放。
  });
  // |result| 是回调的返回值。
} catch (ex) {
  // 如果回调抛出错误，将在此处捕获。
}

当回调因任何原因退出时，无论是代码返回还是抛出，锁都将被释放。

可以将 options 字典作为第二个参数指定；callback 参数始终在最后。

options.mode

mode 选项可以是 "exclusive"（如果未指定，默认为此）或 "shared"。多个标签页或工作者可以以 "shared" 模式持有对同一资源的锁，但在 "exclusive" 模式下只能有一个标签页或工作者持有对资源的锁。

最常见的用途是允许多个读取器同时访问资源，但防止更改。一旦读取器锁被释放，单个排他写入器可以获取锁进行更改，随后可以是另一个排他写入器或更多共享读取器。

await navigator.locks.request('resource', {mode: 'shared'}, async lock => {
  // 锁在此处持有。其他上下文也可能以共享模式持有锁，
  // 但没有其他上下文会以排他模式持有锁。
});

options.ifAvailable: 如果 ifAvailable 选项为 true，则只有在无需额外等待的情况下才会授予锁。请注意，这仍然不是同步的；在许多用户代理中，这将需要跨进程通信以查看锁是否可以被授予。如果锁无法被授予，则回调会用 null 调用。（由于这是预期的，故请求不会被拒绝。）

await navigator.locks.request('resource', {ifAvailable: true}, async lock => {
  if (!lock) {
    // 没有获得锁。可能需要采取适当的行动。
    return;
  }
  // 此处持有锁。
});

options.signal: signal 选项可以设置为一个 AbortSignal。这允许中止锁请求，例如如果在及时的情况下请求未被授予：

const controller = new AbortController(); setTimeout(() => controller.abort(), 200); // 最多等待 200ms。
try {
  await navigator.locks.request(
    'resource', {signal: controller.signal}, async lock => {
      // 此处持有锁。
  });
  // 在此完成锁的使用。
} catch (ex) {
  // 如果定时器触发，|ex| 将是一个名称为 "AbortError" 的 DOMException。
}

如果在授予锁之前发出中止信号，则请求的 Promise 将以 AbortError 被拒绝。一旦锁被授予，信号将被忽略。

options.steal

如果 steal 选项为 true，则将释放对该资源持有的任何锁（并且此类锁的释放的 Promise 将以 AbortError 解析），并授予请求，抢占任何排队的请求。

如果 Web 应用程序检测到不可恢复的状态 — 例如，一些协调点（如 Service Worker）确定持有锁的标签页不再响应 — 那么可以使用此选项 "窃取" 锁。

使用 steal 选项时请谨慎。使用该选项时，之前持有锁的代码将会在没有保证它是唯一有权访问资源的上下文的情况下执行。同样，使用该选项的代码也无法保证其他上下文不会仍然像拥有对抽象资源的访问权一样继续执行。它是为需要在面对应用程序和/或用户代理缺陷时尝试恢复的 Web 应用程序而设计的，在这种情况下，行为已经不可预测。

方法 request(name, callback) 和 request(name, options, callback) 的步骤如下：

如果没有传递 options，则让 options 为一个新的 LockOptions 字典，其成员使用默认值。
让 environment 为 this 的相关设置对象。
如果 environment 的相关全局对象的关联的文档不是完全激活的，则返回一个被拒绝的 Promise，带有一个 "InvalidStateError" DOMException。
让 manager 为获取锁管理器的结果，给定 environment。如果返回失败，则返回一个被拒绝的 Promise，带有一个 "SecurityError" DOMException。
如果 name 以 U+002D HYPHEN-MINUS (-) 开头，则返回一个被拒绝的 Promise，带有一个 "NotSupportedError" DOMException。
如果 options["steal"] 和 options["ifAvailable"] 都为 true，则返回一个被拒绝的 Promise，带有一个 "NotSupportedError" DOMException。
如果 options["steal"] 为 true 且 options["mode"] 不是 "exclusive"，则返回一个被拒绝的 Promise，带有一个 "NotSupportedError" DOMException。
如果 options["signal"] 存在，且 options["steal"] 或 options["ifAvailable"] 为 true，则返回一个被拒绝的 Promise，带有一个 "NotSupportedError" DOMException。
如果 options["signal"] 存在且已中止，则返回一个被拒绝的 Promise，包含 options["signal"] 的中止原因。
让 promise 为一个新的 Promise。
请求一个锁，传入 promise、当前的代理、environment 的 id、manager、callback、name、options["mode"]、options["ifAvailable"]、options["steal"] 和 options["signal"]。
返回 promise。

3.2.2. 方法 `query()`

LockManager/query

在所有当前的引擎中可用。

Firefox96+Safari15.4+Chrome69+

Opera?Edge79+

Edge (旧版)?IE无

Firefox for Android?iOS Safari?Chrome for Android?Android WebView?三星 Internet?Opera Mobile?

state = await navigator.locks.query()

可以使用 query() 方法为一个源生成锁管理器状态的快照，这允许 Web 应用程序检查其锁的使用情况，用于日志记录或调试目的。

返回的 Promise 解析为 state，这是一个普通的数据结构（即类似 JSON 的数据），其形式如下：

{
  held: [
    { name: "resource1", mode: "exclusive",
      clientId: "8b1e730c-7405-47db-9265-6ee7c73ac153" },
    { name: "resource2", mode: "shared",
      clientId: "8b1e730c-7405-47db-9265-6ee7c73ac153" },
    { name: "resource2", mode: "shared",
      clientId: "fad203a5-1f31-472b-a7f7-a3236a1f6d3b" },
  ],
  pending: [
    { name: "resource1", mode: "exclusive",
      clientId: "fad203a5-1f31-472b-a7f7-a3236a1f6d3b" },
    { name: "resource1", mode: "exclusive",
      clientId: "d341a5d0-1d8d-4224-be10-704d1ef92a15" },
  ]
}

clientId 字段对应于唯一的上下文（框架或工作者），并且是 Client 的 id 属性返回的相同值。

方法 query() 的步骤如下：

让 environment 为 this 的相关设置对象。
如果 environment 的相关全局对象的关联的文档不是完全激活的，则返回一个被拒绝的 Promise，带有一个 "InvalidStateError" DOMException。
让 manager 为获取锁管理器的结果，给定 environment。如果返回失败，则返回一个被拒绝的 Promise，带有一个 "SecurityError" DOMException。
让 promise 为一个新的 Promise。
将步骤排入队列以快照锁状态，传入 manager 和 promise 到锁任务队列。
返回 promise。

3.3. `Lock` 类

Lock

在所有当前的引擎中可用。

Firefox96+Safari15.4+Chrome69+

Opera?Edge79+

Edge (旧版)?IE无

Firefox for Android?iOS Safari?Chrome for Android?Android WebView?三星 Internet?Opera Mobile?

[SecureContext, Exposed=(Window,Worker)]
interface Lock {
  readonly attribute DOMString name;
  readonly attribute LockMode mode;
};

Lock 对象有一个关联的锁。

Lock/name

在所有当前的引擎中可用。

Firefox96+Safari15.4+Chrome69+

Opera?Edge79+

Edge (旧版)?IE无

Firefox for Android?iOS Safari?Chrome for Android?Android WebView?三星 Internet?Opera Mobile?

name 获取器的步骤是返回关联的锁的名称。

Lock/mode

在所有当前的引擎中可用。

Firefox96+Safari15.4+Chrome69+

Opera?Edge79+

Edge (旧版)?IE无

Firefox for Android?iOS Safari?Chrome for Android?Android WebView?三星 Internet?Opera Mobile?

mode 获取器的步骤是返回关联的锁的模式。

4. 算法

4.1. 请求锁

要请求锁，需使用 promise、agent、clientId、manager、callback、name、mode、ifAvailable、steal 和 signal：

让 request 成为一个新的锁请求 (agent，clientId，manager，name，mode，callback，promise，signal)。
如果存在 signal，则将算法信号中止请求 request 使用 signal 添加到 signal 中。
将以下步骤排入队列至锁任务队列：
1. 让 queueMap 为 manager 的锁请求队列映射。
2. 让 queue 成为从 queueMap 中获取 name 的锁请求队列的结果。
3. 让 held 为 manager 的持有锁集合。
4. 如果 steal 为 true，则运行以下步骤：
  1. 对于每个 lock 属于 held：
    1. 如果 lock 的名称为 name，则运行以下步骤：
      1. 从 held 中移除锁 lock。
      2. 拒绝 lock 的释放承诺，错误为 "AbortError" DOMException。
  2. 将 request 前置到 queue 中。
5. 否则，运行以下步骤：
  1. 如果 ifAvailable 为 true 且 request 不可授予，则将以下步骤排入队列，在 callback 的相关设置对象的负责事件循环中执行：
    1. 让 r 成为调用 callback，并将 null 作为唯一参数的结果。
    2. 解决 promise 使用 r，并终止这些步骤。
  2. 将 request 入列到 queue 中。
6. 处理锁请求队列 queue。
返回 request。

4.2. 释放锁

要释放锁 lock：

断言：这些步骤在锁任务队列中执行。
让 manager 为 lock 的管理器。
让 queueMap 为 manager 的锁请求队列映射。
让 name 为 lock 的资源名称。
让 queue 成为从 queueMap 中获取 name 的锁请求队列的结果。
从 manager 的持有锁集合中移除锁 lock。
处理锁请求队列 queue。

4.3. 中止请求

要中止请求 request：

断言：这些步骤在锁任务队列中执行。
让 manager 为 request 的管理器。
让 name 为 request 的名称。
让 queueMap 为 manager 的锁请求队列映射。
让 queue 成为从 queueMap 中获取 name 的锁请求队列的结果。
从 queue 中移除 request。
处理锁请求队列 queue。

要发送信号中止请求 request，使用 signal：

将步骤排入队列，将中止请求 request 添加到锁任务队列中。
拒绝 request 的承诺，使用 signal 的中止原因。

4.4. 处理给定资源名称的锁请求队列

要处理锁请求队列 queue：

断言：这些步骤在锁任务队列中执行。
对 queue 中的每个 request：
1. 如果 request 不是可授予的，则返回。
  
  注意：队列中只有第一个项目是可授予的。因此，如果某个项目不可授予，那么后面的所有项目也自动不可授予。
2. 从 queue 中移除 request。
3. 让 agent 为 request 的代理。
4. 让 manager 为 request 的管理器。
5. 让 clientId 为 request 的客户端ID。
6. 让 name 为 request 的名称。
7. 让 mode 为 request 的模式。
8. 让 callback 为 request 的回调函数。
9. 让 p 为 request 的承诺。
10. 让 signal 为 request 的信号。
11. 让 waiting 为一个新的承诺。
12. 让 lock 成为一个新的锁，具有代理 agent，客户端ID clientId，管理器 manager，模式 mode，名称 name，释放承诺 p，以及等待承诺 waiting。
13. 追加 lock 到 manager 的持有锁集合。
14. 将以下步骤排入队列，在 callback 的相关设置对象的负责事件循环中：
  1. 如果 signal 存在，则运行以下步骤：
    1. 如果 signal 被中止，则运行以下步骤：
      1. 将以下步骤排入队列到锁任务队列：
        
        释放锁 lock。
      2. 返回。
    2. 移除算法信号以中止请求 request，从 signal 中。
  2. 让 r 为通过调用 callback，并以与 lock 相关联的新 Lock 对象作为唯一参数的结果。
  3. 解决 waiting，值为 r。

4.5. 快照锁状态

要为 manager 生成锁状态的快照，使用 promise：

断言：这些步骤在锁任务队列中执行。
让 pending 为一个新的列表。
对 manager 的锁请求队列映射中的每个 queue 的值：
1. 对 queue 中的每个 request：
  1. 将 «[ "name" → request 的名称，"mode" → request 的模式，"clientId" → request 的客户端ID ]» 添加到 pending。
让 held 为一个新的列表。
对 manager 的持有锁集合中的每个 lock：
1. 将 «[ "name" → lock 的名称，"mode" → lock 的模式，"clientId" → lock 的客户端ID ]» 添加到 held。
解决 promise，值为 «[ "held" → held，"pending" → pending ]»。

5. 使用注意事项

本节为非规范性内容。

5.1. 死锁

死锁是并发计算中的一个概念，通过此 API 可以引入限制在特定锁管理器的死锁。

通过使用此 API 可能遇到死锁的一个示例如下。

脚本 1：

navigator.locks.request('A', async a => {
  await navigator.locks.request('B', async b => {
    // 使用 A 和 B
  });
});

脚本 2：

navigator.locks.request('B', async b => {
  await navigator.locks.request('A', async a => {
    // 使用 A 和 B
  });
});

如果脚本 1 和脚本 2 几乎同时运行，有可能脚本 1 持有锁 A，而脚本 2 持有锁 B，且双方都无法进一步进展 - 出现死锁。这不会影响整个用户代理、暂停标签页或影响同源的其他脚本，但此特定功能将被阻塞。

防止死锁需要小心。一种方法是始终按照严格的顺序获取多个锁。

可以使用如下的辅助函数来以一致的顺序请求多个锁。

async function requestMultiple(resources, callback) {
  const sortedResources = [...resources];
  sortedResources.sort(); // 始终按相同顺序请求。

  async function requestNext(locks) {
    return await navigator.locks.request(sortedResources.shift(), async lock => {
      // 现在持有此锁，加上所有之前请求的锁。
      locks.push(lock);

      // 如果需要，递归请求下一个锁。
      if (sortedResources.length > 0)
        return await requestNext(locks);

      // 否则，运行回调。
      return await callback(locks);

      // 当回调返回（或抛出）时，所有锁将被释放。
    });
  }
  return await requestNext([]);
}

实际上，使用多个锁往往不如表面看起来那么简单——库和其他工具往往会无意中模糊它们的使用。

6. 安全和隐私注意事项

6.1. 锁的作用域

锁管理器的作用域定义很重要，因为它定义了一个隐私边界。锁可以用作临时状态保留机制，像存储 API 一样，也可以用作通信机制，并且其权限不能高于存储设施。对某些服务施加更细粒度的用户代理也必须对其他服务施加相同的粒度；例如，出于隐私原因，对顶级页面（第一方）和同源的跨域 iframe（第三方）暴露不同存储分区的用户代理也必须同样对锁进行分区。

这也为 Web 应用程序作者提供了合理的期望；如果对存储资源获取锁，所有同源浏览上下文必须观察到相同的状态。

6.2. 隐私浏览

每个私密模式浏览会话在此 API 中被视为一个独立的用户代理。也就是说，在此类会话外请求/持有的锁不会影响此类会话内请求/持有的锁，反之亦然。这防止了网站确定会话是否为“隐私模式”，同时也不允许会话之间通过此类锁进行通信。

6.3. 实现风险

实现时必须确保锁不会跨越不同的来源。如果不这样做，将为在两个不同来源中运行的脚本提供通信侧信道，或允许一个来源中的脚本破坏另一个来源的行为（例如拒绝服务）。

6.4. 检查清单

W3C TAG 为规范编辑者开发了安全与隐私自我评审问卷以提供信息性答案。回顾以下问题：

本规范不涉及可识别个人身份的信息或高价值数据。
未引入跨浏览会话持续的任何新来源状态。
未向 Web 暴露任何新的跨源持久状态。
未向一个来源暴露其当前无法访问的任何新数据（例如，通过轮询 [IndexedDB-2]）。
未启用任何新的脚本执行/加载机制。
本规范不允许来源访问以下任何内容：
- 用户的位置。
- 用户设备上的传感器。
- 用户本地计算环境的各个方面。
- 访问其他设备。
- 对用户代理原生 UI 的任何控制。
未向 Web 暴露任何临时标识符。所有资源名称由 Web 应用程序本身提供。
如果区分存储，则用户代理在第一方和第三方上下文中的行为应区分。请参见§ 6.1 锁的作用域。
在用户代理“隐私模式”上下文中的行为在§ 6.2 隐私浏览中描述。
此 API 不会将数据持久化到用户的本地设备中。
此 API 不允许降低默认的安全特性。

7. 致谢

特别感谢 Alex Russell、Andreas Butler、Anne van Kesteren、Boris Zbarsky、Chris Messina、Darin Fisher、Domenic Denicola、Gus Caplan、Harald Alvestrand、Jake Archibald、Kagami Sascha Rosylight、L. David Baron、Luciano Pacheco、Marcos Caceres、Ralph Chelala、Raymond Toy、Ryan Fioravanti 和 Victor Costan 对本提案的帮助。

特别感谢 Tab Atkins, Jr. 创建和维护了用于编写本规范的Bikeshed工具，并提供了总体的编写建议。

Web 锁 API

摘要

本文件的状态

1. 介绍

1.1. 使用概述

1.2. 动机和使用案例

2. 概念

2.1. 资源名称

2.2. 锁管理器

2.3. 模式和调度

2.4. 锁

2.5. 锁请求

2.6. 锁的终止

3. API

3.1. Navigator 混入

3.2. LockManager 类

3.2.1. 方法 request()

3.2.2. 方法 query()

3.3. Lock 类

4. 算法

4.1. 请求锁

4.2. 释放锁

4.3. 中止请求

4.4. 处理给定资源名称的锁请求队列

4.5. 快照锁状态

5. 使用注意事项

5.1. 死锁

6. 安全和隐私注意事项

6.1. 锁的作用域

6.2. 隐私浏览

6.3. 实现风险

6.4. 检查清单

7. 致谢

一致性

文档约定

一致性算法

索引

本规范定义的术语

通过引用定义的术语

参考文献

规范性参考文献

说明性参考文献

IDL 索引

问题索引

3.2. `LockManager` 类

3.2.1. 方法 `request()`

3.2.2. 方法 `query()`

3.3. `Lock` 类