争用条件在多个表上进行顺序查询

Question

问题：

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

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

将用户分配给研究和研究组时，当前实施中出现的问题是竞争状况。该代码下面提供和它的工作方式是，它覆盖addUser的Study模式，只要用户添加到它会检查有多少用户已经在研究中学习，并为用户组列表这是当前指数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);
});

我可以找到的相关问题是关于在一个表中增加一个值，或者它们只是在不提供示例代码的情况下提到了事务和锁：
使用Node.js Sequelize避免竞争条件
如何在序列化中锁定表，等到另一个请求完成
加法和减法具有Sequelize 数据库竞争条件的赋值运算符

局限性：

• 项目堆栈为nodejs，expressjs并sequelize带有 mysql用于生产，sqlite开发和测试的数据库。
• 该解决方案应同时适用于sqlite和mysql。
• 最好不要将组列表存储在数据库中。列表是由算法和随机种子生成的，但是在示例代码中它们是硬编码的。
• 解决方案应该是序列化解决方案，而不是限制或排队快速服务器中的用户请求。
• 在同时请求的情况下，并非严格要求保留用户注册的确切顺序，因为无法真正验证首先将哪个用户添加到研究中，但是最终结果必须具有正确的0s和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。