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);
To store an object:
MemCachedClient mc = new MemCachedClient();
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);
To retrieve an object from the cache:
MemCachedClient mc = new MemCachedClient();
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);
To flush all items in server(s) //Invalidates the entire cache.
MemCachedClient mc = new MemCachedClient();
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();
200 dedicated memcached servers
Each 16GB quad-core AMD 64
3TB memcache
Limits
A key uniquely identifies data stored in the cache, and is used when storing, retrieving and removing data from the cache.
The maximum size
of a key is 250 characters. Note this value will be less if you are
using client "prefixes" or similar features, since the prefix is tacked
onto the front of the original key. Shorter keys are generally better
since they save memory and use less bandwidth.
The
maximum size of a value you can store in memcached is 1 megabyte. If
your data is larger, consider clientside compression or splitting the
value up into multiple keys.
posted on 2009-04-12 21:29
Justin Chen 閱讀(2101)
評論(0) 編輯 收藏 所屬分類:
Web Architecture