中国邮政Java面试：热点Key的探测和本地缓存方案

码农水水2026-01-10 19:23

一、热点Key问题定义与危害

1.1 热点Key定义

热点Key：在短时间内被大量并发访问的缓存Key

text

复制

下载

复制代码 
特征指标：
• QPS > 10000 或超过集群单节点承载能力
• 访问集中度 > 80%（大部分请求集中在少数Key）
• 持续时间 > 1分钟

1.2 危害分析

text

复制

下载

复制代码 
1. 缓存穿透
   • Redis单节点CPU飙升至100%
   • 网络带宽被打满
   • 响应延迟从ms级上升到秒级

2. 集群倾斜
   • 集群中某个节点负载过高
   • 其他节点资源闲置
   • Hash分片失效

3. 数据库击穿
   • 缓存失效后，大量请求直达DB
   • 连接池耗尽
   • 可能导致数据库宕机

4. 业务影响
   • 核心功能不可用
   • 用户体验下降
   • 可能造成资损

二、热点Key探测方案

2.1 基于监控的被动探测

方案一：Redis监控指标分析

java

复制

下载

复制代码 
@Component
public class RedisHotKeyDetector {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    // 基于Redis INFO命令的热点Key探测
    public List<HotKeyInfo> detectByRedisStats() {
        List<HotKeyInfo> hotKeys = new ArrayList<>();
        
        // 1. 获取Redis INFO命令中的keyspace信息
        Properties info = redisTemplate.getConnectionFactory()
            .getConnection().info("keyspace");
        
        // 2. 分析每个DB的键访问模式
        String dbStats = info.getProperty("db0");
        if (dbStats != null) {
            // 解析格式：keys=100,expires=0,avg_ttl=0
            String[] parts = dbStats.split(",");
            // 分析键数量变化率
        }
        
        // 3. 使用MONITOR命令采样（生产环境慎用）
        // 4. 分析慢查询日志
        List<SlowLog> slowLogs = redisTemplate.getConnectionFactory()
            .getConnection().slowLogGet();
        
        return hotKeys;
    }
}
方案二：客户端埋点统计

java

复制

下载

复制代码 
public class ClientSideHotKeyDetector {
    
    // 滑动窗口统计
    private final Map<String, CircularFifoQueue<Long>> keyAccessWindows;
    private final int windowSize = 60; // 60秒窗口
    private final int threshold = 1000; // 阈值：1000次/秒
    
    @PostConstruct
    public void init() {
        keyAccessWindows = new ConcurrentHashMap<>();
        
        // 定时分析任务
        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
        scheduler.scheduleAtFixedRate(this::analyzeHotKeys, 10, 10, TimeUnit.SECONDS);
    }
    
    // AOP切面：拦截所有缓存访问
    @Around("@annotation(cacheable)")
    public Object monitorCacheAccess(ProceedingJoinPoint joinPoint) throws Throwable {
        String key = generateCacheKey(joinPoint);
        long startTime = System.currentTimeMillis();
        
        try {
            // 1. 记录访问
            recordAccess(key);
            
            // 2. 执行原方法
            return joinPoint.proceed();
            
        } finally {
            long cost = System.currentTimeMillis() - startTime;
            recordAccessTime(key, cost);
        }
    }
    
    private void recordAccess(String key) {
        CircularFifoQueue<Long> window = keyAccessWindows
            .computeIfAbsent(key, k -> new CircularFifoQueue<>(windowSize));
        
        long currentSecond = System.currentTimeMillis() / 1000;
        window.add(currentSecond);
    }
    
    private void analyzeHotKeys() {
        long currentSecond = System.currentTimeMillis() / 1000;
        
        keyAccessWindows.forEach((key, window) -> {
            // 统计最近窗口内的访问次数
            long count = window.stream()
                .filter(time -> time >= currentSecond - windowSize)
                .count();
            
            if (count > threshold) {
                // 发现热点Key
                reportHotKey(key, count);
            }
        });
    }
}

2.2 基于代理的主动探测

方案三：代理层流量分析

java

复制

下载

复制代码 
public class ProxyHotKeyDetector {
    
    // 使用HyperLogLog进行基数估计，节省内存
    private final Map<String, HyperLogLog> keyAccessCounter;
    private final Map<String, Long> keyQpsMap;
    
