1. Introduction to memcached
On many occasions, we will hear the name memcached, but many students have only heard of it and have not used it or actually understood it. They only know that it is a very good thing. Here is a brief introduction: memcached is an efficient and fast distributed memory object caching system, mainly used to accelerate WEB dynamic applications.
2. Memcached installation
The first thing is to download memcached. The latest version is 1.1.12. You can download it directly from the official website to memcached-1.1.12.tar.gz. In addition, memcached uses libevent, and I downloaded libevent-1.1a.tar.gz.
The next step is to unpack, compile and install libevent-1.1a.tar.gz and memcached-1.1.12.tar.gz respectively:
# tar -xzf libevent-1.1a.tar.gz # cd libevent-1.1a# ./configure --prefix=/usr# make# make install# cd .. # tar -xzf memcached-1.1.12.tar.gz# cd memcached-1.1.12 # ./configure --prefix=/usr# make# make install
After the installation is complete, memcached should be in /usr/bin/memcached.
3. Run the memcached daemon
Running the memcached daemon is very simple. It only requires a command line and does not need to modify any configuration files (there are no configuration files for you to modify 
):
/usr/bin/memcached -d -m 128 -l 192.168.1.1 -p 11211 -u httpd
Parameter explanation:
-d runs memcached in daemon mode; -m sets the memory size that memcached can use, in M; -l sets the listening IP address. If it is the local machine, this parameter usually does not need to be set; -p sets The listening port defaults to 11211, so this parameter does not need to be set; -u specifies the user. If you are currently root, you need to use this parameter to specify the user.
Of course, there are other parameters that can be used, man memcached can be seen in a moment.
4. How memcached works
First of all, memcached runs in one or more servers as a daemon, accepting client connection operations at any time. Clients can be written in various languages. Currently known client APIs include Perl/PHP/Python/Ruby/Java/ C#/C etc. After clients such as PHP establish a connection with the memcached service, the next thing is to access objects. Each accessed object has a unique identifier key. Access operations are performed through this key and saved to memcached. The objects in are actually placed in memory, not stored in cache files, which is why memcached can be so efficient and fast. Note that these objects are not persistent, and the data inside will be lost after the service is stopped.
3. How to use PHP as a memcached client
There are two ways to use PHP as a memcached client to call the memcached service for object access operations.
The first one is that PHP has an extension called memcache . When compiling under Linux, you need to bring the –enable-memcache[=DIR] option. Under Windows, remove the comment in front of php_memcache.dll in php.ini. symbol to make it available.
In addition, there is another way to avoid the trouble caused by expansion and recompilation, and that is to use php-memcached-client directly.
This article chooses the second method. Although the efficiency will be slightly worse than that of the extension library, it is not a big problem.
4. PHP memcached application example
First download memcached-client.php. After downloading memcached-client.php, you can operate the memcached service through the class "memcached" in this file. In fact, the code call is very simple. The main methods used are add(), get(), replace() and delete(). The method description is as follows:
add ($key, $val, $exp = 0)
Write objects to memcached. $key is the unique identifier of the object. $val is the written object data. $exp is the expiration time in seconds. The default is unlimited time;
get ($key)
Obtain object data from memcached through the unique identifier $key of the object;
replace ($key, $value, $exp=0)
Use $value to replace the object content with the identifier $key in memcached. The parameters are the same as the add() method. It will only work if the $key object exists;
delete ($key, $time = 0)
Delete the object with the identifier $key in memcached. $time is an optional parameter, indicating how long to wait before deleting.
The following is a simple test code that accesses object data with the identifier 'mykey':
// Contains memcached class files
require_once('memcached-client.php');
// Option settings
$options = array(
'servers' => array('192.168.1.1:11211'), //memcached The address and port of the service can be represented by multiple array elements to represent multiple memcached services
'debug' =>
'compress_threshold' => 10240
, //Compress when the data exceeds how many bytes 🎜>
'persistant' => false
//Whether to use persistent connection
);
// Create memcached object instance
$mc = new
memcached(
$options);
// Set the unique identifier used by this script
$key =
'mykey';
// Write objects into memcached
$mc->
add(
$key, ' some random strings');
$val = $mc->
get($ key);
echo "n".str_pad
('$mc->add() ' , 60, '_')."n" ;
var_dump($val);
// Replace the written object data value
$mc->
replace(
$key, array('some'=>'haha', 'array'=> 'xxx'));
$val = $mc->
get($ key);echo "n".str_pad('$mc->replace() ' , 60, '_')."n" ;
var_dump($val);
// Delete objects in memcached
$mc->delete($key);
$val = $mc->get($ key);
echo "n".str_pad('$mc->delete() ' , 60, '_')."n" ;
var_dump($val);
?>
Isn't it very simple? In actual applications, the result set of the database query is usually saved in memcached, and the next time it is accessed, it is obtained directly from memcached instead of doing the database query operation. This can reduce the database query to a great extent. burden. Usually the value after the SQL statement md5() is used as the unique identifier key. Below is an example of using memcached to cache a database query result set (this code snippet follows the example code above):
$sql = 'SELECT * FROM users';
$key = md5($sql); // memcached object identifier
if ( !($datas = $mc->get($key)) ) {
> // The cache data is not obtained in Memcached, and the database query is used to obtain the record set.
echo "n".str_pad('Read datas from MySQL.' , 60, '_')."n" ;
$conn = mysql_connect('localhost', 'test', 'test');
mysql_select_db('test');
$result = mysql_query($sql);
While (
$row = mysql_fetch_object($result))
$datas[] = $row;
// Save the result set data obtained from the database to memcached for use during the next visit.
$mc->add($key, $datas);
} else {
echo
"n".str_pad('Read datas from memcached.' , 60, '_')."n";
}
var_dump($datas);
?>
I have written an article before called "PHP implements multi-server sharing of SESSION data". The SESSION in the article is saved in a database. When the number of concurrent accesses is large, the load on the server will be very large, and the maximum connection of MySQL will often be exceeded. Number, using memcached, we can solve this problem very well. The working principle is as follows:
When the user accesses the web page, check whether there is the SESSION data of the current user in memcached, and use session_id() as the unique identifier; if the data exists, it will be returned directly. If it does not exist, connect to the database again, obtain the SESSION data, and use this data. Save it to memcached for next time use; When the current PHP operation ends (or session_write_close() is used), the My_Sess::write() method will be called to write the data to the database. In this case, there will still be a database every time Operation, for this method, also needs to be optimized. Use a global variable to record the SESSION data when the user enters the page, and then compare this data in the write() method to see if it is the same as the SESSION data you want to write. If they are different, connect to the database and write it to the database, and at the same time, add the corresponding data in memcached. If the objects are deleted, if they are the same, it means that the SESSION data has not changed, so you can return it directly without doing any operation; So how to solve the user SESSION expiration time? Remember that memcached’s add() method has an expiration time parameter $exp? Just set this parameter value to be less than the maximum survival time of SESSION. In addition, don’t forget to extend the SESSION duration for those users who are always online. This can be solved in the write() method. By judging the time, if the conditions are met, the database data will be updated
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
