问题：订单查询慢

分析：
1. 资源需求：查询是否做了不必要的计算？→ 优化 SQL，减少 JOIN
2. 资源管理：是否可以缓存结果？→ 引入 Redis 缓存
3. 资源仲裁：是否有其他请求占用了资源？→ 调整优先级，分离读写

实施：
- 第一步：添加数据库索引（资源需求）
- 第二步：引入二级缓存（资源管理）
- 第三步：读写分离（资源仲裁）

目标：99.9% 可用性

战术组合：
1. 错误检测：健康检查 + 心跳
2. 错误恢复：冗余部署 + 自动故障转移
3. 错误预防：滚动升级 + 灰度发布

实施：
- 部署至少 2 个实例（冗余）
- 配置负载均衡器健康检查（检测）
- 设置自动故障转移（恢复）
- 使用蓝绿部署策略（预防）

战术层次：
1. 边界：WAF + 身份认证（抵抗）
2. 网络：VPC + 安全组（抵抗）
3. 应用：输入验证 + 授权（抵抗）
4. 数据：加密 + 审计（检测 + 恢复）

实施：
- 每层独立防护，一层失效还有其他层
- 定期渗透测试，检验防护效果
- 建立安全事件响应流程

战术：缓存 + 异步处理 + 事件通知
  ↓ 组合
模式：CQRS（命令查询责任分离）
  ↓ 组合
风格：微服务架构

战术：延迟绑定时间
  ↓ 实现
设计模式：策略模式、工厂模式、观察者模式

战术：防止连锁反应
  ↓ 实现
设计模式：中介者模式、适配器模式、外观模式

战术：缓存
  ↓ 实现
代码：Redis 客户端 + 缓存注解 + 失效策略

战术：重试
  ↓ 实现
代码：Retry 模板 + 指数退避算法 + 熔断器

/**
 * 性能战术综合示例
 * 展示缓存、资源池、批处理和异步处理的应用
 */

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;

public class PerformanceTactics {

    // ==================== 战术一：缓存 ====================
    
    /**
     * 带 TTL 和 LRU 淘汰的缓存实现
     */
    static class Cache<K, V> {
        private final int maxSize;
        private final long ttlMs;
        private final Map<K, CacheEntry<V>> map;
        private final Deque<K> accessOrder;
        
        static class CacheEntry<V> {
            final V value;
            final long expiryTime;
            
            CacheEntry(V value, long ttlMs) {
                this.value = value;
                this.expiryTime = System.currentTimeMillis() + ttlMs;
            }
            
            boolean isExpired() {
                return System.currentTimeMillis() > expiryTime;
            }
        }
        
        public Cache(int maxSize, long ttlMs) {
            this.maxSize = maxSize;
            this.ttlMs = ttlMs;
            this.map = new HashMap<>();
            this.accessOrder = new ArrayDeque<>();
        }
        
        public synchronized V get(K key) {
            CacheEntry<V> entry = map.get(key);
            if (entry == null || entry.isExpired()) {
                if (entry != null) {
                    map.remove(key);
                    accessOrder.remove(key);
                }
                return null;
            }
            // 更新访问顺序
            accessOrder.remove(key);
            accessOrder.addFirst(key);
            return entry.value;
        }
        
        public synchronized void put(K key, V value) {
            if (map.containsKey(key)) {
                accessOrder.remove(key);
            } else if (map.size() >= maxSize) {
                // LRU 淘汰
                K oldest = accessOrder.removeLast();
                map.remove(oldest);
            }
            map.put(key, new CacheEntry<>(value, ttlMs));
            accessOrder.addFirst(key);
        }
        
        public int size() {
            return map.size();
        }
    }
    
    // ==================== 战术二：资源池 ====================
    
    /**
     * 通用对象池实现
     */
    static class ObjectPool<T> {
        private final BlockingQueue<T> pool;
        private final Supplier<T> factory;
        private final Consumer<T> resetter;
        
        public ObjectPool(int size, Supplier<T> factory, Consumer<T> resetter) {
            this.factory = factory;
            this.resetter = resetter;
            this.pool = new ArrayBlockingQueue<>(size);
            
            // 预创建对象
            for (int i = 0; i < size; i++) {
                pool.add(factory.get());
            }
        }
        
        public T borrow(long timeout, TimeUnit unit) throws InterruptedException {
            T obj = pool.poll(timeout, unit);
            if (obj == null) {
                throw new RuntimeException("Pool exhausted");
            }
            return obj;
        }
        
        public void returnObject(T obj) {
            resetter.accept(obj);
            pool.offer(obj);
        }
        
        public int available() {
            return pool.size();
        }
    }
    
    // ==================== 战术三：批处理 ====================
    