    public void detectFromProxyTraffic(List<Request> requests) {
        // 1. 分时间段统计
        Map<String, Map<Long, Integer>> timeWindowStats = new HashMap<>();
        
        for (Request request : requests) {
            String key = extractCacheKey(request);
            long timeWindow = request.getTimestamp() / 10000; // 10秒窗口
            
            timeWindowStats
                .computeIfAbsent(key, k -> new HashMap<>())
                .merge(timeWindow, 1, Integer::sum);
        }
        
        // 2. 计算QPS并识别热点
        timeWindowStats.forEach((key, windowCounts) -> {
            double avgQps = windowCounts.values().stream()
                .mapToInt(Integer::intValue)
                .average()
                .orElse(0.0) * 100; // 换算为秒级
            
            if (avgQps > HOT_KEY_THRESHOLD) {
                HotKeyInfo info = new HotKeyInfo();
                info.setKey(key);
                info.setQps(avgQps);
                info.setDetectionTime(System.currentTimeMillis());
                info.setPattern(analyzePattern(key, requests));
                
                // 3. 上报热点Key
                reportHotKey(info);
            }
        });
    }
    
    // 分析Key模式（如：product:{id}）
    private String analyzePattern(String key, List<Request> requests) {
        // 使用聚类算法识别模式
        // 例如：product_123, product_456 -> product_*
        return KeyPatternAnalyzer.analyze(key, requests);
    }
}

2.3 机器学习预测

方案四：时序预测模型

python

复制

下载

复制代码 
# Python端预测模型（Java可调用）
import pandas as pd
from sklearn.ensemble import RandomForestRegressor
from prophet import Prophet

class HotKeyPredictor:
    def __init__(self):
        self.model = Prophet(
            yearly_seasonality=False,
            weekly_seasonality=True,
            daily_seasonality=True
        )
    
    def train(self, historical_data):
        """训练预测模型"""
        df = pd.DataFrame(historical_data)
        df.columns = ['ds', 'y']
        self.model.fit(df)
    
    def predict_hot_keys(self, current_data, horizon=3600):
        """预测未来一小时的热点Key"""
        future = self.model.make_future_dataframe(
            periods=horizon, 
            freq='s'
        )
        forecast = self.model.predict(future)
        
        # 识别超过阈值的预测点
        hot_points = forecast[forecast['yhat'] > THRESHOLD]
        return hot_points

java

复制

下载

复制代码 
// Java调用层
public class MLHotKeyDetector {
    
    @Autowired
    private HotKeyPredictorClient predictorClient;
    
    public List<String> predictFutureHotKeys() {
        // 1. 准备历史数据
        List<AccessRecord> history = collectAccessHistory(24); // 最近24小时
        
        // 2. 调用Python预测服务
        List<String> predictedKeys = predictorClient.predict(history);
        
        // 3. 预加载到本地缓存
        predictedKeys.forEach(this::preloadToLocalCache);
        
        return predictedKeys;
    }
}

篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc

需要全套面试笔记及答案
【点击此处即可/免费获取】

三、本地缓存解决方案

3.1 多级缓存架构设计

架构图

text

复制

下载

复制代码 
客户端请求
    ↓
负载均衡层
    ↓
应用服务器（本地缓存 L1） → Caffeine/Guava Cache
    ↓
分布式缓存（Redis Cluster）L2
    ↓
数据库 L3
实现方案

java

复制

下载

复制代码 
@Component
public class MultiLevelCacheManager {
    
    // L1: 本地缓存（应用内）
    @Autowired
    private Cache<String, Object> localCache;
    
    // L2: 分布式缓存
    @Autowired
    private RedisTemplate<String, Object> redisCache;
    
    // L3: 数据库
    @Autowired
    private DatabaseService database;
    
    // 热点Key标记
    private final Set<String> hotKeys = ConcurrentHashMap.newKeySet();
    
