How to solve the locking problem in concurrent execution? Using the mallusch/lock library is OK!

Composer can be learned through the following address: Learning address

Ensuring mutually exclusive access to critical code segments is critical when developing applications that need to handle concurrent execution. Recently, I encountered a tricky problem when developing a system that requires multiple users to access bank account balances at the same time: multiple users try to update their account balances at the same time, resulting in inconsistent data. I've tried multiple ways to solve this problem, but it doesn't work well. It wasn't until I discovered the mallusch/lock library that I really solved my troubles.

mallusch/lock is a mutex lock library for PHP, which can be easily installed through Composer:

 <code>composer require malkusch/lock</code>

This library provides several ways to implement locks, including FlockMutex , MemcachedMutex , RedisMutex , SemaphoreMutex , MySQLMutex , PostgreSQLMutex and DistributedMutex . These implementations can be selected according to your needs, ensuring that in a concurrent environment, critical code segments can only be executed by one process or thread.

Here is a simple example using RedisMutex to show how to ensure that the update operation of a bank account balance is performed mutex:

 <code class="php">use Malkusch\Lock\Mutex\RedisMutex; $redis = new \Redis(); $redis->connect('localhost'); $mutex = new RedisMutex($redis, 'balance'); $newBalance = $mutex->synchronized(static function () use ($bankAccount, $amount) { $balance = $bankAccount->getBalance(); $balance -= $amount; if ($balance setBalance($balance); return $balance; });</code>

In this example, the $mutex->synchronized() method ensures that the code block can only be executed by one process at any time, avoiding data inconsistency caused by multiple users to update the balance simultaneously.

In addition, the malkusch/lock library also supports double check lock mode. Through check() and then() methods, condition checks can be performed before locking to further optimize performance and resource usage:

 <code class="php">use Malkusch\Lock\Mutex\RedisMutex; use Malkusch\Lock\Util\DoubleCheckedLocking; $redis = new \Redis(); $redis->connect('localhost'); $mutex = new RedisMutex($redis, 'balance'); $newBalance = $mutex->check(static function () use ($bankAccount, $amount): bool { return $bankAccount->getBalance() >= $amount; })->then(static function () use ($bankAccount, $amount) { $balance = $bankAccount->getBalance(); $balance -= $amount; $bankAccount->setBalance($balance); return $balance; });</code>

In this example, only when the account balance is sufficient will the lock be acquired and the update operation be performed, avoiding unnecessary lock waiting.

Using the malkusch/lock library not only solved my concurrency problem, but also greatly simplified the code and improved the reliability and performance of the system. If you are also facing similar concurrent execution issues, it is highly recommended to try this library.

The above is the detailed content of How to solve the locking problem in concurrent execution? Using the mallusch/lock library is OK!. For more information, please follow other related articles on the PHP Chinese website!