Czkawka Rust磁盘清理工具：内存安全架构与高性能并发设计解析

Czkawka Rust磁盘清理工具：内存安全架构与高性能并发设计解析

【免费下载链接】czkawkaMulti functional app to find duplicates, empty folders, similar images etc.项目地址: https://gitcode.com/GitHub_Trending/cz/czkawka

Czkawka是一款基于Rust语言构建的跨平台磁盘清理工具，通过内存安全设计和并发优化技术，为技术开发者和系统管理员提供高效、可靠的存储空间管理解决方案。该项目采用模块化架构，支持重复文件查找、相似图像识别、视频优化等12种专业功能，完全离线运行保障用户隐私安全，在性能、安全性和跨平台兼容性方面实现了技术突破。

系统设计哲学与架构理念

Czkawka的核心设计理念围绕三个技术支柱：内存安全、零成本抽象和跨平台一致性。项目采用分层架构设计，将核心算法引擎与用户界面完全分离，实现了高度的模块化和可扩展性。

核心库架构分层

czkawka_core/ # 核心算法引擎 - 无UI依赖的纯Rust库 ├── src/tools/ # 12种清理工具实现 ├── src/common/ # 通用基础设施组件 └── src/helpers/ # 辅助工具和实用函数 czkawka_cli/ # 命令行接口 - 适合自动化脚本和服务器环境 czkawka_gui/ # 传统GTK4界面 - 维护模式 krokiet/ # 主桌面GUI - 基于Slint的现代化界面 cedinia/ # Android移动端 - 触摸优化的移动体验

这种架构分离使得核心算法可以独立演进，同时为不同平台提供最适合的用户界面。核心库czkawka_core完全不依赖任何UI框架，保证了算法的纯粹性和可测试性。

内存安全实现机制

Rust的所有权系统是Czkawka内存安全的基础。项目通过以下机制确保运行时安全性：

1. 编译时内存检查：Rust编译器在编译阶段验证所有内存访问的安全性，消除空指针解引用、缓冲区溢出和数据竞争等常见内存错误
2. 借用检查器：确保在任何时刻，要么只有一个可变引用，要么有多个不可变引用，防止数据竞争
3. 生命周期标注：显式标注引用的生命周期，确保不会出现悬垂指针

在czkawka_core/src/common/cache.rs中，缓存系统的实现充分展示了Rust内存安全的优势：