    /**
     * 批量处理器
     * 累积多个请求后批量处理，减少 IO 次数
     */
    static class BatchProcessor<T, R> {
        private final int batchSize;
        private final long flushIntervalMs;
        private final Function<List<T>, List<R>> batchFunction;
        private final List<T> buffer;
        private final ExecutorService executor;
        private long lastFlushTime;
        
        public BatchProcessor(int batchSize, long flushIntervalMs, 
                             Function<List<T>, List<R>> batchFunction) {
            this.batchSize = batchSize;
            this.flushIntervalMs = flushIntervalMs;
            this.batchFunction = batchFunction;
            this.buffer = Collections.synchronizedList(new ArrayList<>());
            this.executor = Executors.newSingleThreadExecutor();
            this.lastFlushTime = System.currentTimeMillis();
        }
        
        public CompletableFuture<List<R>> submit(T item) {
            buffer.add(item);
            
            CompletableFuture<List<R>> future = new CompletableFuture<>();
            
            // 检查是否需要刷新
            if (buffer.size() >= batchSize || 
                System.currentTimeMillis() - lastFlushTime > flushIntervalMs) {
                flush(future);
            }
            
            return future;
        }
        
        private synchronized void flush(CompletableFuture<List<R>> future) {
            if (buffer.isEmpty()) {
                future.complete(Collections.emptyList());
                return;
            }
            
            List<T> items = new ArrayList<>(buffer);
            buffer.clear();
            lastFlushTime = System.currentTimeMillis();
            
            executor.submit(() -> {
                try {
                    List<R> results = batchFunction.apply(items);
                    future.complete(results);
                } catch (Exception e) {
                    future.completeExceptionally(e);
                }
            });
        }
        
        public void shutdown() {
            executor.shutdown();
        }
    }
    
    // ==================== 战术四：异步处理 ====================
    
    /**
     * 异步任务处理器
     */
    static class AsyncTaskHandler {
        private final ExecutorService executor;
        private final CompletionService<String> completionService;
        
        public AsyncTaskHandler(int threadCount) {
            this.executor = Executors.newFixedThreadPool(threadCount);
            this.completionService = new ExecutorCompletionService<>(executor);
        }
        
        public void submitTask(String taskName, Callable<String> task) {
            completionService.submit(() -> {
                long start = System.currentTimeMillis();
                try {
                    String result = task.call();
                    long elapsed = System.currentTimeMillis() - start;
                    return taskName + " completed in " + elapsed + "ms: " + result;
                } catch (Exception e) {
                    long elapsed = System.currentTimeMillis() - start;
                    return taskName + " failed after " + elapsed + "ms: " + e.getMessage();
                }
            });
        }
        
        public String takeResult() throws InterruptedException {
            return completionService.take().get();
        }
        
        public void shutdown() {
            executor.shutdown();
        }
    }
    
    // ==================== 测试 ====================
    
    public static void main(String[] args) throws Exception {
        System.out.println("===== 性能战术演示 =====\n");
        
        // 测试缓存
        testCache();
        
        // 测试对象池
        testObjectPool();
        
        // 测试批处理
        testBatchProcessing();
        
        // 测试异步处理
        testAsyncProcessing();
    }
    
    private static void testCache() {
        System.out.println("--- 缓存战术 ---");
        Cache<String, String> cache = new Cache<>(3, 5000); // 最多 3 个，TTL 5 秒
        
        cache.put("user:1", "Alice");
        cache.put("user:2", "Bob");
        cache.put("user:3", "Charlie");
        
        System.out.println("Get user:1: " + cache.get("user:1")); // 命中
        System.out.println("Get user:2: " + cache.get("user:2")); // 命中
        
        cache.put("user:4", "David"); // 触发 LRU 淘汰，user:1 被移除
        
        System.out.println("Get user:1: " + cache.get("user:1")); // 未命中（已被淘汰）
        System.out.println("Cache size: " + cache.size());
        System.out.println();
    }
    
    private static void testObjectPool() throws Exception {
        System.out.println("--- 资源池战术 ---");
        
        // 创建数据库连接池（模拟）
        ObjectPool<String> connectionPool = new ObjectPool<>(
                3,
                () -> "Connection-" + ThreadLocalRandom.current().nextInt(1000),
                conn -> {} // 重置逻辑（模拟）
        );
        
        System.out.println("Available connections: " + connectionPool.available());
        
        // 借用连接
        String conn1 = connectionPool.borrow(1, TimeUnit.SECONDS);
        String conn2 = connectionPool.borrow(1, TimeUnit.SECONDS);
        
        System.out.println("Borrowed: " + conn1 + ", " + conn2);
        System.out.println("Available connections: " + connectionPool.available());
        
        // 归还连接
        connectionPool.returnObject(conn1);
        connectionPool.returnObject(conn2);
        
        System.out.println("After return, available: " + connectionPool.available());
        System.out.println();
    }
    
