JS `IndexedDB` 事务隔离级别与并发控制：读写锁与版本管理

大家好，欢迎来到今天的 IndexedDB 事务隔离级别与并发控制小课堂！我是你们的老朋友，今天咱们来聊聊 IndexedDB 里那些“锁”事和“版本”故事。别担心，这玩意儿听起来高大上，其实没那么可怕，咱们争取用最接地气的方式把它讲明白。

开场白：IndexedDB，不仅仅是个“本地数据库”

IndexedDB，你可能觉得它就是个浏览器里的本地数据库，用来存点用户数据、缓存些资源啥的。没错，这确实是它的主要用途。但你要是觉得它“仅此而已”，那可就小瞧它了。它可是一个支持事务的 NoSQL 数据库！

事务，这玩意儿在传统的关系型数据库里是标配，用来保证数据的一致性和可靠性。但在 IndexedDB 里，它同样重要。想象一下，你要同时更新多个数据，如果中途出了岔子，部分数据更新成功，部分失败，那可就乱套了。事务就是用来避免这种情况的。

第一部分：IndexedDB 的事务隔离级别：你是哪种“姿势”？

事务隔离级别，说白了就是多个事务并发执行时，它们之间互相影响的程度。IndexedDB 提供了两种隔离级别：

versionchange: 这是最高级别的隔离，也是最严格的。顾名思义，主要用于数据库版本升级的时候。当一个事务以 versionchange 模式打开时，它会独占数据库，其他事务都得等着。就像你在装修房子，其他人都得避让着你。
readonly 和 readwrite: 这两种模式的隔离级别相对较低，允许并发读写。但要注意，IndexedDB 的并发控制机制并没有像关系型数据库那么复杂，它主要依赖于事件循环和锁。

表格一：IndexedDB 事务隔离级别对比

隔离级别	适用场景	并发性	锁机制
`versionchange`	数据库版本升级、初始化	低	独占数据库，其他事务必须等待
`readonly`	只读操作，例如查询数据	高	共享读锁，允许多个事务同时读取数据
`readwrite`	读写操作，例如新增、修改、删除数据	中	共享读锁，排他写锁。读锁可以并发，写锁互斥。当一个事务持有写锁时，其他事务无法获得读锁或写锁，必须等待。

代码示例一：创建和打开数据库（versionchange 模式）

const request = indexedDB.open('myDatabase', 2); // 假设当前版本是 1，要升级到 2

request.onupgradeneeded = (event) => {
  const db = event.target.result;

  // 创建对象仓库（类似于表）
  const objectStore = db.createObjectStore('customers', { keyPath: 'id' });

  // 创建索引
  objectStore.createIndex('name', 'name', { unique: false });
  objectStore.createIndex('email', 'email', { unique: true }); // 邮箱唯一索引

  console.log('数据库升级完成！');
};

request.onsuccess = (event) => {
  const db = event.target.result;
  console.log('数据库打开成功！');
  //后续操作
};

request.onerror = (event) => {
  console.error('数据库打开失败：', event.target.error);
};

这段代码展示了如何以 versionchange 模式打开数据库，并在 onupgradeneeded 事件中创建对象仓库和索引。注意，onupgradeneeded 事件只会在数据库版本升级时触发，而且是在一个独占的事务中执行。

代码示例二：读写数据（readwrite 模式）

const request = indexedDB.open('myDatabase', 2);

request.onsuccess = (event) => {
  const db = event.target.result;

  // 创建一个读写事务
  const transaction = db.transaction(['customers'], 'readwrite');

  // 获取对象仓库
  const objectStore = transaction.objectStore('customers');

  // 添加数据
  const addRequest = objectStore.add({ id: 1, name: '张三', email: '[email protected]' });

  addRequest.onsuccess = () => {
    console.log('数据添加成功！');
  };

  addRequest.onerror = (event) => {
    console.error('数据添加失败：', event.target.error);
  };

  // 获取数据
  const getRequest = objectStore.get(1);

  getRequest.onsuccess = () => {
    console.log('获取到的数据：', getRequest.result);
  };

  getRequest.onerror = (event) => {
    console.error('数据获取失败：', event.target.error);
  };

  // 事务完成时触发
  transaction.oncomplete = () => {
    console.log('事务完成！');
  };

  // 事务出错时触发
  transaction.onerror = (event) => {
    console.error('事务出错：', event.target.error);
  };
};

request.onerror = (event) => {
  console.error('数据库打开失败：', event.target.error);
};

这段代码展示了如何以 readwrite 模式打开数据库，并使用事务来添加和获取数据。注意，所有的数据库操作都必须在事务中进行。

第二部分：IndexedDB 的并发控制：锁的艺术

IndexedDB 的并发控制机制相对简单，它主要依赖于：

事件循环： JavaScript 是单线程的，所有的代码都在事件循环中执行。这意味着，同一时刻只有一个任务在执行。
锁： IndexedDB 使用读写锁来控制并发访问。
- 共享读锁： 允许多个事务同时读取数据，不会互相阻塞。
- 排他写锁： 只允许一个事务修改数据，其他事务必须等待。

当一个事务需要读取数据时，它会尝试获取共享读锁。如果当前没有其他事务持有写锁，那么它可以成功获取读锁。当一个事务需要修改数据时，它会尝试获取排他写锁。如果当前没有其他事务持有读锁或写锁，那么它可以成功获取写锁。

锁的竞争与死锁

锁的竞争是不可避免的，尤其是在高并发场景下。当多个事务同时尝试获取写锁时，只有一个事务能够成功，其他事务必须等待。

死锁，虽然在 IndexedDB 中比较少见，但理论上也是可能发生的。例如，事务 A 持有对象仓库 1 的读锁，同时尝试获取对象仓库 2 的写锁；而事务 B 持有对象仓库 2 的读锁，同时尝试获取对象仓库 1 的写锁。这样，两个事务就互相等待，导致死锁。

如何避免死锁？

尽量减少事务的执行时间： 事务执行时间越长，持有锁的时间就越长，发生锁竞争的可能性就越大。
避免嵌套事务： 嵌套事务会增加锁的复杂性，更容易导致死锁。
使用一致的锁获取顺序： 如果多个事务需要访问相同的对象仓库，尽量按照相同的顺序获取锁，可以避免死锁。

第三部分：IndexedDB 的版本管理：数据的进化

数据库的版本管理是 IndexedDB 的一个重要特性。它可以让你在不丢失数据的前提下，修改数据库的结构，例如添加新的对象仓库、修改索引等。

版本管理的核心是 onupgradeneeded 事件。当你打开数据库时，如果指定的版本号大于当前数据库的版本号，那么 onupgradeneeded 事件就会被触发。你可以在这个事件中执行数据库升级操作。

代码示例三：数据库版本升级

const request = indexedDB.open('myDatabase', 3); // 假设当前版本是 2，要升级到 3

request.onupgradeneeded = (event) => {
  const db = event.target.result;
  const oldVersion = event.oldVersion;
  const newVersion = event.newVersion || db.version; // 兼容旧版本浏览器

  console.log(`数据库版本升级：从 ${oldVersion} 到 ${newVersion}`);

  if (oldVersion < 1) {
    // 创建对象仓库（第一次创建数据库）
    const objectStore = db.createObjectStore('customers', { keyPath: 'id' });
    objectStore.createIndex('name', 'name', { unique: false });
  }

  if (oldVersion < 2) {
    // 添加新的索引
    const objectStore = db.transaction(['customers']).objectStore('customers');
    objectStore.createIndex('email', 'email', { unique: true });
  }

  if (oldVersion < 3) {
    // 创建新的对象仓库
    db.createObjectStore('orders', { keyPath: 'id' });
  }

  console.log('数据库升级完成！');
};

request.onsuccess = (event) => {
  const db = event.target.result;
  console.log('数据库打开成功！');
  //后续操作
};

request.onerror = (event) => {
  console.error('数据库打开失败：', event.target.error);
};

这段代码展示了如何进行数据库版本升级。注意，onupgradeneeded 事件会被多次触发，每次触发的 oldVersion 和 newVersion 都不一样。你需要根据 oldVersion 来判断需要执行哪些升级操作。

版本升级的注意事项

升级必须是幂等的： 也就是说，多次执行相同的升级操作，结果应该是一样的。
处理错误： 在升级过程中，可能会发生错误。你需要捕获这些错误，并进行适当的处理。
数据迁移： 如果数据库结构发生了变化，可能需要将旧数据迁移到新的结构中。

