Detailed explanation of file locks, mutex locks, and read-write locks in PHP

This article mainly introduces the analysis of file locks, mutex locks, and read-write locks in PHP programs. It focuses on the usage examples in the sync module and pthreads module. Friends in need can refer to it. I hope to be helpful.

File lock
The full name is advisory file lock, which is mentioned in the book. This type of lock is relatively common. For example, after mysql and php-fpm are started, there will be a pid file recording the process ID. This file is the file lock.

This lock can prevent a process from running repeatedly. For example, when using crontab, one task is limited to be executed every minute, but this process may run for more than one minute. If the process lock is not used to resolve the conflict, the two processes will be together. There will be problems with execution.

Another advantage of using PID file lock is that it is convenient for the process to send stop or restart signals to itself. For example, the command to restart php-fpm is

kill -USR2 `cat /usr/local/php/var/run/php-fpm.pid`
Send the USR2 signal to the process recorded in the pid file. The signal It belongs to process communication and will be opened in another chapter.

The interface of php is flock, and the documentation is relatively detailed. Let’s take a look at the definition first, bool flock ( resource $handle , int $operation [, int &$wouldblock ] ).

• $handle is the file system pointer, which is typically used by fopen() The resource created. This means that a file must be opened to use flock.

• $operation is the operation type.

• &$wouldblock If the lock is blocking, then this variable will be set to 1.

It should be noted that this function defaults to Blocking. If you want to be non-blocking, you can add a bitmask LOCK_NB to the operation. Next, test it.

$pid_file = "/tmp/process.pid";
$pid = posix_getpid();
$fp = fopen($pid_file, 'w+');
if(flock($fp, LOCK_EX | LOCK_NB)){
  echo "got the lock \n";
  ftruncate($fp, 0);   // truncate file
  fwrite($fp, $pid);
  fflush($fp);      // flush output before releasing the lock
  sleep(300); // long running process
  flock($fp, LOCK_UN);  // 释放锁定
} else {
  echo "Cannot get pid lock. The process is already up \n";
}
fclose($fp);

Save it as process.php, run php process.php &, then run php process.php again and you will see the error message. flock also has shared locks, LOCK_SH.

Mutex locks and read-write locks
Mutex in the sync module:
Mutex is a compound word, mutual exclusion. Use pecl to install the sync module, pecl install sync. The SyncMutex in the document only has two methods, lock and unlock. Let’s go directly to the code test. I didn't write it in IDE, so the cs is extremely ugly, please ignore it.

$mutex = new SyncMutex("UniqueName");

for($i=0; $i<2; $i++){
  $pid = pcntl_fork();
  if($pid <0){
    die("fork failed");
  }elseif ($pid>0){
    echo "parent process \n";
  }else{
    echo "child process {$i} is born. \n";
    obtainLock($mutex, $i);
  }
}

while (pcntl_waitpid(0, $status) != -1) { 
  $status = pcntl_wexitstatus($status); 
  echo "Child $status completed\n"; 
}

function obtainLock ($mutex, $i){
  echo "process {$i} is getting the mutex \n";
  $res = $mutex->lock(200);
  sleep(1);
  if (!$res){
    echo "process {$i} unable to lock mutex. \n";
  }else{
    echo "process {$i} successfully got the mutex \n";
    $mutex->unlock();
  }
  exit();
}

Save as mutex.php, run php mutex.php, output is

##

parent process 
parent process 
child process 1 is born. 
process 1 is getting the mutex 
child process 0 is born. 
process 0 is getting the mutex 
process 1 successfully got the mutex 
Child 0 completed
process 0 unable to lock mutex. 
Child 0 completed

Here child process 0 And 1 does not necessarily mean who is in front. But there is always one who cannot get the lock. The parameter of SyncMutex::lock(int $millisecond) here is millisecond, which represents the blocking duration, and -1 means infinite blocking.

Read-write lock in the sync module:
The method of SyncReaderWriter is similar, readlock, readunlock, writelock, writeunlock, they can appear in pairs, no test code is written, it should be the same as Mutex The code is the same, just replace the lock.

