SET product:123 '{"name":"노트북","price":1200000}' EX 300

GET product:123

TTL product:123

INCR page_view:article:42
INCRBY daily_login:2024-03-15 1
DECR stock:product:123

LPUSH job_queue '{"type":"email","to":"user@example.com"}'
RPOP job_queue

LPUSH recent:user:42 "product:100"
LTRIM recent:user:42 0 9

LRANGE recent:user:42 0 -1
LRANGE recent:user:42 0 4

BRPOP job_queue 0

HSET session:abc123 user_id 42
HSET session:abc123 username "kimdev"
HSET session:abc123 role "admin"
HSET session:abc123 last_active "2024-03-15T10:30:00"

HMSET user:42 name "김개발" email "kim@example.com" level 5

HGET session:abc123 user_id
HMGET user:42 name email

HGETALL session:abc123

HINCRBY user:42 login_count 1

HEXISTS session:abc123 role

EXPIRE session:abc123 1800

SADD likes:post:42 "user:7"
SADD likes:post:42 "user:15"
SADD likes:post:42 "user:7"

SCARD likes:post:42

SISMEMBER likes:post:42 "user:7"

SREM likes:post:42 "user:15"

SINTERSTORE common_followers followers:alice followers:bob

SADD online_users "user:42"
SCARD online_users
SMEMBERS online_users

ZADD leaderboard 15000 "user:alice"
ZADD leaderboard 23000 "user:bob"
ZADD leaderboard 8500  "user:carol"
ZADD leaderboard 23000 "user:dave"

ZREVRANGE leaderboard 0 2 WITHSCORES

ZREVRANK leaderboard "user:bob"

ZSCORE leaderboard "user:alice"

ZRANGEBYSCORE leaderboard 10000 30000 WITHSCORES

ZINCRBY leaderboard 5000 "user:alice"

EXPIRE key 3600
EXPIREAT key 1711234567
PEXPIRE key 5000

TTL key
PTTL key

PERSIST key

[클라이언트]  SET session:abc "..." EX 1800   또는   GET session:abc
   │
   ① 명령 수신·파싱        (소켓으로 도착 → RESP 프로토콜 파싱 후 실행 큐에 적재)
   │
   ② 단일 스레드 이벤트 루프  (명령을 '한 번에 하나씩' 순차 실행 → 그래서 원자적, 락 불필요)
   │
   ③ 인메모리 자료구조 접근   (전역 해시테이블에서 키 조회 → String/Hash/ZSet 값 읽기·쓰기, 대개 O(1))
   │
   ④ TTL 관리             (EX/EXPIRE로 만료시각 기록 → lazy(접근 시 검사)+active(주기 샘플링) 삭제)
   │
   ⑤ 필요 시 영속화         (쓰기를 AOF 버퍼에 기록 / 주기적 RDB 스냅샷 — 재시작 복구용)
   ▼
[응답]  OK 또는 값 반환   (② 이벤트 루프가 다음 명령으로 넘어감)

import redis
import json

r = redis.Redis(host='localhost', port=6379, db=0)

def get_product(product_id: int):
    cache_key = f"product:{product_id}"

    cached = r.get(cache_key)
    if cached:
        return json.loads(cached)

    product = db.query("SELECT * FROM products WHERE id = %s", product_id)
    if not product:
        return None

    r.setex(cache_key, 300, json.dumps(product))
    return product

def update_product(product_id: int, data: dict):
    db.execute("UPDATE products SET price=%s WHERE id=%s",
               data['price'], product_id)

    r.delete(f"product:{product_id}")

import session from 'express-session';
import RedisStore from 'connect-redis';
import { createClient } from 'redis';

const redisClient = createClient({ url: 'redis://localhost:6379' });
await redisClient.connect();

app.use(session({
    store: new RedisStore({ client: redisClient }),
    secret: process.env.SESSION_SECRET,
    resave: false,
    saveUninitialized: false,
    cookie: {
        secure: process.env.NODE_ENV === 'production',
        httpOnly: true,
        maxAge: 30 * 60 * 1000
    }
}));

KEYS sess:*
TTL sess:abc123
HGETALL sess:abc123

import redis
import time

def get_product_with_lock(product_id: int):
    cache_key = f"product:{product_id}"
    lock_key = f"lock:product:{product_id}"

    cached = r.get(cache_key)
    if cached:
        return json.loads(cached)

    acquired = r.set(lock_key, "1", nx=True, ex=5)

    if acquired:
        try:
            product = db.get_product(product_id)
            r.setex(cache_key, 300, json.dumps(product))
            return product
        finally:
            r.delete(lock_key)
    else:
        time.sleep(0.1)
        cached = r.get(cache_key)
        return json.loads(cached) if cached else None

import math
import random

def get_with_early_refresh(key: str, ttl: int, fetch_fn):
    result = r.get(key)
    remaining_ttl = r.ttl(key)

    if result is None or should_refresh(remaining_ttl, ttl):
        fresh_data = fetch_fn()
        r.setex(key, ttl, json.dumps(fresh_data))
        return fresh_data

    return json.loads(result)

def should_refresh(remaining: int, total: int) -> bool:
    if remaining <= 0:
        return True
    probability = math.exp(-remaining / (total * 0.1))
    return random.random() < probability

SUBSCRIBE notifications:user:42

PUBLISH notifications:user:42 '{"type":"comment","message":"새 댓글이 달렸습니다"}'

def subscribe_notifications(user_id: int):
    pubsub = r.pubsub()
    pubsub.subscribe(f"notifications:user:{user_id}")

    for message in pubsub.listen():
        if message['type'] == 'message':
            data = json.loads(message['data'])
            send_websocket(user_id, data)

def publish_notification(user_id: int, notification: dict):
    r.publish(f"notifications:user:{user_id}", json.dumps(notification))