如何在PHP中为每个变量值创建一个互斥方法

Question

我需要在PHP中使用互斥方法，以便通过变量值保持排他性。 这是具有相同值的线程应该一次输入一个方法，而具有不同值的线程可以任意访问该方法。

例如，给定该方法：

/**
 * @param integer $value
 */
function mutexMethod($value)
{
    // Lock for value $value
    echo 'processing';
    sleep(2);
    echo 'this is so heavy';
    // Unlock for value $value
}

例如（我需要通过apache运行）：

time |
0    | php > mutexMethod(1); | php > mutexMethod(2); | php > mutexMethod(1);
1    | processing            | processing            |
2    |                       |                       |
3    | this is so heavy      | this is so heavy      | processing
4    |                       |                       |
5    |                       |                       | this is so heavy

作为第一个解决方案，我尝试使用信号量，但由于$value可能获得任何值，我已经快速耗尽信号量空间（我已经尝试在使用它们之后删除信号量但是这会破坏等待它的其他线程和因为我不知道是否有任何线程等待它们，我无法任意删除它们。

作为第二个解决方案，我尝试使用值$value作为名称创建一个文件，并使用flock锁定任何其他线程。 尽管这在CLI中有效，但我无法通过apache使其工作。 它当然锁定了文件，但它从未释放该锁定，因此任何其他请求都会被卡住，直到第一个超时（30秒后）。

最后我虽然关于使用MySQL锁，但我想避免它们，因为我们不想使用MySQL实例来做这些事情。 理想情况下，我们想要一个纯PHP解决方案。

你对我如何解决这个问题有所了解吗？ 我想避免单信号量解决方案（比如有一个信号量来控制对跟踪锁的文件的访问），因为这会产生巨大的瓶颈（特别是对于那些具有不同值的线程）。

非常感谢你。

Answer 1

https://github.com/arvenil/ninja-mutex

flock / mysql / redis / memcache适配器

您可以尝试所有这些并选择适合您的那个

在您的情况下，示例可能如下所示

<?php
require 'vendor/autoload.php';

use NinjaMutex\Lock\MemcacheLock;
use NinjaMutex\MutexFabric;

$memcache = new Memcache();
$memcache->connect('127.0.0.1', 11211);
$lock = new MemcacheLock($memcache);
$mutexFabric = new MutexFabric('memcache', $lock);
if ($mutexFabric->get($value)->acquireLock(1000)) {
    // Do some very critical stuff

    // and release lock after you finish
    $mutexFabric->get($value)->releaseLock();
} else {
    throw new Exception('Unable to gain lock for very critical stuff!');
}

Answer 2

根据我的理解，您希望确保一次只有一个进程运行某段代码。 我自己使用lockfiles来获得适用于许多平台的解决方案，并且不依赖于仅在Linux等上可用的特定库。

为此，我写了一个小的Lock类。 请注意，它使用我的库中的一些非标准函数，例如，获取存储临时文件的位置等。但您可以轻松地更改它。

<?php   
    class Lock
    {
        private $_owned             = false;

        private $_name              = null;
        private $_lockFile          = null;
        private $_lockFilePointer   = null;

        public function __construct($name)
        {
            $this->_name = $name;
            $this->_lockFile = PluginManager::getInstance()->getCorePlugin()->getTempDir('locks') . $name . '-' . sha1($name . PluginManager::getInstance()->getCorePlugin()->getPreference('EncryptionKey')->getValue()).'.lock';
        }

        public function __destruct()
        {
            $this->release();
        }

        /**
         * Acquires a lock
         *
         * Returns true on success and false on failure.
         * Could be told to wait (block) and if so for a max amount of seconds or return false right away.
         *
         * @param bool $wait
         * @param null $maxWaitTime
         * @return bool
         * @throws \Exception
         */
        public function acquire($wait = false, $maxWaitTime = null) {
            $this->_lockFilePointer = fopen($this->_lockFile, 'c');
            if(!$this->_lockFilePointer) {
                throw new \RuntimeException(__('Unable to create lock file', 'dliCore'));
            }

            if($wait && $maxWaitTime === null) {
                $flags = LOCK_EX;
            }
            else {
                $flags = LOCK_EX | LOCK_NB;
            }

            $startTime = time();

            while(1) {
                if (flock($this->_lockFilePointer, $flags)) {
                    $this->_owned = true;
                    return true;
                } else {
                    if($maxWaitTime === null || time() - $startTime > $maxWaitTime) {
                        fclose($this->_lockFilePointer);
                        return false;
                    }
                    sleep(1);
                }
            }
        }

        /**
         * Releases the lock
         */
        public function release()
        {
            if($this->_owned) {
                @flock($this->_lockFilePointer, LOCK_UN);
                @fclose($this->_lockFilePointer);
                @unlink($this->_lockFile);
                $this->_owned = false;
            }
        }
    }

用法

现在，您可以拥有两个同时运行的进程并执行相同的脚本

过程1

$lock = new Lock('runExpensiveFunction');

if($lock->acquire()) {
  // Some expensive function that should only run one at a time
  runExpensiveFunction();
  $lock->release();
}

过程2

$lock = new Lock('runExpensiveFunction');

// Check will be false since the lock will already be held by someone else so the function is skipped
if($lock->acquire()) {
  // Some expensive function that should only run one at a time
  runExpensiveFunction();
  $lock->release();
}

另一种方法是让第二个进程等待第一个进程完成，而不是跳过代码。

$lock = new Lock('runExpensiveFunction');

// Process will now wait for the lock to become available. A max wait time can be set if needed.
if($lock->acquire(true)) {
  // Some expensive function that should only run one at a time
  runExpensiveFunction();
  $lock->release();
}

RAM磁盘

要使用锁定文件限制对HDD / SSD的写入次数，您可以创建一个RAM磁盘来存储它们。

在Linux上，您可以在/etc/fstab添加以下内容

tmpfs       /mnt/ramdisk tmpfs   nodev,nosuid,noexec,nodiratime,size=1024M   0 0

在Windows上，您可以下载ImDisk Toolkit之类的内容，并使用它创建一个ramdisk。

Answer 3

如果您需要处理的不同ID的数量只是少数，您可能需要考虑使用队列系统，例如。 与RabbitMQ兼容的AMQP，每个ID有一个队列，每个队列有一个消费者。