Analysis of file locks, mutex locks, and read-write lock usage techniques in PHP programs, _PHP tutorial

Analysis of tips for using file locks, mutex locks, and read-write locks in PHP programs,

File locks
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 executed together. There is a problem.

Another benefit 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 belongs to process communication and will be discussed 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 a file system pointer, a resource typically created by fopen(). 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 is blocking by default. 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 a shared lock, LOCK_SH.

Mutex locks and read-write locks
Mutex in 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 sub-processes 0 and 1 are not necessarily 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 sync module:
The method of SyncReaderWriter is similar, readlock, readunlock, writelock, writeunlock, just appear in pairs. There is no test code written, it should be consistent with the Mutex code, just replace the lock.

Event in 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();
}

One fire() is 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 immediately return with 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. An error will occur if the following situation occurs:

• 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 the thread that will lock the mutex first 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; 
}

Semaphore
Semaphore in sync module:
The SyncSemaphore document shows that the difference between it and Mutex is that Semaphore can be obtained by multiple processes (or threads) at a time, while Mutex can only be obtained by one at a time. So in the constructor of SyncSemaphore, there is a parameter that specifies how many processes the semaphore can be obtained by.
public SyncSemaphore::__construct ([ string $name [, integer $initialval [, bool $autounlock ]]] ) is this $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();
}

At this time both processes can get the lock.

• 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 session的锁和并发
• PHP使用flock实现文件加锁的方法
• PHP session文件独占锁引起阻塞问题解决方法
• PHP中使用Memache作为进程锁的操作类分享
• PHP对文件进行加锁、解锁实例
• PHP文件锁函数flock()详细介绍
• PHP通过插入mysql数据来实现多机互锁实例
• PHP文件锁定写入实例解析
• PHP 解决session死锁的方法
• PHP flock 文件锁详细介绍
• 并发下常见的加锁及锁的PHP具体实现代码
• phplock(php进程锁) v1.0 beta1
• PHP 进程锁定问题分析研究
• PHP下通过系统信号量加锁方式获取递增序列ID

http://www.bkjia.com/PHPjc/1113732.htmlwww.bkjia.comtruehttp://www.bkjia.com/PHPjc/1113732.htmlTechArticlePHP程序中的文件锁、互斥锁、读写锁使用技巧解析， 文件锁 全名叫 advisory file lock, 书中有提及。 这类锁比较常见，例如 mysql, php-fpm 启动之...