PHP implements multi-process and multi-threading

This article mainly introduces the implementation of multi-process and multi-threading in PHP, which has certain reference value. Now I share it with everyone. Friends in need can refer to it

Instructions for newbies:

Orphan process: If a parent process exits and one or more of its child processes are still running, those child processes will become orphan processes. The orphan process will be adopted by the init process (process number is 1), and the init process will complete the status collection work for them.

# Zombie process: A process uses fork to create a child process. If the child process exits and the parent process does not call wait or waitpid to obtain the status information of the child process, Then the process descriptor of the child process is still saved in the system. This process is called a zombie process.

Zombie process hazards:If the process does not call wait/waitpid,Then the retained information will not be released, and its process number will always be occupied. However, the process number that the system can use is limited. If a large number of zombie processes are generated, it will cause problems because there is no available process number. The system cannot generate new processes. This is the hazard of zombie processes and should be avoided.Any child process (except init) does not disappear immediately after exit(), but leaves a data structure called a zombie process (Zombie), waiting for the parent process to process.

The zombie process that has been generated, the solution:Kill the parent process, and the zombie process it generates will be Become orphan processes, these orphan processes will be taken over by the init process, and the init process will wait() these orphan processes and release the resources in the system process table they occupy.

## Solutions to zombie processes

(1) Through the signal mechanism

　 (2) fork twice

Comparison between multi-process and multi-thread

1) Prioritized threads that need to be frequently created and destroyed

Please see the comparison above for the reason.

The most common application of this principle is the Web server. A connection creates a thread, and when it is disconnected, the thread is destroyed. If a process is used, the cost of creation and destruction is unbearable

2) Prioritize the use of threads that require a large amount of calculations

The so-called large amount of calculations, of course, consumes a lot of CPU and switches frequently. In this case, threads are the most appropriate.

The most common principles of this kind are image processing and algorithm processing.

3) Threads are used for strong correlation processing, and processes are used for weak correlation processing.

What are strong correlation and weak correlation? It is difficult to define in theory, but you can understand it with a simple example.

General Server needs to complete the following tasks: message sending and receiving, message processing. "Message sending and receiving" and "message processing" are weakly related tasks, and "message processing" may be further divided into "message decoding" and "business processing". These two tasks are relatively more closely related. Therefore, "message sending and receiving" and "message processing" can be designed in separate processes, and "message decoding" and "business processing" can be designed in separate threads.

Of course, this division method is not static and can also be adjusted according to the actual situation.

4) It may be extended to multi-machine distributed user processes and multi-core distributed user threads

Please see the comparison above for the reason.

5) When all requirements are met, use the method you are most familiar with and best at

As for "data sharing, synchronization", "programming, debugging", How to choose between the so-called "complexity and simplicity" in the dimensions of "reliability", I can only say: there is no clear choice method. But I can tell you a selection principle: If both multi-processing and multi-threading can meet the requirements, then choose the one you are most familiar with and best at.

What needs to be reminded is: Although I have given so many selection principles, actual applications are basically a combination of "process and thread". Don't really fall into an either/or. Misunderstanding.

Consumption of resources:

From the kernel's point of view, the purpose of the process is to serve as the basis for allocating system resources (CPU time, memory, etc.) unit. A thread is an execution stream of a process and the basic unit of CPU scheduling and dispatch. It is a basic unit that is smaller than a process and can run independently.

Threads, they use the same address space with each other and share most of the data. The space taken to start a thread is much less than the space taken to start a process. Moreover, the time required to switch between threads is also far. Much less than the time required to switch between processes. According to statistics, in general, the overhead of a process is about 30 times that of a thread. Of course, on specific systems, this data may be significantly different.

Communication method:

The only way to transfer data between processes is through communication, which is time-consuming and inconvenient. Most of the thread time data is shared (not shared within the thread function), which is fast and convenient. However, data synchronization requires locks. Pay special attention to static variables.

Thread's own advantages:

Improve application response; make multi-CPU systems more effective.The operating system will ensure that when the number of threads is not greater than the number of CPUs, different threads run on different CPUs;

Improve the program structure. A long and complex process can be divided into multiple threads and become several independent or semi-independent running parts. Such a program will be easier to understand and modify.

1. [Code] PHP implements multi-process parallel operation (can be used as a daemon)

/** * 入口函数 * 将此文件保存为 ProcessOpera.php * 在terminal中运行 /usr/local/php/bin/php ProcessOpera.php & * 查看进程 ps aux|grep php */ ProcessOpera("runCode", array(), 8); /** * run Code */ function runCode($opt = array()) { //需要在守护进程中运行的代码 } /** * $func为子进程执行具体事物的函数名称 * $opt为$func的参数 数组形式 * $pNum 为fork的子进程数量 */ function ProcessOpera($func, $opts = array(), $pNum = 1) { while(true) { $pid = pcntl_fork(); if($pid == -1) { exit("pid fork error"); } if($pid) { static $execute = 0; $execute++; if($execute >= $pNum) { pcntl_wait($status); $execute--; } } else { while(true) { //somecode $func($opts); sleep(1); } exit(0); } } }

2. [Code] PHP implements multi-threaded operation

class My extends Thread { protected $name; public $runing; function __construct($name){ $this->runing=1; $this->param=0; $this->name=$name; } public function run() { while($this->runing){ if($this->param){ $time=rand(1,5); echo 'I am thread '.$this->name.',pid: '.$this->getCreatorId().",param: {$this->param},need {$time}s\n"; sleep($time); $this->param=0; }else{ echo "Thread {$this->name} waiting...\n"; } sleep(1); } } } $pool=array(); $pool[]=new My('a'); $pool[]=new My('b'); $pool[]=new My('c'); //开启所有线程 foreach ($pool as $w) { $w->start(); } //派发任务 unset($w); for($i=1;$i<10;$i++){ $woker_content=$i; while(1){ foreach($pool as $w){ if(!$w->param){ $w->param=$woker_content; echo "Thread {$w->name} empty,put param {$woker_content}.\n"; break 2; } } sleep(1); } } unset($w); while(count($pool)){ foreach ($pool as $k => $w) { if(!$w->param){ $w->runing=false; unset($pool[$k]); echo "Thread {$w->name} end,exit！\n"; } } sleep(1); } echo 'All thread end!';

Related recommendations:

Detailed explanation of five ways to implement scheduled tasks in PHP

The above is the detailed content of PHP implements multi-process and multi-threading. For more information, please follow other related articles on the PHP Chinese website!