对多个表的 sequelize 查询中的竞争条件

Question

问题：

我正在开展一个项目，该项目由多项研究和一组用户组成，每个用户都参与其中一项研究。每项研究都会根据使用某种随机算法生成的列表将参与者分成两组。注册后，每个用户都被分配到一项研究，他们的组由注册顺序和组列表中的相应索引决定。例如，如果研究A 的总席位为4，组列表为[0, 1, 1, 0]，则第一个用户被分配到组0，第二个用户被分配到1，依此类推，直到研究已满。

项目中还定义了其他用户角色，即管理员，可以分配给多个研究，而无需在研究中占据一席之地。这意味着用户与研究的关系是n:m。

当前实施中出现的问题是在将用户分配到研究和研究组时出现竞争条件。下面提供了代码，它的工作方式是覆盖Study 模型的addUser，并且每当将用户添加到研究中时，它都会检查研究中有多少用户并为用户提供当前索引seatsTaken 号码的组列表。只要用户每隔一段时间被添加到研究中，这就会起作用。但是，只要同时添加多个用户，异步查询就会导致竞争条件，并且seatsTaken 计数会受到同时注册的其他用户的影响。

在下面的示例中，分配给研究A 的用户分配了正确的组，但同时查询的研究B 分配了不正确的组。

const Sequelize = require('sequelize');
const assert = require('assert');

const sequelize = new Sequelize({
  database: 'database',
  username: 'username',
  password: 'password',
  dialect: process.env.DB_DIALECT || 'sqlite',
  storage: 'db.sqlite',
  logging: false
});

const User = sequelize.define('user', {
  id: {
    type: Sequelize.INTEGER,
    autoIncrement: true,
    primaryKey: true,
  },
  group: {
    type: Sequelize.INTEGER,
    allowNull: true,
    defaultValue: null
  }
});

// Groups list for studies 'A' and 'B'
const groupLists = {
  a: [0, 1, 1, 0],
  b: [1, 0, 1, 0]
}

const Study = sequelize.define('study', {
  id: {
    type: Sequelize.INTEGER,
    autoIncrement: true,
    primaryKey: true,
  },
  name: {
    type: Sequelize.STRING,
    allowNull: false
  },
  seatsTotal: {
    type: Sequelize.INTEGER,
    defaultValue: 0
  }
});

// n:m relation between users and studies
User.belongsToMany(Study, {through: 'UserStudy'});
Study.belongsToMany(User, {through: 'UserStudy'});

// Overridden 'addUser' method for groups assignment
Study.prototype.addUser = async function(user) {
  // Count already occupied seats
  const seatsTaken = await User.count({
    include: [{
      model: Study,
      where: {
        name: this.name
      }
    }]
  });
  // Add the user to study
  await Study.associations.users.add(this, user);
  // Assign the group of the user based on the seatsTaken
  await user.update({ group: groupLists[this.name][seatsTaken] });
}

sequelize.sync({force: true}).then(async () => {
  // Studies 'A' and 'B' with 4 seats
  await Study.bulkCreate([{name: 'a', seatsTotal: 4}, {name: 'b', seatsTotal: 4}]);
  // 8 users
  await User.bulkCreate(new Array(8).fill(0).map(() => ({})));

  const studies = await Study.findAll();
  const users = await User.findAll(); 

  // Assign half of the users to study 'A' in intervals
  users.filter((_, idx) => idx % 2 === 0).forEach((user, idx) => {
    setTimeout(() => {
      studies[0].addUser(user);
    }, 100*idx);
  });

  // Assign the other half to study 'B' at the same time
  await Promise.all(users.filter((_, idx) => idx % 2 === 1).map(user => {
    return studies[1].addUser(user);
  }));

  setTimeout(async () => {
    // Wait for all queries to finish and assert the results
    const userStudies = await User.findAll({
      include: [Study]
    });

    const studyUsersA = userStudies.filter(u => u.studies.some(s => s.name === 'a'));
    const studyUsersB = userStudies.filter(u => u.studies.some(s => s.name === 'b'));

    try {
      console.log('Group list A actual:', studyUsersA.map(u => u.group), 'expected:', groupLists['a']);
      assert.deepEqual(studyUsersA.map(u => u.group).sort((a, b) => a-b), groupLists['a'].sort((a, b) => a-b), 'Group list A is not assigned correctly');
      console.log('Group list B actual:', studyUsersB.map(u => u.group), 'expected:', groupLists['b']);
      assert.deepEqual(studyUsersB.map(u => u.group).sort((a, b) => a-b), groupLists['b'].sort((a, b) => a-b), 'Group list B is not assigned correctly');
      console.log(`Passed: Group lists are assigned correctly.`);
    } catch (e) {
      console.log(`Failed: ${e.message}`);
    }
  }, 500);
});

我能找到的相关问题要么是关于在一个表中增加一个值，要么只是提到事务和锁而没有提供示例代码：
Avoiding race condition with Nodejs Sequelize
How to lock table in sequelize, wait until another request to be complete
Addition and Subtraction Assignment Operator With Sequelize
Database race conditions

限制：

• 项目堆栈是nodejs、expressjs和sequelize mysql 生产数据库和sqlite 开发和 测试。
• 该解决方案应该适用于sqlite 和mysql。
• 最好不要将组列表存储在数据库中。这些列表由算法和随机种子生成，但在示例代码中它们是硬编码的。
• 解决方案应该是 sequelize 解决方案，而不是在 express 服务器中限制或排队用户请求。
• 在同时请求的情况下，不严格要求保留用户注册的确切顺序，因为无法真正验证首先将哪个用户添加到研究中，但最终结果必须具有正确数量的 0 s 和 1s 是分配的组。
• 我尝试过对事务进行后续处理，但我在 sqlite 兼容性方面遇到了很多问题，并且由于数据库锁定而导致请求失败，但这可能是因为我缺乏正确执行此操作的知识。此处的限制是请求不应因数据库锁定而失败。

提供的代码是重现问题的最小示例。请以它为基础。

运行代码

npm install sequelize sqlite3 mysql2

sqlite：

node index.js

mysql（使用 docker）：

docker run -d --env MYSQL_DATABASE=database --env MYSQL_USER=username --env MYSQL_PASSWORD=password --env MYSQL_RANDOM_ROOT_PASSWORD=yes -p 3306:3306 mysql:5.7
DB_DIALECT=mysql node index.js

注意：

• 示例代码仅用于演示当前实现中的问题，间隔和超时用于模拟用户与服务器的交互。请不要关注示例中的错误模式，而应关注问题本身以及如何在满足限制部分中提到的要求的同时以更好的方式解决问题。
• 这是一个相当大的项目的一部分，我可能会根据实际项目要求和我在这里收到的反馈来更新要求。

如果我应该提供任何其他信息，请告诉我。提前谢谢你。

Answer 1

恐怕这是预期的行为。

• 您将seatsTaken 声明为异步计算属性。
• 您也可以异步插入多个用户。
• 您不会将每个用户创建隔离在其自己的事务中。

因此，您会看到一笔交易的状态在变化，而且它的变化相当混乱，因为您没有指定任何特定的顺序。最终状态会变得一致，但实现该状态的方法只是等待一段时间。

我认为实现一致性的最简单方法是将每个插入包装在一个事务中。

如果每次插入的事务太慢，您可以在一个事务中批量插入所有用户记录，然后计算另一个事务中占用的席位，甚至只是同步执行所有操作。

无论如何，如果你想要一致性，你需要逻辑序列化，一个清晰的“前后”关系。目前你的代码缺少它，AFAICT。