当前位置： 首页 > news >正文

贪心算法在云计算虚拟机部署问题中的应用

news 2025/9/15 6:05:30

在这里插入图片描述

Java中的贪心算法在云计算虚拟机部署问题中的应用

贪心算法是一种在每一步选择中都采取当前状态下最优的选择，从而希望导致结果是全局最优的算法。在云计算环境中，虚拟机(VM)部署是一个经典的资源分配问题，贪心算法因其简单高效的特点，常被用于解决这类问题。

一、问题定义与背景

1.1 云计算虚拟机部署问题

在云计算环境中，虚拟机部署问题可以描述为：给定一组物理主机(PM)和一组虚拟机请求(VM)，如何将虚拟机分配到物理主机上，以优化某些目标(如最小化使用的物理主机数量、最大化资源利用率等)，同时满足各种约束条件(如资源容量、亲和性/反亲和性规则等)。

1.2 问题分类

根据优化目标不同，虚拟机部署问题可以分为：

  • 装箱问题(Bin Packing)：最小化使用的物理主机数量
  • 负载均衡问题：最大化资源利用率，避免热点
  • 能耗优化问题：最小化总能耗
  • QoS保障问题：最大化满足服务质量要求

二、贪心算法基础

2.1 贪心算法原理

贪心算法通过以下步骤解决问题：

  1. 建立数学模型来描述问题
  2. 将问题分解为若干子问题
  3. 对每个子问题求解局部最优解
  4. 将局部最优解组合成原问题的解

2.2 贪心算法的适用条件

贪心算法适用于具有"贪心选择性质"和"最优子结构"的问题：

  • 贪心选择性质：全局最优解可以通过局部最优选择达到
  • 最优子结构：问题的最优解包含子问题的最优解

2.3 贪心算法的优缺点

优点：

  • 算法简单，易于实现
  • 运行效率高，时间复杂度通常较低
  • 适合解决实时性要求高的问题

缺点：

  • 不一定能得到全局最优解
  • 需要证明其正确性

三、虚拟机部署中的贪心策略

3.1 常见贪心策略

在虚拟机部署中，常用的贪心策略包括：

  1. First-Fit (首次适应)

    • 按顺序遍历物理主机，将虚拟机部署到第一个能满足资源需求的物理主机上

  2. Best-Fit (最佳适应)

    • 将虚拟机部署到能够满足其资源需求且剩余资源最少的物理主机上

  3. Worst-Fit (最差适应)

    • 将虚拟机部署到能够满足其资源需求且剩余资源最多的物理主机上

  4. Next-Fit (下次适应)

    • 类似于First-Fit，但从上次分配的物理主机开始查找

3.2 策略选择依据

不同策略适用于不同场景：

  • 最小化物理主机数量：First-Fit和Best-Fit通常表现更好
  • 负载均衡：Worst-Fit可能更合适
  • 动态环境：Next-Fit可以减少搜索时间

四、Java实现细节

4.1 数据模型定义

首先定义基本的数据结构：

// 物理主机类
class PhysicalMachine {String id;int cpuCores;       // CPU核心数int memory;         // 内存(MB)int storage;        // 存储(GB)int bandwidth;      // 带宽(Mbps)List<VirtualMachine> vms = new ArrayList<>();// 剩余资源计算public int getRemainingCpu() {return cpuCores - vms.stream().mapToInt(vm -> vm.cpuCores).sum();}public int getRemainingMemory() {return memory - vms.stream().mapToInt(vm -> vm.memory).sum();}// 检查是否能容纳虚拟机public boolean canHost(VirtualMachine vm) {return getRemainingCpu() >= vm.cpuCores && getRemainingMemory() >= vm.memory;}// 添加虚拟机public boolean addVm(VirtualMachine vm) {if (canHost(vm)) {vms.add(vm);return true;}return false;}
}// 虚拟机类
class VirtualMachine {String id;int cpuCores;int memory;// 其他可能的属性：优先级、QoS要求等
}

4.2 First-Fit算法实现