    /**
     * 三级缓存获取流程
     */
    public <T> T get(String key, Class<T> type, Supplier<T> loader) {
        // 1. 检查是否为热点Key
        boolean isHotKey = hotKeys.contains(key);
        
        // 2. 热点Key优先从本地缓存获取
        if (isHotKey) {
            T value = (T) localCache.getIfPresent(key);
            if (value != null) {
                // 命中本地缓存，更新访问时间
                recordAccess(key, "local_hit");
                return value;
            }
        }
        
        // 3. 尝试从Redis获取
        T value = (T) redisCache.opsForValue().get(key);
        if (value != null) {
            // 命中Redis，如果是热点Key则回填本地缓存
            if (isHotKey) {
                localCache.put(key, value);
            }
            recordAccess(key, "redis_hit");
            return value;
        }
        
        // 4. 从数据库加载（加分布式锁防止击穿）
        return loadFromDatabase(key, type, loader);
    }
    
    private <T> T loadFromDatabase(String key, Class<T> type, Supplier<T> loader) {
        // 分布式锁，防止缓存击穿
        String lockKey = "lock:" + key;
        boolean locked = false;
        
        try {
            // 尝试获取锁
            locked = redisCache.opsForValue()
                .setIfAbsent(lockKey, "1", Duration.ofSeconds(10));
            
            if (locked) {
                // 获取到锁，执行加载
                T value = loader.get();
                
                // 写入各级缓存
                redisCache.opsForValue().set(key, value, Duration.ofMinutes(30));
                
                if (hotKeys.contains(key)) {
                    localCache.put(key, value);
                }
                
                return value;
            } else {
                // 未获取到锁，等待并重试
                Thread.sleep(100);
                return get(key, type, loader);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new CacheException("加载数据被中断", e);
        } finally {
            if (locked) {
                redisCache.delete(lockKey);
            }
        }
    }
}

3.2 本地缓存实现方案

方案一：Caffeine本地缓存

java

复制

下载

复制代码 
@Configuration
public class CaffeineCacheConfig {
    
    @Bean("hotKeyCache")
    public Cache<String, Object> hotKeyCache() {
        return Caffeine.newBuilder()
            // 容量策略
            .maximumSize(10000)  // 最多缓存10000个热点Key
            .maximumWeight(100 * 1024 * 1024)  // 最大内存100MB
            
            // 过期策略
            .expireAfterWrite(Duration.ofMinutes(5))  // 写入5分钟后过期
            .expireAfterAccess(Duration.ofMinutes(2))  // 访问2分钟后过期
            
            // 刷新策略（异步刷新）
            .refreshAfterWrite(Duration.ofMinutes(1))
            
            // 弱引用策略
            .weakKeys()
            .weakValues()
            
            // 统计信息
            .recordStats()
            
            // 移除监听器
            .removalListener((key, value, cause) -> 
                logRemoval(key, value, cause))
            
            // 构建缓存
            .build();
    }
    
    @Bean("hotKeyLoadingCache")
    public LoadingCache<String, Object> hotKeyLoadingCache() {
        return Caffeine.newBuilder()
            .maximumSize(5000)
            .expireAfterWrite(Duration.ofMinutes(3))
            .build(new CacheLoader<String, Object>() {
                @Override
                public Object load(String key) throws Exception {
                    // 同步加载
                    return loadFromSource(key);
                }
                
                @Override
                public Map<String, Object> loadAll(Set<? extends String> keys) {
                    // 批量加载
                    return batchLoadFromSource(keys);
                }
                
                @Override
                public CompletableFuture<Object> asyncLoad(String key, 
                        Executor executor) {
                    // 异步加载
                    return CompletableFuture.supplyAsync(() -> 
                        loadFromSource(key), executor);
                }
            });
    }
}
方案二：Guava Cache实现

java

复制

下载

复制代码 
public class GuavaCacheManager {
    
    private final LoadingCache<String, Object> cache;
    
    public GuavaCacheManager() {
        this.cache = CacheBuilder.newBuilder()
            // 容量设置
            .maximumSize(10000)
            .concurrencyLevel(16)  // 并发级别
            
            // 过期策略
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .expireAfterAccess(2, TimeUnit.MINUTES)
            
            // 软引用，内存不足时自动清理
            .softValues()
            
            // 统计
            .recordStats()
            
            // 构建
            .build(new CacheLoader<String, Object>() {
                @Override
                public Object load(String key) {
                    return loadData(key);
                }
                
                @Override
                public ListenableFuture<Object> reload(String key, 
                        Object oldValue) throws Exception {
                    // 异步刷新
                    return MoreExecutors.listeningDecorator(
                        Executors.newSingleThreadExecutor())
                        .submit(() -> reloadData(key));
                }
            });
    }
    
