cat /proc/meminfo | grep -E "(Cached|Buffers|Slab)"

Cached:           2048576 kB
Buffers:           123456 kB
Slab:              789012 kB

# 清理頁緩存
echo 1 > /proc/sys/vm/drop_caches

# 清理目錄項(xiàng)和inode緩存
echo 2 > /proc/sys/vm/drop_caches

# 同時(shí)清理頁緩存、目錄項(xiàng)和inode緩存（推薦）
echo 3 > /proc/sys/vm/drop_caches

sync && echo 3 > /proc/sys/vm/drop_caches

sync && sysctl vm.drop_caches=3

#!/bin/bash
# clean_cache.sh

LOG_FILE="/var/log/clean_cache.log"
echo "[$(date)] 開始清理緩存..." >> $LOG_FILE

# 同步磁盤
sync

# 清理緩存
echo 3 > /proc/sys/vm/drop_caches

echo "[$(date)] 緩存清理完成" >> $LOG_FILE
free -h >> $LOG_FILE
echo "------------------------" >> $LOG_FILE

0 3 * * 0 /path/to/clean_cache.sh

sudo apt-get clean          # 清除.deb包緩存
sudo apt-get autoclean      # 清除過期包
sudo apt-get autoremove     # 刪除無用依賴

sudo yum clean all          # 清除yum緩存
# 或
sudo dnf clean all          # dnf用戶

# 查看大日志文件
find /var/log -name "*.log" -size +100M -exec ls -lh {} \;

# 清空特定日志（保留文件結(jié)構(gòu)）
truncate -s 0 /var/log/syslog

# 使用logrotate配置自動(dòng)輪轉(zhuǎn)（推薦）
sudo logrotate -f /etc/logrotate.conf

# 清理/tmp目錄（重啟后自動(dòng)清空，也可手動(dòng)）
sudo find /tmp -type f -atime +7 -delete

# 清理用戶臨時(shí)文件
sudo rm -rf /tmp/*
sudo rm -rf /var/tmp/*

# 清理thumbnail緩存（桌面環(huán)境）
rm -rf ~/.cache/thumbnails/*

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.FileHandler;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;

/**
 * Linux系統(tǒng)緩存清理工具類
 * @author SysAdmin
 * @version 1.0
 */
public class LinuxCacheCleaner {

    private static final Logger logger = Logger.getLogger(LinuxCacheCleaner.class.getName());
    private static final String LOG_FILE_PATH = "/var/log/java_cache_cleaner.log";
    
    static {
        try {
            FileHandler fileHandler = new FileHandler(LOG_FILE_PATH, true);
            fileHandler.setFormatter(new SimpleFormatter());
            logger.addHandler(fileHandler);
        } catch (IOException e) {
            System.err.println("無法初始化日志處理器: " + e.getMessage());
        }
    }

    /**
     * 檢測是否為Linux系統(tǒng)
     */
    public static boolean isLinuxSystem() {
        String osName = System.getProperty("os.name").toLowerCase();
        return osName.contains("linux");
    }

    /**
     * 檢查是否具有root權(quán)限（通過嘗試寫入/proc/sys）
     */
    public static boolean hasRootPermission() {
        try {
            Process process = Runtime.getRuntime().exec("id -u");
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String uid = reader.readLine();
            process.waitFor();
            return "0".equals(uid.trim()); // root用戶UID為0
        } catch (Exception e) {
            logger.warning("權(quán)限檢測失敗: " + e.getMessage());
            return false;
        }
    }

    /**
     * 執(zhí)行系統(tǒng)命令并返回輸出
     */
    private static List<String> executeCommand(String command) throws IOException, InterruptedException {
        List<String> output = new ArrayList<>();
        
        ProcessBuilder pb = new ProcessBuilder("/bin/bash", "-c", command);
        pb.redirectErrorStream(true); // 合并錯(cuò)誤流
        
        Process process = pb.start();
        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        
        String line;
        while ((line = reader.readLine()) != null) {
            output.add(line);
        }
        
        int exitCode = process.waitFor();
        if (exitCode != 0) {
            throw new RuntimeException("命令執(zhí)行失敗，退出碼: " + exitCode);
        }
        
        return output;
    }

    /**
     * 獲取當(dāng)前內(nèi)存使用情況
     */
    public static MemoryInfo getMemoryInfo() {
        try {
            List<String> lines = executeCommand("cat /proc/meminfo");
            long total = 0, free = 0, cached = 0, buffers = 0;
            
            for (String line : lines) {
                if (line.startsWith("MemTotal:")) {
                    total = parseMemoryValue(line);
                } else if (line.startsWith("MemFree:")) {
                    free = parseMemoryValue(line);
                } else if (line.startsWith("Cached:")) {
                    cached = parseMemoryValue(line);
                } else if (line.startsWith("Buffers:")) {
                    buffers = parseMemoryValue(line);
                }
            }
            
            return new MemoryInfo(total, free, cached, buffers);
        } catch (Exception e) {
            logger.severe("獲取內(nèi)存信息失敗: " + e.getMessage());
            return new MemoryInfo(0, 0, 0, 0);
        }
    }

