I like FlockMutex because it work on kernel level and is reliable.

however there's the problem that acquiring the lock makes program wait forever. I wish to get error "unable to obtain lock withing timeout"

for flock there's LOCK_NB flag which can be used.

ps: SemaphoreMutex has similar issue

Shouldn't the unlock method of SpinlockMutex throw a TimeoutException if the executed time lasted longer than the set timeout instead of an LockReleaseException?

Related code from SpinlockMutex:

protected function unlock()
    {
        $elapsed = microtime(true) - $this->acquired;
        if ($elapsed >= $this->timeout) {
            $message = sprintf(
                "The code executed for %d seconds. But the timeout is %d seconds.",
                $elapsed,
                $this->timeout
            );
            throw new LockReleaseException($message);
        }
        /*
         * Worst case would still be one second before the key expires.
         * This guarantees that we don't delete a wrong key.
         */
        if (!$this->release($this->key)) {
            throw new LockReleaseException("Failed to release the lock.");
        }
    }

If not, can you explain why?

When LockReleaseException or ExecutionOutsideLockException is thrown there is no way to access the return value of the code block (it was executed).

Following change to LockMutex::synchronized() comes to mind:

    public function synchronized(callable $code)
    {
        $this->lock();

        $result = null;
        try {
            $result = $code();
        } finally {
	        try {
		        $this->unlock();
	        } catch (ExecutionOutsideLockException|LockReleaseException $e) {
		        $e->setCodeResult($result);
		        throw $e;
	        }
        }

        return $result;
    }

Also setCodeResult and getCodeResult should be added to both exception classes.

Of course a library user can always extend specific LockMutex subclass (ex. PredisMutex) and override the synchronized() method to deal with this problem, but maybe it's worth incorporating directly into the library.

• Added ExecutionOutsideLockException which can be thrown when the lock is released or times out before the synchronized code finished execution.
• Changed SpinlockMutex to use the new ExecutionOutsideLockException when the synchronized code executes longer than the set timeout.

Resolves php-lock/lock#19

• Added php-cs-fixer with a configurable ruleset for code format. Run vendor/bin/php-cs-fixer fix to run php-cs-fixer against the .phpcs_dist or .phpcs config. Current configuration is based on PSR-12 plus a few extras.
• Added declare(strict_types=1); to all files to enable strict type checking.
• Fixed a missing log placeholder 2ca1e30.
• Added many missing docblock comments.
• Improved documentation in many classes.
• Improved exception inheritance. All exceptions extend one common project specific interface.
• Fixed package case to support composer 2.0 921622c.

Add ability to do this:

try {
    $mutex->synchronized(function () {
        if (someCondition()) {
            throw new \DomainException();
        }

        return "result";
    });
} catch (LockReleaseException $e) {
    if ($e->getCodeException() !== null) {
        // do something with the code exception
    } else {
        $result = $e->getCodeResult();
        // do something with the code result
    }
    
    // deal with or propagate the LockReleaseException
    throw $e;
}

php-lock/lock#25: Drop support for php 5.6 and 7.0

• Updated all packages.
• Updated all tests to use phpunit 7.x.x
• Updated project files.

What else needs to be done?

I have a simple piece of code:

$mutex = new \malkusch\lock\mutex\PHPRedisMutex([$app['redis']], "lock.".$guid, 8);
            $mutex->synchronized(function () use ($object) {
                echo 'test';
                sleep(3);
            });

but it throws the following exception: LockReleaseException in SpinlockMutex.php line 94: Failed to release the lock.

I am running PHP Version 7.0.15 with Redis extension 3.0.0

Seems that the problem is with the file PHPRedisMutex.php, at line 63: return $redis->eval($script, $arguments, $numkeys);

At https://github.com/phpredis/phpredis#eval we can read:

Return value

Mixed. What is returned depends on what the LUA script itself returns, which could be a scalar value (int/string), or an array.

So, I have replaced the code at line 63 with:

$redis->eval($script, $arguments, $numkeys);
            return $redis->getlasterror() == 0;

In that way it seems to work properly. I think that with the new php redis extension the return of the eval function has changed, and becouse of that it returns an unexpected value. So I have changed the code in a way that it returns a boolean, checking if redis encountered an error. I'm not sure if that's the best way to fix that trouble, but with my tests it seems working.

(We are using php 7.3.22 on Linux together with php-lock v2.1, but it seems this issue persists in v2.2 as well)

I'm not quite sure if this is desired behavior, but I want to talk about Loop::execute():

Let's suppose the call $result = $code(); was successful, meaning $code() called Loop::end() and had side effects, but its successful execution took longer than $this->timeout.

In that case

if (microtime(true) >= $deadline) {
        throw TimeoutException::create($this->timeout);
}

which appears after the for loop, would still throw a TimeoutException, which seems counterintuitive to me.