    // 批量预热热点Key
    public void preloadHotKeys(Set<String> hotKeys) {
        try {
            cache.getAll(hotKeys);
        } catch (ExecutionException e) {
            log.error("预热热点Key失败", e);
        }
    }
}

3.3 热点Key本地缓存策略

策略一：主动预热

java

复制

下载

复制代码 
@Service
public class HotKeyPreheatService {
    
    @Autowired
    private Cache<String, Object> localCache;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    // 定时预热任务
    @Scheduled(fixedDelay = 30000)  // 每30秒执行一次
    public void preheatHotKeys() {
        // 1. 获取当前热点Key列表
        List<HotKeyInfo> hotKeys = hotKeyDetector.getCurrentHotKeys();
        
        // 2. 批量预热
        hotKeys.parallelStream().forEach(hotKey -> {
            String key = hotKey.getKey();
            
            // 检查本地缓存是否存在
            if (localCache.getIfPresent(key) == null) {
                // 从Redis加载并预热
                Object value = redisTemplate.opsForValue().get(key);
                if (value != null) {
                    localCache.put(key, value);
                    log.info("预热热点Key: {} 成功", key);
                }
            }
        });
    }
    
    // 事件驱动预热
    @EventListener
    public void handleHotKeyEvent(HotKeyDetectedEvent event) {
        HotKeyInfo hotKey = event.getHotKeyInfo();
        
        // 异步预热
        CompletableFuture.runAsync(() -> {
            preheatKey(hotKey.getKey());
        }, preheatExecutor);
    }
    
    private void preheatKey(String key) {
        try {
            // 加锁防止重复预热
            String lockKey = "preheat:lock:" + key;
            boolean locked = redisTemplate.opsForValue()
                .setIfAbsent(lockKey, "1", Duration.ofSeconds(5));
            
            if (locked) {
                Object value = redisTemplate.opsForValue().get(key);
                if (value != null) {
                    localCache.put(key, value);
                }
                redisTemplate.delete(lockKey);
            }
        } catch (Exception e) {
            log.error("预热Key失败: {}", key, e);
        }
    }
}
策略二：动态过期时间

java

复制

下载

复制代码 
public class DynamicTTLManager {
    
    private final Map<String, Long> keyAccessTime = new ConcurrentHashMap<>();
    private final Map<String, Long> keyTTLMap = new ConcurrentHashMap<>();
    
    // 动态计算TTL：访问越频繁，TTL越长
    public Duration calculateDynamicTTL(String key) {
        long currentTime = System.currentTimeMillis();
        Long lastAccess = keyAccessTime.get(key);
        
        if (lastAccess == null) {
            // 首次访问，基础TTL
            return Duration.ofSeconds(30);
        }
        
        // 计算访问频率
        long interval = currentTime - lastAccess;
        double frequency = 1000.0 / interval;  // 次/秒
        
        // 根据频率调整TTL
        if (frequency > 100) {  // 每秒访问超过100次
            return Duration.ofMinutes(10);
        } else if (frequency > 10) {  // 每秒访问超过10次
            return Duration.ofMinutes(5);
        } else {
            return Duration.ofMinutes(1);
        }
    }
    
    // 更新访问时间
    public void recordAccess(String key) {
        keyAccessTime.put(key, System.currentTimeMillis());
    }
}

四、集群解决方案

4.1 热点Key分片

方案一：Key加盐分片

java

复制

下载

复制代码 
public class HotKeySharding {
    
    // 原始Key: product_123
    // 分片Key: product_123_1, product_123_2, ...
    
    private final int shardCount = 10;
    
    public List<String> getShardKeys(String originalKey) {
        List<String> shardKeys = new ArrayList<>();
        
        for (int i = 0; i < shardCount; i++) {
            shardKeys.add(originalKey + "_" + i);
        }
        
        return shardKeys;
    }
    