    private static long parseMemoryValue(String line) {
        String[] parts = line.split("\\s+");
        return Long.parseLong(parts[1]); // 單位是KB
    }

    /**
     * 清理系統(tǒng)緩存（頁緩存+目錄項(xiàng)+inode）
     */
    public static boolean cleanSystemCache() {
        if (!isLinuxSystem()) {
            logger.warning("非Linux系統(tǒng)，不支持此操作");
            return false;
        }
        
        if (!hasRootPermission()) {
            logger.severe("需要root權(quán)限才能清理系統(tǒng)緩存");
            return false;
        }
        
        try {
            MemoryInfo before = getMemoryInfo();
            
            logger.info("開始清理系統(tǒng)緩存...");
            logger.info("清理前內(nèi)存狀態(tài): " + before);
            
            // 先同步磁盤
            executeCommand("sync");
            
            // 清理緩存
            executeCommand("echo 3 > /proc/sys/vm/drop_caches");
            
            Thread.sleep(2000); // 等待緩存釋放
            
            MemoryInfo after = getMemoryInfo();
            logger.info("清理后內(nèi)存狀態(tài): " + after);
            
            long cacheFreed = (before.cached + before.buffers) - (after.cached + after.buffers);
            logger.info(String.format("釋放緩存: %.2f MB", cacheFreed / 1024.0));
            
            return true;
        } catch (Exception e) {
            logger.severe("清理緩存失敗: " + e.getMessage());
            return false;
        }
    }

    /**
     * 清理APT包管理器緩存（僅限D(zhuǎn)ebian系）
     */
    public static boolean cleanAptCache() {
        if (!isLinuxSystem()) {
            return false;
        }
        
        try {
            logger.info("開始清理APT緩存...");
            
            executeCommand("apt-get clean");
            executeCommand("apt-get autoclean");
            executeCommand("apt-get autoremove -y");
            
            logger.info("APT緩存清理完成");
            return true;
        } catch (Exception e) {
            logger.warning("APT清理失敗: " + e.getMessage());
            return false;
        }
    }

    /**
     * 清理臨時(shí)文件（/tmp 和 /var/tmp）
     */
    public static boolean cleanTempFiles(int daysOld) {
        if (!isLinuxSystem()) {
            return false;
        }
        
        if (!hasRootPermission()) {
            logger.severe("需要root權(quán)限才能清理臨時(shí)文件");
            return false;
        }
        
        try {
            logger.info("開始清理臨時(shí)文件（超過" + daysOld + "天）...");
            
            String cmd1 = "find /tmp -type f -mtime +" + daysOld + " -delete 2>/dev/null || true";
            String cmd2 = "find /var/tmp -type f -mtime +" + daysOld + " -delete 2>/dev/null || true";
            
            executeCommand(cmd1);
            executeCommand(cmd2);
            
            logger.info("臨時(shí)文件清理完成");
            return true;
        } catch (Exception e) {
            logger.warning("臨時(shí)文件清理失敗: " + e.getMessage());
            return false;
        }
    }

    /**
     * 綜合清理：緩存 + 包管理器 + 臨時(shí)文件
     */
    public static void comprehensiveClean() {
        logger.info("=== 開始綜合系統(tǒng)清理 ===");
        
        LocalDateTime start = LocalDateTime.now();
        
        cleanSystemCache();
        cleanAptCache(); // 如果不是Debian系會(huì)自動(dòng)跳過
        cleanTempFiles(7);
        
        LocalDateTime end = LocalDateTime.now();
        long duration = java.time.Duration.between(start, end).toSeconds();
        
        logger.info("=== 綜合清理完成，耗時(shí): " + duration + "秒 ===");
    }

    /**
     * 內(nèi)存信息數(shù)據(jù)類
     */
    public static class MemoryInfo {
        public final long total;   // KB
        public final long free;    // KB
        public final long cached;  // KB
        public final long buffers; // KB

        public MemoryInfo(long total, long free, long cached, long buffers) {
            this.total = total;
            this.free = free;
            this.cached = cached;
            this.buffers = buffers;
        }

        public double getTotalGB() {
            return total / 1024.0 / 1024.0;
        }

        public double getUsedGB() {
            return (total - free) / 1024.0 / 1024.0;
        }

        public double getCachedGB() {
            return cached / 1024.0 / 1024.0;
        }

        @Override
        public String toString() {
            return String.format(
                "總內(nèi)存: %.2fGB, 已用: %.2fGB, 緩存: %.2fGB, 緩沖: %.2fMB",
                getTotalGB(),
                getUsedGB(),
                getCachedGB(),
                buffers / 1024.0
            );
        }
    }

