性能
├── 延迟（Latency）：单个请求的响应时间
├── 吞吐量（Throughput）：单位时间处理的请求数
└── 资源利用率（Resource Utilization）：CPU、内存、磁盘的使用效率

可用性
├── 平均无故障时间（MTBF）：系统连续正常运行的平均时间
├── 平均修复时间（MTTR）：故障恢复所需的平均时间
└── 容错能力（Fault Tolerance）：系统在部分组件故障时继续运行的能力

安全性
├── 机密性（Confidentiality）：防止未授权访问
├── 完整性（Integrity）：防止未授权修改
├── 可用性（Availability）：防止拒绝服务攻击
└── 可审计性（Auditability）：追踪和记录安全事件的能力

可用性 = (总时间 - 停机时间) / 总时间 × 100%

/**
 * 性能优化策略示例
 * 展示缓存、并行处理和资源池的使用
 */
import java.util.*;
import java.util.concurrent.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class PerformanceOptimization {

    // ==================== 策略一：缓存 ====================
    
    /**
     * 简单的内存缓存实现
     * 使用 LRU（最近最少使用）淘汰策略
     */
    static class LRUCache<K, V> {
        private final int capacity;
        private final Map<K, V> cache;
        private final Deque<K> accessOrder;
        
        public LRUCache(int capacity) {
            this.capacity = capacity;
            this.cache = new HashMap<>();
            this.accessOrder = new ArrayDeque<>();
        }
        
        public synchronized V get(K key) {
            if (!cache.containsKey(key)) {
                return null;
            }
            // 更新访问顺序
            accessOrder.remove(key);
            accessOrder.addFirst(key);
            return cache.get(key);
        }
        
        public synchronized void put(K key, V value) {
            if (cache.containsKey(key)) {
                accessOrder.remove(key);
            } else if (cache.size() >= capacity) {
                // 淘汰最久未使用的元素
                K oldest = accessOrder.removeLast();
                cache.remove(oldest);
            }
            cache.put(key, value);
            accessOrder.addFirst(key);
        }
        
        public int size() {
            return cache.size();
        }
    }
    
    /**
     * 使用缓存优化数据库查询
     */
    static class CachedDataService {
        private final LRUCache<String, String> cache;
        private final DatabaseSimulator database;
        
        public CachedDataService(int cacheSize) {
            this.cache = new LRUCache<>(cacheSize);
            this.database = new DatabaseSimulator();
        }
        
        public String getData(String key) {
            // 先查缓存
            String cached = cache.get(key);
            if (cached != null) {
                System.out.println("Cache hit for: " + key);
                return cached;
            }
            
            // 缓存未命中，查询数据库
            System.out.println("Cache miss, querying database for: " + key);
            String data = database.query(key);
            
            // 存入缓存
            cache.put(key, data);
            return data;
        }
    }
    
    /**
     * 模拟慢速数据库
     */
    static class DatabaseSimulator {
        private final Map<String, String> data = new ConcurrentHashMap<>();
        
        public DatabaseSimulator() {
            // 初始化一些数据
            for (int i = 0; i < 1000; i++) {
                data.put("key_" + i, "value_" + i);
            }
        }
        
        public String query(String key) {
            try {
                // 模拟数据库延迟
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return data.getOrDefault(key, "not_found");
        }
    }
    
    // ==================== 策略二：并行处理 ====================
    
    /**
     * 串行处理 vs 并行处理对比
     */
    static class ParallelProcessing {
        
        /**
         * 串行处理：逐个处理任务
         */
        public static long processSequentially(List<Integer> tasks) {
            long startTime = System.currentTimeMillis();
            
            List<Integer> results = new ArrayList<>();
            for (Integer task : tasks) {
                results.add(compute(task));
            }
            
            long endTime = System.currentTimeMillis();
            System.out.println("Sequential processing time: " + (endTime - startTime) + "ms");
            return endTime - startTime;
        }
        
        /**
         * 并行处理：使用线程池并行执行
         */
        public static long processInParallel(List<Integer> tasks) {
            long startTime = System.currentTimeMillis();
            
            ExecutorService executor = Executors.newFixedThreadPool(4);
            List<Future<Integer>> futures = new ArrayList<>();
            
            for (Integer task : tasks) {
                futures.add(executor.submit(() -> compute(task)));
            }
            
            // 收集结果
            List<Integer> results = futures.stream()
                    .map(future -> {
                        try {
                            return future.get();
                        } catch (Exception e) {
                            throw new RuntimeException(e);
                        }
                    })
                    .collect(Collectors.toList());
            
            executor.shutdown();
            
            long endTime = System.currentTimeMillis();
            System.out.println("Parallel processing time: " + (endTime - startTime) + "ms");
            return endTime - startTime;
        }
        
        /**
         * 使用 Java Stream 并行处理（更简洁的方式）
         */
        public static long processWithParallelStream(List<Integer> tasks) {
            long startTime = System.currentTimeMillis();
            
            List<Integer> results = tasks.parallelStream()
                    .map(ParallelProcessing::compute)
                    .collect(Collectors.toList());
            
            long endTime = System.currentTimeMillis();
            System.out.println("Parallel stream processing time: " + (endTime - startTime) + "ms");
            return endTime - startTime;
        }
        
        /**
         * 模拟耗时计算
         */
        private static Integer compute(Integer input) {
            try {
                Thread.sleep(10); // 模拟计算延迟
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return input * input;
        }
    }
    
    // ==================== 策略三：资源池 ====================
    
    /**
     * 简单的数据库连接池实现
     */
    static class ConnectionPool {
        private final BlockingQueue<Connection> pool;
        private final int maxSize;
        
        public ConnectionPool(int maxSize) {
            this.maxSize = maxSize;
            this.pool = new ArrayBlockingQueue<>(maxSize);
            
            // 预创建连接
            for (int i = 0; i < maxSize; i++) {
                pool.add(new Connection(i));
            }
        }
        
        public Connection borrowConnection(long timeout, TimeUnit unit) 
                throws InterruptedException {
            Connection conn = pool.poll(timeout, unit);
            if (conn == null) {
                throw new RuntimeException("Connection pool exhausted");
            }
            System.out.println("Borrowed connection: " + conn.getId());
            return conn;
        }
        
        public void returnConnection(Connection conn) {
            System.out.println("Returned connection: " + conn.getId());
            pool.offer(conn);
        }
        
        public int availableConnections() {
            return pool.size();
        }
    }
    
    /**
     * 模拟数据库连接
     */
    static class Connection {
        private final int id;
        private boolean inUse;
        
        public Connection(int id) {
            this.id = id;
            this.inUse = false;
        }
        
        public int getId() {
            return id;
        }
        
        public void executeQuery(String sql) {
            if (inUse) {
                throw new IllegalStateException("Connection is already in use");
            }
            inUse = true;
            try {
                System.out.println("Executing query on connection " + id + ": " + sql);
                Thread.sleep(5); // 模拟查询延迟
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                inUse = false;
            }
        }
    }
    
    // ==================== 测试 ====================
    
    public static void main(String[] args) throws Exception {
        System.out.println("===== 测试缓存 =====");
        testCache();
        
        System.out.println("\n===== 测试并行处理 =====");
        testParallelProcessing();
        
        System.out.println("\n===== 测试连接池 =====");
        testConnectionPool();
    }
    
    private static void testCache() {
        CachedDataService service = new CachedDataService(3);
        
        // 第一次查询：缓存未命中
        service.getData("key_1");
        service.getData("key_2");
        service.getData("key_3");
        
        // 第二次查询：缓存命中
        service.getData("key_1");
        service.getData("key_2");
        
        // 超出容量，触发淘汰
        service.getData("key_4"); // 淘汰 key_1
        service.getData("key_1"); // 缓存未命中，重新加载
    }
    
    private static void testParallelProcessing() {
        List<Integer> tasks = IntStream.rangeClosed(1, 20)
                .boxed()
                .collect(Collectors.toList());
        
        ParallelProcessing.processSequentially(tasks);
        ParallelProcessing.processInParallel(tasks);
        ParallelProcessing.processWithParallelStream(tasks);
    }
    
    private static void testConnectionPool() throws Exception {
        ConnectionPool pool = new ConnectionPool(3);
        
        System.out.println("Available connections: " + pool.availableConnections());
        
        // 借用连接
        Connection conn1 = pool.borrowConnection(1, TimeUnit.SECONDS);
        Connection conn2 = pool.borrowConnection(1, TimeUnit.SECONDS);
        
        System.out.println("Available connections: " + pool.availableConnections());
        
        // 执行查询
        conn1.executeQuery("SELECT * FROM users");
        conn2.executeQuery("SELECT * FROM orders");
        
        // 归还连接
        pool.returnConnection(conn1);
        pool.returnConnection(conn2);
        
        System.out.println("Available connections: " + pool.availableConnections());
    }
}

"""
可用性模式示例
展示熔断器、重试和舱壁模式的实现
"""

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


class CircuitState(Enum):
    """熔断器状态"""
    CLOSED = "closed"       # 正常状态，请求通过
    OPEN = "open"           # 熔断状态，请求被拒绝
    HALF_OPEN = "half_open" # 半开状态，允许试探性请求


@dataclass
class CircuitBreakerConfig:
    """熔断器配置"""
    failure_threshold: int = 5      # 失败次数阈值
    success_threshold: int = 3      # 成功次数阈值（半开状态）
    timeout: float = 30.0           # 熔断持续时间（秒）


class CircuitBreaker:
    """
    熔断器模式实现
    
    当依赖服务频繁失败时，熔断器会打开，阻止后续请求，
    给依赖服务恢复的时间。超时后进入半开状态，允许少量
    请求试探，如果成功则关闭熔断器，否则重新打开。
    """
    
    def __init__(self, config: CircuitBreakerConfig = None):
        self.config = config or CircuitBreakerConfig()
        self.state = CircuitState.CLOSED
        self.failure_count = 0
        self.success_count = 0
        self.last_failure_time: Optional[float] = None
        self._lock = threading.Lock()
    
    def execute(self, func: Callable, *args, **kwargs):
        """执行受保护的函数调用"""
        with self._lock:
            self._check_state()
            
            if self.state == CircuitState.OPEN:
                raise CircuitBreakerOpenError("Circuit breaker is open")
        
        try:
            result = func(*args, **kwargs)
            self._on_success()
            return result
        except Exception as e:
            self._on_failure()
            raise
    
    def _check_state(self):
        """检查并可能转换状态"""
        if self.state == CircuitState.OPEN:
            elapsed = time.time() - self.last_failure_time
            if elapsed >= self.config.timeout:
                self.state = CircuitState.HALF_OPEN
                self.success_count = 0
                print("Circuit breaker transitioned to HALF_OPEN")
    
    def _on_success(self):
        """处理成功"""
        with self._lock:
            if self.state == CircuitState.HALF_OPEN:
                self.success_count += 1
                if self.success_count >= self.config.success_threshold:
                    self.state = CircuitState.CLOSED
                    self.failure_count = 0
                    print("Circuit breaker closed after successful probes")
            else:
                self.failure_count = 0
    
    def _on_failure(self):
        """处理失败"""
        with self._lock:
            self.failure_count += 1
            self.last_failure_time = time.time()
            
            if self.state == CircuitState.HALF_OPEN:
                self.state = CircuitState.OPEN
                print("Circuit breaker re-opened after failed probe")
            elif self.failure_count >= self.config.failure_threshold:
                self.state = CircuitState.OPEN
                print(f"Circuit breaker opened after {self.failure_count} failures")


class CircuitBreakerOpenError(Exception):
    """熔断器打开异常"""
    pass


class RetryConfig:
    """重试配置"""
    
    def __init__(
        self,
        max_retries: int = 3,
        base_delay: float = 1.0,
        max_delay: float = 60.0,
        exponential_base: float = 2.0,
        jitter: bool = True
    ):
        self.max_retries = max_retries
        self.base_delay = base_delay
        self.max_delay = max_delay
        self.exponential_base = exponential_base
        self.jitter = jitter


def retry_with_backoff(func: Callable, config: RetryConfig = None, *args, **kwargs):
    """
    带指数退避的重试机制
    
    当操作失败时，等待一段时间后重试，等待时间逐次增加。
    加入随机抖动避免多个客户端同时重试造成雪崩。
    """
    config = config or RetryConfig()
    last_exception = None
    
    for attempt in range(config.max_retries + 1):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            last_exception = e
            
            if attempt < config.max_retries:
                # 计算延迟时间（指数退避）
                delay = min(
                    config.base_delay * (config.exponential_base ** attempt),
                    config.max_delay
                )
                
                # 添加随机抖动
                if config.jitter:
                    delay *= random.uniform(0.5, 1.5)
                
                print(f"Attempt {attempt + 1} failed: {e}. Retrying in {delay:.2f}s...")
                time.sleep(delay)
            else:
                print(f"All {config.max_retries + 1} attempts failed")
    
    raise last_exception


class Bulkhead:
    """
    舱壁模式实现
    
    将系统资源划分为多个隔离的部分，防止一个部分的故障
    耗尽全部资源而影响其他部分。类似于船舱的防水隔板。
    """
    
    def __init__(self, max_concurrent: int):
        self.max_concurrent = max_concurrent
        self._semaphore = threading.Semaphore(max_concurrent)
        self._active_count = 0
        self._lock = threading.Lock()
    
    def execute(self, func: Callable, *args, **kwargs):
        """在舱壁保护下执行函数"""
        acquired = self._semaphore.acquire(timeout=5)
        
        if not acquired:
            raise BulkheadExhaustedError(
                f"Bulkhead exhausted (max concurrent: {self.max_concurrent})"
            )
        
        try:
            with self._lock:
                self._active_count += 1
            return func(*args, **kwargs)
        finally:
            with self._lock:
                self._active_count -= 1
            self._semaphore.release()
    
    @property
    def active_count(self) -> int:
        """当前活跃的执行数"""
        return self._active_count


class BulkheadExhaustedError(Exception):
    """舱壁资源耗尽异常"""
    pass


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

class UnreliableService:
    """模拟不稳定的外部服务"""
    
    def __init__(self, failure_rate: float = 0.3):
        self.failure_rate = failure_rate
        self.call_count = 0
    
    def call(self, request: str) -> str:
        """调用服务，可能失败"""
        self.call_count += 1
        
        if random.random() < self.failure_rate:
            raise ConnectionError(f"Service call failed (attempt {self.call_count})")
        
        time.sleep(random.uniform(0.1, 0.5))
        return f"Response for: {request}"


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

def test_circuit_breaker():
    """测试熔断器"""
    print("\n===== 测试熔断器 =====")
    
    service = UnreliableService(failure_rate=0.7)  # 高失败率
    breaker = CircuitBreaker(CircuitBreakerConfig(
        failure_threshold=3,
        success_threshold=2,
        timeout=2.0
    ))
    
    for i in range(10):
        try:
            result = breaker.execute(service.call, f"request_{i}")
            print(f"Request {i}: Success - {result}")
        except CircuitBreakerOpenError as e:
            print(f"Request {i}: Rejected - {e}")
        except ConnectionError as e:
            print(f"Request {i}: Failed - {e}")
        
        time.sleep(0.3)


def test_retry():
    """测试重试机制"""
    print("\n===== 测试重试机制 =====")
    
    service = UnreliableService(failure_rate=0.5)
    
    config = RetryConfig(
        max_retries=3,
        base_delay=0.5,
        max_delay=5.0,
        jitter=True
    )
    
    try:
        result = retry_with_backoff(service.call, config, "test_request")
        print(f"Final result: {result}")
    except ConnectionError as e:
        print(f"All retries exhausted: {e}")


def test_bulkhead():
    """测试舱壁模式"""
    print("\n===== 测试舱壁模式 =====")
    
    bulkhead = Bulkhead(max_concurrent=2)
    service = UnreliableService(failure_rate=0.1)
    
    def make_request(request_id: int):
        try:
            result = bulkhead.execute(service.call, f"request_{request_id}")
            print(f"Request {request_id}: Success - {result}")
        except BulkheadExhaustedError as e:
            print(f"Request {request_id}: Rejected - {e}")
        except ConnectionError as e:
            print(f"Request {request_id}: Failed - {e}")
    
    # 并发发起多个请求
    threads = []
    for i in range(5):
        t = threading.Thread(target=make_request, args=(i,))
        threads.append(t)
        t.start()
    
    for t in threads:
        t.join()
    
    print(f"Final active count: {bulkhead.active_count}")


if __name__ == "__main__":
    test_circuit_breaker()
    test_retry()
    test_bulkhead()

源（Source）：刺激产生的来源（用户、系统、定时器等）
刺激（Stimulus）：到达系统的事件
环境（Environment）：刺激发生时的条件
制品（Artifact）：受刺激影响的系统部分
响应（Response）：系统对刺激的反应
响应度量（Response Measure）：如何衡量响应的有效性

性能场景：
- 源：终端用户
- 刺激：提交订单请求
- 环境：正常负载（1000 QPS）
- 制品：订单处理服务
- 响应：处理订单并返回确认
- 响应度量：P95 延迟 < 2 秒

可用性场景：
- 源：数据库服务器
- 刺激：数据库连接失败
- 环境：生产环境，高峰时段
- 制品：数据访问层
- 响应：切换到备用数据库，记录错误
- 响应度量：服务中断时间 < 5 秒，无数据丢失

性能 ←→ 安全性：加密和验证增加开销
性能 ←→ 一致性：缓存和异步导致不一致
可用性 ←→ 一致性：CAP 定理的权衡
可修改性 ←→ 性能：抽象层增加运行时开销
安全性 ←→ 可用性：严格的安全措施可能影响可用性