    public Object getShardedValue(String originalKey) {
        // 随机选择一个分片
        int shardIndex = ThreadLocalRandom.current().nextInt(shardCount);
        String shardKey = originalKey + "_" + shardIndex;
        
        return redisTemplate.opsForValue().get(shardKey);
    }
    
    public void setShardedValue(String originalKey, Object value) {
        // 写入所有分片
        List<String> shardKeys = getShardKeys(originalKey);
        
        shardKeys.parallelStream().forEach(shardKey -> {
            redisTemplate.opsForValue().set(shardKey, value);
        });
    }
}
方案二：二级索引

java

复制

下载

复制代码 
public class SecondaryIndexCache {
    
    // 主Key: product:123
    // 二级Key: hot:product:123 -> 实际存储节点的信息
    
    public Object getWithSecondaryIndex(String key) {
        // 1. 查询二级索引，获取实际存储位置
        String secondaryKey = "hot:" + key;
        String actualNode = (String) redisTemplate.opsForValue().get(secondaryKey);
        
        if (actualNode != null) {
            // 2. 从指定节点获取数据
            return getFromSpecificNode(actualNode, key);
        } else {
            // 3. 正常流程
            return redisTemplate.opsForValue().get(key);
        }
    }
    
    // 当检测到热点时，创建二级索引
    public void createSecondaryIndex(String key, String targetNode) {
        String secondaryKey = "hot:" + key;
        redisTemplate.opsForValue().set(
            secondaryKey, 
            targetNode, 
            Duration.ofMinutes(10)
        );
    }
}

4.2 本地只读副本

java

复制

下载

复制代码 
public class LocalReadReplica {
    
    private final Map<String, Object> localReplica = new ConcurrentHashMap<>();
    private final ScheduledExecutorService refreshExecutor;
    
    public LocalReadReplica() {
        this.refreshExecutor = Executors.newScheduledThreadPool(2);
    }
    
    // 为热点Key创建本地副本
    public void createReplica(String key, Object value) {
        localReplica.put(key, value);
        
        // 定时刷新副本
        refreshExecutor.scheduleAtFixedRate(() -> 
            refreshReplica(key), 1, 1, TimeUnit.SECONDS);
    }
    
    private void refreshReplica(String key) {
        try {
            // 从Redis主节点同步最新值
            Object latestValue = redisTemplate.opsForValue().get(key);
            if (latestValue != null) {
                localReplica.put(key, latestValue);
            }
        } catch (Exception e) {
            log.error("刷新副本失败: {}", key, e);
        }
    }
    
    public Object getFromReplica(String key) {
        return localReplica.get(key);
    }
}

五、监控与告警

5.1 监控指标

java

复制

下载

复制代码 
@Slf4j
@Component
public class HotKeyMonitor {
    
    // 监控指标
    private final MeterRegistry meterRegistry;
    
    @Autowired
    public HotKeyMonitor(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    public void recordHit(String cacheLevel, String key) {
        // 记录命中率
        Counter counter = Counter.builder("cache.hits")
            .tag("level", cacheLevel)
            .tag("key", key)
            .register(meterRegistry);
        counter.increment();
    }
    
    public void recordMiss(String cacheLevel, String key) {
        // 记录未命中
        Counter counter = Counter.builder("cache.misses")
            .tag("level", cacheLevel)
            .tag("key", key)
            .register(meterRegistry);
        counter.increment();
    }
    
    public void recordLatency(String operation, long duration) {
        Timer timer = Timer.builder("cache.latency")
            .tag("operation", operation)
            .register(meterRegistry);
        timer.record(duration, TimeUnit.MILLISECONDS);
    }
    
    // 实时分析
    public void analyzeMetrics() {
        // 获取热点Key Top 10
        List<String> topKeys = meterRegistry.get("cache.hits")
            .counters()
            .stream()
            .sorted((c1, c2) -> Double.compare(c2.count(), c1.count()))
            .limit(10)
            .map(counter -> counter.getId().getTag("key"))
            .collect(Collectors.toList());
        
        // 触发告警
        if (topKeys.size() > 0) {
            double highestQps = meterRegistry.get("cache.hits")
                .counters()
                .stream()
                .mapToDouble(Counter::count)
                .max()
                .orElse(0);
            
            if (highestQps > 10000) {
                sendAlert("检测到热点Key", topKeys.get(0), highestQps);
            }
        }
    }
}

5.2 告警规则

yaml

复制

下载

复制代码 
# alert-rules.yml
hot_key_detection:
  rules:
    - alert: HotKeyDetected
      expr: |
        rate(cache_hits_total{level="redis"}[5m]) > 1000
      for: 1m
      labels:
        severity: warning
      annotations:
        summary: "检测到热点Key {{ $labels.key }}"
        description: "Key {{ $labels.key }} 在5分钟内QPS超过1000"
    
