Example code of how to lock concurrency in php

CleverCode In the work project, you will encounter some PHP concurrent access to modify a data problem. If the data is not locked, it will cause data errors. Next CleverCode will analyze a financial payment lock problem.

1 No application lock mechanism

1.1 Financial payment simplified version code

<?php

/** 
 * pay.php 
 * 
 * 支付没有应用锁
 * 
 * Copy right (c) 2016 http://blog.csdn.net/CleverCode 
 * 
 * modification history: 
 * -------------------- 
 * 2016/9/10, by CleverCode, Create 
 * 
 */  

//用户支付
function pay($userId,$money)
{
    
    if(false == is_int($userId) || false == is_int($money))
    {
        return false;
    }  
    
    //取出总额
    $total = getUserLeftMoney($userId);
    
    //花费大于剩余
    if($money > $total)
    {
        return false;    
    }
    
    //余额
    $left = $total - $money;
    
    //更新余额
    return setUserLeftMoney($userId,$left);

}

//取出用户的余额
function getUserLeftMoney($userId)
{
    if(false == is_int($userId))
    {
        return 0;
    }
    $sql = "select account form user_account where userid = ${userId}";
    
    //$mysql = new mysql();//mysql数据库
    return $mysql->query($sql);
}

//更新用户余额
function setUserLeftMoney($userId,$money)
{
    if(false == is_int($userId) || false == is_int($money))
    {
        return false;
    }        
    
    $sql = "update user_account set account = ${money} where userid = ${userId}";
    
    //$mysql = new mysql();//mysql数据库
    return $mysql->execute($sql);
}

?>

1.2 Problem analysis

If there are two operators (p and m), both use accounts with user number 100, and log in simultaneously on PC and mobile phone respectively. The total balance of the 100 account is 1000, operator p spends 200, and operator m spends 300. The concurrent process is as follows.

pOperator:

1 Withdraw the user’s balance of 1,000.

2 The remaining amount after payment is 800 = 1000 - 200.

3 The updated account balance is 800.

mOperator:

1 Withdraw the user’s balance of 1,000.

2 700 remaining after payment = 1000 - 300.

3 The account balance after payment is 700.

After two payments, the account balance is still 700. It should be that after spending 500, the account balance is 500. The root cause of this phenomenon is that during concurrency, the balance data obtained by p and m at the same time is both 1000.

2 Lock design

The lock operation generally only has two steps, one is to obtain the lock (getLock); the other is to release the lock (releaseLock). However, there are many ways to implement locks in reality, including file implementation; sql implementation; Memcache implementation; according to this scenario, we consider using strategy mode.

2.1 The class diagram design is as follows

##2.2 The php source code design is as follows

LockSystem.php

<?php

/** 
 * LockSystem.php 
 * 
 * php锁机制
 * 
 * Copy right (c) 2016 http://blog.csdn.net/CleverCode 
 * 
 * modification history: 
 * -------------------- 
 * 2016/9/10, by CleverCode, Create 
 * 
 */ 

class LockSystem
{
    const LOCK_TYPE_DB = &#39;SQLLock&#39;;
    const LOCK_TYPE_FILE = &#39;FileLock&#39;;
    const LOCK_TYPE_MEMCACHE = &#39;MemcacheLock&#39;;
    