    /**
     * 主方法 - 命令行接口
     */
    public static void main(String[] args) {
        System.out.println("?? Linux系統(tǒng)緩存清理工具 v1.0");
        System.out.println("作者: SysAdmin | " + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        System.out.println();

        if (!isLinuxSystem()) {
            System.err.println("? 錯(cuò)誤: 此工具僅支持Linux系統(tǒng)");
            return;
        }

        if (!hasRootPermission()) {
            System.err.println("??  警告: 當(dāng)前用戶非root，部分功能可能受限");
        }

        // 顯示菜單
        System.out.println("請選擇操作:");
        System.out.println("1. 查看內(nèi)存狀態(tài)");
        System.out.println("2. 清理系統(tǒng)緩存");
        System.out.println("3. 清理APT緩存");
        System.out.println("4. 清理臨時(shí)文件(7天以上)");
        System.out.println("5. 綜合清理");
        System.out.println("0. 退出");
        System.out.print("請輸入選項(xiàng): ");

        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
            String choice = reader.readLine().trim();
            
            switch (choice) {
                case "1":
                    MemoryInfo info = getMemoryInfo();
                    System.out.println("?? 當(dāng)前內(nèi)存狀態(tài):");
                    System.out.println(info);
                    break;
                case "2":
                    if (cleanSystemCache()) {
                        System.out.println("? 系統(tǒng)緩存清理成功");
                    } else {
                        System.out.println("? 系統(tǒng)緩存清理失敗");
                    }
                    break;
                case "3":
                    if (cleanAptCache()) {
                        System.out.println("? APT緩存清理成功");
                    } else {
                        System.out.println("??  APT緩存清理失敗或系統(tǒng)不支持");
                    }
                    break;
                case "4":
                    if (cleanTempFiles(7)) {
                        System.out.println("? 臨時(shí)文件清理成功");
                    } else {
                        System.out.println("? 臨時(shí)文件清理失敗");
                    }
                    break;
                case "5":
                    comprehensiveClean();
                    System.out.println("? 綜合清理完成");
                    break;
                case "0":
                    System.out.println("?? 再見!");
                    return;
                default:
                    System.out.println("? 無效選項(xiàng)");
            }
        } catch (Exception e) {
            System.err.println("程序執(zhí)行出錯(cuò): " + e.getMessage());
        }
    }
}

import java.time.LocalTime;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 自動(dòng)化緩存監(jiān)控與清理服務(wù)
 */
public class AutoCacheCleanerService {

    private ScheduledExecutorService scheduler;
    private final LinuxCacheCleaner cleaner;
    private final long memoryThresholdMB; // 觸發(fā)清理的內(nèi)存閾值(MB)
    private final int checkIntervalMinutes; // 檢查間隔(分鐘)

    public AutoCacheCleanerService(long memoryThresholdMB, int checkIntervalMinutes) {
        this.cleaner = new LinuxCacheCleaner();
        this.memoryThresholdMB = memoryThresholdMB;
        this.checkIntervalMinutes = checkIntervalMinutes;
        this.scheduler = Executors.newScheduledThreadPool(1);
    }

    /**
     * 啟動(dòng)監(jiān)控服務(wù)
     */
    public void start() {
        System.out.println("?? 啟動(dòng)自動(dòng)化緩存監(jiān)控服務(wù)...");
        System.out.println("內(nèi)存閾值: " + memoryThresholdMB + " MB");
        System.out.println("檢查間隔: " + checkIntervalMinutes + " 分鐘");
        
        scheduler.scheduleAtFixedRate(
            this::checkAndClean,
            0,
            checkIntervalMinutes,
            TimeUnit.MINUTES
        );
    }

    /**
     * 停止監(jiān)控服務(wù)
     */
    public void stop() {
        if (scheduler != null) {
            scheduler.shutdown();
            System.out.println("??  自動(dòng)化緩存監(jiān)控服務(wù)已停止");
        }
    }

    /**
     * 檢查內(nèi)存使用情況并決定是否清理
     */
    private void checkAndClean() {
        try {
            LinuxCacheCleaner.MemoryInfo info = cleaner.getMemoryInfo();
            long usedMemoryMB = (info.total - info.free) / 1024; // 轉(zhuǎn)換為MB
            
            System.out.println("[" + LocalTime.now() + "] 當(dāng)前內(nèi)存使用: " + usedMemoryMB + " MB");
            
            // 判斷是否達(dá)到清理閾值
            if (usedMemoryMB > memoryThresholdMB) {
                System.out.println("??  內(nèi)存使用超過閾值，準(zhǔn)備清理...");
                
                // 檢查是否在業(yè)務(wù)高峰期（9:00-18:00避免清理）
                LocalTime now = LocalTime.now();
                if (now.isAfter(LocalTime.of(9, 0)) && now.isBefore(LocalTime.of(18, 0))) {
                    System.out.println("?? 當(dāng)前為業(yè)務(wù)高峰期，推遲清理");
                    return;
                }
                
                // 執(zhí)行清理
                if (cleaner.cleanSystemCache()) {
                    System.out.println("? 緩存清理成功");
                    
                    // 重新獲取內(nèi)存信息
                    LinuxCacheCleaner.MemoryInfo after = cleaner.getMemoryInfo();
                    long freedMB = (usedMemoryMB - (after.total - after.free) / 1024);
                    System.out.println("?? 釋放內(nèi)存: " + freedMB + " MB");
                }
            }
        } catch (Exception e) {
            System.err.println("監(jiān)控檢查出錯(cuò): " + e.getMessage());
        }
    }