    private static void testBatchProcessing() throws Exception {
        System.out.println("--- 批处理战术 ---");
        
        // 批量查询用户
        BatchProcessor<String, String> processor = new BatchProcessor<>(
                5, // 批量大小
                1000, // 最大等待时间 1 秒
                items -> {
                    System.out.println("Batch processing " + items.size() + " items: " + items);
                    // 模拟批量数据库查询
                    return items.stream()
                            .map(id -> "User_" + id)
                            .collect(Collectors.toList());
                }
        );
        
        // 提交多个请求
        for (int i = 1; i <= 5; i++) {
            CompletableFuture<List<String>> future = processor.submit("user:" + i);
            future.thenAccept(results -> 
                System.out.println("Results: " + results)
            );
        }
        
        // 等待处理完成
        Thread.sleep(1500);
        processor.shutdown();
        System.out.println();
    }
    
    private static void testAsyncProcessing() throws Exception {
        System.out.println("--- 异步处理战术 ---");
        
        AsyncTaskHandler handler = new AsyncTaskHandler(3);
        
        // 提交多个任务
        handler.submitTask("Task-A", () -> {
            Thread.sleep(500);
            return "Result-A";
        });
        
        handler.submitTask("Task-B", () -> {
            Thread.sleep(300);
            return "Result-B";
        });
        
        handler.submitTask("Task-C", () -> {
            Thread.sleep(700);
            return "Result-C";
        });
        
        // 收集结果（按完成顺序）
        for (int i = 0; i < 3; i++) {
            String result = handler.takeResult();
            System.out.println(result);
        }
        
        handler.shutdown();
    }
}

"""
可用性战术示例
展示错误检测、恢复和预防的实现
"""

import time
import random
import threading
from typing import Callable, Optional
from enum import Enum


class CircuitState(Enum):
    CLOSED = "closed"
    OPEN = "open"
    HALF_OPEN = "half_open"


# ==================== 战术一：熔断器（错误恢复） ====================

class CircuitBreaker:
    """
    熔断器模式
    当依赖服务频繁失败时，暂时停止调用，给服务恢复时间
    """
    
    def __init__(self, failure_threshold: int = 5, recovery_timeout: float = 30.0):
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.state = CircuitState.CLOSED
        self.failure_count = 0
        self.last_failure_time: Optional[float] = None
        self._lock = threading.Lock()
    
    def execute(self, func: Callable, *args, **kwargs):
        with self._lock:
            if self.state == CircuitState.OPEN:
                if time.time() - self.last_failure_time > self.recovery_timeout:
                    self.state = CircuitState.HALF_OPEN
                    print("Circuit breaker: HALF_OPEN (probing)")
                else:
                    raise CircuitBreakerOpenError("Circuit is open")
        
        try:
            result = func(*args, **kwargs)
            self._on_success()
            return result
        except Exception as e:
            self._on_failure()
            raise
    
    def _on_success(self):
        with self._lock:
            if self.state == CircuitState.HALF_OPEN:
                self.state = CircuitState.CLOSED
                print("Circuit breaker: CLOSED (recovered)")
            self.failure_count = 0
    
    def _on_failure(self):
        with self._lock:
            self.failure_count += 1
            self.last_failure_time = time.time()
            if self.failure_count >= self.failure_threshold:
                self.state = CircuitState.OPEN
                print(f"Circuit breaker: OPEN ({self.failure_count} failures)")


class CircuitBreakerOpenError(Exception):
    pass


# ==================== 战术二：重试带退避（错误恢复） ====================

def retry_with_backoff(
    func: Callable,
    max_retries: int = 3,
    base_delay: float = 1.0,
    max_delay: float = 60.0,
    exponential_base: float = 2.0
):
    """
    带指数退避的重试机制
    临时故障时自动重试，等待时间逐次增加
    """
    last_exception = None
    
    for attempt in range(max_retries + 1):
        try:
            return func()
        except Exception as e:
            last_exception = e
            if attempt < max_retries:
                delay = min(base_delay * (exponential_base ** attempt), max_delay)
                jitter = random.uniform(0.5, 1.5)
                delay *= jitter
                print(f"Attempt {attempt + 1} failed: {e}. Retrying in {delay:.2f}s...")
                time.sleep(delay)
            else:
                print(f"All {max_retries + 1} attempts failed")
    
    raise last_exception


# ==================== 战术三：健康检查（错误检测） ====================

