INCR and DECR for counters in Redis - Deep Dive

Overview - INCR and DECR for counters

What is it?

INCR and DECR are commands in Redis used to increase or decrease the value of a key that holds a number. They help manage counters by adding or subtracting one from the current value. If the key does not exist, Redis creates it with a starting value of zero before changing it. These commands are simple but powerful for tracking counts like page views or inventory.

Why it matters

Without INCR and DECR, managing counters would require reading the value, changing it in your code, and writing it back, which can cause errors when many users update at the same time. These commands solve the problem by making the increment or decrement happen safely and quickly inside Redis. This ensures accurate counts even with many users updating simultaneously, which is crucial for real-time applications.

Where it fits

Before learning INCR and DECR, you should understand basic Redis keys and values and how Redis stores data. After mastering these commands, you can explore more advanced Redis features like atomic operations, transactions, and Lua scripting to handle complex data updates safely.

Mental Model

Core Idea

INCR and DECR are atomic commands that safely add or subtract one from a numeric value stored in Redis, ensuring accurate counters even with many simultaneous updates.

Think of it like...

Imagine a shared scoreboard at a game where players press a button to add or subtract points. INCR and DECR are like those buttons that instantly update the score without mistakes, no matter how many players press them at once.

┌─────────────┐
│ Redis Key   │
│ (Counter)   │
├─────────────┤
│ Value: 42   │
└─────┬───────┘
      │
  ┌───▼───┐       ┌───────────────┐
  │ INCR  │──────▶│ Value becomes │
  └───────┘       │ 43 (atomic)   │
                  └───────────────┘

Similarly for DECR:

  ┌───────┐       ┌───────────────┐
  │ DECR  │──────▶│ Value becomes │
  └───────┘       │ 41 (atomic)   │
                  └───────────────┘

Build-Up - 7 Steps

1

Foundation

What is Redis and keys

Concept: Redis stores data as keys with values, like labels on boxes holding information.

Redis is a fast database that keeps data in memory. You store data by giving it a key name and a value. For example, you can store a number under the key 'page_views'. This is like putting a number inside a labeled box.

Result

You can save and retrieve values quickly using keys.

Understanding keys and values is the base for using any Redis command, including counters.

2

Foundation

Basic numeric values in Redis

Concept: Redis can store numbers as values, which can be changed with commands.

You can store a number as a string in Redis, like '42'. Redis treats it as a number when you use commands like INCR or DECR. This lets you do math on stored values without reading and rewriting manually.

Result

Numbers stored in Redis can be changed directly with commands.

Knowing that Redis treats numeric strings as numbers allows safe and fast updates.

3

Intermediate

Using INCR to increase counters

🤔Before reading on: do you think INCR creates the key if it doesn't exist, or does it return an error? Commit to your answer.

Concept: INCR adds one to the number stored at a key, creating the key with value 0 if missing.

When you run INCR on a key, Redis adds 1 to its value. If the key does not exist, Redis first sets it to 0, then adds 1, so the new value is 1. This makes it easy to start counting without extra setup.

Result

The key's value increases by one, or becomes 1 if it was missing.

Understanding that INCR auto-creates keys prevents errors and simplifies counter initialization.

4

Intermediate

Using DECR to decrease counters

🤔Before reading on: do you think DECR can make the value negative, or does it stop at zero? Commit to your answer.

Concept: DECR subtracts one from the number stored at a key, allowing negative values.

DECR reduces the value by 1. If the key doesn't exist, Redis creates it with 0 first, then subtracts 1, resulting in -1. Redis does not prevent negative numbers, so counters can go below zero if decremented too much.

Result

The key's value decreases by one, possibly becoming negative.

Knowing DECR allows negative values helps avoid bugs when counters should not go below zero.

5

Intermediate

Atomicity of INCR and DECR commands

🤔Before reading on: do you think multiple clients running INCR at the same time can cause wrong counts? Commit to your answer.

Concept: INCR and DECR are atomic, meaning Redis handles each command fully before the next, preventing conflicts.

When many clients send INCR or DECR commands at once, Redis processes them one by one without mixing results. This atomic behavior ensures counters are always accurate, even with many users updating simultaneously.

Result

Counters remain consistent and correct under concurrent updates.

Understanding atomicity explains why Redis counters are reliable in real-time, multi-user environments.

6

Advanced

INCRBY and DECRBY for custom steps

🤔Before reading on: do you think INCRBY can only add positive numbers, or can it subtract too? Commit to your answer.

Concept: INCRBY and DECRBY let you add or subtract any integer, not just one.

INCRBY key amount adds the specified amount to the key's value. DECRBY key amount subtracts the amount. The amount can be any positive integer. To subtract larger steps, use DECRBY. Negative amounts are not allowed; use the opposite command instead.

Result

Counters can be increased or decreased by custom amounts atomically.

Knowing these commands extends counter flexibility beyond simple increments or decrements.

7

Expert

Handling overflow and non-integer values

🤔Before reading on: do you think INCR works on keys holding non-numeric strings? Commit to your answer.

Concept: INCR and DECR only work on keys holding integers; non-integer or very large values cause errors or overflow.

If a key holds a value that is not an integer (like 'hello' or '3.14'), INCR and DECR commands will return an error. Also, Redis uses 64-bit signed integers, so values beyond this range cause overflow errors. Handling these cases requires careful design or using other data types.

Result

INCR/DECR fail with errors on invalid or out-of-range values.

Understanding these limits prevents runtime errors and data corruption in production.

Under the Hood