    /**
     * 示例：啟動(dòng)監(jiān)控服務(wù)
     */
    public static void main(String[] args) {
        // 設(shè)置當(dāng)內(nèi)存使用超過8GB時(shí)觸發(fā)清理，每30分鐘檢查一次
        AutoCacheCleanerService service = new AutoCacheCleanerService(8192, 30);
        
        // 注冊關(guān)閉鉤子
        Runtime.getRuntime().addShutdownHook(new Thread(service::stop));
        
        // 啟動(dòng)服務(wù)
        service.start();
        
        // 保持主線程運(yùn)行
        try {
            Thread.currentThread().join();
        } catch (InterruptedException e) {
            System.out.println("服務(wù)被中斷");
        }
    }
}

import java.io.IOException;
import java.nio.file.*;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 智能緩存清理器 - 基于文件訪問模式
 */
public class SmartCacheCleaner extends LinuxCacheCleaner {

    /**
     * 分析指定目錄下的文件訪問模式
     */
    public Map<String, FileAccessStats> analyzeFileAccessPatterns(String directoryPath, int daysBack) {
        Map<String, FileAccessStats> stats = new HashMap<>();
        
        try {
            Instant cutoff = Instant.now().minus(daysBack, ChronoUnit.DAYS);
            
            Files.walk(Paths.get(directoryPath))
                .filter(Files::isRegularFile)
                .forEach(path -> {
                    try {
                        BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
                        
                        // 過濾太舊的文件
                        if (attrs.creationTime().toInstant().isBefore(cutoff)) {
                            return;
                        }
                        
                        FileAccessStats stat = new FileAccessStats(
                            path.toString(),
                            attrs.size(),
                            attrs.lastModifiedTime().toInstant(),
                            attrs.lastAccessTime().toInstant()
                        );
                        
                        stats.put(path.toString(), stat);
                        
                    } catch (IOException e) {
                        logger.warning("無法讀取文件屬性: " + path + " - " + e.getMessage());
                    }
                });
                
        } catch (IOException e) {
            logger.severe("遍歷目錄失敗: " + e.getMessage());
        }
        
        return stats;
    }

    /**
     * 根據(jù)訪問頻率識別"冷數(shù)據(jù)"
     */
    public List<String> identifyColdData(Map<String, FileAccessStats> stats, int coldThresholdDays) {
        Instant threshold = Instant.now().minus(coldThresholdDays, ChronoUnit.DAYS);
        
        return stats.values().stream()
            .filter(stat -> stat.lastAccessTime.isBefore(threshold))
            .sorted((a, b) -> Long.compare(a.size, b.size)) // 按大小排序
            .map(stat -> stat.filePath)
            .collect(Collectors.toList());
    }

    /**
     * 清理冷數(shù)據(jù)文件（移動(dòng)到備份目錄而非刪除）
     */
    public boolean archiveColdData(List<String> coldFiles, String archiveDir) {
        if (!Files.exists(Paths.get(archiveDir))) {
            try {
                Files.createDirectories(Paths.get(archiveDir));
            } catch (IOException e) {
                logger.severe("無法創(chuàng)建歸檔目錄: " + e.getMessage());
                return false;
            }
        }
        
        boolean success = true;
        
        for (String filePath : coldFiles) {
            try {
                Path source = Paths.get(filePath);
                Path target = Paths.get(archiveDir, source.getFileName().toString());
                
                // 移動(dòng)文件
                Files.move(source, target, StandardCopyOption.REPLACE_EXISTING);
                logger.info("歸檔冷數(shù)據(jù): " + filePath + " -> " + target);
                
            } catch (IOException e) {
                logger.warning("歸檔失敗: " + filePath + " - " + e.getMessage());
                success = false;
            }
        }
        
        return success;
    }

    /**
     * 文件訪問統(tǒng)計(jì)信息
     */
    public static class FileAccessStats {
        public final String filePath;
        public final long size; // 字節(jié)
        public final Instant lastModifiedTime;
        public final Instant lastAccessTime;

        public FileAccessStats(String filePath, long size, Instant lastModifiedTime, Instant lastAccessTime) {
            this.filePath = filePath;
            this.size = size;
            this.lastModifiedTime = lastModifiedTime;
            this.lastAccessTime = lastAccessTime;
        }

        public double getSizeMB() {
            return size / 1024.0 / 1024.0;
        }

        public long getDaysSinceLastAccess() {
            return ChronoUnit.DAYS.between(lastAccessTime, Instant.now());
        }

        @Override
        public String toString() {
            return String.format(
                "%s | %.2fMB | 最后訪問: %d天前",
                filePath,
                getSizeMB(),
                getDaysSinceLastAccess()
            );
        }
    }

