第89集运维磁盘监控与性能优化实战

/**
 * 磁盘监控数据实体类
 */
@Data
@TableName("disk_monitor_data")
public class DiskMonitorData {
    
    @TableId(type = IdType.AUTO)
    private Long id;                    // 主键ID
    
    private String hostname;             // 主机名
    
    private String ip;                   // IP地址
    
    private String deviceName;           // 设备名称
    
    private String mountPoint;           // 挂载点
    
    private String fileSystem;           // 文件系统类型
    
    private Long totalCapacity;          // 总容量
    
    private Long usedCapacity;           // 已使用容量
    
    private Long freeCapacity;           // 空闲容量
    
    private Double capacityUsage;        // 容量使用率
    
    private Long readBytes;              // 读取字节数
    
    private Long writeBytes;             // 写入字节数
    
    private Long readOps;                // 读取操作数
    
    private Long writeOps;               // 写入操作数
    
    private Double readLatency;          // 读取延迟(ms)
    
    private Double writeLatency;         // 写入延迟(ms)
    
    private Double ioUtilization;        // IO利用率(%)
    
    private Double throughput;           // 吞吐量(MB/s)
    
    private Integer queueDepth;          // 队列深度
    
    private Double serviceTime;          // 服务时间(ms)
    
    private String healthStatus;          // 健康状态
    
    private Date collectTime;            // 采集时间
    
    private Date createTime;             // 创建时间
}

/**
 * 磁盘性能统计实体类
 */
@Data
@TableName("disk_performance_stats")
public class DiskPerformanceStats {
    
    @TableId(type = IdType.AUTO)
    private Long id;                    // 主键ID
    
    private String hostname;             // 主机名
    
    private String deviceName;           // 设备名称
    
    private Double avgReadLatency;       // 平均读取延迟
    
    private Double avgWriteLatency;      // 平均写入延迟
    
    private Double avgIoUtilization;     // 平均IO利用率
    
    private Double avgThroughput;        // 平均吞吐量
    
    private Long totalReadOps;           // 总读取操作数
    
    private Long totalWriteOps;          // 总写入操作数
    
    private Long totalReadBytes;         // 总读取字节数
    
    private Long totalWriteBytes;        // 总写入字节数
    
    private Date statsTime;              // 统计时间
    
    private Date createTime;             // 创建时间
}

/**
 * 磁盘监控服务
 * 负责磁盘数据的采集、存储和分析
 */
@Service
public class DiskMonitorService {

    @Autowired
    private DiskMonitorDataMapper diskMonitorDataMapper;
    
    @Autowired
    private DiskPerformanceStatsMapper diskPerformanceStatsMapper;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private AlertService alertService;

    /**
     * 采集磁盘数据
     * 定期采集磁盘IO性能和容量信息
     */
    @Scheduled(fixedRate = 5000) // 每5秒执行一次
    public void collectDiskData() {
        try {
            // 1. 获取所有磁盘信息
            List<DiskInfo> diskInfos = getDiskInfos();
            
            // 2. 采集每个磁盘的数据
            for (DiskInfo diskInfo : diskInfos) {
                collectDiskInfoData(diskInfo);
            }
            
            // 3. 分析磁盘性能
            analyzeDiskPerformance();
            
        } catch (Exception e) {
            log.error("采集磁盘数据失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 获取磁盘信息列表
     */
    private List<DiskInfo> getDiskInfos() {
        List<DiskInfo> diskInfos = new ArrayList<>();
        
        try {
            // 使用OSHI获取磁盘信息
            SystemInfo systemInfo = new SystemInfo();
            HardwareAbstractionLayer hal = systemInfo.getHardware();
            
            // 获取文件系统信息
            List<OSFileStore> fileStores = hal.getFileStores();
            for (OSFileStore fileStore : fileStores) {
                DiskInfo diskInfo = new DiskInfo();
                diskInfo.setName(fileStore.getName());
                diskInfo.setMountPoint(fileStore.getMount());
                diskInfo.setFileSystem(fileStore.getType());
                diskInfo.setTotalCapacity(fileStore.getTotalSpace());
                diskInfo.setFreeCapacity(fileStore.getUsableSpace());
                diskInfo.setUsedCapacity(fileStore.getTotalSpace() - fileStore.getUsableSpace());
                diskInfo.setCapacityUsage((double) diskInfo.getUsedCapacity() / diskInfo.getTotalCapacity() * 100);
                
                // 获取IO统计信息
                updateDiskIoStats(diskInfo);
                
                diskInfos.add(diskInfo);
            }
            
        } catch (Exception e) {
            log.error("获取磁盘信息失败: {}", e.getMessage(), e);
        }
        
        return diskInfos;
    }

    /**
     * 更新磁盘IO统计信息
     */
    private void updateDiskIoStats(DiskInfo diskInfo) {
        try {
            // 读取/proc/diskstats文件获取IO统计信息
            Path diskStatsPath = Paths.get("/proc/diskstats");
            if (Files.exists(diskStatsPath)) {
                List<String> lines = Files.readAllLines(diskStatsPath);
                
                for (String line : lines) {
                    String[] parts = line.trim().split("\\s+");
                    if (parts.length >= 14 && parts[2].equals(diskInfo.getName())) {
                        // 解析IO统计信息
                        diskInfo.setReadOps(Long.parseLong(parts[3]));
                        diskInfo.setWriteOps(Long.parseLong(parts[7]));
                        diskInfo.setReadBytes(Long.parseLong(parts[5]) * 512); // 转换为字节
                        diskInfo.setWriteBytes(Long.parseLong(parts[9]) * 512);
                        diskInfo.setReadLatency(Double.parseDouble(parts[6]));
                        diskInfo.setWriteLatency(Double.parseDouble(parts[10]));
                        diskInfo.setIoUtilization(Double.parseDouble(parts[11]));
                        diskInfo.setQueueDepth(Integer.parseInt(parts[11]));
                        diskInfo.setServiceTime(Double.parseDouble(parts[12]));
                        break;
                    }
                }
            }
            
        } catch (Exception e) {
            log.error("更新磁盘IO统计信息失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 采集单个磁盘数据
     */
    private void collectDiskInfoData(DiskInfo diskInfo) {
        try {
            // 1. 创建磁盘监控数据
            DiskMonitorData diskData = createDiskMonitorData(diskInfo);
            
            // 2. 保存到数据库
            diskMonitorDataMapper.insert(diskData);
            
            // 3. 更新缓存
            updateDiskCache(diskData);
            
            // 4. 检查磁盘告警
            checkDiskAlert(diskData);
            
            log.debug("采集磁盘数据: deviceName={}, ioUtilization={}%, capacityUsage={}%", 
                    diskData.getDeviceName(), diskData.getIoUtilization(), diskData.getCapacityUsage());
                    
        } catch (Exception e) {
            log.error("采集磁盘数据失败: deviceName={}, error={}", 
                    diskInfo.getName(), e.getMessage(), e);
        }
    }

    /**
     * 创建磁盘监控数据
     */
    private DiskMonitorData createDiskMonitorData(DiskInfo diskInfo) {
        DiskMonitorData diskData = new DiskMonitorData();
        
        // 设置基本信息
        diskData.setHostname(getHostname());
        diskData.setIp(getLocalIpAddress());
        diskData.setDeviceName(diskInfo.getName());
        diskData.setMountPoint(diskInfo.getMountPoint());
        diskData.setFileSystem(diskInfo.getFileSystem());
        diskData.setCollectTime(new Date());
        diskData.setCreateTime(new Date());
        
        // 设置容量信息
        diskData.setTotalCapacity(diskInfo.getTotalCapacity());
        diskData.setUsedCapacity(diskInfo.getUsedCapacity());
        diskData.setFreeCapacity(diskInfo.getFreeCapacity());
        diskData.setCapacityUsage(diskInfo.getCapacityUsage());
        
        // 设置IO信息
        diskData.setReadBytes(diskInfo.getReadBytes());
        diskData.setWriteBytes(diskInfo.getWriteBytes());
        diskData.setReadOps(diskInfo.getReadOps());
        diskData.setWriteOps(diskInfo.getWriteOps());
        diskData.setReadLatency(diskInfo.getReadLatency());
        diskData.setWriteLatency(diskInfo.getWriteLatency());
        diskData.setIoUtilization(diskInfo.getIoUtilization());
        diskData.setQueueDepth(diskInfo.getQueueDepth());
        diskData.setServiceTime(diskInfo.getServiceTime());
        
        // 计算吞吐量
        diskData.setThroughput(calculateThroughput(diskInfo));
        
        // 设置健康状态
        diskData.setHealthStatus(diskInfo.getHealthStatus());
        
        return diskData;
    }

    /**
     * 计算吞吐量
     */
    private Double calculateThroughput(DiskInfo diskInfo) {
        try {
            // 计算总IO字节数
            long totalBytes = diskInfo.getReadBytes() + diskInfo.getWriteBytes();
            
            // 转换为MB/s
            return totalBytes / (1024.0 * 1024.0);
            
        } catch (Exception e) {
            return 0.0;
        }
    }

    /**
     * 更新磁盘缓存
     */
    private void updateDiskCache(DiskMonitorData diskData) {
        try {
            String cacheKey = "disk:realtime:" + diskData.getHostname() + ":" + diskData.getDeviceName();
            redisTemplate.opsForValue().set(cacheKey, diskData, Duration.ofMinutes(5));
            
            // 更新历史数据缓存
            String historyKey = "disk:history:" + diskData.getHostname() + ":" + diskData.getDeviceName();
            redisTemplate.opsForList().leftPush(historyKey, diskData);
            redisTemplate.opsForList().trim(historyKey, 0, 99);
            redisTemplate.expire(historyKey, Duration.ofHours(1));
            
        } catch (Exception e) {
            log.warn("更新磁盘缓存失败: {}", e.getMessage());
        }
    }

    /**
     * 检查磁盘告警
     */
    private void checkDiskAlert(DiskMonitorData diskData) {
        try {
            String alertType = null;
            String alertLevel = null;
            String alertMessage = null;
            
            // 检查IO利用率告警
            if (diskData.getIoUtilization() >= 95) {
                alertType = "DISK_IO_CRITICAL";
                alertLevel = "CRITICAL";
                alertMessage = String.format("磁盘IO利用率过高: %s 利用率 %.2f%%", 
                        diskData.getDeviceName(), diskData.getIoUtilization());
            } else if (diskData.getIoUtilization() >= 80) {
                alertType = "DISK_IO_HIGH";
                alertLevel = "WARNING";
                alertMessage = String.format("磁盘IO利用率较高: %s 利用率 %.2f%%", 
                        diskData.getDeviceName(), diskData.getIoUtilization());
            }
            
            // 检查延迟告警
            if (diskData.getReadLatency() > 100) {
                alertType = "DISK_READ_LATENCY_HIGH";
                alertLevel = "WARNING";
                alertMessage = String.format("磁盘读取延迟过高: %s 延迟 %.2fms", 
                        diskData.getDeviceName(), diskData.getReadLatency());
            }
            
            if (diskData.getWriteLatency() > 100) {
                alertType = "DISK_WRITE_LATENCY_HIGH";
                alertLevel = "WARNING";
                alertMessage = String.format("磁盘写入延迟过高: %s 延迟 %.2fms", 
                        diskData.getDeviceName(), diskData.getWriteLatency());
            }
            
            // 检查容量告警
            if (diskData.getCapacityUsage() >= 95) {
                alertType = "DISK_CAPACITY_CRITICAL";
                alertLevel = "CRITICAL";
                alertMessage = String.format("磁盘容量严重不足: %s 使用率 %.2f%%", 
                        diskData.getDeviceName(), diskData.getCapacityUsage());
            } else if (diskData.getCapacityUsage() >= 85) {
                alertType = "DISK_CAPACITY_HIGH";
                alertLevel = "WARNING";
                alertMessage = String.format("磁盘容量不足: %s 使用率 %.2f%%", 
                        diskData.getDeviceName(), diskData.getCapacityUsage());
            }
            
            // 发送告警
            if (alertType != null) {
                sendDiskAlert(diskData, alertType, alertLevel, alertMessage);
            }
            
        } catch (Exception e) {
            log.error("检查磁盘告警失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 发送磁盘告警
     */
    private void sendDiskAlert(DiskMonitorData diskData, String alertType, String alertLevel, String alertMessage) {
        try {
            // 检查是否已经发送过相同告警
            String alertKey = "disk:alert:" + diskData.getHostname() + ":" + diskData.getDeviceName() + ":" + alertType;
            Boolean hasAlert = redisTemplate.hasKey(alertKey);
            
            if (hasAlert == null || !hasAlert) {
                // 创建告警记录
                DiskAlertRecord alertRecord = new DiskAlertRecord();
                alertRecord.setHostname(diskData.getHostname());
                alertRecord.setDeviceName(diskData.getDeviceName());
                alertRecord.setAlertType(alertType);
                alertRecord.setAlertLevel(alertLevel);
                alertRecord.setAlertMessage(alertMessage);
                alertRecord.setAlertStatus("ACTIVE");
                alertRecord.setAlertTime(new Date());
                
                // 发送告警通知
                alertService.sendDiskAlert(alertRecord);
                
                // 设置告警缓存
                redisTemplate.opsForValue().set(alertKey, "1", Duration.ofMinutes(5));
                
                log.warn("发送磁盘告警: hostname={}, deviceName={}, type={}, level={}", 
                        diskData.getHostname(), diskData.getDeviceName(), alertType, alertLevel);
            }
            
        } catch (Exception e) {
            log.error("发送磁盘告警失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 分析磁盘性能
     */
    private void analyzeDiskPerformance() {
        try {
            // 获取所有磁盘的实时数据
            List<DiskMonitorData> diskDataList = getRealTimeDiskData();
            
            // 分析整体性能
            analyzeOverallPerformance(diskDataList);
            
            // 分析IO性能
            analyzeIoPerformance(diskDataList);
            
            // 更新性能统计
            updatePerformanceStats(diskDataList);
            
        } catch (Exception e) {
            log.error("分析磁盘性能失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 分析整体性能
     */
    private void analyzeOverallPerformance(List<DiskMonitorData> diskDataList) {
        try {
            // 计算平均IO利用率
            double avgIoUtilization = diskDataList.stream()
                    .mapToDouble(DiskMonitorData::getIoUtilization)
                    .average()
                    .orElse(0.0);
            
            // 计算平均吞吐量
            double avgThroughput = diskDataList.stream()
                    .mapToDouble(DiskMonitorData::getThroughput)
                    .average()
                    .orElse(0.0);
            
            // 计算平均延迟
            double avgReadLatency = diskDataList.stream()
                    .mapToDouble(DiskMonitorData::getReadLatency)
                    .average()
                    .orElse(0.0);
            
            double avgWriteLatency = diskDataList.stream()
                    .mapToDouble(DiskMonitorData::getWriteLatency)
                    .average()
                    .orElse(0.0);
            
            log.debug("磁盘整体性能分析: avgIoUtilization={}%, avgThroughput={}MB/s, avgReadLatency={}ms, avgWriteLatency={}ms", 
                    avgIoUtilization, avgThroughput, avgReadLatency, avgWriteLatency);
            
        } catch (Exception e) {
            log.error("分析整体性能失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 分析IO性能
     */
    private void analyzeIoPerformance(List<DiskMonitorData> diskDataList) {
        try {
            // 找出IO性能最差的磁盘
            DiskMonitorData worstIoDisk = diskDataList.stream()
                    .max(Comparator.comparing(DiskMonitorData::getIoUtilization))
                    .orElse(null);
            
            if (worstIoDisk != null && worstIoDisk.getIoUtilization() > 80) {
                log.warn("发现IO性能差的磁盘: deviceName={}, ioUtilization={}%", 
                        worstIoDisk.getDeviceName(), worstIoDisk.getIoUtilization());
            }
            
            // 找出延迟最高的磁盘
            DiskMonitorData highestLatencyDisk = diskDataList.stream()
                    .max(Comparator.comparing(DiskMonitorData::getReadLatency))
                    .orElse(null);
            
            if (highestLatencyDisk != null && highestLatencyDisk.getReadLatency() > 50) {
                log.warn("发现延迟较高的磁盘: deviceName={}, readLatency={}ms", 
                        highestLatencyDisk.getDeviceName(), highestLatencyDisk.getReadLatency());
            }
            
        } catch (Exception e) {
            log.error("分析IO性能失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 更新性能统计
     */
    private void updatePerformanceStats(List<DiskMonitorData> diskDataList) {
        try {
            for (DiskMonitorData diskData : diskDataList) {
                String statsKey = "disk:performance:" + diskData.getHostname() + ":" + diskData.getDeviceName();
                
                Map<String, Object> stats = new HashMap<>();
                stats.put("avgReadLatency", diskData.getReadLatency());
                stats.put("avgWriteLatency", diskData.getWriteLatency());
                stats.put("avgIoUtilization", diskData.getIoUtilization());
                stats.put("avgThroughput", diskData.getThroughput());
                stats.put("totalReadOps", diskData.getReadOps());
                stats.put("totalWriteOps", diskData.getWriteOps());
                stats.put("totalReadBytes", diskData.getReadBytes());
                stats.put("totalWriteBytes", diskData.getWriteBytes());
                stats.put("lastUpdateTime", System.currentTimeMillis());
                
                redisTemplate.opsForValue().set(statsKey, stats, Duration.ofMinutes(10));
            }
            
        } catch (Exception e) {
            log.warn("更新性能统计失败: {}", e.getMessage());
        }
    }

    /**
     * 获取实时磁盘数据
     */
    public List<DiskMonitorData> getRealTimeDiskData() {
        List<DiskMonitorData> diskDataList = new ArrayList<>();
        
        try {
            String hostname = getHostname();
            String pattern = "disk:realtime:" + hostname + ":*";
            
            Set<String> keys = redisTemplate.keys(pattern);
            if (keys != null) {
                for (String key : keys) {
                    DiskMonitorData diskData = (DiskMonitorData) redisTemplate.opsForValue().get(key);
                    if (diskData != null) {
                        diskDataList.add(diskData);
                    }
                }
            }
            
        } catch (Exception e) {
            log.error("获取实时磁盘数据失败: {}", e.getMessage(), e);
        }
        
        return diskDataList;
    }

    /**
     * 获取磁盘历史数据
     */
    public List<DiskMonitorData> getDiskHistoryData(String hostname, String deviceName, Date startTime, Date endTime) {
        return diskMonitorDataMapper.selectByHostnameAndDeviceNameAndTimeRange(hostname, deviceName, startTime, endTime);
    }

    /**
     * 获取磁盘性能统计
     */
    public Map<String, Object> getDiskPerformanceStats(String hostname, String deviceName) {
        String statsKey = "disk:performance:" + hostname + ":" + deviceName;
        return (Map<String, Object>) redisTemplate.opsForValue().get(statsKey);
    }

    /**
     * 获取主机名
     */
    private String getHostname() {
        try {
            return InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
            return "unknown";
        }
    }

    /**
     * 获取本地IP地址
     */
    private String getLocalIpAddress() {
        try {
            return InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            return "127.0.0.1";
        }
    }
}

/**
 * 磁盘信息实体类
 */
@Data
public class DiskInfo {
    private String name;                 // 设备名称
    private String mountPoint;            // 挂载点
    private String fileSystem;           // 文件系统类型
    private Long totalCapacity;           // 总容量
    private Long usedCapacity;           // 已使用容量
    private Long freeCapacity;            // 空闲容量
    private Double capacityUsage;         // 容量使用率
    private Long readBytes;               // 读取字节数
    private Long writeBytes;              // 写入字节数
    private Long readOps;                 // 读取操作数
    private Long writeOps;                // 写入操作数
    private Double readLatency;           // 读取延迟
    private Double writeLatency;          // 写入延迟
    private Double ioUtilization;         // IO利用率
    private Integer queueDepth;           // 队列深度
    private Double serviceTime;           // 服务时间
    private String healthStatus;          // 健康状态
}

/**
 * 磁盘性能优化服务
 * 提供磁盘性能优化和调优功能
 */
@Service
public class DiskPerformanceOptimizationService {

    @Autowired
    private DiskMonitorService diskMonitorService;
    
    @Autowired
    private AlertService alertService;

    /**
     * 自动磁盘性能优化
     * 根据磁盘性能情况自动进行优化
     */
    @Scheduled(fixedRate = 300000) // 每5分钟执行一次
    public void autoOptimizeDiskPerformance() {
        try {
            String hostname = getHostname();
            List<DiskMonitorData> diskDataList = diskMonitorService.getRealTimeDiskData();
            
            // 检查每个磁盘的性能
            for (DiskMonitorData diskData : diskDataList) {
                if (diskData.getIoUtilization() > 90) {
                    // IO利用率过高，执行紧急优化
                    executeEmergencyOptimization(diskData);
                } else if (diskData.getIoUtilization() > 70) {
                    // IO利用率较高，执行预防性优化
                    executePreventiveOptimization(diskData);
                }
            }
            
        } catch (Exception e) {
            log.error("自动磁盘性能优化失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 执行紧急优化
     */
    private void executeEmergencyOptimization(DiskMonitorData diskData) {
        log.warn("执行紧急磁盘性能优化: deviceName={}, ioUtilization={}%", 
                diskData.getDeviceName(), diskData.getIoUtilization());
        
        try {
            // 1. 调整IO调度器
            adjustIoScheduler(diskData.getDeviceName());
            
            // 2. 优化IO队列深度
            optimizeIoQueueDepth(diskData.getDeviceName());
            
            // 3. 调整IO优先级
            adjustIoPriority(diskData.getDeviceName());
            
            // 4. 清理IO缓存
            cleanupIoCache(diskData.getMountPoint());
            
            // 5. 发送优化通知
            sendOptimizationNotification(diskData, "EMERGENCY_OPTIMIZATION");
            
        } catch (Exception e) {
            log.error("执行紧急优化失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 执行预防性优化
     */
    private void executePreventiveOptimization(DiskMonitorData diskData) {
        log.info("执行预防性磁盘性能优化: deviceName={}, ioUtilization={}%", 
                diskData.getDeviceName(), diskData.getIoUtilization());
        
        try {
            // 1. 优化文件系统参数
            optimizeFileSystemParameters(diskData.getMountPoint());
            
            // 2. 调整IO参数
            adjustIoParameters(diskData.getDeviceName());
            
            // 3. 优化缓存策略
            optimizeCacheStrategy(diskData.getMountPoint());
            
            // 4. 发送优化通知
            sendOptimizationNotification(diskData, "PREVENTIVE_OPTIMIZATION");
            
        } catch (Exception e) {
            log.error("执行预防性优化失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 调整IO调度器
     */
    private void adjustIoScheduler(String deviceName) {
        log.info("调整IO调度器: deviceName={}", deviceName);
        
        try {
            // 检查当前IO调度器
            String currentScheduler = getCurrentIoScheduler(deviceName);
            log.info("当前IO调度器: {}", currentScheduler);
            
            // 根据设备类型选择最优调度器
            String optimalScheduler = getOptimalIoScheduler(deviceName);
            
            if (!optimalScheduler.equals(currentScheduler)) {
                // 设置新的IO调度器
                setIoScheduler(deviceName, optimalScheduler);
                log.info("IO调度器已调整为: {}", optimalScheduler);
            }
            
        } catch (Exception e) {
            log.error("调整IO调度器失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 获取当前IO调度器
     */
    private String getCurrentIoScheduler(String deviceName) {
        try {
            Path schedulerPath = Paths.get("/sys/block/" + deviceName + "/queue/scheduler");
            if (Files.exists(schedulerPath)) {
                String content = Files.readString(schedulerPath);
                // 解析调度器名称
                Pattern pattern = Pattern.compile("\\[(\\w+)\\]");
                Matcher matcher = pattern.matcher(content);
                if (matcher.find()) {
                    return matcher.group(1);
                }
            }
        } catch (Exception e) {
            log.error("获取当前IO调度器失败: {}", e.getMessage(), e);
        }
        return "unknown";
    }

    /**
     * 获取最优IO调度器
     */
    private String getOptimalIoScheduler(String deviceName) {
        // 根据设备类型和负载情况选择最优调度器
        // SSD通常使用noop或deadline
        // HDD通常使用cfq或deadline
        // 高IO负载使用mq-deadline
        
        if (isSSD(deviceName)) {
            return "noop";
        } else {
            return "deadline";
        }
    }

    /**
     * 判断是否为SSD
     */
    private boolean isSSD(String deviceName) {
        try {
            Path rotationalPath = Paths.get("/sys/block/" + deviceName + "/queue/rotational");
            if (Files.exists(rotationalPath)) {
                String content = Files.readString(rotationalPath).trim();
                return "0".equals(content);
            }
        } catch (Exception e) {
            log.error("判断SSD失败: {}", e.getMessage(), e);
        }
        return false;
    }

    /**
     * 设置IO调度器
     */
    private void setIoScheduler(String deviceName, String scheduler) {
        try {
            ProcessBuilder pb = new ProcessBuilder("echo", scheduler, ">", "/sys/block/" + deviceName + "/queue/scheduler");
            Process process = pb.start();
            int exitCode = process.waitFor();
            
            if (exitCode == 0) {
                log.info("IO调度器设置成功: deviceName={}, scheduler={}", deviceName, scheduler);
            } else {
                log.error("IO调度器设置失败: deviceName={}, scheduler={}", deviceName, scheduler);
            }
            
        } catch (Exception e) {
            log.error("设置IO调度器失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 优化IO队列深度
     */
    private void optimizeIoQueueDepth(String deviceName) {
        log.info("优化IO队列深度: deviceName={}", deviceName);
        
        try {
            // 获取当前队列深度
            int currentDepth = getCurrentQueueDepth(deviceName);
            log.info("当前队列深度: {}", currentDepth);
            
            // 计算最优队列深度
            int optimalDepth = calculateOptimalQueueDepth(deviceName);
            
            if (optimalDepth != currentDepth) {
                // 设置新的队列深度
                setQueueDepth(deviceName, optimalDepth);
                log.info("队列深度已调整为: {}", optimalDepth);
            }
            
        } catch (Exception e) {
            log.error("优化IO队列深度失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 获取当前队列深度
     */
    private int getCurrentQueueDepth(String deviceName) {
        try {
            Path depthPath = Paths.get("/sys/block/" + deviceName + "/queue/nr_requests");
            if (Files.exists(depthPath)) {
                String content = Files.readString(depthPath).trim();
                return Integer.parseInt(content);
            }
        } catch (Exception e) {
            log.error("获取当前队列深度失败: {}", e.getMessage(), e);
        }
        return 128; // 默认值
    }

    /**
     * 计算最优队列深度
     */
    private int calculateOptimalQueueDepth(String deviceName) {
        // 根据设备类型和性能计算最优队列深度
        if (isSSD(deviceName)) {
            return 256; // SSD可以使用更大的队列深度
        } else {
            return 128; // HDD使用较小的队列深度
        }
    }

    /**
     * 设置队列深度
     */
    private void setQueueDepth(String deviceName, int depth) {
        try {
            ProcessBuilder pb = new ProcessBuilder("echo", String.valueOf(depth), ">", "/sys/block/" + deviceName + "/queue/nr_requests");
            Process process = pb.start();
            int exitCode = process.waitFor();
            
            if (exitCode == 0) {
                log.info("队列深度设置成功: deviceName={}, depth={}", deviceName, depth);
            } else {
                log.error("队列深度设置失败: deviceName={}, depth={}", deviceName, depth);
            }
            
        } catch (Exception e) {
            log.error("设置队列深度失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 调整IO优先级
     */
    private void adjustIoPriority(String deviceName) {
        log.info("调整IO优先级: deviceName={}", deviceName);
        
        try {
            // 设置IO优先级
            setIoPriority(deviceName, 1); // 高优先级
            
        } catch (Exception e) {
            log.error("调整IO优先级失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 设置IO优先级
     */
    private void setIoPriority(String deviceName, int priority) {
        try {
            ProcessBuilder pb = new ProcessBuilder("ionice", "-c", "1", "-n", String.valueOf(priority), "-p", "1");
            Process process = pb.start();
            int exitCode = process.waitFor();
            
            if (exitCode == 0) {
                log.info("IO优先级设置成功: deviceName={}, priority={}", deviceName, priority);
            } else {
                log.error("IO优先级设置失败: deviceName={}, priority={}", deviceName, priority);
            }
            
        } catch (Exception e) {
            log.error("设置IO优先级失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 清理IO缓存
     */
    private void cleanupIoCache(String mountPoint) {
        log.info("清理IO缓存: mountPoint={}", mountPoint);
        
        try {
            // 同步文件系统
            ProcessBuilder pb = new ProcessBuilder("sync");
            Process process = pb.start();
            process.waitFor();
            
            // 清理页面缓存
            ProcessBuilder pb2 = new ProcessBuilder("echo", "3", ">", "/proc/sys/vm/drop_caches");
            Process process2 = pb2.start();
            process2.waitFor();
            
            log.info("IO缓存清理完成");
            
        } catch (Exception e) {
            log.error("清理IO缓存失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 优化文件系统参数
     */
    private void optimizeFileSystemParameters(String mountPoint) {
        log.info("优化文件系统参数: mountPoint={}", mountPoint);
        
        try {
            // 优化文件系统参数
            optimizeFileSystemMountOptions(mountPoint);
            
            // 优化文件系统缓存
            optimizeFileSystemCache(mountPoint);
            
        } catch (Exception e) {
            log.error("优化文件系统参数失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 优化文件系统挂载选项
     */
    private void optimizeFileSystemMountOptions(String mountPoint) {
        try {
            // 检查当前挂载选项
            ProcessBuilder pb = new ProcessBuilder("mount", "|", "grep", mountPoint);
            Process process = pb.start();
            
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line = reader.readLine();
            
            if (line != null) {
                log.info("当前挂载选项: {}", line);
                
                // 根据文件系统类型优化挂载选项
                if (line.contains("ext4")) {
                    optimizeExt4MountOptions(mountPoint);
                } else if (line.contains("xfs")) {
                    optimizeXfsMountOptions(mountPoint);
                }
            }
            
        } catch (Exception e) {
            log.error("优化文件系统挂载选项失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 优化ext4挂载选项
     */
    private void optimizeExt4MountOptions(String mountPoint) {
        // ext4优化选项
        log.info("优化ext4挂载选项: mountPoint={}", mountPoint);
    }

    /**
     * 优化xfs挂载选项
     */
    private void optimizeXfsMountOptions(String mountPoint) {
        // xfs优化选项
        log.info("优化xfs挂载选项: mountPoint={}", mountPoint);
    }

    /**
     * 优化文件系统缓存
     */
    private void optimizeFileSystemCache(String mountPoint) {
        try {
            // 调整文件系统缓存参数
            adjustFileSystemCacheParameters();
            
        } catch (Exception e) {
            log.error("优化文件系统缓存失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 调整文件系统缓存参数
     */
    private void adjustFileSystemCacheParameters() {
        try {
            // 调整脏页比例
            ProcessBuilder pb1 = new ProcessBuilder("echo", "10", ">", "/proc/sys/vm/dirty_ratio");
            Process process1 = pb1.start();
            process1.waitFor();
            
            // 调整脏页后台刷新比例
            ProcessBuilder pb2 = new ProcessBuilder("echo", "5", ">", "/proc/sys/vm/dirty_background_ratio");
            Process process2 = pb2.start();
            process2.waitFor();
            
            log.info("文件系统缓存参数调整完成");
            
        } catch (Exception e) {
            log.error("调整文件系统缓存参数失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 调整IO参数
     */
    private void adjustIoParameters(String deviceName) {
        log.info("调整IO参数: deviceName={}", deviceName);
        
        try {
            // 调整IO参数
            adjustIoReadAhead(deviceName);
            adjustIoWriteCache(deviceName);
            
        } catch (Exception e) {
            log.error("调整IO参数失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 调整IO预读
     */
    private void adjustIoReadAhead(String deviceName) {
        try {
            // 设置预读大小
            ProcessBuilder pb = new ProcessBuilder("echo", "1024", ">", "/sys/block/" + deviceName + "/queue/read_ahead_kb");
            Process process = pb.start();
            process.waitFor();
            
            log.info("IO预读调整完成: deviceName={}", deviceName);
            
        } catch (Exception e) {
            log.error("调整IO预读失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 调整IO写缓存
     */
    private void adjustIoWriteCache(String deviceName) {
        try {
            // 启用写缓存
            ProcessBuilder pb = new ProcessBuilder("echo", "1", ">", "/sys/block/" + deviceName + "/queue/write_cache");
            Process process = pb.start();
            process.waitFor();
            
            log.info("IO写缓存调整完成: deviceName={}", deviceName);
            
        } catch (Exception e) {
            log.error("调整IO写缓存失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 优化缓存策略
     */
    private void optimizeCacheStrategy(String mountPoint) {
        log.info("优化缓存策略: mountPoint={}", mountPoint);
        
        try {
            // 优化缓存策略
            optimizePageCache();
            optimizeBufferCache();
            
        } catch (Exception e) {
            log.error("优化缓存策略失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 优化页面缓存
     */
    private void optimizePageCache() {
        try {
            // 调整页面缓存参数
            ProcessBuilder pb = new ProcessBuilder("echo", "1", ">", "/proc/sys/vm/swappiness");
            Process process = pb.start();
            process.waitFor();
            
            log.info("页面缓存优化完成");
            
        } catch (Exception e) {
            log.error("优化页面缓存失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 优化缓冲区缓存
     */
    private void optimizeBufferCache() {
        try {
            // 调整缓冲区缓存参数
            ProcessBuilder pb = new ProcessBuilder("echo", "1", ">", "/proc/sys/vm/drop_caches");
            Process process = pb.start();
            process.waitFor();
            
            log.info("缓冲区缓存优化完成");
            
        } catch (Exception e) {
            log.error("优化缓冲区缓存失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 发送优化通知
     */
    private void sendOptimizationNotification(DiskMonitorData diskData, String optimizationType) {
        try {
            AlertMessage alert = new AlertMessage();
            alert.setType("DISK_OPTIMIZATION");
            alert.setLevel("INFO");
            alert.setMessage(String.format("磁盘性能优化完成: 类型=%s, 设备=%s, IO利用率=%.2f%%", 
                    optimizationType, diskData.getDeviceName(), diskData.getIoUtilization()));
            alert.setTimestamp(new Date());
            
            alertService.sendAlert(alert);
            
        } catch (Exception e) {
            log.error("发送优化通知失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 获取主机名
     */
    private String getHostname() {
        try {
            return InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
            return "unknown";
        }
    }
}