pub struct CacheData { version: u32, entries: Vec<CacheEntry>, timestamp: u64, } impl CacheData { pub fn new() -> Self { Self { version: CACHE_DUPLICATE_VERSION, entries: Vec::with_capacity(1000), timestamp: SystemTime::now() .duration_since(UNIX_EPOCH) .unwrap() .as_secs(), } } pub fn add_entry(&mut self, entry: CacheEntry) { // 自动管理容量，避免内存泄漏 if self.entries.len() >= MAX_CACHE_ENTRIES { self.entries.remove(0); } self.entries.push(entry); } }

并发模型与性能优化策略

Czkawka采用基于Rayon库的数据并行模型，充分利用现代多核处理器的计算能力。并发设计遵循"无共享数据"原则，通过消息传递实现线程间通信。

多线程文件系统遍历

在czkawka_core/src/common/dir_traversal.rs中，文件系统遍历实现了高效的多线程处理：

pub fn run_parallel(&self) -> DirTraversalResult { let (progress_sender, progress_receiver) = crossbeam_channel::bounded(1024); // 创建工作线程池 let pool = rayon::ThreadPoolBuilder::new() .num_threads(num_cpus::get().min(8)) .build() .unwrap(); pool.scope(|s| { // 生产者线程：遍历目录结构 s.spawn(|_| { self.walk_directory(&progress_sender); }); // 消费者线程：处理文件条目 for _ in 0..4 { let receiver = progress_receiver.clone(); s.spawn(move |_| { while let Ok(entry) = receiver.recv() { self.process_file_entry(entry); } }); } }); self.collect_results() }

性能基准测试数据

项目包含详细的性能基准测试，位于czkawka_core/benches/hash_calculation_benchmark.rs。测试数据显示了不同哈希算法和缓冲区大小的性能差异：

Czkawka采用多种哈希算法平衡速度与准确性，Blake3在安全性和性能间取得最佳平衡

三级渐进式比对算法

重复文件检测采用三级渐进式比对策略，在准确性和性能之间取得平衡：

第一阶段：文件名快速过滤

pub fn check_files_name(&mut self) -> WorkContinueStatus { let group_by_func = if self.case_sensitive { |fe: &FileEntry| fe.path.file_name().to_string_lossy().to_string() } else { |fe: &FileEntry| fe.path.file_name().to_string_lossy().to_lowercase() }; // 按文件名分组，快速排除明显不同的文件 let mut groups: HashMap<String, Vec<FileEntry>> = HashMap::new(); for entry in self.files.iter() { let key = group_by_func(entry); groups.entry(key).or_insert_with(Vec::new).push(entry.clone()); } // 过滤出可能重复的文件组 groups.retain(|_, entries| entries.len() > 1); self.potential_duplicates = groups; }

第二阶段：文件大小比对

pub fn check_files_size(&mut self) -> WorkContinueStatus { // 对每个文件名组，进一步按文件大小分组 let mut size_groups = HashMap::new(); for (name, entries) in &self.potential_duplicates { for entry in entries { let key = (name.clone(), entry.size); size_groups.entry(key).or_insert_with(Vec::new).push(entry.clone()); } } // 保留大小相同的文件组 size_groups.retain(|_, entries| entries.len() > 1); self.size_matched_duplicates = size_groups; }

第三阶段：哈希值精确验证

pub fn check_files_hash(&mut self, hash_type: HashType) -> WorkContinueStatus { // 对每个大小匹配的组，计算哈希值进行最终验证 for ((name, size), entries) in &mut self.size_matched_duplicates { let mut hash_groups = HashMap::new(); for entry in entries { let hash = self.calculate_hash(entry, hash_type); hash_groups.entry(hash).or_insert_with(Vec::new).push(entry.clone()); } // 保留哈希值相同的文件组作为最终重复文件 hash_groups.retain(|_, entries| entries.len() > 1); self.confirmed_duplicates.extend(hash_groups.values()); } }

算法工程实践与优化技巧

相似图像识别技术

Czkawka的相似图像检测基于感知哈希（pHash）算法，在czkawka_core/src/tools/similar_images/core.rs中实现。算法流程经过精心优化：

1. 图像预处理优化：使用快速图像缩放算法，将图像统一缩放到8×8像素
2. 灰度转换优化：采用整数运算替代浮点运算，提升性能30%
3. DCT计算优化：使用查表法预计算余弦值，减少重复计算
4. 汉明距离计算：使用SIMD指令集加速位运算

pub fn compare_image_hashes(hash1: &[u8; 8], hash2: &[u8; 8]) -> u32 { // 使用SIMD指令并行计算汉明距离 #[cfg(target_arch = "x86_64")] { use std::arch::x86_64::*; unsafe { let v1 = _mm_loadu_si128(hash1.as_ptr() as *const __m128i); let v2 = _mm_loadu_si128(hash2.as_ptr() as *const __m128i); let xor_result = _mm_xor_si128(v1, v2); _mm_popcnt_u64(_mm_extract_epi64(xor_result, 0) as u64) as u32 + _mm_popcnt_u64(_mm_extract_epi64(xor_result, 1) as u64) as u32 } } #[cfg(not(target_arch = "x86_64"))] { // 通用实现 hash1.iter().zip(hash2.iter()) .map(|(a, b)| (a ^ b).count_ones()) .sum() } }

视频相似性检测架构

视频相似性检测结合了视觉特征和音频指纹技术，实现多层次比对：

pub struct VideoSimilarityDetector { visual_similarity_threshold: f32, // 视觉相似度阈值 audio_similarity_threshold: f32, // 音频相似度阈值 temporal_alignment_window: usize, // 时间对齐窗口 } impl VideoSimilarityDetector { pub fn compare_videos(&self, video1: &VideoEntry, video2: &VideoEntry) -> SimilarityResult { // 1. 提取关键帧特征 let visual_features1 = self.extract_visual_features(video1); let visual_features2 = self.extract_visual_features(video2); // 2. 计算视觉相似度 let visual_score = self.calculate_visual_similarity(&visual_features1, &visual_features2); // 3. 提取音频指纹 let audio_fingerprint1 = self.extract_audio_fingerprint(video1); let audio_fingerprint2 = self.extract_audio_fingerprint(video2); // 4. 计算音频相似度 let audio_score = self.calculate_audio_similarity(&audio_fingerprint1, &audio_fingerprint2); // 5. 综合评分 SimilarityResult { visual_score, audio_score, combined_score: visual_score * 0.7 + audio_score * 0.3, } } }

Czkawka视频相似性检测采用多特征融合策略，结合视觉和音频分析提高准确性

缓存系统设计与性能调优

智能缓存架构

Czkawka的缓存系统采用LRU（最近最少使用）策略，自动管理缓存大小和有效期：

pub struct SmartCache { max_size: usize, max_age_seconds: u64, entries: LinkedHashMap<CacheKey, CacheValue>, hit_count: usize, miss_count: usize, } impl SmartCache { pub fn get(&mut self, key: &CacheKey) -> Option<&CacheValue> { if let Some(value) = self.entries.get_refresh(key) { self.hit_count += 1; // 检查是否过期 if value.timestamp + self.max_age_seconds > current_timestamp() { Some(value) } else { self.entries.remove(key); self.miss_count += 1; None } } else { self.miss_count += 1; None } } pub fn put(&mut self, key: CacheKey, value: CacheValue) { // 检查容量限制 if self.entries.len() >= self.max_size { if let Some(oldest_key) = self.entries.front().map(|(k, _)| k.clone()) { self.entries.remove(&oldest_key); } } self.entries.insert(key, value); } pub fn hit_rate(&self) -> f64 { if self.hit_count + self.miss_count == 0 { 0.0 } else { self.hit_count as f64 / (self.hit_count + self.miss_count) as f64 } } }

性能调优配置指南

针对不同使用场景，Czkawka提供灵活的配置选项：

开发环境配置（快速扫描）

[performance] hash_type = "crc32" # 使用CRC32快速哈希 max_file_size = "100MB" # 限制大文件处理 thread_count = 4 # 限制线程数 cache_enabled = true # 启用缓存 cache_ttl = "3600" # 缓存有效期1小时

生产环境配置（全面扫描）

[performance] hash_type = "blake3" # 使用Blake3安全哈希 max_file_size = "10GB" # 支持大文件 thread_count = "auto" # 自动检测CPU核心数 cache_enabled = true # 启用缓存 cache_ttl = "604800" # 缓存有效期7天 prehash_buffer_size = "1MB" # 预哈希缓冲区大小

SSD优化配置

[performance] hash_type = "blake3" io_buffer_size = "2MB" # 增大IO缓冲区 parallel_io_operations = 8 # 并行IO操作数 read_ahead_size = "4MB" # 预读大小

网络存储配置

[performance] hash_type = "crc32" # 减少计算开销 io_timeout = "30" # IO超时时间 retry_count = 3 # 重试次数 connection_pool_size = 4 # 连接池大小

错误处理与容错机制

分级错误处理策略

Czkawka采用分级错误处理策略，确保单个文件处理失败不会影响整体扫描：

pub enum FileProcessingError { IoError(std::io::Error), # IO错误 PermissionDenied, # 权限不足 FileNotFound, # 文件不存在 UnsupportedFormat, # 不支持的文件格式 CorruptedData, # 数据损坏 OutOfMemory, # 内存不足 } impl FileProcessor { pub fn process_file(&self, path: &Path) -> Result<ProcessResult, FileProcessingError> { match self.try_process(path) { Ok(result) => Ok(result), Err(FileProcessingError::PermissionDenied) => { // 记录权限错误，继续处理其他文件 self.log_permission_error(path); Err(FileProcessingError::PermissionDenied) } Err(FileProcessingError::UnsupportedFormat) => { // 跳过不支持的文件格式 self.log_unsupported_format(path); Err(FileProcessingError::UnsupportedFormat) } Err(e) => { // 其他错误需要记录并可能终止处理 self.log_critical_error(path, &e); Err(e) } } } }

资源清理与状态恢复

项目实现了完善的资源清理机制，确保在异常情况下正确释放资源：

pub struct ScopedResource<T: Drop> { resource: Option<T>, cleanup_action: Box<dyn FnOnce(&mut T)>, } impl<T: Drop> ScopedResource<T> { pub fn new(resource: T, cleanup: impl FnOnce(&mut T) + 'static) -> Self { Self { resource: Some(resource), cleanup_action: Box::new(cleanup), } } } impl<T: Drop> Drop for ScopedResource<T> { fn drop(&mut self) { if let Some(mut resource) = self.resource.take() { (self.cleanup_action)(&mut resource); } } } // 使用示例 let file = ScopedResource::new( File::open("data.bin")?, |f| { if let Err(e) = f.sync_all() { eprintln!("Failed to sync file: {}", e); } } );

扩展性设计与插件架构

工具插件系统

Czkawka的核心设计支持工具插件系统，允许开发者扩展新的清理功能：

pub trait CleaningTool: Send + Sync { fn name(&self) -> &'static str; fn description(&self) -> &'static str; fn supported_platforms(&self) -> &[Platform]; fn scan(&mut self, directories: &[PathBuf], stop_flag: &Arc<AtomicBool>, progress_sender: &Sender<ProgressData>) -> Result<Vec<ScanResult>, ToolError>; fn cleanup(&self, results: &[ScanResult], stop_flag: &Arc<AtomicBool>) -> Result<CleanupStats, ToolError>; } // 工具注册机制 pub struct ToolRegistry { tools: HashMap<String, Box<dyn CleaningTool>>, } impl ToolRegistry { pub fn register_tool(&mut self, name: &str, tool: Box<dyn CleaningTool>) { self.tools.insert(name.to_string(), tool); } pub fn get_tool(&self, name: &str) -> Option<&dyn CleaningTool> { self.tools.get(name).map(|t| t.as_ref()) } }

配置系统扩展性

项目的配置系统设计支持动态扩展和向后兼容：

#[derive(Serialize, Deserialize, Clone)] pub struct ToolConfig { pub enabled: bool, pub parameters: HashMap<String, ConfigValue>, #[serde(flatten)] pub extra_fields: HashMap<String, serde_json::Value>, } impl ToolConfig { pub fn merge(&mut self, other: &ToolConfig) { // 合并配置，新版本配置优先 for (key, value) in &other.parameters { self.parameters.insert(key.clone(), value.clone()); } // 保留未知字段，确保向后兼容 for (key, value) in &other.extra_fields { self.extra_fields.insert(key.clone(), value.clone()); } } }

部署与集成最佳实践

Docker容器化部署

Czkawka支持Docker容器化部署，适合CI/CD流水线和服务器环境：

FROM rust:1.70-slim AS builder WORKDIR /app COPY . . # 构建优化版本 RUN cargo build --release --features "cli" FROM debian:bullseye-slim WORKDIR /app # 安装运行时依赖 RUN apt-get update && apt-get install -y \ libssl-dev \ ca-certificates \ && rm -rf /var/lib/apt/lists/* # 复制可执行文件 COPY --from=builder /app/target/release/czkawka_cli /usr/local/bin/czkawka # 设置数据卷 VOLUME /data VOLUME /config # 运行配置 ENTRYPOINT ["czkawka"] CMD ["--help"]

系统服务集成

对于生产环境，建议将Czkawka配置为系统服务：

systemd服务配置(/etc/systemd/system/czkawka-cleanup.service)

[Unit] Description=Czkawka Disk Cleanup Service After=network.target [Service] Type=oneshot User=cleanup-user Group=cleanup-group WorkingDirectory=/var/lib/czkawka ExecStart=/usr/local/bin/czkawka_cli \ duplicate \ --directories /data,/home \ --exclude "**/node_modules" \ --exclude "**/.git" \ --hash-type blake3 \ --min-file-size 1M \ --output-format json \ --cache-file /var/cache/czkawka/cache.bin # 安全配置 NoNewPrivileges=true PrivateTmp=true ProtectSystem=strict ReadWritePaths=/var/cache/czkawka /data /home [Install] WantedBy=multi-user.target

定时任务配置(/etc/cron.weekly/czkawka-cleanup)

#!/bin/bash # 每周日凌晨2点执行磁盘清理 0 2 * * 0 cleanup-user /usr/local/bin/czkawka_cli \ duplicate \ --directories /data,/home \ --output-format json \ --report-file /var/log/czkawka/last-run.json

监控与诊断技术

性能指标收集

Czkawka内置详细的性能指标收集功能，便于监控和调优：

pub struct PerformanceMetrics { start_time: Instant, files_processed: AtomicUsize, bytes_processed: AtomicU64, cache_hits: AtomicUsize, cache_misses: AtomicUsize, io_errors: AtomicUsize, } impl PerformanceMetrics { pub fn record_file_processed(&self, size: u64) { self.files_processed.fetch_add(1, Ordering::Relaxed); self.bytes_processed.fetch_add(size, Ordering::Relaxed); } pub fn record_cache_hit(&self) { self.cache_hits.fetch_add(1, Ordering::Relaxed); } pub fn record_cache_miss(&self) { self.cache_misses.fetch_add(1, Ordering::Relaxed); } pub fn generate_report(&self) -> PerformanceReport { let elapsed = self.start_time.elapsed(); let files_per_second = self.files_processed.load(Ordering::Relaxed) as f64 / elapsed.as_secs_f64(); let throughput = self.bytes_processed.load(Ordering::Relaxed) as f64 / elapsed.as_secs_f64(); PerformanceReport { elapsed_time: elapsed, files_processed: self.files_processed.load(Ordering::Relaxed), bytes_processed: self.bytes_processed.load(Ordering::Relaxed), files_per_second, throughput_mb_per_second: throughput / (1024.0 * 1024.0), cache_hit_rate: self.calculate_hit_rate(), io_error_rate: self.calculate_error_rate(), } } }

日志系统配置

项目支持多级别日志记录，便于问题诊断：

pub fn setup_logging(level: LogLevel, output: LogOutput) -> Result<(), LogError> { let mut builder = env_logger::Builder::new(); match level { LogLevel::Error => builder.filter_level(log::LevelFilter::Error), LogLevel::Warn => builder.filter_level(log::LevelFilter::Warn), LogLevel::Info => builder.filter_level(log::LevelFilter::Info), LogLevel::Debug => builder.filter_level(log::LevelFilter::Debug), LogLevel::Trace => builder.filter_level(log::LevelFilter::Trace), }; match output { LogOutput::Stdout => builder.target(env_logger::Target::Stdout), LogOutput::Stderr => builder.target(env_logger::Target::Stderr), LogOutput::File(path) => { let file = OpenOptions::new() .create(true) .append(true) .open(path)?; builder.target(env_logger::Target::Pipe(Box::new(file))); } LogOutput::Syslog => { // 系统日志集成 builder.format(|buf, record| { writeln!(buf, "[{}] {}: {}", record.level(), record.target(), record.args()) }); } }; builder.init(); Ok(()) }

技术选型决策框架

编程语言选择：Rust的优势分析

Czkawka选择Rust作为实现语言，基于以下技术决策：

内存安全保证

• 编译时内存安全检查，消除缓冲区溢出和空指针解引用
• 所有权系统避免内存泄漏和数据竞争
• 零成本抽象，高级语言特性不引入运行时开销

性能考量

• 无垃圾回收，避免GC停顿影响响应性
• 与C/C++相当的原生性能
• LLVM后端优化，生成高效机器码

生态系统成熟度

• 成熟的包管理器Cargo和构建系统
• 丰富的第三方库支持
• 活跃的社区和持续的语言演进

框架选择：Slint vs GTK4

项目支持多种UI框架，每个选择都有明确的技术理由：

哈希算法选择策略

Czkawka支持多种哈希算法，根据使用场景智能选择：

pub enum HashAlgorithm { Blake3, // 平衡安全性和性能 Crc32, // 最高速度，最低安全性 Sha256, // 最高安全性，较低性能 XxHash3, // 非加密哈希，极致性能 } impl HashAlgorithm { pub fn recommend_for_scenario(&self, scenario: ScanScenario) -> Self { match scenario { ScanScenario::QuickScan => HashAlgorithm::Crc32, ScanScenario::SecurityCritical => HashAlgorithm::Sha256, ScanScenario::LargeDataset => HashAlgorithm::Blake3, ScanScenario::Benchmarking => HashAlgorithm::XxHash3, _ => HashAlgorithm::Blake3, } } pub fn performance_characteristics(&self) -> HashPerformance { match self { HashAlgorithm::Blake3 => HashPerformance { speed_mb_per_sec: 2400, security_level: SecurityLevel::High, memory_usage_kb: 32, }, HashAlgorithm::Crc32 => HashPerformance { speed_mb_per_sec: 6100, security_level: SecurityLevel::Low, memory_usage_kb: 4, }, // ... 其他算法特性 } } }

故障排查与性能调优实战

常见问题诊断指南

问题1：扫描速度缓慢

# 诊断步骤 1. 检查磁盘IO性能 $ iostat -x 1 2. 监控内存使用 $ top -p $(pgrep czkawka) 3. 调整线程配置 $ RAYON_NUM_THREADS=4 czkawka_cli duplicate --directories /path 4. 优化哈希算法 $ czkawka_cli duplicate --hash-type crc32 --directories /path 5. 启用详细日志 $ RUST_LOG=debug czkawka_cli duplicate --directories /path

问题2：内存占用过高

# 解决方案 1. 限制最大文件大小 $ czkawka_cli duplicate --max-file-size 100M 2. 调整缓冲区大小 $ czkawka_cli duplicate --buffer-size 65536 3. 禁用缓存（临时） $ czkawka_cli duplicate --no-cache 4. 使用更轻量的哈希算法 $ czkawka_cli duplicate --hash-type crc32

问题3：结果不准确

# 验证步骤 1. 清除缓存重新扫描 $ rm ~/.cache/czkawka/cache.bin $ czkawka_cli duplicate --directories /path 2. 验证哈希算法一致性 $ czkawka_cli duplicate --hash-type blake3 --verify 3. 检查文件权限 $ ls -la /path/to/suspicious/file 4. 启用详细调试信息 $ RUST_LOG=trace czkawka_cli duplicate --directories /path

性能优化检查清单

1. 硬件层面优化

   • 使用SSD替代HDD提升IO性能
   • 确保足够的内存（至少8GB）
   • 多核CPU可显著提升并发性能

2. 软件配置优化

   • 根据文件类型选择合适的哈希算法
   • 调整线程数匹配CPU核心数
   • 合理设置缓存大小和有效期

3. 扫描策略优化

   • 分批次处理超大目录
   • 排除系统目录和缓存文件
   • 使用--min-file-size过滤小文件

4. 监控与调整

   • 定期检查缓存命中率
   • 监控内存使用趋势
   • 根据实际负载调整配置参数

技术演进与未来展望

当前技术架构优势

Czkawka当前架构在以下方面表现出色：

1. 内存安全：Rust的所有权系统彻底消除内存相关错误
2. 并发性能：基于Rayon的数据并行模型充分利用多核CPU
3. 跨平台兼容：Slint框架实现真正的跨平台一致性
4. 算法优化：三级比对策略在准确性和性能间取得平衡
5. 可扩展性：插件化架构支持功能扩展

技术演进方向

基于项目代码库和社区需求，未来技术演进可能包括：

1. GPU加速计算

   • 使用Vulkan计算着色器加速图像处理
   • CUDA/OpenCL支持大规模并行哈希计算
   • 硬件视频解码加速

2. 机器学习增强

   • 基于深度学习的图像相似性检测
   • 自然语言处理分析文件内容
   • 智能分类和推荐系统

3. 云存储集成

   • S3、Google Drive、Dropbox等云服务支持
   • 增量同步和差异扫描
   • 云存储API优化

4. 实时监控系统

   • 文件系统inotify/FSEvents集成
   • 实时重复文件检测
   • 自动清理策略

5. 容器化与微服务

   • Docker镜像扫描和优化
   • Kubernetes Operator实现
   • 微服务架构拆分

社区贡献指南

项目采用开放的开发模式，欢迎技术贡献：

1. 代码质量要求

   • 遵循Rust编码规范
   • 所有PR必须通过CI测试
   • 性能关键路径需要基准测试

2. 贡献流程

   # 1. 克隆仓库 git clone https://gitcode.com/GitHub_Trending/cz/czkawka # 2. 运行测试 cargo test --all-features # 3. 代码格式化 just fix # 4. 提交更改 git commit -m "feat: 添加新功能描述"

3. 技术文档要求

   • 新功能需要API文档
   • 性能优化需要基准测试数据
   • 配置变更需要更新配置文档

Czkawka项目通过严谨的技术架构设计和持续的优化迭代，为存储空间管理提供了可靠的技术解决方案。其内存安全实现、并发优化策略和跨平台设计，为Rust生态中的系统工具开发提供了有价值的参考实践。

【免费下载链接】czkawkaMulti functional app to find duplicates, empty folders, similar images etc.项目地址: https://gitcode.com/GitHub_Trending/cz/czkawka