public class VmPlacement {// First-Fit算法实现public static List<PhysicalMachine> firstFit(List<VirtualMachine> vms, List<PhysicalMachine> pms) {List<PhysicalMachine> usedPms = new ArrayList<>(pms);for (VirtualMachine vm : vms) {boolean placed = false;// 遍历所有物理机，找到第一个能容纳的for (PhysicalMachine pm : usedPms) {if (pm.canHost(vm)) {pm.addVm(vm);placed = true;break;}}// 如果没有找到合适的物理机，添加一个新的if (!placed) {// 实际应用中可能需要从资源池获取新物理机// 这里简化处理，假设有无限物理机可用PhysicalMachine newPm = new PhysicalMachine();// 初始化新物理机资源...newPm.addVm(vm);usedPms.add(newPm);}}return usedPms;}
}

4.3 Best-Fit算法实现

public static List<PhysicalMachine> bestFit(List<VirtualMachine> vms, List<PhysicalMachine> pms) {List<PhysicalMachine> usedPms = new ArrayList<>(pms);for (VirtualMachine vm : vms) {PhysicalMachine bestPm = null;int minRemaining = Integer.MAX_VALUE;// 寻找剩余资源最少的合适物理机for (PhysicalMachine pm : usedPms) {if (pm.canHost(vm)) {int remaining = pm.getRemainingCpu() + pm.getRemainingMemory();if (remaining < minRemaining) {minRemaining = remaining;bestPm = pm;}}}if (bestPm != null) {bestPm.addVm(vm);} else {// 添加新物理机PhysicalMachine newPm = new PhysicalMachine();// 初始化...newPm.addVm(vm);usedPms.add(newPm);}}return usedPms;
}

4.4 多资源维度的考虑

实际场景中需要考虑多种资源类型(CPU、内存、存储、带宽等)，需要修改资源判断逻辑：

// 在PhysicalMachine类中添加多资源检查
public boolean canHostMultiResource(VirtualMachine vm) {return getRemainingCpu() >= vm.cpuCores && getRemainingMemory() >= vm.memory&& getRemainingStorage() >= vm.storage&& getRemainingBandwidth() >= vm.bandwidth;
}// 多资源Best-Fit实现
public static List<PhysicalMachine> bestFitMultiResource(List<VirtualMachine> vms, List<PhysicalMachine> pms) {List<PhysicalMachine> usedPms = new ArrayList<>(pms);for (VirtualMachine vm : vms) {PhysicalMachine bestPm = null;double minScore = Double.MAX_VALUE;// 定义资源评分函数Function<PhysicalMachine, Double> scoreFunction = pm -> {double cpuUtil = 1.0 - (double)pm.getRemainingCpu() / pm.cpuCores;double memUtil = 1.0 - (double)pm.getRemainingMemory() / pm.memory;// 可以加入其他资源的利用率return cpuUtil + memUtil; // 简单的加权和};for (PhysicalMachine pm : usedPms) {if (pm.canHostMultiResource(vm)) {double score = scoreFunction.apply(pm);if (score < minScore) {minScore = score;bestPm = pm;}}}if (bestPm != null) {bestPm.addVm(vm);} else {PhysicalMachine newPm = new PhysicalMachine();// 初始化...newPm.addVm(vm);usedPms.add(newPm);}}return usedPms;
}

五、高级优化与扩展

5.1 资源碎片整理

长期运行后会产生资源碎片，可以定期进行碎片整理：

public static void defragment(List<PhysicalMachine> pms) {// 按照剩余资源排序pms.sort(Comparator.comparingInt(pm -> pm.getRemainingCpu() + pm.getRemainingMemory()));// 尝试将虚拟机从较空的物理机迁移到较满的物理机int left = 0, right = pms.size() - 1;while (left < right) {PhysicalMachine src = pms.get(left);PhysicalMachine dst = pms.get(right);// 尝试迁移虚拟机for (int i = 0; i < src.vms.size(); i++) {VirtualMachine vm = src.vms.get(i);if (dst.canHost(vm)) {dst.addVm(vm);src.vms.remove(i);i--; // 因为移除了元素}}// 如果源物理机没有虚拟机了，可以移除if (src.vms.isEmpty()) {pms.remove(left);right--; // 因为列表缩短了} else {left++;}}
}

5.2 动态资源调整

根据负载情况动态调整资源分配：

public static void dynamicAdjustment(List<PhysicalMachine> pms, double cpuThreshold, double memThreshold) {for (PhysicalMachine pm : pms) {double cpuUsage = 1.0 - (double)pm.getRemainingCpu() / pm.cpuCores;double memUsage = 1.0 - (double)pm.getRemainingMemory() / pm.memory;if (cpuUsage > cpuThreshold || memUsage > memThreshold) {// 过载，需要迁移部分虚拟机migrateVmsFromOverloaded(pm, pms, cpuThreshold, memThreshold);} else if (cpuUsage < 0.3 && memUsage < 0.3) {// 低负载，考虑合并tryConsolidate(pm, pms);}}
}private static void migrateVmsFromOverloaded(PhysicalMachine pm, List<PhysicalMachine> pms,double cpuTh, double memTh) {// 实现虚拟机迁移逻辑// ...
}private static void tryConsolidate(PhysicalMachine pm, List<PhysicalMachine> pms) {// 实现虚拟机合并逻辑// ...
}

5.3 考虑能耗的贪心策略

在数据中心场景中，能耗是一个重要考量因素：

public static List<PhysicalMachine> energyAwarePlacement(List<VirtualMachine> vms, List<PhysicalMachine> pms) {// 按照能效排序(假设有能效属性)pms.sort(Comparator.comparingDouble(pm -> pm.energyEfficiency));List<PhysicalMachine> usedPms = new ArrayList<>();for (VirtualMachine vm : vms) {boolean placed = false;// 优先使用能效高的物理机for (PhysicalMachine pm : pms) {if (pm.canHost(vm)) {pm.addVm(vm);placed = true;if (!usedPms.contains(pm)) {usedPms.add(pm);}break;}}if (!placed) {// 尝试开启新的能效最高的物理机for (PhysicalMachine pm : pms) {if (!usedPms.contains(pm) && pm.canHost(vm)) {pm.addVm(vm);usedPms.add(pm);placed = true;break;}}}}return usedPms;
}

六、性能分析与优化

6.1 时间复杂度分析

  • First-Fit：O(n*m)，n为虚拟机数量，m为物理机数量
  • Best-Fit/Worst-Fit：同样O(n*m)，但常数因子更大
  • 排序优化：如果保持物理机有序，可以降低搜索时间

6.2 数据结构优化

使用更高效的数据结构加速查找：

// 使用TreeSet保持物理机有序
public static List<PhysicalMachine> bestFitWithTreeSet(List<VirtualMachine> vms, List<PhysicalMachine> pms) {// 按照剩余资源排序TreeSet<PhysicalMachine> pmSet = new TreeSet<>(Comparator.comparingInt((PhysicalMachine pm) -> pm.getRemainingCpu() + pm.getRemainingMemory()).thenComparing(pm -> pm.id));pmSet.addAll(pms);List<PhysicalMachine> usedPms = new ArrayList<>(pms);for (VirtualMachine vm : vms) {// 寻找最小的能满足的物理机PhysicalMachine dummy = new PhysicalMachine();dummy.cpuCores = vm.cpuCores;dummy.memory = vm.memory;PhysicalMachine target = pmSet.ceiling(dummy);if (target != null) {// 移除-修改-重新添加以保持有序pmSet.remove(target);target.addVm(vm);pmSet.add(target);} else {// 添加新物理机PhysicalMachine newPm = new PhysicalMachine();// 初始化...newPm.addVm(vm);pmSet.add(newPm);usedPms.add(newPm);}}return usedPms;
}

6.3 并行化处理

对于大规模部署，可以采用并行处理：

public static List<PhysicalMachine> parallelFirstFit(List<VirtualMachine> vms, List<PhysicalMachine> pms,int threadCount) {ExecutorService executor = Executors.newFixedThreadPool(threadCount);List<Future<?>> futures = new ArrayList<>();List<PhysicalMachine> usedPms = Collections.synchronizedList(new ArrayList<>(pms));// 将虚拟机列表分区List<List<VirtualMachine>> partitions = partitionList(vms, threadCount);for (List<VirtualMachine> partition : partitions) {futures.add(executor.submit(() -> {for (VirtualMachine vm : partition) {synchronized (usedPms) {boolean placed = false;for (PhysicalMachine pm : usedPms) {if (pm.canHost(vm)) {pm.addVm(vm);placed = true;break;}}if (!placed) {PhysicalMachine newPm = new PhysicalMachine();// 初始化...newPm.addVm(vm);usedPms.add(newPm);}}}}));}// 等待所有任务完成for (Future<?> future : futures) {try {future.get();} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}}executor.shutdown();return usedPms;
}private static <T> List<List<T>> partitionList(List<T> list, int partitions) {// 实现列表分区逻辑// ...
}

七、实际应用中的考虑因素

7.1 异构环境处理

真实的云计算环境通常是异构的：

class HeterogeneousPlacement {// 物理机类型enum PmType {GENERAL, COMPUTE_OPTIMIZED, MEMORY_OPTIMIZED, STORAGE_OPTIMIZED}// 带类型的物理机class TypedPhysicalMachine extends PhysicalMachine {PmType type;// 根据类型有不同的资源分配策略}// 根据虚拟机特性选择最合适的物理机类型public PmType suggestVmType(VirtualMachine vm) {double cpuMemRatio = (double)vm.cpuCores / vm.memory;if (cpuMemRatio > 0.5) return PmType.COMPUTE_OPTIMIZED;if (cpuMemRatio < 0.1) return PmType.MEMORY_OPTIMIZED;return PmType.GENERAL;}// 异构感知的部署算法public List<TypedPhysicalMachine> heterogeneousPlacement(List<VirtualMachine> vms, List<TypedPhysicalMachine> pms) {// 按类型分组Map<PmType, List<TypedPhysicalMachine>> pmByType = pms.stream().collect(Collectors.groupingBy(pm -> pm.type));List<TypedPhysicalMachine> usedPms = new ArrayList<>();for (VirtualMachine vm : vms) {PmType suggestedType = suggestVmType(vm);List<TypedPhysicalMachine> candidates = pmByType.getOrDefault(suggestedType, new ArrayList<>());boolean placed = false;// 先尝试建议类型的物理机for (TypedPhysicalMachine pm : candidates) {if (pm.canHost(vm)) {pm.addVm(vm);placed = true;if (!usedPms.contains(pm)) {usedPms.add(pm);}break;}}// 如果没有找到，尝试其他类型的物理机if (!placed) {for (TypedPhysicalMachine pm : pms) {if (pm.canHost(vm)) {pm.addVm(vm);placed = true;if (!usedPms.contains(pm)) {usedPms.add(pm);}break;}}}// 仍然没有，添加新物理机if (!placed) {TypedPhysicalMachine newPm = new TypedPhysicalMachine();newPm.type = suggestedType;// 根据类型初始化资源...newPm.addVm(vm);usedPms.add(newPm);pmByType.computeIfAbsent(suggestedType, k -> new ArrayList<>()).add(newPm);}}return usedPms;}
}

7.2 亲和性与反亲和性规则

考虑虚拟机之间的亲和性(应该部署在一起)和反亲和性(应该分开部署)：

class VmAffinityPlacement {// 亲和性规则class AffinityRule {String vmId1;String vmId2;boolean isAffinity; // true表示亲和性，false表示反亲和性}public List<PhysicalMachine> placementWithAffinity(List<VirtualMachine> vms, List<PhysicalMachine> pms,List<AffinityRule> rules) {// 构建亲和性图Map<String, Set<String>> affinityMap = new HashMap<>();Map<String, Set<String>> antiAffinityMap = new HashMap<>();for (AffinityRule rule : rules) {if (rule.isAffinity) {affinityMap.computeIfAbsent(rule.vmId1, k -> new HashSet<>()).add(rule.vmId2);affinityMap.computeIfAbsent(rule.vmId2, k -> new HashSet<>()).add(rule.vmId1);} else {antiAffinityMap.computeIfAbsent(rule.vmId1, k -> new HashSet<>()).add(rule.vmId2);antiAffinityMap.computeIfAbsent(rule.vmId2, k -> new HashSet<>()).add(rule.vmId1);}}// 按照亲和性关系排序虚拟机List<VirtualMachine> sortedVms = sortVmsByAffinity(vms, affinityMap);List<PhysicalMachine> usedPms = new ArrayList<>(pms);Map<String, PhysicalMachine> vmToPm = new HashMap<>();for (VirtualMachine vm : sortedVms) {PhysicalMachine selectedPm = null;// 1. 首先检查亲和性规则Set<String> affinityVms = affinityMap.getOrDefault(vm.id, Collections.emptySet());for (String affinityVmId : affinityVms) {if (vmToPm.containsKey(affinityVmId)) {PhysicalMachine candidate = vmToPm.get(affinityVmId);if (candidate.canHost(vm)) {selectedPm = candidate;break;}}}// 2. 如果没有亲和性约束或找不到合适主机，尝试普通放置if (selectedPm == null) {// 使用Best-Fit策略int minScore = Integer.MAX_VALUE;for (PhysicalMachine pm : usedPms) {if (pm.canHost(vm)) {// 检查反亲和性规则boolean antiAffinityViolated = false;Set<String> antiAffinityVms = antiAffinityMap.getOrDefault(vm.id, Collections.emptySet());for (String antiAffinityVmId : antiAffinityVms) {if (pm.vms.stream().anyMatch(v -> v.id.equals(antiAffinityVmId))) {antiAffinityViolated = true;break;}}if (!antiAffinityViolated) {int score = pm.getRemainingCpu() + pm.getRemainingMemory();if (score < minScore) {minScore = score;selectedPm = pm;}}}}}// 3. 如果仍然没有找到，添加新物理机if (selectedPm == null) {selectedPm = new PhysicalMachine();// 初始化...usedPms.add(selectedPm);}selectedPm.addVm(vm);vmToPm.put(vm.id, selectedPm);}return usedPms;}private List<VirtualMachine> sortVmsByAffinity(List<VirtualMachine> vms, Map<String, Set<String>> affinityMap) {// 实现基于亲和性的排序算法// 可以使用图算法找出紧密连接的组件// ...return vms;}
}

八、测试与验证

8.1 测试用例设计

class VmPlacementTest {@Testvoid testFirstFit() {// 准备测试数据List<PhysicalMachine> pms = Arrays.asList(new PhysicalMachine("pm1", 16, 32),new PhysicalMachine("pm2", 16, 32));List<VirtualMachine> vms = Arrays.asList(new VirtualMachine("vm1", 4, 8),new VirtualMachine("vm2", 8, 16),new VirtualMachine("vm3", 4, 8),new VirtualMachine("vm4", 8, 16));// 执行算法List<PhysicalMachine> result = VmPlacement.firstFit(vms, pms);// 验证结果assertEquals(2, result.size());assertEquals(2, result.get(0).vms.size());assertEquals(2, result.get(1).vms.size());}@Testvoid testBestFitWithFullUtilization() {// 准备测试数据List<PhysicalMachine> pms = Arrays.asList(new PhysicalMachine("pm1", 16, 32),new PhysicalMachine("pm2", 16, 32));List<VirtualMachine> vms = Arrays.asList(new VirtualMachine("vm1", 8, 16),new VirtualMachine("vm2", 4, 8),new VirtualMachine("vm3", 4, 8),new VirtualMachine("vm4", 8, 16));// 执行算法List<PhysicalMachine> result = VmPlacement.bestFit(vms, pms);// 验证结果 - Best-Fit应该能完全利用两台物理机assertEquals(2, result.size());assertTrue(result.get(0).getRemainingCpu() == 0 || result.get(1).getRemainingCpu() == 0);assertTrue(result.get(0).getRemainingMemory() == 0 || result.get(1).getRemainingMemory() == 0);}@Testvoid testEnergyAwarePlacement() {// 准备异构测试数据List<EnergyAwarePhysicalMachine> pms = Arrays.asList(new EnergyAwarePhysicalMachine("pm1", 16, 32, 0.9),new EnergyAwarePhysicalMachine("pm2", 16, 32, 0.7),new EnergyAwarePhysicalMachine("pm3", 16, 32, 0.8));List<VirtualMachine> vms = Arrays.asList(new VirtualMachine("vm1", 8, 16),new VirtualMachine("vm2", 4, 8),new VirtualMachine("vm3", 4, 8));// 执行算法List<EnergyAwarePhysicalMachine> result = EnergyAwarePlacement.place(vms, pms);// 验证结果 - 应该优先使用能效高的pm2(0.7)assertEquals(1, result.size());assertEquals("pm2", result.get(0).id);}
}

8.2 性能测试

class PerformanceTest {@Testvoid testLargeScalePlacement() {// 生成大规模测试数据List<PhysicalMachine> pms = generatePms(100); // 100台物理机List<VirtualMachine> vms = generateVms(1000); // 1000台虚拟机// 测试各种算法性能long start, end;start = System.currentTimeMillis();VmPlacement.firstFit(vms, pms);end = System.currentTimeMillis();System.out.println("First-Fit time: " + (end - start) + "ms");start = System.currentTimeMillis();VmPlacement.bestFit(vms, pms);end = System.currentTimeMillis();System.out.println("Best-Fit time: " + (end - start) + "ms");start = System.currentTimeMillis();VmPlacement.parallelFirstFit(vms, pms, 4);end = System.currentTimeMillis();System.out.println("Parallel First-Fit time: " + (end - start) + "ms");}private List<PhysicalMachine> generatePms(int count) {// 生成物理机List<PhysicalMachine> pms = new ArrayList<>();Random random = new Random();for (int i = 0; i < count; i++) {int cpu = 16 + random.nextInt(16); // 16-32核心int memory = 32 + random.nextInt(32); // 32-64GBpms.add(new PhysicalMachine("pm-" + i, cpu, memory));}return pms;}private List<VirtualMachine> generateVms(int count) {// 生成虚拟机List<VirtualMachine> vms = new ArrayList<>();Random random = new Random();for (int i = 0; i < count; i++) {int cpu = 1 + random.nextInt(8); // 1-8核心int memory = 2 + random.nextInt(16); // 2-18GBvms.add(new VirtualMachine("vm-" + i, cpu, memory));}return vms;}
}

九、实际应用案例

9.1 OpenStack中的虚拟机调度

OpenStack Nova调度器可以使用类似的贪心算法。自定义调度器示例：

public class GreedyScheduler extends NovaScheduler {@Overridepublic List<Host> schedule(List<Instance> instances, List<Host> hosts) {// 将Instance和Host转换为我们的模型List<VirtualMachine> vms = convertToVms(instances);List<PhysicalMachine> pms = convertToPms(hosts);// 使用Best-Fit算法List<PhysicalMachine> result = VmPlacement.bestFit(vms, pms);// 转换回OpenStack模型return convertToHosts(result);}// 其他必要的转换方法...
}

9.2 Kubernetes中的Pod调度

虽然Kubernetes主要调度容器，但原理类似。自定义调度器示例：

public class GreedyK8sScheduler implements Scheduler {public void schedule(Pod pod, List<Node> nodes) {// 将Pod和Node转换为我们的模型VirtualMachine vm = convertToVm(pod);List<PhysicalMachine> pms = convertToPms(nodes);// 使用First-Fit算法for (PhysicalMachine pm : pms) {if (pm.canHost(vm)) {pm.addVm(vm);bindPodToNode(pod, pm);return;}}// 没有合适节点throw new UnschedulableException("No node available for pod " + pod.getMetadata().getName());}// 其他必要的方法...
}

十、总结

贪心算法在云计算虚拟机部署中有着广泛的应用，它提供了简单高效的解决方案，特别适合大规模和实时性要求高的场景。本文详细介绍了：

  1. 各种贪心策略的实现和适用场景
  2. Java实现的详细代码和优化技巧
  3. 多维度资源、异构环境、亲和性等高级主题
  4. 性能测试和实际应用案例

开发方向：

  • 与机器学习结合，动态调整贪心策略
  • 考虑更多实际约束，如网络拓扑、延迟要求等
  • 混合使用贪心算法和其他优化算法

贪心算法虽然不一定总能得到全局最优解，但在实际生产环境中，它往往能在合理时间内得到足够好的解决方案，是云计算资源管理中的重要工具。


文章转载自：

http://i2bPbQIX.mtzyr.cn
http://fPnvKpI7.mtzyr.cn
http://fS6lOeQE.mtzyr.cn
http://sERbjs02.mtzyr.cn
http://aakVGBeB.mtzyr.cn
http://COebCqNw.mtzyr.cn
http://lhvMk6br.mtzyr.cn
http://KRDPaaot.mtzyr.cn
http://9zG3LHyF.mtzyr.cn
http://mFigGUkL.mtzyr.cn
http://DmBDChlC.mtzyr.cn
http://3mZDMqto.mtzyr.cn
http://PDtmM0QE.mtzyr.cn
http://gA3aBelW.mtzyr.cn
http://5HXeI2xC.mtzyr.cn
http://SBnHImUu.mtzyr.cn
http://lnLtkI0o.mtzyr.cn
http://ihyexxRT.mtzyr.cn
http://vhE8aEqK.mtzyr.cn
http://lcReUEOy.mtzyr.cn
http://015W1w0e.mtzyr.cn
http://wgKppf1r.mtzyr.cn
http://dncqsdoy.mtzyr.cn
http://FyMk4zlU.mtzyr.cn
http://kMUPhFZS.mtzyr.cn
http://VQcRedMn.mtzyr.cn
http://adGhFpyA.mtzyr.cn
http://QKP4yFpH.mtzyr.cn
http://rtbZEYxq.mtzyr.cn
http://q2POyufU.mtzyr.cn
http://www.dtcms.com/a/383056.html

相关文章：

  • macOS中找不到钥匙串访问
  • 基于FPGA实现LeNet-5（经典CNN识别手写数字）推理
  • 算法-双指针5.6
  • Eino Indexer 组件完全指南
  • 算法-双指针3.4
  • 【开题答辩全过程】以 “旧书驿站”微信小程序的设计与开发为例，包含答辩的问题和答案
  • Altium Designer使用精通教程 第七章（PCB输出）
  • 【秋招笔试】2025.09.13美团秋招算法岗真题\
  • LeetCode 2367.等差三元组的数目
  • 第16课：多模态Agent协作
  • 《网络攻防技术》第一章： 网络攻防概述
  • 消息语义一致性：Exactly-Once 之外的“效果等价”设计
  • SPI NOR Flash 的命令码详解
  • kafka--基础知识点--5.2--最多一次、至少一次、精确一次
  • Spark（1）：不依赖Hadoop搭建Spark环境
  • Python快速入门专业版（三十）：函数进阶：函数嵌套与作用域（内部函数访问外部变量）
  • LLaMA-Factory windows wls 安装vllm，并对比速度
  • 全排列问题深度解析：用 Python 玩转 DFS 回溯与迭代
  • 视觉智能的「破壁者」——Transformer如何重塑计算机视觉范式？三大CV算法论文介绍 ViTMAESwin Transformer
  • 语言模型为何会产生幻觉
  • 【Linux指南】Makefile入门：从概念到基础语法
  • 【deepseek】官方API的申请和调用
  • ARM的GIC
  • ＜ 自用文 acme.sh ＞ 使用 Cloudflare API 自动更新证书
  • vLLM - LLMEngine
  • 天猫返利app的多租户架构设计：数据隔离与资源共享方案
  • 数据库造神计划第六天---增删改查（CRUD）（2）
  • AI 赋能内容创作：从文案生成到视频剪辑，创作者的工具革命已至
  • 如何使用“线程级微内核架构”打造应用
  • [硬件电路-219]：自由电子与空穴导电的比较（异同）