The Semaphore Component

Installation

1

$ composer require symfony/semaphore

Usage

In computer science, a semaphore is a variable or abstract data type used to control access to a common resource by multiple processes in a concurrent system such as a multitasking operating system. The main difference with locks is that semaphores allow more than one process to access a resource, whereas locks only allow one process.

Create semaphores with the SemaphoreFactory class, which in turn requires another class to manage the storage:

1
2
3
4
5
6
7
8

use Symfony\Component\Semaphore\SemaphoreFactory;
use Symfony\Component\Semaphore\Store\RedisStore;

$redis = new Redis();
$redis->connect('172.17.0.2');

$store = new RedisStore($redis);
$factory = new SemaphoreFactory($store);

The semaphore is created by calling the createSemaphore() method. Its first argument is an arbitrary string that represents the locked resource. Its second argument is the maximum number of processes allowed. Then, a call to the acquire() method will try to acquire the semaphore:

1
2
3
4
5
6
7
8
9

// ...
$semaphore = $factory->createSemaphore('pdf-invoice-generation', 2);

if ($semaphore->acquire()) {
    // The resource "pdf-invoice-generation" is locked.
    // Here you can safely compute and generate the invoice.

    $semaphore->release();
}

If the semaphore can not be acquired, the method returns false. The acquire() method can be safely called repeatedly, even if the semaphore is already acquired.

Using Locks as Semaphore Stores

You can also use the LockStore to use any Lock component backend (flock, Redis, PDO, etc.) as a semaphore store:

1
2
3
4
5
6
7
8

use Symfony\Component\Lock\LockFactory;
use Symfony\Component\Lock\Store\FlockStore;
use Symfony\Component\Semaphore\SemaphoreFactory;
use Symfony\Component\Semaphore\Store\LockStore;

$lockFactory = new LockFactory(new FlockStore());
$store = new LockStore($lockFactory);
$factory = new SemaphoreFactory($store);

When using the FrameworkBundle, you can configure this with the lock:// DSN:

1
2
3
4

# config/packages/semaphore.yaml
framework:
    lock: 'flock'
    semaphore: 'lock://'

1
2
3
4
5
6
7
8
9

// config/packages/semaphore.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

return App::config([
    'framework' => [
        'lock' => 'flock',
        'semaphore' => 'lock://',
    ],
]);

You can also reference a specific named lock resource using lock://name:

1
2
3
4
5
6
7
8

# config/packages/semaphore.yaml
framework:
    lock:
        default: 'flock'
        my_locks: '%env(REDIS_DSN)%'
    semaphore:
        default: 'lock://'          # uses lock.default.factory
        other: 'lock://my_locks'    # uses lock.my_locks.factory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// config/packages/semaphore.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

return App::config([
    'framework' => [
        'lock' => [
            'default' => 'flock',
            'my_locks' => env('REDIS_DSN'),
        ],
        'semaphore' => [
            'default' => 'lock://',         // uses lock.default.factory
            'other' => 'lock://my_locks',   // uses lock.my_locks.factory
        ],
    ],
]);

Serializing Semaphores

The Key contains the state of the Semaphore and can be serialized. This allows acquiring a semaphore in one process and releasing it in another, which is useful for workflows, message queues, or any scenario where the acquire and release happen in different contexts.

First, create the semaphore and acquire a slot:

1
2
3
4
5
6
7
8
9
10
11
12
13

use Symfony\Component\Semaphore\Key;

$key = new Key('pdf-generation', 5);  // 5 concurrent slots available
$semaphore = $factory->createSemaphoreFromKey(
    $key,
    300,   // ttl
    false  // autoRelease
);

if ($semaphore->acquire()) {
    // dispatch to worker, passing $key
    $this->bus->dispatch(new GeneratePdfMessage($document, $key));
}

Then, in the worker, use the key to reconstruct and release the semaphore:

1
2
3
4
5
6
7

$semaphore = $factory->createSemaphoreFromKey($key, 300, false);

try {
    // do work
} finally {
    $semaphore->release();
}

Semaphores can be serialized using both the native PHP serialization system and its serialize function, or using the Serializer component.