Persistence top

Get started with Spring Data JPA through the reference Learn Spring Data JPA course:


1. Overview

In this article, we'll examine the similarities and differences of two popular in-memory databases, Memcached and Redis.

2. Memcached and Redis

Often, we think about caching to improve performance while processing a large amount of data.

Memcached is a distributed memory caching system designed for ease of use and simplicity and is well-suited as a cache or a session store.

Redis is an in-memory data structure store that offers a rich set of features. It is useful as a cache, database, message broker, and queue.

3. Installation

3.1. Installing Memcached

We can install the latest Memcached server by downloading the package and running make:

$ wget
$ tar -zxvf memcached-1.6.3.tar.gz
$ cd memcached-1.6.3
$ ./configure && make && make test && sudo make install

3.2. Installing Redis

Similarly, we can install the latest Redis server:

$ wget
$ tar xzf redis-5.0.8.tar.gz
$ cd redis-5.0.8
$ make

4. Similarities

4.1. Sub-Millisecond Latency

Both Memcached and Redis offers sub-millisecond response times by keeping data in memory.

4.2. Data Partitioning

Similarly, both in-memory databases allow distributing data across multiple nodes.

4.3. Programming Languages Support

Likewise, both support all major programming languages including Java, Python, JavaScript, C, and Ruby.

Additionally, there are a few Java clients available for both in-memory databases. For instance, Xmemcached and Memcached-java-client are available for Memcached, while Jedis, Lettuce, and Redisson are available for Redis.

4.4. Cache Clearing

Memcached allows clearing the cache using the flush_all command. Similarly, Redis allows us to delete everything from a cache by using commands like FLUSHDB and FLUSHALL.

4.5. Scaling

Both caching solutions offer high scalability to handle large data when demand grows exponentially.

5. Differences

5.1. Command-Line

Memcached allows us to run commands by connecting to the server using telnet:

$ telnet 5678
Connected to
$ stats
STAT pid 14868
STAT uptime 175931
STAT time 1220540125
// ...

In contrast to Memcached, Redis comes with a dedicated command-line interface, redis-cli, allowing us to execute commands:

$ redis-cli COMMAND
1) 1) "save"
     2) (integer) 1
     3) 1) "admin"
        2) "noscript"
     // ...
2) 1) "multi"
   2) (integer) 1
   3) 1) "noscript"
      2) "fast"
   // ...
3) 1) "geodist"
   2) (integer) -4
   3) 1) "readonly"
   // ...

// ...

Here, we've executed COMMAND to list all the commands provided by Redis.

5.2. Disk I/O Dumping

Memcached handles disk dumping only with third-party tools like libmemcached-tools or forks like memcached-dd.

However, Redis provides highly configurable default mechanisms like RDB (Redis database file) or AOF (Append-only files) for disk dumping. This can be useful for archival and recovery.

Using redis-cli, we can execute the synchronous SAVE command to take a snapshot of the in-memory data:

$ redis-cli SAVE

Here, the command stores the snapshot in a dump.rdb binary file and returns the status OK when complete.

However, the execution of the asynchronous BGSAVE starts the background process of taking a snapshot:

$ redis-cli BGSAVE

Additionally, we can use the LASTSAVE command to check the Unix time of the last successful DB snapshot.

$ redis-cli LASTSAVE
(integer) 1410853592

5.3. Data Structures

Memcached stores key-value pairs as a String and has a 1MB size limit per value. However, Redis also supports other data structures like list, set, and hash, and can store values of up to 512MB in size.

5.4. Replication

Memcached supports replication with third-party forks like repcached.

Unlike Memcached, Redis provides us functionality to multiply clusters by replicating the primary storage for better scalability and high availability.

First, we can use the REPLICAOF command to create a replica of the Redis master server. Next, we execute the PSYNC command on the replica to initiate the replication from the master.

5.5. Transactions

Memcached doesn't support transactions, although its operations are atomic.

Redis provides out-of-the-box support for transactions to execute commands.

We can start the transaction using the MULTI command. Then, we can use the EXEC command for the execution of the following subsequent commands. Finally, Redis provides the WATCH command for the conditional execution of the transaction.

5.6. Publish and Subscribe Messaging

Memcached doesn't support publish/subscribe messaging out-of-the-box.

Redis, on the other hand, provides functionality to publish and subscribe to messages using pub/sub message queues.

This can be useful when designing applications that require real-time communication like chat rooms, social media feeds, and server intercommunication.

Redis comes with dedicated commands like PUBLISH, SUBSCRIBE, and UNSUBSCRIBE to publish a message to the channel, subscribe, and unsubscribe the client to the specified channels, respectively.

5.7. Geospatial Support

Geospatial support is useful for implementing location-based features for our applications. Unlike Memcached, Redis comes with special commands to manage real-time geospatial data.

For instance, the GEODIST command calculates the distance between two geospatial entries. Likewise, the GEORADIUS command returns all the entries within the radius provided.

Additionally, we can use Spring Data Redis to enable Redis geospatial support in a Java application.

5.8. Architecture

Redis uses a single core and shows better performance than Memcached in storing small datasets when measured in terms of cores.

Memcached implements a multi-threaded architecture by utilizing multiple cores. Therefore, for storing larger datasets, Memcached can perform better than Redis.

Another benefit of Memcached's multi-threaded architecture is its high scalability, achieved by utilizing multiple computational resources.

Redis can scale horizontally via clustering, which is comparatively more complex to set up and operate. Also, we can use Jedis or Lettuce to enable a Redis cluster using a Java application.

5.9. LUA Scripting

In contrast to Memcached, we can execute LUA scripts against Redis. It provides commands like EVAL and SCRIPT LOAD, useful for the execution of the LUA scripts.

For instance, we can execute the EVAL command to evaluate the script:

$ redis-cli eval "return'set',KEYS[1],'baeldung')" 1 website

Here, we've set the key website to the value baeldung by evaluating a script.

5.10. Memory Usage

Memcached has a higher memory utilization rate than Redis when comparing the String data structure.

In spite of that, when Redis uses the hash structure, it provides a higher memory utilization rate than Memcached.

6. Conclusion

In this article, we explored Memcached and Redis. First, we looked at the similarities of both in-memory databases. Then, we looked at the differences in the features provided by both caching solutions.

There are many in-memory caching solutions available. Therefore, we should consider the features of a caching engine and match them against our use cases.

We can certainly conclude that Memcached is a solid choice for solving simple caching problems. However, generally speaking, Redis outperforms Memcached by offering richer functionality and various features that are promising for complex use-cases.

Persistence bottom
Get started with Spring Data JPA through the reference Learn Spring Data JPA course: >> CHECK OUT THE COURSE
Comments are closed on this article!