    /**
     * 演示智能清理流程
     */
    public static void demoSmartCleaning() {
        SmartCacheCleaner cleaner = new SmartCacheCleaner();
        
        System.out.println("?? 開始智能緩存分析...");
        
        // 分析/var/log目錄下30天內(nèi)的文件
        Map<String, FileAccessStats> stats = cleaner.analyzeFileAccessPatterns("/var/log", 30);
        
        System.out.println("?? 發(fā)現(xiàn) " + stats.size() + " 個(gè)文件");
        
        // 識別超過7天未訪問的"冷數(shù)據(jù)"
        List<String> coldFiles = cleaner.identifyColdData(stats, 7);
        
        System.out.println("??  發(fā)現(xiàn) " + coldFiles.size() + " 個(gè)冷數(shù)據(jù)文件");
        
        // 顯示最大的5個(gè)冷文件
        stats.values().stream()
            .filter(stat -> stat.getDaysSinceLastAccess() > 7)
            .sorted((a, b) -> Long.compare(b.size, a.size))
            .limit(5)
            .forEach(System.out::println);
        
        // 歸檔冷數(shù)據(jù)（需要root權(quán)限）
        if (!coldFiles.isEmpty()) {
            System.out.println("?? 開始?xì)w檔冷數(shù)據(jù)...");
            boolean result = cleaner.archiveColdData(coldFiles, "/var/log/archive");
            System.out.println(result ? "? 歸檔完成" : "? 歸檔失敗");
        }
    }
}

/**
 * Docker環(huán)境緩存清理工具
 */
public class DockerCacheCleaner {

    /**
     * 清理Docker構(gòu)建緩存
     */
    public static boolean cleanDockerBuildCache() {
        try {
            System.out.println("?? 清理Docker構(gòu)建緩存...");
            
            // 清理未使用的構(gòu)建緩存
            LinuxCacheCleaner.executeCommand("docker builder prune -a -f");
            
            // 清理未使用的鏡像
            LinuxCacheCleaner.executeCommand("docker image prune -a -f");
            
            // 清理未使用的容器
            LinuxCacheCleaner.executeCommand("docker container prune -f");
            
            // 清理未使用的卷
            LinuxCacheCleaner.executeCommand("docker volume prune -f");
            
            // 清理未使用的網(wǎng)絡(luò)
            LinuxCacheCleaner.executeCommand("docker network prune -f");
            
            System.out.println("? Docker緩存清理完成");
            return true;
        } catch (Exception e) {
            System.err.println("Docker清理失敗: " + e.getMessage());
            return false;
        }
    }

    /**
     * 獲取Docker磁盤使用情況
     */
    public static String getDockerDiskUsage() {
        try {
            List<String> output = LinuxCacheCleaner.executeCommand("docker system df");
            return String.join("\n", output);
        } catch (Exception e) {
            return "無法獲取Docker磁盤使用情況: " + e.getMessage();
        }
    }
}

import java.util.Properties;
import javax.mail.*;
import javax.mail.internet.*;

/**
 * 緩存清理報(bào)警通知系統(tǒng)
 */
public class CacheAlertSystem {

    private final Properties mailProperties;
    private final String fromEmail;
    private final String password;

    public CacheAlertSystem(String smtpHost, int smtpPort, String fromEmail, String password) {
        this.mailProperties = new Properties();
        this.fromEmail = fromEmail;
        this.password = password;
        
        mailProperties.put("mail.smtp.host", smtpHost);
        mailProperties.put("mail.smtp.port", smtpPort);
        mailProperties.put("mail.smtp.auth", "true");
        mailProperties.put("mail.smtp.starttls.enable", "true");
    }

    /**
     * 發(fā)送報(bào)警郵件
     */
    public boolean sendAlertEmail(String toEmail, String subject, String body) {
        try {
            Session session = Session.getInstance(mailProperties, new Authenticator() {
                @Override
                protected PasswordAuthentication getPasswordAuthentication() {
                    return new PasswordAuthentication(fromEmail, password);
                }
            });

            Message message = new MimeMessage(session);
            message.setFrom(new InternetAddress(fromEmail));
            message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(toEmail));
            message.setSubject(subject);
            message.setText(body);

            Transport.send(message);
            System.out.println("?? 報(bào)警郵件發(fā)送成功");
            return true;
        } catch (MessagingException e) {
            System.err.println("郵件發(fā)送失敗: " + e.getMessage());
            return false;
        }
    }

    /**
     * 內(nèi)存監(jiān)控與報(bào)警
     */
    public void monitorMemoryWithAlert(String alertEmail, long thresholdMB) {
        System.out.println("?? 啟動(dòng)內(nèi)存監(jiān)控報(bào)警系統(tǒng)...");
        
        Timer timer = new Timer();
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                try {
                    LinuxCacheCleaner.MemoryInfo info = new LinuxCacheCleaner().getMemoryInfo();
                    long usedMB = (info.total - info.free) / 1024;
                    
                    System.out.println("[" + java.time.LocalTime.now() + "] 內(nèi)存使用: " + usedMB + " MB");
                    
                    if (usedMB > thresholdMB) {
                        String subject = "?? 系統(tǒng)內(nèi)存警告 - " + java.time.LocalDateTime.now();
                        String body = String.format(
                            "服務(wù)器內(nèi)存使用超過閾值!\n\n" +
                            "當(dāng)前使用: %d MB\n" +
                            "閾值: %d MB\n" +
                            "總內(nèi)存: %.2f GB\n" +
                            "緩存占用: %.2f GB\n\n" +
                            "建議執(zhí)行緩存清理或擴(kuò)容。",
                            usedMB,
                            thresholdMB,
                            info.getTotalGB(),
                            info.getCachedGB()
                        );
                        
                        sendAlertEmail(alertEmail, subject, body);
                    }
                } catch (Exception e) {
                    System.err.println("監(jiān)控檢查出錯(cuò): " + e.getMessage());
                }
            }
        }, 0, 5 * 60 * 1000); // 每5分鐘檢查一次
    }
}

