[Web Architecture] An Introduction to memcached - Improve Your Web Site Performance By Cache
What is Cache?
A “ cache” is a mechanism used by computers to store frequently used information in a readily accessible place to reduce the need to retrieve that information repeatedly and needlessly.What is memcached?
memcached is a memory cache; but it is so more than that. Memcache can be deployed anywhere and be accessed from anywhere over a network. Additionally the cache can span as many machines as you need, but no matter how many machines make up your memcached cluster, as far as your code is concerned memcached acts as a single cache so that you never have to worry about which machine your information is stored on. Finally, memcached is fast. It utilizes highly efficient, non-blocking networking libraries to ensure that memcached is always fast even under heavy load.What to cache?
- Query Results
- Objects with much calculation
- Thumbnails
- Anything that takes a while to generate
How do I use memcached?
- Right before you query the database to retrieve data, check to see if that information is stored in the cache. If the data is found in memcached, then use the cached data as opposed to querying the database for the information.
- If the information is not found in memcached, then go ahead, call the database. Once you load the data you queried for, don’t forget to put in the cache. Then proceed normally. Now, in subsequent calls to fetch this information you don’t need to call the database at all.
- Now, if the information changes for some reason, a user updates the data for example, then delete the data from the cache. That way if someone tries to load it again, they will be forced to go back to the database to get it again. This keeps the cache fresh and accurate.
Memcached Server - How does memcached work?
Memcached's magic lies in its two-stage hash approach. It behaves as though it were a giant hash table, looking up key = value pairs. Give it a key, and set or get some arbitrary data.When doing a memcached lookup, first the client hashes the key against the whole list of servers. Once it has chosen a server, the client then sends its request, and the server does an internal hash key lookup for the actual item data.
For example, if we have clients 1, 2, 3, and servers A, B, C:
Client 1 wants to set key "foo" with value "barbaz". Client 1 takes the full list of servers (A, B, C), hashes the key against them, then lets say ends up picking server B. Client 1 then directly connects to server B, and sets key "foo" with value "barbaz". Next, client 2 wants to get key "foo". Client 2 runs the same client library as client 1, and has the same server list (A, B, C). It is able to use the same hashing process to figure out key "foo" is on server B. It then directly requests key "foo" and gets back "barbaz".
Different client implementations store data into memcached differently (perl Storable, php serialize, java hibernate, JSON, etc). Some clients also implement the hashing algorithm differently. The server is always the same however.
Finally, memcached itself is implemented as a non-blocking event-based server. This is an architecture used to solve the C10K problem and scale like crazy.
The cache structure is an LRU (Least Recently Used), plus expiration timeouts. When you store items into memcached, you may state how long it should be valid in the cache. Which is forever, or some time in the future. If the server is out of memory, expired slabs are replaced first, then the oldest unused slabs go next.
Memcahced Client - Java Examples
Typically, you use a client library from your application to access one or more memcached servers. The Clients page has list of available API libraries, which are available for Perl, C, C#, PHP, Python, Java, Ruby, and Postgresql Stored Procedures and Triggers.
To create cache client object and set params:
MemCachedClient mc
=
new
MemCachedClient();
// compression is enabled by default
mc.setCompressEnable( true );
// set compression threshhold to 4 KB (default: 15 KB)
mc.setCompressThreshold( 4096 );
// turn on storing primitive types as a string representation
// Should not do this in most cases.
mc.setPrimitiveAsString( true );
// compression is enabled by default
mc.setCompressEnable( true );
// set compression threshhold to 4 KB (default: 15 KB)
mc.setCompressThreshold( 4096 );
// turn on storing primitive types as a string representation
// Should not do this in most cases.
mc.setPrimitiveAsString( true );
To store an object:
MemCachedClient mc
=
new
MemCachedClient();
String key = " cacheKey1 " ;
Object value = SomeClass.getObject();
mc.set(key, value);
String key = " cacheKey1 " ;
Object value = SomeClass.getObject();
mc.set(key, value);
To delete a cache entry:
MemCachedClient mc
=
new
MemCachedClient();
String key = " cacheKey1 " ;
mc.delete(key);
String key = " cacheKey1 " ;
mc.delete(key);
To retrieve an object from the cache:
MemCachedClient mc
=
new
MemCachedClient();
String key = " key " ;
Object value = mc.get(key);
String key = " key " ;
Object value = mc.get(key);
To retrieve an multiple objects from the cache
MemCachedClient mc
=
new
MemCachedClient();
String[] keys = { " key " , " key1 " , " key2 " };
Map < Object > values = mc.getMulti(keys);
String[] keys = { " key " , " key1 " , " key2 " };
Map < Object > values = mc.getMulti(keys);
To flush all items in server(s) //Invalidates the entire cache.
MemCachedClient mc
=
new
MemCachedClient();
mc.flushAll();
mc.flushAll();
To get stats from server(s) //Retrieves stats for all servers. Returns a map keyed on the servername. The value is another map which contains stats with stat name as key and value as value.
MemCachedClient mc
=
new
MemCachedClient();
Map stats = mc.stats();
Map stats = mc.stats();
The Live Example From FaceBook
200 dedicated memcached servers
Each 16GB quad-core AMD 64
3TB memcache
Limits
-
Max Key Size
-
Max Data Size