锁组件

自动释放锁

当 Lock 对象被销毁时，锁会自动释放。这是一个实现细节，在进程之间共享锁时非常重要。在下面的示例中，pcntl_fork() 创建了两个进程，并且一旦一个进程完成，锁将自动释放

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// ...
$lock = $factory->createLock('pdf-creation');
if (!$lock->acquire()) {
    return;
}

$pid = pcntl_fork();
if (-1 === $pid) {
    // Could not fork
    exit(1);
} elseif ($pid) {
    // Parent process
    sleep(30);
} else {
    // Child process
    echo 'The lock will be released now.';
    exit(0);
}
// ...

要禁用此行为，请将 LockFactory::createLock() 的 autoRelease 参数设置为 false。这将使锁被获取 3600 秒或直到 Lock::release() 被调用

1
2
3
4
5

$lock = $factory->createLock(
    'pdf-creation',
    3600, // ttl
    false // autoRelease
);

FlockStore

FlockStore 使用本地计算机上的文件系统来创建锁。它不支持过期，但当锁对象超出作用域并被垃圾回收器释放时（例如，当 PHP 进程结束时），锁会自动释放

1
2
3
4
5

use Symfony\Component\Lock\Store\FlockStore;

// the argument is the path of the directory where the locks are created
// if none is given, sys_get_temp_dir() is used internally.
$store = new FlockStore('/var/stores');

MemcachedStore

MemcachedStore 将锁保存在 Memcached 服务器上，它需要实现 \Memcached 类的 Memcached 连接。此存储不支持阻塞，并期望使用 TTL 以避免死锁

1
2
3
4
5
6

use Symfony\Component\Lock\Store\MemcachedStore;

$memcached = new \Memcached();
$memcached->addServer('localhost', 11211);

$store = new MemcachedStore($memcached);

MongoDbStore

MongoDbStore 将锁保存在 MongoDB 服务器 >=2.2 上，它需要来自 mongodb/mongodb 的 \MongoDB\Collection 或 \MongoDB\Client，或者 MongoDB 连接字符串。此存储不支持阻塞，并期望使用 TTL 以避免死锁

1
2
3
4
5
6
7
8
9
10
11

use Symfony\Component\Lock\Store\MongoDbStore;

$mongo = 'mongodb://127.0.0.1/database?collection=lock';
$options = [
    'gcProbability' => 0.001,
    'database' => 'myapp',
    'collection' => 'lock',
    'uriOptions' => [],
    'driverOptions' => [],
];
$store = new MongoDbStore($mongo, $options);

MongoDbStore 接受以下 $options（取决于第一个参数类型）

当第一个参数是

MongoDB\Collection:

• $options['database'] 被忽略
• $options['collection'] 被忽略

MongoDB\Client:

• $options['database'] 是必需的
• $options['collection'] 是必需的

MongoDB 连接字符串

• 使用 $options['database']，否则使用来自 DSN 的 /path，至少需要一个
• 使用 $options['collection']，否则使用来自 DSN 的 ?collection=，至少需要一个

PdoStore

PdoStore 将锁保存在 SQL 数据库中。它需要 PDO 连接或 数据源名称 (DSN)。此存储不支持阻塞，并期望使用 TTL 以避免死锁

1
2
3
4
5

use Symfony\Component\Lock\Store\PdoStore;

// a PDO instance or DSN for lazy connecting through PDO
$databaseConnectionOrDSN = 'mysql:host=127.0.0.1;dbname=app';
$store = new PdoStore($databaseConnectionOrDSN, ['db_username' => 'myuser', 'db_password' => 'mypassword']);

存储值的表在首次调用 save() 方法时自动创建。您也可以通过在代码中调用 createTable() 方法显式创建此表。

DoctrineDbalStore

DoctrineDbalStore 将锁保存在 SQL 数据库中。它与 PdoStore 相同，但需要 Doctrine DBAL 连接 或 Doctrine DBAL URL。此存储不支持阻塞，并期望使用 TTL 以避免死锁

1
2
3
4
5

use Symfony\Component\Lock\Store\DoctrineDbalStore;

// a Doctrine DBAL connection or DSN
$connectionOrURL = 'mysql://myuser:[email protected]/app';
$store = new DoctrineDbalStore($connectionOrURL);

当您运行命令时，将自动生成存储值的表

1

$ php bin/console make:migration

如果您希望自己创建表并且尚未创建，则可以通过调用 createTable() 方法显式创建此表。您也可以通过在代码中调用 configureSchema() 方法将此表添加到您的架构中

如果上游尚未创建表，则在首次调用 save() 方法时将自动创建。

PostgreSqlStore