/**
 * 安全的緩存清理執(zhí)行器
 */
public class SecureCacheCleaner {

    /**
     * 使用sudo執(zhí)行特定命令（需要配置sudoers）
     */
    public static boolean executeWithSudo(String command, String sudoPassword) {
        try {
            // 創(chuàng)建ProcessBuilder
            ProcessBuilder pb = new ProcessBuilder("/bin/bash", "-c", 
                "echo '" + sudoPassword + "' | sudo -S " + command);
            
            pb.redirectErrorStream(true);
            
            Process process = pb.start();
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            
            int exitCode = process.waitFor();
            return exitCode == 0;
            
        } catch (Exception e) {
            System.err.println("安全執(zhí)行失敗: " + e.getMessage());
            return false;
        }
    }

    /**
     * 驗(yàn)證要清理的路徑是否安全
     */
    public static boolean isSafePath(String path) {
        // 禁止清理系統(tǒng)關(guān)鍵目錄
        String[] dangerousPaths = {
            "/", "/bin", "/sbin", "/usr", "/etc", "/lib", "/lib64",
            "/proc", "/sys", "/dev", "/boot", "/root"
        };
        
        for (String dangerous : dangerousPaths) {
            if (path.equals(dangerous) || path.startsWith(dangerous + "/")) {
                return false;
            }
        }
        
        // 必須是絕對路徑
        if (!path.startsWith("/")) {
            return false;
        }
        
        // 不能包含..或符號鏈接攻擊
        try {
            Path normalized = Paths.get(path).normalize();
            if (!normalized.toString().equals(path)) {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
        
        return true;
    }
}

/**
 * AI預(yù)測式緩存管理器（概念演示）
 */
public class AICacheManager {

    /**
     * 基于歷史數(shù)據(jù)預(yù)測最佳清理時(shí)機(jī)
     */
    public static class CachePredictionModel {
        
        private final List<MemorySnapshot> history;
        private final int predictionWindowHours;
        
        public CachePredictionModel(int predictionWindowHours) {
            this.history = new ArrayList<>();
            this.predictionWindowHours = predictionWindowHours;
        }
        
        /**
         * 添加內(nèi)存快照
         */
        public void addSnapshot(LinuxCacheCleaner.MemoryInfo info) {
            history.add(new MemorySnapshot(
                System.currentTimeMillis(),
                (info.total - info.free) / 1024, // 使用內(nèi)存MB
                info.cached / 1024,              // 緩存MB
                info.buffers / 1024              // 緩沖MB
            ));
            
            // 保留最近30天的數(shù)據(jù)
            long cutoff = System.currentTimeMillis() - 30L * 24 * 60 * 60 * 1000;
            history.removeIf(snapshot -> snapshot.timestamp < cutoff);
        }
        
        /**
         * 預(yù)測未來內(nèi)存壓力
         */
        public double predictMemoryPressure() {
            if (history.size() < 24) { // 至少需要24個(gè)樣本
                return 0.5; // 默認(rèn)中等壓力
            }
            
            // 簡單的線性回歸預(yù)測（實(shí)際應(yīng)用中應(yīng)使用機(jī)器學(xué)習(xí)模型）
            double avgGrowthRate = calculateAverageGrowthRate();
            double currentUsage = history.get(history.size() - 1).usedMemoryMB;
            
            // 預(yù)測predictionWindowHours小時(shí)后的內(nèi)存使用
            double predictedUsage = currentUsage * (1 + avgGrowthRate * predictionWindowHours);
            
            // 返回壓力系數(shù)（0-1）
            LinuxCacheCleaner.MemoryInfo currentInfo = new LinuxCacheCleaner().getMemoryInfo();
            double totalMemoryMB = currentInfo.total / 1024;
            
            return Math.min(predictedUsage / totalMemoryMB, 1.0);
        }
        
        private double calculateAverageGrowthRate() {
            if (history.size() < 2) return 0;
            
            double totalGrowth = 0;
            int count = 0;
            
            for (int i = 1; i < history.size(); i++) {
                double growth = history.get(i).usedMemoryMB - history.get(i-1).usedMemoryMB;
                double timeDiffHours = (history.get(i).timestamp - history.get(i-1).timestamp) / (3600.0 * 1000);
                
                if (timeDiffHours > 0) {
                    totalGrowth += growth / timeDiffHours;
                    count++;
                }
            }
            
            return count > 0 ? totalGrowth / count : 0;
        }
    }
    
    /**
     * 內(nèi)存快照數(shù)據(jù)類
     */
    private static class MemorySnapshot {
        final long timestamp;
        final double usedMemoryMB;
        final double cachedMemoryMB;
        final double bufferMemoryMB;
        
        MemorySnapshot(long timestamp, double usedMemoryMB, double cachedMemoryMB, double bufferMemoryMB) {
            this.timestamp = timestamp;
            this.usedMemoryMB = usedMemoryMB;
            this.cachedMemoryMB = cachedMemoryMB;
            this.bufferMemoryMB = bufferMemoryMB;
        }
    }
    
    /**
     * 演示AI預(yù)測式緩存管理
     */
    public static void demoAICacheManagement() {
        CachePredictionModel model = new CachePredictionModel(4); // 預(yù)測4小時(shí)后的情況
        
        // 模擬收集歷史數(shù)據(jù)
        for (int i = 0; i < 48; i++) { // 48小時(shí)數(shù)據(jù)
            LinuxCacheCleaner.MemoryInfo info = new LinuxCacheCleaner().getMemoryInfo();
            model.addSnapshot(info);
            
            try {
                Thread.sleep(1000); // 實(shí)際應(yīng)用中應(yīng)該是定時(shí)采集
            } catch (InterruptedException e) {
                break;
            }
        }
        
        // 預(yù)測內(nèi)存壓力
        double pressure = model.predictMemoryPressure();
        System.out.println("?? 預(yù)測內(nèi)存壓力系數(shù): " + String.format("%.2f", pressure));
        
        // 根據(jù)預(yù)測結(jié)果決定是否清理
        if (pressure > 0.8) {
            System.out.println("??  預(yù)測高內(nèi)存壓力，建議提前清理緩存");
            new LinuxCacheCleaner().cleanSystemCache();
        } else if (pressure > 0.6) {
            System.out.println("??  預(yù)測中等內(nèi)存壓力，建議監(jiān)控");
        } else {
            System.out.println("? 預(yù)測低內(nèi)存壓力，無需操作");
        }
    }
}

/**
 * 完整的Linux系統(tǒng)維護(hù)工具包
 */
public class LinuxMaintenanceToolkit {

    public static void main(String[] args) {
        System.out.println("???  Linux系統(tǒng)維護(hù)工具包 v2.0");
        System.out.println("================================");
        
        if (!LinuxCacheCleaner.isLinuxSystem()) {
            System.err.println("? 此工具僅支持Linux系統(tǒng)");
            return;
        }
        
        showMenu();
    }
    
    private static void showMenu() {
        Scanner scanner = new Scanner(System.in);
        
        while (true) {
            System.out.println("\n?? 主菜單:");
            System.out.println("1. 系統(tǒng)狀態(tài)檢查");
            System.out.println("2. 緩存清理");
            System.out.println("3. 磁盤清理");
            System.out.println("4. Docker清理");
            System.out.println("5. 自動(dòng)化監(jiān)控");
            System.out.println("6. 智能分析");
            System.out.println("0. 退出");
            System.out.print("請選擇功能: ");
            
            String choice = scanner.nextLine().trim();
            
            switch (choice) {
                case "1":
                    showSystemStatus();
                    break;
                case "2":
                    performCacheCleanup();
                    break;
                case "3":
                    performDiskCleanup();
                    break;
                case "4":
                    performDockerCleanup();
                    break;
                case "5":
                    startAutoMonitoring();
                    break;
                case "6":
                    performSmartAnalysis();
                    break;
                case "0":
                    System.out.println("?? 感謝使用，再見!");
                    scanner.close();
                    return;
                default:
                    System.out.println("? 無效選項(xiàng)，請重新選擇");
            }
        }
    }
    
    private static void showSystemStatus() {
        System.out.println("\n?? 系統(tǒng)狀態(tài)報(bào)告:");
        
        // 內(nèi)存信息
        LinuxCacheCleaner.MemoryInfo memInfo = new LinuxCacheCleaner().getMemoryInfo();
        System.out.println("內(nèi)存狀態(tài): " + memInfo);
        
        // CPU信息
        try {
            List<String> cpuInfo = LinuxCacheCleaner.executeCommand("lscpu | grep -E '(Model name|CPU\\(s\\)|Thread\\(s\\) per core)'");
            System.out.println("CPU信息:");
            cpuInfo.forEach(System.out::println);
        } catch (Exception e) {
            System.out.println("無法獲取CPU信息: " + e.getMessage());
        }
        
        // 磁盤使用
        try {
            System.out.println("\n磁盤使用情況:");
            List<String> diskInfo = LinuxCacheCleaner.executeCommand("df -h");
            diskInfo.forEach(System.out::println);
        } catch (Exception e) {
            System.out.println("無法獲取磁盤信息: " + e.getMessage());
        }
    }
    
    private static void performCacheCleanup() {
        System.out.println("\n?? 緩存清理選項(xiàng):");
        System.out.println("1. 清理系統(tǒng)緩存");
        System.out.println("2. 清理APT緩存");
        System.out.println("3. 清理YUM/DNF緩存");
        System.out.println("4. 全部清理");
        System.out.print("請選擇: ");
        
        Scanner scanner = new Scanner(System.in);
        String choice = scanner.nextLine().trim();
        
        LinuxCacheCleaner cleaner = new LinuxCacheCleaner();
        
        switch (choice) {
            case "1":
                cleaner.cleanSystemCache();
                break;
            case "2":
                cleaner.cleanAptCache();
                break;
            case "3":
                try {
                    LinuxCacheCleaner.executeCommand("yum clean all || dnf clean all");
                    System.out.println("? YUM/DNF緩存清理完成");
                } catch (Exception e) {
                    System.out.println("? 清理失敗: " + e.getMessage());
                }
                break;
            case "4":
                cleaner.comprehensiveClean();
                break;
            default:
                System.out.println("無效選項(xiàng)");
        }
    }
    
    private static void performDiskCleanup() {
        System.out.println("\n???  磁盤清理選項(xiàng):");
        System.out.println("1. 清理臨時(shí)文件(7天以上)");
        System.out.println("2. 清理日志文件(30天以上)");
        System.out.println("3. 清理縮略圖緩存");
        System.out.print("請選擇: ");
        
        Scanner scanner = new Scanner(System.in);
        String choice = scanner.nextLine().trim();
        
        try {
            switch (choice) {
                case "1":
                    new LinuxCacheCleaner().cleanTempFiles(7);
                    break;
                case "2":
                    LinuxCacheCleaner.executeCommand(
                        "find /var/log -name \"*.log\" -mtime +30 -exec truncate -s 0 {} \\;"
                    );
                    System.out.println("? 日志文件清理完成");
                    break;
                case "3":
                    LinuxCacheCleaner.executeCommand("rm -rf ~/.cache/thumbnails/* 2>/dev/null || true");
                    System.out.println("? 縮略圖緩存清理完成");
                    break;
                default:
                    System.out.println("無效選項(xiàng)");
            }
        } catch (Exception e) {
            System.out.println("清理失敗: " + e.getMessage());
        }
    }
    
    private static void performDockerCleanup() {
        System.out.println("\n?? Docker清理選項(xiàng):");
        System.out.println("1. 查看Docker磁盤使用");
        System.out.println("2. 清理所有未使用資源");
        System.out.println("3. 僅清理構(gòu)建緩存");
        System.out.print("請選擇: ");
        
        Scanner scanner = new Scanner(System.in);
        String choice = scanner.nextLine().trim();
        
        try {
            switch (choice) {
                case "1":
                    System.out.println(DockerCacheCleaner.getDockerDiskUsage());
                    break;
                case "2":
                    DockerCacheCleaner.cleanDockerBuildCache();
                    break;
                case "3":
                    LinuxCacheCleaner.executeCommand("docker builder prune -a -f");
                    System.out.println("? Docker構(gòu)建緩存清理完成");
                    break;
                default:
                    System.out.println("無效選項(xiàng)");
            }
        } catch (Exception e) {
            System.out.println("Docker操作失敗: " + e.getMessage());
        }
    }
    
    private static void startAutoMonitoring() {
        System.out.print("請輸入內(nèi)存閾值(MB，默認(rèn)8192): ");
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine().trim();
        long threshold = input.isEmpty() ? 8192 : Long.parseLong(input);
        
        System.out.print("請輸入檢查間隔(分鐘，默認(rèn)30): ");
        input = scanner.nextLine().trim();
        int interval = input.isEmpty() ? 30 : Integer.parseInt(input);
        
        AutoCacheCleanerService service = new AutoCacheCleanerService(threshold, interval);
        service.start();
        
        System.out.println("??  監(jiān)控服務(wù)已啟動(dòng)，按Enter鍵返回主菜單...");
        scanner.nextLine();
    }
    
    private static void performSmartAnalysis() {
        System.out.println("\n?? 智能分析選項(xiàng):");
        System.out.println("1. 分析日志文件訪問模式");
        System.out.println("2. 預(yù)測內(nèi)存壓力");
        System.out.println("3. 識別大文件");
        System.out.print("請選擇: ");
        
        Scanner scanner = new Scanner(System.in);
        String choice = scanner.nextLine().trim();
        
        try {
            switch (choice) {
                case "1":
                    SmartCacheCleaner.demoSmartCleaning();
                    break;
                case "2":
                    AICacheManager.demoAICacheManagement();
                    break;
                case "3":
                    System.out.print("請輸入目錄路徑(默認(rèn)/var/log): ");
                    String dir = scanner.nextLine().trim();
                    if (dir.isEmpty()) dir = "/var/log";
                    
                    System.out.print("請輸入最小文件大小(MB，默認(rèn)100): ");
                    String sizeInput = scanner.nextLine().trim();
                    long minSizeMB = sizeInput.isEmpty() ? 100 : Long.parseLong(sizeInput);
                    
                    List<String> output = LinuxCacheCleaner.executeCommand(
                        "find " + dir + " -type f -size +" + minSizeMB + "M -exec ls -lh {} \\;"
                    );
                    
                    System.out.println("\n?? 發(fā)現(xiàn)的大文件:");
                    if (output.isEmpty()) {
                        System.out.println("未發(fā)現(xiàn)大于" + minSizeMB + "MB的文件");
                    } else {
                        output.forEach(System.out::println);
                    }
                    break;
                default:
                    System.out.println("無效選項(xiàng)");
            }
        } catch (Exception e) {
            System.out.println("分析失敗: " + e.getMessage());
        }
    }
}