表格二：版本升级中的常见操作

操作	说明
创建对象仓库	使用 `db.createObjectStore()` 方法创建新的对象仓库。
删除对象仓库	使用 `db.deleteObjectStore()` 方法删除已有的对象仓库。
创建索引	使用 `objectStore.createIndex()` 方法创建新的索引。
删除索引	使用 `objectStore.deleteIndex()` 方法删除已有的索引。
修改对象仓库选项	无法直接修改对象仓库的选项（例如 `keyPath`）。你需要先删除对象仓库，然后再重新创建。
数据迁移	如果数据库结构发生了变化，需要将旧数据迁移到新的结构中。这通常需要读取旧数据，然后将其转换为新的格式，并写入新的对象仓库。在迁移过程中，需要注意数据的一致性，可以使用事务来保证数据的一致性。对于大量数据迁移，建议分批进行，避免阻塞主线程。可以考虑使用 Web Workers 来执行数据迁移，避免影响用户体验。在数据迁移完成后，可以考虑删除旧的对象仓库和索引。

第四部分：最佳实践：让你的 IndexedDB 代码更靠谱

使用事务： 所有的数据库操作都应该在事务中进行，以保证数据的一致性和可靠性。
尽量减少事务的执行时间： 事务执行时间越长，持有锁的时间就越长，发生锁竞争的可能性就越大。
避免嵌套事务： 嵌套事务会增加锁的复杂性，更容易导致死锁。
处理错误： 数据库操作可能会失败，你需要捕获这些错误，并进行适当的处理。
使用异步操作： IndexedDB 的所有操作都是异步的，你需要使用回调函数或 Promise 来处理操作结果。
合理使用索引： 索引可以提高查询效率，但也会增加写入的成本。你需要根据实际情况，选择合适的索引。
注意版本管理： 在修改数据库结构时，一定要进行版本升级，并进行数据迁移。

代码示例四：使用 Promise 封装 IndexedDB 操作

function openDatabase(dbName, version, upgradeCallback) {
  return new Promise((resolve, reject) => {
    const request = indexedDB.open(dbName, version);

    request.onupgradeneeded = (event) => {
      upgradeCallback(event.target.result, event.oldVersion, event.newVersion || event.target.result.version);
    };

    request.onsuccess = (event) => {
      resolve(event.target.result);
    };

    request.onerror = (event) => {
      reject(event.target.error);
    };
  });
}

function addObject(db, objectStoreName, data) {
  return new Promise((resolve, reject) => {
    const transaction = db.transaction([objectStoreName], 'readwrite');
    const objectStore = transaction.objectStore(objectStoreName);
    const request = objectStore.add(data);

    request.onsuccess = () => {
      resolve();
    };

    request.onerror = (event) => {
      reject(event.target.error);
    };

    transaction.oncomplete = () => {
      // console.log('事务完成');
    };

    transaction.onerror = (event) => {
      console.error('事务出错：', event.target.error);
    };
  });
}

// 使用示例
openDatabase('myDatabase', 4, (db, oldVersion, newVersion) => {
  console.log(`数据库升级：${oldVersion} -> ${newVersion}`);
  if (oldVersion < 4) {
    db.createObjectStore('products', { keyPath: 'id' });
  }
})
  .then((db) => {
    console.log('数据库打开成功');
    return addObject(db, 'products', { id: 1, name: 'Apple', price: 5 });
  })
  .then(() => {
    console.log('数据添加成功');
  })
  .catch((error) => {
    console.error('发生错误：', error);
  });

这段代码展示了如何使用 Promise 封装 IndexedDB 操作，使其更加易于使用和维护。

总结：IndexedDB，小身材，大能量

IndexedDB 虽然是个浏览器里的本地数据库，但它支持事务、并发控制和版本管理，这使得它能够胜任一些复杂的应用场景。掌握 IndexedDB 的事务隔离级别、并发控制机制和版本管理，可以让你写出更健壮、更可靠的 Web 应用。希望今天的课程能帮助你更好地理解和使用 IndexedDB。

感谢大家的收听！下次再见！

发表回复 取消回复

发表回复取消回复