PostgreSqlStore 使用 PostgreSQL 提供的 咨询锁。它需要 PDO 连接或 数据源名称 (DSN)。它支持原生阻塞以及共享锁

1
2
3
4
5

use Symfony\Component\Lock\Store\PostgreSqlStore;

// a PDO instance or DSN for lazy connecting through PDO
$databaseConnectionOrDSN = 'pgsql:host=localhost;port=5634;dbname=app';
$store = new PostgreSqlStore($databaseConnectionOrDSN, ['db_username' => 'myuser', 'db_password' => 'mypassword']);

与 PdoStore 相反，PostgreSqlStore 不需要表来存储锁，并且它不会过期。

DoctrineDbalPostgreSqlStore

DoctrineDbalPostgreSqlStore 使用 PostgreSQL 提供的 咨询锁。它与 PostgreSqlStore 相同，但需要 Doctrine DBAL 连接 或 Doctrine DBAL URL。它支持原生阻塞以及共享锁。

1
2
3
4
5

use Symfony\Component\Lock\Store\DoctrineDbalPostgreSqlStore;

// a Doctrine Connection or DSN
$databaseConnectionOrDSN = 'postgresql+advisory://myuser:[email protected]:5634/lock';
$store = new DoctrineDbalPostgreSqlStore($databaseConnectionOrDSN);

与 DoctrineDbalStore 相反，DoctrineDbalPostgreSqlStore 不需要表来存储锁，并且不会过期。

RedisStore

RedisStore 将锁保存在 Redis 服务器上，它需要实现 \Redis, \RedisArray, \RedisCluster, \Relay\Relay 或 \Predis 类的 Redis 连接。此存储不支持阻塞，并期望使用 TTL 来避免锁停滞。

1
2
3
4
5
6

use Symfony\Component\Lock\Store\RedisStore;

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

$store = new RedisStore($redis);

SemaphoreStore

SemaphoreStore 使用 PHP 信号量函数 来创建锁。

1
2
3

use Symfony\Component\Lock\Store\SemaphoreStore;

$store = new SemaphoreStore();

CombinedStore

CombinedStore 专为高可用性应用而设计，因为它同步管理多个存储（例如，多个 Redis 服务器）。当获取锁时，它会将调用转发到所有受管理的存储，并收集它们的响应。如果大多数存储已获取锁，则认为锁已获取。

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

use Symfony\Component\Lock\Store\CombinedStore;
use Symfony\Component\Lock\Store\RedisStore;
use Symfony\Component\Lock\Strategy\ConsensusStrategy;

$stores = [];
foreach (['server1', 'server2', 'server3'] as $server) {
    $redis = new \Redis();
    $redis->connect($server);

    $stores[] = new RedisStore($redis);
}

$store = new CombinedStore($stores, new ConsensusStrategy());

除了简单多数策略 (ConsensusStrategy) 外，还可以使用 UnanimousStrategy 来要求在所有存储中都获取锁。

1
2
3
4

use Symfony\Component\Lock\Store\CombinedStore;
use Symfony\Component\Lock\Strategy\UnanimousStrategy;

$store = new CombinedStore($stores, new UnanimousStrategy());

ZookeeperStore

ZookeeperStore 将锁保存在 ZooKeeper 服务器上。它需要实现 \Zookeeper 类的 ZooKeeper 连接。此存储不支持阻塞和过期，但当 PHP 进程终止时，锁会自动释放。

1
2
3
4
5
6
7

use Symfony\Component\Lock\Store\ZookeeperStore;

$zookeeper = new \Zookeeper('localhost:2181');
// use the following to define a high-availability cluster:
// $zookeeper = new \Zookeeper('localhost1:2181,localhost2:2181,localhost3:2181');

$store = new ZookeeperStore($zookeeper);

远程存储

远程存储 (MemcachedStore, MongoDbStore, PdoStore, PostgreSqlStore, RedisStore 和 ZookeeperStore) 使用唯一令牌来识别锁的真正所有者。此令牌存储在 Key 对象中，并由 Lock 在内部使用。

每个并发进程都必须将 Lock 存储在同一服务器上。否则，两台不同的机器可能允许两个不同的进程获取同一个 Lock。

过期存储

过期存储 (MemcachedStore, MongoDbStore, PdoStore 和 RedisStore) 保证锁仅在定义的持续时间内被获取。如果任务花费的时间更长才能完成，则锁可能会被存储释放并被其他人获取。

Lock 提供了几种方法来检查其健康状况。isExpired() 方法检查其生命周期是否结束，而 getRemainingLifetime() 方法返回其剩余生存时间（以秒为单位）。

使用上述方法，健壮的代码将是

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

// ...
$lock = $factory->createLock('pdf-creation', 30);

