Introduction to file lock and process lock examples in PHP

This article mainly introduces the usage examples of PHP file lock and process lock. The editor thinks it is quite good, so I will share it with you now and give it as a reference. Let’s follow the editor to take a look.

In view of the introduction of swoole before, let’s use swoole’s server/client and multi-process mechanism to explain the lock.

This is only for PHP The lock mechanism will be explained. Since SQL locks have different modes of action and application scenarios, they will be explained separately.

1. File lock

• flock()

• ##fclose()

##swoole_lock()
Possible application scenarios of file locks are:

1. Limit concurrent multiple processes or multiple servers that need to access and modify the same file;

2. /O process queuing and artificial blocking;

3. Guard the file content in the business logic;

The following is the file lock C/S communication mechanism For use, the specific communication process has been omitted

Server (the server communication process has been omitted):

//监听数据发送事件
$serv->on('receive', function ($serv, $fd, $from_id, $data) {
  $serv->send($fd, "ServerEnd");

  $p_file = "locktest.txt";
  var_dump(file_get_contents($p_file));
});

Client1 (the server communication process has been omitted):

$s_recv = "ww";

$p_file = "locktest.txt";

$o_file = fopen($p_file,'w+');
// flock()加锁方式:
flock($o_file,LOCK_EX);

// // swoole加锁方式:
// $lock = new swoole_lock(SWOOLE_FILELOCK, $p_file);
// $lock->lock();

fwrite($o_file, 'ss' . $s_recv);

sleep(30);
// 两种解锁方式
// flock($o_file, LOCK_UN);
// $lock->unlock();

Client2 (server communication process omitted):

$s_recv = "xx";

$p_file = "locktest.txt";

$o_file = fopen($p_file,'w+');
// flock()加锁方式:
flock($o_file,LOCK_EX);

// // swoole加锁方式:
// $lock = new swoole_lock(SWOOLE_FILELOCK, $p_file);
// $lock->lock();


fwrite($o_file, 'ss' . $s_recv);

// 两种解锁方式
// flock($o_file, LOCK_UN);
// $lock->unlock();

Result:

Client2 was blocked for 30s, and did not write to the file until Client1 finished executing;

[l0.16@4 m29.5% c30s04] $ php swoole_client2.php

It should be noted that:

1. Both flock() and swoole_lock() provided by swoole have a mechanism to automatically unlock when the process ends, so it can run normally even without manual unlocking in the demo, so sleep() is executed in the first Client. ) Pause the function to observe the effect of file lock;

2. The standard release method of flock() is flock($file,LOCK_UN);, but I personally like fclose() to avoid future troubles;

2. Process lockDifferent from file locks, process locks are not used to prevent I/O to files. It is used to prevent unexpected consequences caused by multi-process concurrency. Therefore, it is necessary to queue multiple processes when they are concurrent, that is, blocking the logic execution of other concurrent processes before the key logic execution of a process ends.

There are several implementation ideas:

1. Use flock() file lock to create a temporary lock file, use LOCK_NB to simulate blocking or non-blocking flow, and then use judgment inside the process Conditional control logic execution;

Non-blocking model demo:

$p_file = "locktest.txt";
$o_file = fopen($p_file, 'w+');

// 如果临时文件被锁定,这里的flock()将返回false
if (!flock($o_file, LOCK_EX + LOCK_NB)) {
  var_dump('Process Locked');
}
else {
  // 非阻塞模型必须在flock()中增加LOCK_NB参数
  // 当然,这里取消LOCK_NB参数就是阻塞模型了
  flock($o_file, LOCK_EX + LOCK_NB);
  var_dump('Process Locking');
  // 模拟长时间的执行操作
  sleep(10);
}

2. Use the shared memory, cache method or communication method provided by swoole in different processes Pass a global variable in, and the process will use judgment conditions to control logic execution after obtaining the status of the variable;

There are many ways to pass variables, here is only one idea, take memcached as an example;

Blocking model demo:

// 初始化memcached
$memcached = new Memcache;
$memcached->connect("localhost", 11211);

// 获取用来做状态判定的全局变量
$s_flag = $memcached->get("flag");

if (!$s_flag) {
  // 这里利用了memcached的过期时间作为演示,实际上业务处理完成后销毁该变量即可
  $memcached->set("flag", "locked", 0, 10);
  main();
}
else {
  // 阻塞模型
  while ($s_flag == 'locked') {
    var_dump('Process locked, retrying...');
    // 设置重试时间, 避免过于频繁的操作尝试
    sleep(1);
    // 更新状态变量
    $s_flag = $memcached->get("flag");
  }
  // // 非阻塞模型
  // if ($s_flag == 'locked') {
  //   var_dump('Process locked, suspended');
  //   die();
  // }
  main();
}

// 模拟业务主函数
function main() {
  var_dump('Process Running');
  // 业务执行结束后回收memcached
  // $memcached->delete("flag");
}

What needs to be noted here is:

1.memcached expiration time It cannot be less than the actual time of program running, so it is recommended to be slightly longer and recycle after the logic execution is completed;

2. In the non-blocking model, if the status is judged to be false, the process should be terminated or block to avoid the continued execution of business logic;

3. In actual applications, it is necessary to set a retry time, which can greatly reduce the large amount of I/O concurrency for memcached. , reduce server pressure;

The above is the detailed content of Introduction to file lock and process lock examples in PHP. For more information, please follow other related articles on the PHP Chinese website!