    - alert: CacheNodeOverloaded
      expr: |
        redis_cpu_usage > 80
      for: 2m
      labels:
        severity: critical
      annotations:
        summary: "Redis节点CPU使用率过高"
        description: "节点 {{ $labels.instance }} CPU使用率 {{ $value }}%"

篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc

需要全套面试笔记及答案
【点击此处即可/免费获取】

六、最佳实践总结

6.1 探测层

text

复制

下载

复制代码 
✅ 多维度监控：客户端埋点 + 代理分析 + Redis监控
✅ 实时分析：滑动窗口 + 流处理
✅ 预测预防：机器学习预测未来热点

6.2 缓存层

text

复制

下载

复制代码 
✅ 多级缓存：本地L1 + Redis L2 + DB L3
✅ 智能预热：主动预热 + 事件驱动预热
✅ 动态TTL：根据访问频率调整过期时间

6.3 架构层

text

复制

下载

复制代码 
✅ 分片策略：Key加盐 + 二级索引
✅ 本地副本：只读副本 + 定时刷新
✅ 降级方案：熔断 + 本地兜底

6.4 监控层

text

复制

下载

复制代码 
✅ 实时指标：命中率、延迟、QPS
✅ 智能告警：分级告警 + 自动处理
✅ 可视化：热点Key地图 + 趋势分析

6.5 实施建议

java

复制

下载

复制代码 
// 分阶段实施
public class HotKeySolutionRoadmap {
    
    // Phase 1: 监控探测（1-2周）
    // 实现客户端埋点 + Redis监控
    
    // Phase 2: 本地缓存（2-3周）
    // 引入Caffeine + 多级缓存
    
    // Phase 3: 智能优化（3-4周）
    // 动态预热 + 预测模型
    
    // Phase 4: 集群方案（4-6周）
    // 分片策略 + 只读副本
}

通过以上综合方案，可以有效地探测、缓解和处理热点Key问题，保障系统在高并发场景下的稳定性和性能。

相关推荐
CCPC不拿奖不改名14 小时前
python基础：python语言中的控制结构+面试习题
开发语言·python·学习
MM_MS14 小时前
Halcon基础知识点及其算子用法
开发语言·人工智能·python·算法·计算机视觉·视觉检测
a程序小傲14 小时前
小红书Java面试被问：TCC事务的悬挂、空回滚问题解决方案
java·开发语言·人工智能·后端·python·面试·职场和发展
短剑重铸之日14 小时前
《SpringBoot4.0初识》第五篇：实战代码
java·后端·spring·springboot4.0
heartbeat..14 小时前
Spring MVC 全面详解（Java 主流 Web 开发框架）
java·网络·spring·mvc·web
-西门吹雪14 小时前
c++线程之std::async浅析
java·jvm·c++
a努力。14 小时前
国家电网Java面试被问：最小生成树的Kruskal和Prim算法
java·后端·算法·postgresql·面试·linq
朝九晚五ฺ14 小时前
从零到实战：鲲鹏平台 HPC 技术栈与并行计算
java·开发语言
Geminit14 小时前
无人机培训，蚂蚁智飞在线训练，AI赋能新培训/学习模式
职场和发展
热门推荐
01GitHub 镜像站点02Labelme从安装到标注：零基础完整指南03安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）04Linux下V2Ray安装配置指南05jdk21下载、安装（Windows、Linux、macOS）062025-04-03 Latex学习1——本地配置Latex + VScode环境07【踩坑笔记】50系显卡适配的 PyTorch 安装08Opencode CLI 安装成功,但是启动失败09UV安装并设置国内源10全球最强模型Grok4，国内已可免费使用！（附教程）