Comment gérer les verrous distribués et le contrôle de concurrence dans le développement PHP

Titre : Pratique du verrouillage distribué et du contrôle de concurrence dans le développement PHP

Dans le développement d'applications Web à haute concurrence, le verrouillage distribué et le contrôle de concurrence sont des moyens techniques essentiels. Cet article explique comment utiliser PHP pour gérer les verrous distribués et le contrôle de concurrence, avec des exemples de code spécifiques.

1. Le concept de verrouillage distribué
   Le verrouillage distribué fait référence à un mécanisme qui garantit l'ordre et la cohérence des opérations de données pour une certaine ressource dans un système distribué. Dans les scénarios à forte concurrence, les verrous distribués peuvent empêcher plusieurs processus d'accéder et de modifier la même ressource en même temps, garantissant ainsi l'exactitude des données.
2. Méthodes d'implémentation de verrous distribués
   2.1 Implémentation basée sur le cache
   L'utilisation du cache pour implémenter des verrous distribués est un moyen courant et simple, et peut être implémentée à l'aide de services de cache tels que Redis et Memcached.
   L'exemple de code est le suivant :

$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

$lockKey = 'resource_lock';
$lockExpire = 10;

// 尝试获取锁
$lockResult = $redis->set($lockKey, 1, ['NX', 'EX' => $lockExpire]);

if ($lockResult) {
    // 获取锁成功，执行业务逻辑
    // ...

    // 释放锁
    $redis->del($lockKey);
} else {
    // 获取锁失败，处理业务逻辑
    // ...
}

2.2 Basé sur l'implémentation de la base de données
Simulez un verrou distribué en ajoutant une nouvelle table dans la base de données et utilisez les caractéristiques de transaction de la base de données pour implémenter la fonction de verrouillage.
L'exemple de code est le suivant :

// 假设数据库连接已经创建
$lockTable = 'resource_lock';
$lockExpire = 10;

$pdo->beginTransaction();

try {
    // 尝试获取锁
    $selectSql = "SELECT * FROM $lockTable WHERE resource='resource_key' FOR UPDATE";
    $selectStmt = $pdo->prepare($selectSql);
    $selectStmt->execute();

    $lockRow = $selectStmt->fetch(PDO::FETCH_ASSOC);

    if ($lockRow) {
        // 锁已经存在，获取锁失败，处理业务逻辑
        // ...
    } else {
        // 锁不存在，获取锁成功，执行业务逻辑
        // ...

        // 插入锁信息
        $insertSql = "INSERT INTO $lockTable (resource, create_time) VALUES ('resource_key', UNIX_TIMESTAMP())";
        $insertStmt = $pdo->prepare($insertSql);
        $insertStmt->execute();

        // 提交事务
        $pdo->commit();
    }
} catch (Exception $e) {
    // 发生异常，回滚事务
    $pdo->rollback();

    // 错误处理
    // ...
}

3. Comment implémenter le contrôle de concurrence
   Le contrôle de concurrence fait référence à une méthode de contrôle permettant de garantir la cohérence des données dans un environnement à forte concurrence. Les méthodes courantes de contrôle de concurrence incluent le verrouillage optimiste et le verrouillage pessimiste.

3.1 Implémentation du verrouillage optimiste
Le verrouillage optimiste signifie qu'avant d'effectuer des opérations sur les données, il est supposé qu'aucun conflit ne se produira et détermine uniquement s'il correspond au numéro de version précédent lors de la mise à jour. S'il correspond, l'opération de mise à jour sera effectuée. , sinon un message d'erreur sera renvoyé.
L'exemple de code est le suivant :

// 假设从数据库中获取到的数据是当前版本号为2的数据
$data = [
    'id' => 1,
    'name' => 'test',
    'version' => 2
];

$optimizedVersion = $data['version'] + 1;

// 更新数据
$updateSql = "UPDATE resource_table SET name='updated_name', version=$optimizedVersion WHERE id=1 AND version={$data['version']}";
$updateStmt = $pdo->prepare($updateSql);
$updateStmt->execute();

if ($updateStmt->rowCount() <= 0) {
    // 操作失败，版本号不匹配，处理业务逻辑
    // ...
}

3.2 Implémentation du verrouillage pessimiste
Le verrouillage pessimiste signifie obtenir le verrou avant d'effectuer des opérations sur les données pour garantir que l'utilisateur actuel peut posséder exclusivement les données et que les autres utilisateurs ne peuvent pas modifier les données jusqu'à ce que l'utilisateur actuel les libère. la serrure.
L'exemple de code est le suivant :

$pdo->beginTransaction();

try {
    // 获取锁
    $selectSql = "SELECT * FROM resource_table WHERE id=1 FOR UPDATE";
    $selectStmt = $pdo->prepare($selectSql);
    $selectStmt->execute();

    $data = $selectStmt->fetch(PDO::FETCH_ASSOC);

    if ($data) {
        // 获取锁成功，执行业务逻辑
        // ...

        // 释放锁
        $pdo->commit();
    } else {
        // 获取锁失败，处理业务逻辑
        // ...
    }
} catch (Exception $e) {
    // 发生异常，回滚事务
    $pdo->rollback();

    // 错误处理
    // ...
}

Résumé :
Dans le développement PHP, les verrous distribués et le contrôle de concurrence sont des moyens importants pour obtenir une concurrence élevée et une cohérence des données. Cet article présente l'implémentation de verrous distribués basés sur le cache et la base de données, ainsi que l'implémentation du contrôle de concurrence des verrous optimistes et pessimistes, et est accompagné d'exemples de code spécifiques. J'espère qu'il pourra aider les lecteurs à mieux gérer les verrous distribués et la concurrence dans le développement. . Scène contrôlée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!