Question

问题：

我正在研究一个项目，该项目包含多个研究和一组用户，每个用户都参与其中的一项研究。每个研究都根据使用某种随机算法生成的列表将参与者分为两组。注册后，将为每个用户分配一个研究，并且他们的组由注册顺序和组列表中的相应索引确定。例如，如果研究A的总席位为4，并且组列表为[0, 1, 1, 0]，则第一个用户被分配到组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);
});

我可以找到的相关问题是关于在一个表中增加一个值，或者它们只是提及事务和锁而没有提供示例代码：
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。
最好将组列表不存储在数据库中。列表是由算法和随机种子生成的，但在示例代码中是经过硬编码的。
该解决方案应该是续集解决方案，而不是限制或排队快速服务器中的用户请求。
在同时请求的情况下，不严格要求保留用户注册的确切顺序，因为不能真正验证首先将哪个用户添加到研究中，但是最终结果必须具有正确的{{1 }}和0是已分配的组。
我曾尝试过序列化事务，但是sqlite兼容性存在很多问题，并且由于数据库锁定而导致请求失败，但这可能是因为我缺乏如何正确执行操作的知识。此处的限制是请求不应由于数据库锁定而失败。

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

运行代码

sqlite：

npm install sequelize sqlite3 mysql2

mysql（使用docker）：

node index.js

注意：

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

请告知我是否应该提供其他信息。预先谢谢你。

Answer 1

恐怕这是预期的行为。

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

因此，您看到一个事务的变化状态，并且由于没有指定任何特定的顺序，它的变化相当混乱。最终状态变得一致，但是达到该状态的方法就是等待一段时间。

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

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

无论如何，如果需要一致性，则需要逻辑序列化，即明确的“前后”关系。目前，您的代码缺少AFAICT。

在多个表上进行顺序查询时的竞争条件

1 个答案: