How to use the Hyperf framework for distributed lock management

How to use the Hyperf framework for distributed lock management

Introduction:
In a distributed system, due to multiple nodes executing tasks concurrently at the same time, there will be multiple When multiple nodes access shared resources at the same time, this may lead to problems such as data inconsistency and dirty reads. In order to solve this problem, it is often necessary to use a distributed lock mechanism to ensure the exclusivity of resources. The Hyperf framework provides a convenient way to manage distributed locks.

1. Introduction to Hyperf framework
Hyperf is a high-performance, flexible framework based on PHP coroutines, suitable for quickly building data-driven applications. It has the characteristics of low threshold, flexible dependency injection, powerful IoC container, high performance, and rich standard components.

2. Principle of distributed lock
Distributed locks usually have two implementation methods: database-based and cache-based. Database-based distributed lock implementation is relatively simple, but has lower performance. Cache-based distributed locks are usually implemented using high-performance cache services such as Redis or Memcached, which have high performance and reliability.

3. Hyperf framework integrates Redis

1. Install Redis extension

To use Redis extension in PHP environment, you need to install Redid related extension first.

pecl install redis

2. Add Redis configuration

Add Redis connection parameters in the configuration file of the Hyperf project config/autoload/redis.php:

<?php

declare(strict_types=1);

return [
    'default' => [
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'auth' => env('REDIS_AUTH', null),
        'port' => (int) env('REDIS_PORT', 6379),
        'db' => (int) env('REDIS_DB', 0),
        'pool' => [
            'max_connections' => (int) env('REDIS_MAX_CONNECTIONS', 10),
            'min_connections' => (int) env('REDIS_MIN_CONNECTIONS', 1),
            'connect_timeout' => (float) env('REDIS_CONNECT_TIMEOUT', 1.0),
            'wait_timeout' => (float) env('REDIS_WAIT_TIMEOUT', 3.0),
            'heartbeat' => (int) env('REDIS_HEARTBEAT', -1),
            'max_idle_time' => (float) env('REDIS_MAX_IDLE_TIME', 60),
        ],
    ],
];

3. Configure Redis connection information

Add the following Redis connection information to the .env file in the root directory. Be careful to modify the parameters according to the actual situation:

REDIS_HOST=127.0.0.1
REDIS_PORT=6379
REDIS_DB=0

4. Use the Hyperf framework for distributed locks

1. Create a lock service class

In the app/Utils directory of Hyperf Create the LockService.php file below to encapsulate distributed lock-related methods:

<?php

declare(strict_types=1);

namespace AppUtils;

use HyperfRedisRedisFactory;
use HyperfUtilsApplicationContext;
use RedisException;

class LockService
{
    /**
     * 获取锁
     * @param string $key 锁的key
     * @param int $expire 过期时间，单位为秒
     * @return bool
     */
    public function lock(string $key, int $expire): bool
    {
        $redis = $this->getRedis();
        try {
            return $redis->set($key, 1, ['nx', 'ex' => $expire]) ? true : false;
        } catch (RedisException $exception) {
            return false;
        }
    }

    /**
     * 解锁
     * @param string $key 锁的key
     * @return bool
     */
    public function unlock(string $key): bool
    {
        $redis = $this->getRedis();
        try {
            return $redis->del([$key]) > 0;
        } catch (RedisException $exception) {
            return false;
        }
    }

    /**
     * 获取Redis实例
     * @return mixed
     */
    private function getRedis()
    {
        $container = ApplicationContext::getContainer();
        return $container->get(RedisFactory::class)->get('default');
    }
}

2. Use the lock service class

When you need to use distribution For locks, push the lock service class through dependency injection and use it. The following example demonstrates how to use distributed locks to achieve idempotent request processing:

<?php

declare(strict_types=1);

namespace AppController;

use AppUtilsLockService;
use HyperfHttpServerAnnotationAutoController;

/**
 * @AutoController()
 */
class DemoController
{
    public function index(LockService $lockService)
    {
        // 获取锁
        $lockKey = 'demo_lock';
        $expire = 10; // 过期时间10秒
        if ($lockService->lock($lockKey, $expire)) {
            // 获得锁，执行业务逻辑
            // TODO: 处理业务逻辑

            // 释放锁
            $lockService->unlock($lockKey);
        } else {
            // 未获得锁，返回重试或失败的响应
        }
    }
}

5. Summary
Passed The Hyperf framework integrates Redis and encapsulates distributed lock service classes. We can use simple, reliable, and high-performance distributed locks to manage shared resources in distributed systems to ensure data consistency and reliability. At the same time, it also improves the system’s concurrent processing capabilities and request processing efficiency. Distributed locks are very important in practical applications. I hope that the introduction of this article can help readers better understand and use distributed locks.

The above is the detailed content of How to use the Hyperf framework for distributed lock management. For more information, please follow other related articles on the PHP Chinese website!