A possible fix could be to only throw if additionally $this->looping is true:

if (microtime(true) >= $deadline && $this->looping) {
        throw TimeoutException::create($this->timeout);
}

See LongLockTest.txt for a quick unit test

max. sleep duration should be based on timeout, as for shorter timeouts, we should loop more often (like for web/API) vs. some long timeouts (for CLI/crons)

In PHP Redis extension, closing the connection won't trigger RedisException on further function calls, as it will reconnect and continue to work. This fix makes sure the exception is thrown on closed connection.

After upgrading Symfony and Sentry ("sentry/sentry-symfony": "^4.3.0") I got the message that I needed to also upgrade doctrine/dbal ("doctrine/dbal": "^2.13.9",) , which then subsequently broke my use of MySQLMutex.

<b>Fatal error</b>:  Uncaught Symfony\Component\Debug\Exception\FatalThrowableError: Type error: Argument 1 
passed to malkusch\lock\mutex\MySQLMutex::__construct() must be an instance of PDO, instance of 
Sentry\SentryBundle\Tracing\Doctrine\DBAL\TracingServerInfoAwareDriverConnection given, called in 
/var/www/html/src/ApiBundle/Controller/Invoicing/InvoiceController.php on line 533 in 
/var/www/html/vendor/malkusch/lock/classes/mutex/MySQLMutex.php:27

The MySQLMutex class only expects an instance of PDO to be provided, and in my case this is actually an instance of the Doctrine\DBAL\Connection interface with the updated Sentry package.

$em = $this->getContainer()->get('doctrine.orm.entity_manager');
$pdo = $em->getConnection()->getWrappedConnection();
$mutex = new MySQLMutex($pdo, 'Some lock');

A solution would be to adapt the package so that the MySQLMutex class accepts both an instance of PDO and Doctrine\DBAL\Connection.

Might make a PR for this in the coming week.

The following PHPUnit test fails if I try to use parallel threads

I'm using php-lock version 2.1 on windows with php version 7.4.6

If I deactivate the $this->mutex->synchronized function by commenting out the function the test is executed without an error. Does anyone have an idea whats wrong with my test case?

<?php
namespace Squeeze;

use Exception;
use malkusch\lock\mutex\FlockMutex;
use PHPUnit\Framework\TestCase;

class ThreadLockTest extends TestCase
{

    /**
     * @var FlockMutex
     */
    private $mutex;

    /**
     * @var resource
     */
    private $file;

    protected function setUp(): void
    {
        parent::setUp();

        $this->file = __DIR__ . DIRECTORY_SEPARATOR . 'flock';
        $this->mutex = new FlockMutex(fopen($this->file, 'w'), 1);
    }

    protected function tearDown(): void
    {
        unlink($this->file);

        parent::tearDown();
    }

    public function testThreadLock(): void
    {
        $syncFunction = function ($i) {
            try {
                require_once __DIR__ . '/../../../bootstrap/app.php';
                echo $i .' Running ' . PHP_EOL;
                return $this->mutex->synchronized(function () use ($i) : string {
                    sleep(1);
                    return $i .' Finished.' . PHP_EOL;
                });
            } catch (Exception $e) {
                return $e->getMessage() . PHP_EOL;
            }
        };

        $results = array();
        for ($i = 1; $i < 6; $i++) {
            $results[] = \parallel\run($syncFunction, array($i));
        }

        foreach ($results as $item) {
            echo $item->value();
        }
    }
}

Spinlock with a twist (pun intended 😉)

Problem: I needed to throw an exception if the lock is already taken, but only after a given timeout.

Proposed solution The spinlock already has its own timeout (eg: 5 seconds). With this new option: lockedTimeout you can now specify a timeout while lock is already taken. (eg: 3 seconds). The process will try to acquire the lock for 3 seconds then throw an exception if it doesn't succeed.

If we specify a lockedTimeout of 0, the exception will be thrown immediately after the first lock acquire attempt.

This (with a lockedTimeout of zero) also addresses: https://github.com/php-lock/lock/issues/21#issuecomment-394963109

Some improvements that can be made:

• If the lock fails to be acquired on a majority of servers, immediately abort the lock.
• Only release locks on servers where we tried to set the lock
• Further investigate multiplexing (does not seem possible with current approaches)
• Acquire locks in random order of servers

What is this this error?

It's not possible to acquire a lock because at least half of the Redis serv er are not available.

This is my code:

        $redis = new Client;
        $redis->auth(REDIS-PASSWORD,null);
        $redis->connect();
        $my_range = range(1,100);

        foreach ($my_range as $each_range){
            $mutex = new PredisMutex([$redis], "balance");
            $mutex->synchronized(function () use($each_range) {
                $this->use_this_range($each_range);
            });
        }