问题:

我正在开展一个项目，该项目由多项研究和一组用户组成，每个用户都参与其中一项研究。每项研究都根据使用某种随机化算法生成的列表将参与者分为两组。注册后，每个用户都会被分配到一个研究中，他们的组由注册顺序和组列表中的相应索引决定。例如，如果学习 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);
});

npm install sequelize sqlite3 mysql2

node index.js

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

最佳答案

恐怕这是预期的行为。

关于mysql - 多个表上的 sequelize 查询中的竞争条件，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/56939409/