Welcome back! In this lesson, we will explore a crucial feature of Redis: key expiration. This topic builds on our Redis knowledge and adds another tool to our kit for managing data efficiently in high-performance applications.

You will learn how to set expiration times on your Redis keys. This is useful for many situations, such as caching data, managing session lifetimes, or any scenario where you want data to automatically expire after a certain period. We will learn how to set expiration times on keys and check the remaining time-to-live (TTL) for a key.

Here's a quick preview of what you will be doing:

To set a key with an expiration time, you can use the StringSet method with an expiry parameter:

The above code snippet shows how to set a key (session:12345) with a value (data) that expires after 2 seconds.

To check the remaining time-to-live (TTL) for a key, you can use the KeyTimeToLive method with the key name as the parameter.

After waiting for the expiration time, you can verify that the key no longer exists. This code waits 3 seconds and then attempts to get the value of the key, which should return null because the key has expired.

Another useful method is KeyExpire, which allows you to set the expiration time for a key after it has been created:

This code snippet sets the key session:12345 with a value of and then sets the expiration time to 2 seconds. We will explore this method in more detail in the practice section.

Key expiration is an essential feature for managing limited memory resources efficiently. By setting expiration times, you can ensure that outdated data is removed automatically without manual intervention. This can significantly improve your application's performance and reliability.

It's important to understand how Redis handles expired keys internally. Redis follows two main strategies:

• Passive expiration: A key is only removed when a client tries to access it and Redis detects it has expired.
• Active expiration: Redis runs periodic background checks to delete expired keys to free memory. However, it does not check all keys at once to avoid performance degradation.

This means that an expired key may still exist in memory for a short period if not accessed. Understanding this behavior helps you make informed decisions about memory usage and expiration strategies in high-performance applications.

By mastering key expiration, you can build more intelligent caching mechanisms, manage user sessions effectively, and handle temporary data seamlessly. This concept is a critical aspect of maintaining high-performance applications that need to run efficiently over time.