Event in the sync module:
It feels more like Cond in golang, wait() blocks, and fire() wakes up a process blocked by Event. There is a good article introducing Cond. It can be seen that Cond is a fixed usage of locks. The same goes for SyncEvent. The examples in the php documentation show that the fire() method seems to be used in web applications.

Test code

for($i=0; $i<3; $i++){
  $pid = pcntl_fork();
  if($pid <0){
    die("fork failed");
  }elseif ($pid>0){
    //echo "parent process \n";
  }else{
    echo "child process {$i} is born. \n";
    switch ($i) {
    case 0:
      wait();
      break;
    case 1:
      wait();
      break;
    case 2:
      sleep(1);
      fire();
      break;
    }
  }
}

while (pcntl_waitpid(0, $status) != -1) { 
  $status = pcntl_wexitstatus($status); 
  echo "Child $status completed\n"; 
}

function wait(){
  $event = new SyncEvent("UniqueName");
  echo "before waiting. \n";
  $event->wait();
  echo "after waiting. \n";
  exit();
}

function fire(){
  $event = new SyncEvent("UniqueName");
  $event->fire();
  exit();
}

There is one less fire() deliberately written here, so the program will block, which proves that fire() only wakes up one process at a time.

pthreads module
Lock and unlock mutex:

Function:

##

pthread_mutex_lock (mutex) 
pthread_mutex_trylock (mutex) 
pthread_mutex_unlock (mutex)

Usage:

The thread uses the pthread_mutex_lock() function to lock the specified mutex variable. If the mutex is already locked by another thread, this call will block the thread until the mutex is unlocked.

pthread_mutex_trylock() will attempt to lock a mutex. However, if the mutex is already locked, the routine will return immediately with a "busy" error code. This routine may be useful in pthread_mutex_trylock().

Attempt to lock a mutex. However, if the mutex is already locked, the program will return immediately and return a busy error value. This function is useful to prevent deadlock in the case of priority changes. A thread can use pthread_mutex_unlock() to unlock the mutex it occupies. This function can be called when one thread completes the use of protected data and other threads want to obtain a mutex to work on the protected data. If the following situation occurs, an error will occur:

The mutex has been unlocked
The mutex is occupied by another thread
There is nothing "magical" about mutexes. In fact, they are the "gentleman's agreement" of the participating threads. When writing code, be sure to lock and unlock mutexes correctly.

Q: There are multiple threads waiting for the same locked mutex. When the mutex is unlocked, which thread will be the first to lock the mutex?

A: Unless the thread uses the priority scheduling mechanism, the thread will be allocated by the system scheduler, and which thread will be the first to lock the mutex is random.

#include<stdlib.h> 
#include<stdio.h> 
#include<unistd.h> 
#include<pthread.h> 

typedef struct ct_sum 
{ 
  int sum; 
  pthread_mutex_t lock; 
}ct_sum; 

void * add1(void *cnt) 
{    
  pthread_mutex_lock(&(((ct_sum*)cnt)->lock)); 
  for(int i=0; i < 50; i++) 
  {
    (*(ct_sum*)cnt).sum += i;   
  } 
  pthread_mutex_unlock(&(((ct_sum*)cnt)->lock)); 
  pthread_exit(NULL); 
  return 0; 
} 
void * add2(void *cnt) 
{    
  pthread_mutex_lock(&(((ct_sum*)cnt)->lock)); 
  for(int i=50; i<101; i++) 
  {  
     (*(ct_sum*)cnt).sum += i;  
  } 
  pthread_mutex_unlock(&(((ct_sum*)cnt)->lock)); 
  pthread_exit(NULL); 
  return 0; 
} 
 