if (!$lock->acquire()) {
    return;
}
while (!$finished) {
    if ($lock->getRemainingLifetime() <= 5) {
        if ($lock->isExpired()) {
            // lock was lost, perform a rollback or send a notification
            throw new \RuntimeException('Lock lost during the overall process');
        }

        $lock->refresh();
    }

    // Perform the task whose duration MUST be less than 5 seconds
}

根据设计，锁存储在具有定义生命周期的服务器上。如果机器的日期或时间发生更改，则锁可能会比预期更早释放。

FlockStore

通过使用文件系统，只要并发进程使用相同的物理目录来存储锁，此 Store 就是可靠的。

进程必须在同一台机器、虚拟机或容器上运行。更新 Kubernetes 或 Swarm 服务时要小心，因为在短时间内，可能有两个容器并行运行。

目录的绝对路径必须保持不变。小心可能随时更改的符号链接：Capistrano 和蓝/绿部署经常使用这种技巧。当该目录的路径在两次部署之间更改时要小心。

某些文件系统（例如某些类型的 NFS）不支持锁定。

文件系统上的文件可能会在维护操作期间被删除。例如，清理 /tmp 目录或在机器重启后当目录使用 tmpfs 时。如果锁在进程结束后释放，则这不是问题，但在请求之间重用 Lock 的情况下，这是一个问题。

MemcachedStore

Memcached 的工作方式是将项目存储在内存中。这意味着通过使用 MemcachedStore，锁不会被持久化，并且可能随时意外消失。

如果 Memcached 服务或托管它的机器重启，则每个锁都会丢失，而不会通知正在运行的进程。

默认情况下，当 Memcached 服务需要空间添加新项目时，它使用 LRU 机制来删除旧条目。

当 Memcached 服务被共享并用于多种用途时，锁可能会被错误地删除。例如，PSR-6 clear() 方法的某些实现使用 Memcached 的 flush() 方法，该方法会清除并删除所有内容。

MongoDbStore

必须使用 TTL 索引来自动清理过期的锁。这样的索引可以手动创建

1
2
3
4

db.lock.createIndex(
    { "expires_at": 1 },
    { "expireAfterSeconds": 0 }
)

或者，可以调用 MongoDbStore::createTtlIndex(int $expireAfterSeconds = 0) 方法一次，以便在数据库设置期间创建 TTL 索引。阅读更多关于 MongoDB 中 通过设置 TTL 从集合中使数据过期 的信息。

writeConcern 和 readConcern 未由 MongoDbStore 指定，这意味着集合的设置将生效。readPreference 对于所有查询都是 primary。阅读更多关于 MongoDB 中 副本集读取和写入语义 的信息。

PdoStore

PdoStore 依赖于 SQL 引擎的 ACID 属性。

为了清除旧锁，此存储使用当前日期时间来定义过期日期参考。此机制依赖于所有服务器节点都具有同步时钟。

PostgreSqlStore

PostgreSqlStore 依赖于 PostgreSQL 数据库的 咨询锁 属性。这意味着通过使用 PostgreSqlStore，如果客户端由于任何原因无法解锁，锁将在会话结束时自动释放。

如果 PostgreSQL 服务或托管它的机器重启，则每个锁都会丢失，而不会通知正在运行的进程。

如果 TCP 连接丢失，PostgreSQL 可能会释放锁，而不会通知应用程序。

RedisStore

Redis 的工作方式是将项目存储在内存中。这意味着通过使用 RedisStore，锁不会被持久化，并且可能随时意外消失。

如果 Redis 服务或托管它的机器重启，则每个锁都会丢失，而不会通知正在运行的进程。

当 Redis 服务被共享并用于多种用途时，锁可能会被错误地删除。

CombinedStore

组合存储允许跨多个后端存储锁。认为锁定机制会更可靠是一个常见的错误。这是错误的。CombinedStore 最多只能与所有受管理存储中最不可靠的存储一样可靠。一旦一个受管理存储返回错误信息，CombinedStore 将不可靠。

SemaphoreStore

信号量由内核级别处理。为了可靠，进程必须在同一台机器、虚拟机或容器上运行。更新 Kubernetes 或 Swarm 服务时要小心，因为在短时间内，可能有两个容器并行运行。

ZookeeperStore

ZookeeperStore 的工作方式是通过将锁维护为服务器上的临时节点。这意味着通过使用 ZookeeperStore，如果客户端由于任何原因无法解锁，锁将在会话结束时自动释放。

如果 ZooKeeper 服务或托管它的机器重启，则每个锁都会丢失，而不会通知正在运行的进程。

概述

更改存储的配置应非常谨慎。例如，在新版本部署期间。当具有旧配置的旧进程仍在运行时，不得启动具有新配置的进程。