Redis processes INCR and DECR commands atomically inside its single-threaded event loop. When a command arrives, Redis reads the current value, converts it to an integer, adds or subtracts one, and writes back the new value before handling the next command. This guarantees no two commands can interleave and cause race conditions. Redis stores numbers as strings but treats them as integers for these commands, using efficient internal parsing and 64-bit integer arithmetic.

Why designed this way?

Redis was designed as a fast, in-memory database with a single-threaded core to avoid complex locking. Atomic commands like INCR and DECR fit this model perfectly, providing safe concurrent updates without overhead. Alternatives like multi-threading or external locks would slow performance and complicate usage. The choice to store numbers as strings allows flexibility but requires careful command design to ensure atomic numeric operations.

┌───────────────┐
│ Client sends  │
│ INCR command  │
└──────┬────────┘
       │
┌──────▼────────┐
│ Redis event   │
│ loop receives │
│ command       │
└──────┬────────┘
       │
┌──────▼────────┐
│ Reads current │
│ value as int  │
└──────┬────────┘
       │
┌──────▼────────┐
│ Adds 1 to     │
│ value         │
└──────┬────────┘
       │
┌──────▼────────┐
│ Writes new    │
│ value back    │
└──────┬────────┘
       │
┌──────▼────────┐
│ Sends new     │
│ value to      │
│ client        │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does INCR create a key if it doesn't exist, or does it fail? Commit to yes or no.

Common Belief: INCR will fail if the key does not exist because there is no value to increment.

Reality: INCR automatically creates the key with value 0 before incrementing, so it never fails for missing keys.

Why it matters: Believing INCR fails on missing keys leads to unnecessary code to check and create keys, complicating logic.

Quick: Can DECR prevent the value from going below zero? Commit to yes or no.

Common Belief: DECR stops at zero and does not allow negative values.

Reality: DECR can decrease values below zero; Redis does not enforce a minimum limit.

Why it matters: Assuming DECR stops at zero can cause bugs when counters unexpectedly become negative.

Quick: Can INCR work on keys holding non-numeric strings? Commit to yes or no.

Common Belief: INCR can convert any string to a number and increment it.

Reality: INCR only works on keys holding valid integers; otherwise, it returns an error.

Why it matters: Misusing INCR on non-numeric keys causes runtime errors and crashes.

Quick: Does running multiple INCR commands at the same time cause wrong counts? Commit to yes or no.

Common Belief: Concurrent INCR commands can overwrite each other, causing incorrect counts.

Reality: Redis processes INCR commands atomically, so counts remain accurate even with concurrency.

Why it matters: Not trusting atomicity leads to complex locking in application code, reducing performance.

Expert Zone

1

INCR and DECR commands are atomic because Redis is single-threaded, but this atomicity does not extend across multiple commands; transactions or Lua scripts are needed for multi-step atomicity.

2

Using INCRBY and DECRBY with large values can cause integer overflow silently if not checked, leading to unexpected negative or incorrect counts.

3

Redis stores numbers as strings internally, so commands like INCR convert and parse values each time, which is efficient but means non-integer strings cause errors immediately.

When NOT to use

INCR and DECR are not suitable when you need to increment or decrement floating-point numbers; use INCRBYFLOAT instead. Also, if you require atomic updates involving multiple keys or complex logic, use Redis transactions or Lua scripting. For counters that must never go below zero, application logic or Lua scripts should enforce this constraint.

Production Patterns

In production, INCR and DECR are used for real-time counters like page views, likes, or inventory stock. They are often combined with expiration commands to reset counters periodically. For complex scenarios, developers use Lua scripts to enforce limits or combine multiple increments atomically. Monitoring for overflow and key type errors is common to maintain data integrity.

Connections

Atomic operations in databases

INCR and DECR are examples of atomic operations that ensure safe concurrent updates.

Understanding Redis atomic commands helps grasp how databases prevent race conditions and maintain consistency.

Concurrency control in operating systems

Both Redis atomic commands and OS concurrency controls manage access to shared resources safely.

Knowing how Redis handles atomicity deepens understanding of synchronization mechanisms in computing.

Event-driven programming

Redis processes commands in a single-threaded event loop, similar to event-driven programming models.

Recognizing Redis's event loop explains why commands like INCR are atomic without locks.

Common Pitfalls

#1 Trying to increment a key holding a non-numeric string.

Wrong approach:

INCR mykey
# mykey holds 'hello'

Correct approach:

Set mykey to a numeric string first:
SET mykey 0
INCR mykey

Root cause:

Misunderstanding that INCR requires the key to hold an integer value.

#2 Assuming DECR stops at zero and prevents negative values.

Wrong approach:

DECR stock
# stock is 0, expecting it to stay at 0

Correct approach:

Use a Lua script or application logic to check before decrementing:
if tonumber(redis.call('GET', 'stock')) > 0 then
redis.call('DECR', 'stock')
end

Root cause:

Believing DECR enforces a minimum value automatically.

#3 Manually reading, incrementing, and writing back a counter in application code.

Wrong approach:

val = GET counter
val = val + 1
SET counter val

Correct approach:

Use Redis atomic command:
INCR counter

Root cause:

Not knowing Redis provides atomic increment commands, leading to race conditions.

Key Takeaways

INCR and DECR are simple Redis commands that safely increase or decrease numeric counters atomically.

They automatically create keys with value zero if the key does not exist, simplifying counter initialization.

These commands only work on integer values and will error if the key holds non-numeric data.

INCR and DECR allow counters to be updated safely even with many clients at the same time, preventing race conditions.

For more complex increments or constraints, use INCRBY, DECRBY, Lua scripts, or transactions.