There are two common timers: one is executed periodically, for example, a report is issued at three o'clock in the morning every day; the other is This is executed (once) after a specified time. For example, daily login rewards are issued five minutes after a member logs into the system. The two situations correspond to the cron and at commands in the shell, and the setInterval and setTimeout functions in JavaScript Similar (strictly speaking, setInterval is executed periodically, and the execution at the specified time point needs to be handled by itself).
PHP programmers who do web development should be familiar with the two timer functions in JavaScript. Returning to the PHP level, they are a bit dumbfounded: there is sleep in PHP, but not (built-in ) timer function is available. The sleep function can barely do it, but it will cause the process to be blocked and cannot do anything else (or become unresponsive) during this period. Why doesn't PHP provide the timer function?
Reason
Personally believe that the essential reason why PHP cannot use timers in web development is the lack of controllable resident memory running environment. Two key points: first, resident memory, and second, controllable. In CGI mode, the process exits directly after executing the script and cannot be expected to run the task at a specified time; in PHP-FPM mode, the process (mostly) resides in memory but is uncontrollable.
Uncontrollable means that the process executing PHP is not affected by the PHP code, and the entry point and exit timing of the process are controlled by additional programs. For example, in FPM mode, the exit and die functions in the PHP script only interrupt the execution of the script and will not have any special impact on the process executing the script (except for memory leaks). The script written by PHP developers is the execution body of the process. After execution, it is unloaded from the execution context of the process. In this case, the timing of executing the PHP script is still driven by the outside. If there is no external request, the PHP code will lie quietly on the hard disk, doing nothing, and it will be a scheduled task.
Since PHP is mainly oriented to web development, the execution mode of PHP is stable and reliable, and the development efficiency is fast. For example, omitting the resource release step can avoid a lot of workload and pitfalls in development. Think about some third-party library codes that change the time zone, character encoding, etc. and still not restore them. In a resident memory running environment, it will almost certainly cause problems with subsequent requests. However, in FPM mode, this pitfall is unintentionally smoothed out, saving a lot of debugging time and making a considerable contribution to programmers' ability to keep their hairline.
The problem has been understood, so how to use a timer to perform scheduled tasks in PHP?
Dangerous Practice
In a web environment, PHP scripts have a timeout by default. Remove the timeout setting and you can keep the program running in the background (if the process does not exit). For example, the following code continues to run in the background after responding to the request, and outputs the time to the file every five seconds:
# test.php
set_time_limit(0); # 取消超时设置，让脚本可一直运行
echo 'This is a background run forever script. Now you can leave me alone.';
fastcgi_finish_request(); # 结束当前请求
do{
file_put_contents("/tmp/out.dat", "test script, now:" . date("Y-m-d H:i:s") . "\n", FILE_APPEND);
sleep(5);
}while(true);
After requesting the http://localhost:8080/test.php file, Monitor the /tmp/out.dat file and you will find that content is constantly output, regardless of whether the client disconnects, closes the browser, or restarts the computer (the server cannot be restarted). This shows that the program has been executing and the timer function we want has been achieved. If we change sleep to usleep, time_nanosleep, we can also implement microsecond and nanosecond level timers, wouldn’t it be nice?
In practice, you should try to avoid implementing timers in this way, not only because it is inefficient, but also slightly dangerous. One of the reasons is that each request will occupy a process, and one hundred thousand requests will require one hundred thousand processes, which will basically cause the system to crash or subsequent requests to become unresponsive; in addition, if the session is opened but you forget to call session_write_close , will cause subsequent requests from the same user to be hung (the session is in a locked state when it is active, and failure to close the session will cause subsequent processes to be unable to open the session).
Web development should respond to user requests as quickly as possible. Forcing a timer in web development in this way will make the entire web application unstable, unreliable or unpredictable. Mencius said: Know and act prudently, a gentleman does not stand under a dangerous wall. Unreliable practices should be avoided as much as possible, and by the way, blame-taking and blame-shifting should also be avoided.
Next, let’s take a look at the correct posture for using timers in PHP.
Correct posture
The methods of implementing timers in PHP can be simply summarized as follows:
- Use scheduling tools such as cron and Jenkins to do periodic scheduled tasks (It can either execute a script or request a certain URL);
- One-time execution tasks are delivered to third-party programs for execution through message queues, databases, etc.;
- Simulate like WordPress Scheduled tasks, but remember that this method relies on client requests and needs to handle process concurrency issues by itself;
- Use the resident memory mode to run PHP programs, that is, CLI mode.
Except for the third method, all other methods are recommended. Please consider the specific plan based on actual needs. As a PHP programmer, of course, the first choice is to use PHP, which is the CLI mode.
CLI mode
I can honestly say that the CLI mode allows PHP to expand its space a lot. In CLI mode, the entry point of the program is the script, and the code can be resident in memory, and the process is completely controlled by the PHP code. In this form, there are many ways to implement the timer. This article lists several methods to inspire others:
- Use frameworks such as
swooleandworkerman, with built-in (high-precision) timers; - Use multi-process (pool)/multi-thread (pool) technology (
pcntl,pthreadsextensions are only available in CLI mode); - handle ticks or alarms, etc. Signal;
- Use
libevent,libevand other event-driven libraries; -
sleepAdd a loop or implement the event loop yourself.
If you want to mess with it, use the 2-5 plan yourself. If you don’t want to mess with swoole, workerman and other frameworks, they are the first choice, stable and reliable.
Summary
Distinguish the relationship between HTTP requests and tasks, and it is simple to implement scheduled tasks. As for whether to use PHP to implement it, that is another matter. Of course, as the preferred language for web development, PHP can easily implement scheduled tasks.
Recommended learning: "PHP Video Tutorial"