    private $_lock = null;
    private static $_supportLocks = array(&#39;FileLock&#39;, &#39;SQLLock&#39;, &#39;MemcacheLock&#39;);  
    
    public function construct($type, $options = array()) 
    {
        if(false == empty($type))
        {
            $this->createLock($type, $options);
        }
    }   

    public function createLock($type, $options=array())
    {
        if (false == in_array($type, self::$_supportLocks))
        {
            throw new Exception("not support lock of ${type}");
        }
        $this->_lock = new $type($options);
    }
    
    public function getLock($key, $timeout = ILock::EXPIRE)
    {
        if (false == $this->_lock instanceof ILock)  
        {
            throw new Exception(&#39;false == $this->_lock instanceof ILock&#39;);          
        }  
        $this->_lock->getLock($key, $timeout);   
    }
    
    public function releaseLock($key)
    {
        if (false == $this->_lock instanceof ILock)  
        {
            throw new Exception(&#39;false == $this->_lock instanceof ILock&#39;);          
        }  
        $this->_lock->releaseLock($key);         
    }   
}

interface ILock
{
    const EXPIRE = 5;
    public function getLock($key, $timeout=self::EXPIRE);
    public function releaseLock($key);
}

class FileLock implements ILock
{
    private $_fp;
    private $_single;

    public function construct($options)
    {
        if (isset($options[&#39;path&#39;]) && is_dir($options[&#39;path&#39;]))
        {
            $this->_lockPath = $options[&#39;path&#39;].&#39;/&#39;;
        }
        else
        {
            $this->_lockPath = &#39;/tmp/&#39;;
        }
       
        $this->_single = isset($options[&#39;single&#39;])?$options[&#39;single&#39;]:false;
    }

    public function getLock($key, $timeout=self::EXPIRE)
    {
        $startTime = Timer::getTimeStamp();

        $file = md5(FILE.$key);
        $this->fp = fopen($this->_lockPath.$file.&#39;.lock&#39;, "w+");
        if (true || $this->_single)
        {
            $op = LOCK_EX + LOCK_NB;
        }
        else
        {
            $op = LOCK_EX;
        }
        if (false == flock($this->fp, $op, $a))
        {
            throw new Exception(&#39;failed&#39;);
        }
       
	    return true;
    }

    public function releaseLock($key)
    {
        flock($this->fp, LOCK_UN);
        fclose($this->fp);
    }
}

class SQLLock implements ILock
{
    public function construct($options)
    {
        $this->_db = new mysql(); 
    }

    public function getLock($key, $timeout=self::EXPIRE)
    {       
        $sql = "SELECT GET_LOCK(&#39;".$key."&#39;, &#39;".$timeout."&#39;)";
        $res =  $this->_db->query($sql);
        return $res;
    }

    public function releaseLock($key)
    {
        $sql = "SELECT RELEASE_LOCK(&#39;".$key."&#39;)";
        return $this->_db->query($sql);
    }
}

class MemcacheLock implements ILock
{
    public function construct($options)
    {
        
        $this->memcache = new Memcache();
    }

    public function getLock($key, $timeout=self::EXPIRE)
    {     
        $waitime = 20000;
        $totalWaitime = 0;
        $time = $timeout*1000000;
        while ($totalWaitime < $time && false == $this->memcache->add($key, 1, $timeout)) 
        {
            usleep($waitime);
            $totalWaitime += $waitime;
        }
        if ($totalWaitime >= $time)
            throw new Exception(&#39;can not get lock for waiting &#39;.$timeout.&#39;s.&#39;);

    }

    public function releaseLock($key)
    {
        $this->memcache->delete($key);
    }
}

3 Application lock mechanism

3.1 Payment system application lock

<?php

/** 
 * pay.php 
 * 
 * 支付应用锁
 * 
 * Copy right (c) 2016 http://blog.csdn.net/CleverCode 
 * 
 * modification history: 
 * -------------------- 
 * 2016/9/10, by CleverCode, Create 
 * 
 */  

//用户支付
function pay($userId,$money)
{
    
    if(false == is_int($userId) || false == is_int($money))
    {
        return false;
    }  
    
    try
    {
        //创建锁(推荐使用MemcacheLock)
        $lockSystem = new LockSystem(LockSystem::LOCK_TYPE_MEMCACHE);             
        
        //获取锁
        $lockKey = &#39;pay&#39;.$userId;
        $lockSystem->getLock($lockKey,8);
        
        //取出总额
        $total = getUserLeftMoney($userId);
        
        //花费大于剩余
        if($money > $total)
        {
            $ret = false;    
        }
        else
        { 
            //余额
            $left = $total - $money;
            
            //更新余额
            $ret = setUserLeftMoney($userId,$left);
        }
        
        //释放锁
        $lockSystem->releaseLock($lockKey); 
    }
    catch (Exception $e)
    {
        //释放锁
        $lockSystem->releaseLock($lockKey);     
    }

}

//取出用户的余额
function getUserLeftMoney($userId)
{
    if(false == is_int($userId))
    {
        return 0;
    }
    $sql = "select account form user_account where userid = ${userId}";
    
    //$mysql = new mysql();//mysql数据库
    return $mysql->query($sql);
}

//更新用户余额
function setUserLeftMoney($userId,$money)
{
    if(false == is_int($userId) || false == is_int($money))
    {
        return false;
    }        
    
    $sql = "update user_account set account = ${money} where userid = ${userId}";
    
    //$mysql = new mysql();//mysql数据库
    return $mysql->execute($sql);
}

?>

3.2 Lock analysis

pOperator:

1 Get the lock: pay100

2 Take out the user’s balance 1000.

3 The remaining amount after payment is 800 = 1000 - 200.

4 The updated account balance is 800.

5 Release lock: pay100

m Operator:

1 Wait for lock: pay100

2 Get lock: pay100

3 Get the balance: 800

4 The remaining 500 after payment = 800 - 300.

5 The account balance is 500 after payment.

6 Release the lock: pay100

After two payments, the balance is 500. It perfectly solves the access problem of critical section resources caused by concurrency.

The above is the detailed content of Example code of how to lock concurrency in php. For more information, please follow other related articles on the PHP Chinese website!