int main(void) 
{
  pthread_t ptid1, ptid2; 
  ct_sum cnt; 
  pthread_mutex_init(&(cnt.lock), NULL); 
  cnt.sum=0; 
 
  pthread_create(&ptid1, NULL, add1, &cnt); 
  pthread_create(&ptid2, NULL, add2, &cnt); 
  
  pthread_join(ptid1,NULL); 
  pthread_join(ptid2,NULL);

  printf("sum %d\n", cnt.sum);
  pthread_mutex_destroy(&(cnt.lock)); 

  return 0; 
}

信号量
sync模块中的信号量：
SyncSemaphore文档中显示，它和Mutex的不同之处，在于Semaphore一次可以被多个进程(或线程)得到，而Mutex一次只能被一个得到。所以在SyncSemaphore的构造函数中，有一个参数指定信号量可以被多少进程得到。
public SyncSemaphore::__construct ([ string $name [, integer $initialval [, bool $autounlock ]]] ) 就是这个$initialval (initial value)

$lock = new SyncSemaphore("UniqueName", 2);

for($i=0; $i<2; $i++){
  $pid = pcntl_fork();
  if($pid <0){
    die("fork failed");
  }elseif ($pid>0){
    echo "parent process \n";
  }else{
    echo "child process {$i} is born. \n";
    obtainLock($lock, $i);
  }
}

while (pcntl_waitpid(0, $status) != -1) { 
  $status = pcntl_wexitstatus($status); 
  echo "Child $status completed\n"; 
}

function obtainLock ($lock, $i){
  echo "process {$i} is getting the lock \n";
  $res = $lock->lock(200);
  sleep(1);
  if (!$res){
    echo "process {$i} unable to lock lock. \n";
  }else{
    echo "process {$i} successfully got the lock \n";
    $lock->unlock();
  }
  exit();
}

这时候两个进程都能得到锁。

• sysvsem模块中的信号量

• sem_get 创建信号量

• sem_remove 删除信号量（一般不用）

• sem_acquire 请求得到信号量

• sem_release 释放信号量。和 sem_acquire 成对使用。

$key = ftok('/tmp', 'c');

$sem = sem_get($key);

for($i=0; $i<2; $i++){
  $pid = pcntl_fork();
  if($pid <0){
    die("fork failed");
  }elseif ($pid>0){
    //echo "parent process \n";
  }else{
    echo "child process {$i} is born. \n";
    obtainLock($sem, $i);
  }
}

while (pcntl_waitpid(0, $status) != -1) { 
  $status = pcntl_wexitstatus($status); 
  echo "Child $status completed\n"; 
}
sem_remove($sem); // finally remove the sem

function obtainLock ($sem, $i){
  echo "process {$i} is getting the sem \n";
  $res = sem_acquire($sem, true);
  sleep(1);
  if (!$res){
    echo "process {$i} unable to get sem. \n";
  }else{
    echo "process {$i} successfully got the sem \n";
    sem_release($sem);
  }
  exit();
}

这里有一个问题，sem_acquire()第二个参数$nowait默认为false，阻塞。我设为了true，如果得到锁失败，那么后面的sem_release会报警告 PHP Warning:  sem_release(): SysV semaphore 4 (key 0x63000081) is not currently acquired in /home/jason/sysvsem.php on line 33, 所以这里的release操作必须放在得到锁的情况下执行，前面的几个例子中没有这个问题，没得到锁执行release也不会报错。当然最好还是成对出现，确保得到锁的情况下再release。
此外，ftok这个方法的参数有必要说明下，第一个 必须是existing, accessable的文件, 一般使用项目中的文件，第二个是单字符字符串。返回一个int。

输出为

parent process 
parent process 
child process 1 is born. 
process 1 is getting the mutex 
child process 0 is born. 
process 0 is getting the mutex 
process 1 successfully got the mutex 
Child 0 completed
process 0 unable to lock mutex. 
Child 0 completed

相关推荐：

简单介绍PHP 文件锁与进程锁

php 文件读取系列方法详解

简单谈谈 php 文件锁

The above is the detailed content of Detailed explanation of file locks, mutex locks, and read-write locks in PHP. For more information, please follow other related articles on the PHP Chinese website!