Why doesn't php have a timing function?

The essential reason why PHP cannot use timers in web development is the lack of a controllable resident memory operating environment; two key points, the first is resident memory, and the second is 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 is resident in memory but cannot be controlled.

The operating environment of this tutorial: windows7 system, PHP8 version, DELL G3 computer

Why does php not have a timing function

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 executed after a specified time (once), for example, each member is issued five minutes after logging in to the system. Daily login rewards. Corresponds to the setInterval and setTimeout functions in JavaScript (strictly speaking, setInterval is executed periodically, and execution at a 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 is a bit dumbfounded:

There is sleep in PHP, but No (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 other things (or become unresponsive) during this period. Why doesn't PHP provide the timer function?

Reason

The essential reason why PHP cannot use timers in web development is the lack of a controllable resident memory operating 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 of 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 time zones, character encodings, etc. and do 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 method of implementing timer in PHP can be simply summarized as follows:

• Use cron, Scheduling tools such as Jenkins do periodic scheduled tasks (either to execute a script or to request a certain URL);

• One-time execution tasks are delivered to the server through message queues, databases, etc. Third-party program execution;

• Simulate scheduled tasks like WordPress, but remember that this method relies on client requests and needs to handle process concurrency issues by yourself;

• Use 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 swoole, workerman and other frameworks, with built-in (high-precision) timers;

• Use multi-process (pool)/multi-thread (pool) technology (pcntl, pthreads expansion is only available in CLI mode);

• Process signals such as tick or alarm;

• Use event-driven libraries such as libevent and libev;

• 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"

The above is the detailed content of Why doesn't php have a timing function?. For more information, please follow other related articles on the PHP Chinese website!