class HealthChecker:
    """
    健康检查器
    定期检查组件状态，发现故障
    """
    
    def __init__(self, check_interval: float = 5.0):
        self.check_interval = check_interval
        self.is_healthy = True
        self.last_check_time: Optional[float] = None
        self._running = False
        self._thread: Optional[threading.Thread] = None
    
    def register_check(self, name: str, check_func: Callable[[], bool]):
        """注册健康检查函数"""
        if not hasattr(self, '_checks'):
            self._checks = {}
        self._checks[name] = check_func
    
    def start(self):
        """启动定期检查"""
        self._running = True
        self._thread = threading.Thread(target=self._check_loop, daemon=True)
        self._thread.start()
        print("Health checker started")
    
    def stop(self):
        """停止检查"""
        self._running = False
        if self._thread:
            self._thread.join()
        print("Health checker stopped")
    
    def _check_loop(self):
        while self._running:
            self._run_checks()
            time.sleep(self.check_interval)
    
    def _run_checks(self):
        if not hasattr(self, '_checks'):
            return
        
        all_healthy = True
        for name, check_func in self._checks.items():
            try:
                healthy = check_func()
                if not healthy:
                    print(f"Health check failed: {name}")
                    all_healthy = False
            except Exception as e:
                print(f"Health check error: {name} - {e}")
                all_healthy = False
        
        self.is_healthy = all_healthy
        self.last_check_time = time.time()
    
    def get_status(self) -> dict:
        return {
            "is_healthy": self.is_healthy,
            "last_check_time": self.last_check_time
        }


# ==================== 战术四：降级（错误恢复） ====================

class GracefulDegradation:
    """
    优雅降级
    当非核心功能不可用时，核心功能仍能工作
    """
    
    def __init__(self):
        self.degraded_features = set()
    
    def execute_with_fallback(self, primary_func: Callable, fallback_func: Callable, feature_name: str):
        """
        执行主要功能，失败时使用降级方案
        """
        if feature_name in self.degraded_features:
            print(f"Feature '{feature_name}' is degraded, using fallback")
            return fallback_func()
        
        try:
            return primary_func()
        except Exception as e:
            print(f"Feature '{feature_name}' failed: {e}, degrading")
            self.degraded_features.add(feature_name)
            return fallback_func()
    
    def recover_feature(self, feature_name: str):
        """恢复已降级的功能"""
        self.degraded_features.discard(feature_name)
        print(f"Feature '{feature_name}' recovered")


# ==================== 模拟服务 ====================

class UnreliableService:
    """模拟不稳定的服务"""
    
    def __init__(self, failure_rate: float = 0.3):
        self.failure_rate = failure_rate
        self.call_count = 0
    
    def call(self) -> str:
        self.call_count += 1
        if random.random() < self.failure_rate:
            raise ConnectionError(f"Service call failed (attempt {self.call_count})")
        return f"Success response #{self.call_count}"


# ==================== 测试 ====================

def test_circuit_breaker():
    """测试熔断器"""
    print("\n===== 测试熔断器 =====")
    
    service = UnreliableService(failure_rate=0.7)
    breaker = CircuitBreaker(failure_threshold=3, recovery_timeout=2.0)
    
    for i in range(8):
        try:
            result = breaker.execute(service.call)
            print(f"Call {i + 1}: {result}")
        except CircuitBreakerOpenError as e:
            print(f"Call {i + 1}: Rejected - {e}")
        except ConnectionError as e:
            print(f"Call {i + 1}: Failed - {e}")
        
        time.sleep(0.3)


def test_retry():
    """测试重试"""
    print("\n===== 测试重试带退避 =====")
    
    service = UnreliableService(failure_rate=0.5)
    
    try:
        result = retry_with_backoff(
            service.call,
            max_retries=3,
            base_delay=0.5
        )
        print(f"Final result: {result}")
    except ConnectionError as e:
        print(f"All retries exhausted: {e}")


def test_health_checker():
    """测试健康检查"""
    print("\n===== 测试健康检查 =====")
    
    checker = HealthChecker(check_interval=1.0)
    
    # 注册检查
    checker.register_check("database", lambda: random.random() > 0.2)
    checker.register_check("cache", lambda: random.random() > 0.1)
    
    checker.start()
    
    # 运行一段时间
    time.sleep(3)
    
    status = checker.get_status()
    print(f"Health status: {status}")
    
    checker.stop()


def test_degradation():
    """测试降级"""
    print("\n===== 测试优雅降级 =====")
    
    degradation = GracefulDegradation()
    
    def primary_recommendation():
        if random.random() < 0.5:
            raise ConnectionError("Recommendation service unavailable")
        return "Personalized recommendations based on AI"
    
    def fallback_recommendation():
        return "Popular items (fallback)"
    
    for i in range(5):
        result = degradation.execute_with_fallback(
            primary_recommendation,
            fallback_recommendation,
            "recommendations"
        )
        print(f"Request {i + 1}: {result}")
        time.sleep(0.5)


if __name__ == "__main__":
    test_circuit_breaker()
    test_retry()
    test_health_checker()
    test_degradation()