# 假设 key "test" 不存在
set test 0 0 5
hello
STORED              # set 成功

add test 0 0 5
world
NOT_STORED          # add 失败，key 已存在

replace test 0 0 5
world
STORED              # replace 成功，key 已存在

# 假设 key "newkey" 不存在
replace newkey 0 0 5
hello
NOT_FOUND           # replace 失败，key 不存在

# 1. 使用 gets 获取当前值及其 CAS 唯一标识
gets counter
VALUE counter 0 1 123456
5
END

# 2. 尝试用 CAS 更新（仅当 cas_unique 匹配时生效）
cas counter 0 0 1 123456
6
STORED              # 成功：版本匹配

# 3. 再次尝试（版本已变化）
cas counter 0 0 1 123456
7
EXISTS              # 失败：版本已变化

get <key> [key2 key3 ...]\r\n

gets <key> [key2 key3 ...]\r\n

get user:1 user:2 user:3
VALUE user:1 0 11
{"id":1,"a"}
VALUE user:2 0 11
{"id":2,"b"}
END
# user:3 不存在，被静默忽略

delete <key> [noreply]\r\n

incr <key> <delta> [noreply]\r\n
decr <key> <delta> [noreply]\r\n

# 初始化计数器
set counter 0 0 2
10
STORED

# 递增
incr counter 3
13

# 递减
decr counter 5
8

# 下限为 0
decr counter 100
0

# 递增溢出（行为未定义）
set big 0 0 20
18446744073709551615
STORED
incr big 1
# 结果不确定，不应依赖此行为

#!/usr/bin/env python3
"""counter.py — 使用 Memcached 实现原子计数器"""

import socket

class AtomicCounter:
    def __init__(self, sock, key: str, initial: int = 0, ttl: int = 0):
        self.sock = sock
        self.key = key
        self._initialize(initial, ttl)

    def _initialize(self, value: int, ttl: int):
        data = str(value).encode()
        cmd = f"set {self.key} 0 {ttl} {len(data)}\r\n"
        self.sock.sendall(cmd.encode() + data + b"\r\n")
        self.sock.recv(1024)

    def increment(self, delta: int = 1) -> int:
        self.sock.sendall(f"incr {self.key} {delta}\r\n".encode())
        return int(self.sock.recv(1024).decode().strip())

    def decrement(self, delta: int = 1) -> int:
        self.sock.sendall(f"decr {self.key} {delta}\r\n".encode())
        return int(self.sock.recv(1024).decode().strip())

    def get(self) -> int:
        self.sock.sendall(f"get {self.key}\r\n".encode())
        resp = self.sock.recv(4096).decode()
        lines = resp.strip().split("\r\n")
        if lines[0].startswith("VALUE"):
            return int(lines[1])
        return 0

# 使用
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('127.0.0.1', 11211))

views = AtomicCounter(sock, "page:home:views", initial=0)
print(f"当前浏览量: {views.get()}")
print(f"增加 1: {views.increment()}")
print(f"增加 10: {views.increment(10)}")
print(f"减少 3: {views.decrement(3)}")
print(f"最终值: {views.get()}")

stats\r\n

def get_hit_rate(sock) -> float:
    """计算缓存命中率"""
    sock.sendall(b"stats\r\n")
    data = sock.recv(8192).decode()

    hits = misses = 0
    for line in data.split("\r\n"):
        if line.startswith("STAT get_hits"):
            hits = int(line.split()[2])
        elif line.startswith("STAT get_misses"):
            misses = int(line.split()[2])

    total = hits + misses
    return (hits / total * 100) if total > 0 else 0.0

# 使用
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('127.0.0.1', 11211))
print(f"缓存命中率: {get_hit_rate(sock):.2f}%")

stats items\r\n

stats slabs\r\n

stats cachedump <slab_id> <limit>\r\n

stats cachedump 1 100
ITEM user:1001 [13 b; 1620000000 s]
ITEM session:abc [50 b; 1620003600 s]
END

stats sizes\r\n

# 立即清除
flush_all

# 延迟 10 秒清除
flush_all 10

version
# VERSION 1.6.22

verbosity 2
# OK

quit

import socket
import time
import uuid

class MemcachedLock:
    """基于 Memcached add 命令的分布式锁"""

    def __init__(self, sock, lock_key: str, ttl: int = 30):
        self.sock = sock
        self.lock_key = f"lock:{lock_key}"
        self.token = str(uuid.uuid4()).encode()
        self.ttl = ttl
        self.acquired = False

    def acquire(self, timeout: int = 10) -> bool:
        deadline = time.time() + timeout
        while time.time() < deadline:
            cmd = f"add {self.lock_key} 0 {self.ttl} {len(self.token)}\r\n"
            self.sock.sendall(cmd.encode() + self.token + b"\r\n")
            resp = self.sock.recv(1024).decode().strip()
            if resp == "STORED":
                self.acquired = True
                return True
            time.sleep(0.1)  # 等待后重试
        return False

    def release(self) -> bool:
        if not self.acquired:
            return False
        cmd = f"delete {self.lock_key}\r\n"
        self.sock.sendall(cmd.encode())
        resp = self.sock.recv(1024).decode().strip()
        self.acquired = False
        return resp == "DELETED"

    def __enter__(self):
        if not self.acquire():
            raise TimeoutError("Failed to acquire lock")
        return self

    def __exit__(self, *args):
        self.release()

# 使用示例
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('127.0.0.1', 11211))

with MemcachedLock(sock, "order:12345"):
    print("已获取锁，执行临界区操作...")
    time.sleep(1)
    print("操作完成，释放锁")