The main way for WEB programs to obtain information is to query the database. When the database is not very large, there will not be much of a problem. However, as the website develops and the database grows exponentially, bottlenecks will appear, so PHP caching technology was born. When PHP caching technology works, when the program queries data, the corresponding results will be serialized and saved in the file. In the future, the same query statement can be obtained from the cache file without directly querying the database. This improvement greatly increases the running speed of the program.
The application of PHP caching technology is quite common. Maybe some people don’t know much about this technology. We will now introduce the relevant application skills of PHP caching technology in detail.
In most cases our website will use a database as a container for site data storage. When you execute a SQL query, the typical process is: connect to the database -> prepare the SQL query -> send the query to the database -> get the results returned by the database -> close the database connection. However, some data in the database is completely static or changes infrequently. The caching system will cache the results of SQL queries to a faster storage system to avoid frequent database operations and greatly improve program execution. time, and caching query results also allows you to process them later.
The data cache mentioned here refers to the database query PHP cache mechanism. Every time you access the page, it will first detect whether the corresponding cached data exists. If it does not exist, connect to the database, obtain the data, and sequence the query results. After being transformed and saved to a file, the same query results will be obtained directly from the cache table or file in the future. The most widely used example is the search function of Discuz, which caches the result ID into a table and searches the cache table first when searching for the same keyword next time.
As a common method, when multiple tables are associated, generate an array and save the contents in the attached table to a field in the main table. When necessary, decompose the array. The advantage of this is that only one table can be read, but the disadvantage is There will be many more steps to synchronize the two data. The database is always the bottleneck. Trading the hard disk for speed is the key point of this.
Every time you visit a page, it will first detect whether the corresponding cached page file exists. If it does not exist, connect to the database, get the data, display the page and generate the cached page file at the same time, so that the page file will be the same the next time you visit. It worked. (Template engines and some common cache classes on the Internet usually have this function)
I won’t introduce it here, it is not what this article will discuss, I will just briefly mention:
Memcached is a high-performance, distributed memory object caching system used to reduce database load and improve access speed in dynamic applications. dbcached is a distributed key-value database memory caching system based on Memcached and NMDB. Although the above caching technology can effectively solve the problem of frequent database queries, its shortcoming is that the data is not timely.
Check whether the file exists and the timestamp is less than the set expiration time. If the file modification timestamp is greater than the current timestamp minus the expiration timestamp, then use the cache, otherwise update the cache. Do not judge whether the data needs to be updated within the set time, and update the cache after the set time. The above is only suitable for use when timeliness requirements are not high.
Force the cache to be updated when data is inserted or updated. Here we can see that when a large amount of data needs to be updated frequently, disk read and write operations will eventually be involved. How to solve it? In my daily projects, I usually do not cache all the content, but cache some content that does not change frequently to solve the problem. But in the case of heavy load, it is best to use shared memory as a cache system.
PHP caching may be a solution here, but its disadvantage is that because each request still needs to be parsed by PHP, the efficiency problem is still more serious under heavy load. In this case, you may use to the static cache.
The static cache mentioned here refers to HTML cache. HTML cache generally does not need to determine whether the data needs to be updated, because usually when HTML is used, it is usually a page whose content does not change frequently. When the data is updated, just force the HTML to be updated.
In addition to the above caching methods, there are also some server-side caching solutions, non-code level: