Umgang mit verteilten Sperren und Parallelitätskontrolle in der PHP-Entwicklung

Titel: Praxis der verteilten Sperre und Parallelitätskontrolle in der PHP-Entwicklung

Bei der Entwicklung von Webanwendungen mit hoher Parallelität sind verteilte Sperre und Parallelitätskontrolle wesentliche technische Mittel. In diesem Artikel wird anhand konkreter Codebeispiele erläutert, wie Sie mit PHP verteilte Sperren und Parallelitätskontrolle handhaben.

1. Das Konzept der verteilten Sperre
   Verteilte Sperre bezieht sich auf einen Mechanismus, der die Reihenfolge und Konsistenz von Datenoperationen für eine bestimmte Ressource in einem verteilten System gewährleistet. In Szenarien mit hoher Parallelität können verteilte Sperren verhindern, dass mehrere Prozesse gleichzeitig auf dieselbe Ressource zugreifen und diese ändern, wodurch die Datengenauigkeit sichergestellt wird.
2. Methoden zur Implementierung verteilter Sperren
   2.1 Cache-basierte Implementierung
   Die Verwendung von Cache zur Implementierung verteilter Sperren ist eine gängige und einfache Methode und kann mithilfe von Cache-Diensten wie Redis und Memcached implementiert werden.
   Der Beispielcode lautet wie folgt:

$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 Basierend auf der Datenbankimplementierung
Simulieren Sie eine verteilte Sperre, indem Sie eine neue Tabelle in der Datenbank hinzufügen, und verwenden Sie die Transaktionseigenschaften der Datenbank, um die Sperrfunktion zu implementieren.
Der Beispielcode lautet wie folgt:

// 假设数据库连接已经创建
$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. So implementieren Sie die Parallelitätskontrolle
   Parallelitätskontrolle bezieht sich auf eine Kontrollmethode, um die Datenkonsistenz in einer Umgebung mit hoher Parallelität sicherzustellen. Zu den gängigen Methoden zur Parallelitätskontrolle gehören optimistisches Sperren und pessimistisches Sperren.

3.1 Implementierung der optimistischen Sperre
Optimistische Sperre bedeutet, dass vor der Durchführung von Datenvorgängen davon ausgegangen wird, dass kein Konflikt auftritt, und nur festgestellt wird, ob sie während der Aktualisierung mit der vorherigen Versionsnummer übereinstimmt. Wenn sie übereinstimmt, wird der Aktualisierungsvorgang durchgeführt , andernfalls wird eine Fehlermeldung zurückgegeben.
Der Beispielcode lautet wie folgt:

// 假设从数据库中获取到的数据是当前版本号为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 Pessimistische Sperrimplementierung
Pessimistische Sperre bedeutet, die Sperre zu erhalten, bevor Datenoperationen ausgeführt werden, um sicherzustellen, dass der aktuelle Benutzer ausschließlich Eigentümer der Daten sein kann und andere Benutzer die Daten nicht ändern können, bis der aktuelle Benutzer sie freigibt das Schloss.
Der Beispielcode lautet wie folgt:

$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();

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

Zusammenfassung:
In der PHP-Entwicklung sind verteilte Sperren und Parallelitätskontrolle wichtige Mittel, um eine hohe Parallelität und Datenkonsistenz zu erreichen. In diesem Artikel wird die Implementierung verteilter Sperren basierend auf Cache und Datenbank sowie die Implementierung der Parallelitätskontrolle optimistischer und pessimistischer Sperren vorgestellt. Außerdem werden spezifische Codebeispiele mitgeliefert, um den Lesern dabei zu helfen, besser mit verteilten Sperren und Parallelität in der Entwicklung umzugehen. Kontrollierte Szene.

Das obige ist der detaillierte Inhalt vonUmgang mit verteilten Sperren und Parallelitätskontrolle in der PHP-Entwicklung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!