The source code for this article can be found on Github.

Redis streams are an interesting data structure that act as a sort of go-between for list and pub/sub operations: It’s like a list in the sense that anything pushed onto the stream is retained, it’s like pub/sub in the sense that multiple consumers can see what is happening to it. There are many other features of streams that are covered in that article, but that’s at least how you can think of it at the start.

The source code for this article can be found on Github.

Using Redis as a best effort locking mechanism can be very useful in practice, to prevent two logical threads from clobbering each other. While redis locking is certainly not perfect, and you shouldn’t use redis locking if the underlying operation can’t be occasionally done twice, it can still be useful for that “best effort, do this once” use case.

We already know how to subscribe to redis using lettuce when it’s not running in clustered mode. If it’s running in clustered mode, it’s not terribly different, but I did discover one thing that is interesting, which is the subject of this article.

The source code for what follows can be found on github.

In a previous article, we showed how to efficiently execute a lua script in redis using lettuce. To really scale our caching solution horizontally [and elegantly deal with many scaling headaches], we will also want to make sure we can execute our lua scripts against clustered redis, which as we’ll see here is pretty straightforward.

The source code for what follows can be found on Github.

Optimistic Locking in Redis is one of the only reasons to want to use transactions, in my opinion. You can ensure a grouping of atomic operations only occur if a watched key does not change out from underneath you. On the CLI, this might start with:

The source code for what follows can be found on Github.

Redis Transactions do not operate exactly the way you would expect if you’re coming from a relational database management system like MySQL or postrgres. It’s mostly useful for optimistic locking, but honestly there are better ways to accomplish many of the things you’re probably trying to, like running a lua script with arguments [which is guaranteed to be atomic]. The documentation on transactions in redis describes some of the caveats, the biggest one probably being that it does not support rollbacks, only commits or discards.

The source code for what follows can be found on Github.

Pub/Sub in redis allows a publisher to send things to subscribers without knowing who is actually subscribed. In a previous post, we covered a simple unit test for publishing and subscribing to lettuce, but if you want to have a subscription initialized on application startup, and respond to events, we’ll have to do a bit more, which I’ll demonstrate here.

The source code for what follows can be found on Github.

In my last article on running a lua script against redis with lettuce, we just sent the entire script [that redis will execute atomically] along with the arguments every time. For very small scripts this is unlikely to be a problem, but there is definitely a more efficient way to do this, using EVALSHA.

The source code for what follows can be found on Github.

Running a lua script against redis is done using EVAL. The primary benefit of using a lua script is that the entire script is guaranteed to be run at once, and nothing else will interfere with it [it’s atomic]. This allows for operating on multiple keys, or check-then-set type operations on the same key.

The source code for what follows can be found on Github.

Subscribing to topics in redis allows for a fanout behavior, where any number of subscribers can be notified of a message from a publisher.

The source code for what follows can be found on Github.

Redis does not allow you to set the expiration on individual members in a set, it only allows you to set an expiration on the entire set itself. If you want to have a sort of expiry on individual elements in a set, this article shares a workaround to that problem that works well in practice. Because I have already written a lot of boilerplate code for testing any redis operation using lettuce, I’m going to be showing you this technique using a reactive lettuce client, however the basic concept should transfer easily to any other client.

The source code for what follows can be found on Github.

MSETNX when you’re working with a single redis primary node is simple enough to understand: it sets all of the key/value pairs, or none at all. If one of the keys already exists in the cluster, then all of them are rejected.