C#开发者必看:如何让PDF批量处理效率提升10倍?

这个活主要是最近为ai喂数据时用到了，按照之前的单线程处理方式，一个文件平均2秒，30000个文件就是60000秒。

等等！ 如果你还在用传统的单线程方式处理PDF文件，那你就OUT了！

今天我来教你一招狠活儿：使用C#的Parallel编程，让PDF批量处理效率瞬间提升10倍！从此告别加班熬夜，让领导对你刮目相看！

痛点分析：为什么传统方式这么慢？

传统单线程处理的三大问题

1. CPU利用率低
   现代服务器都是多核CPU，单线程只能用到一个核心
2. I/O等待浪费
   读取PDF文件时，CPU在等待磁盘操作
3. 处理时间线性增长
   文件数量翻倍，处理时间也翻倍

数据说话 ：

解决方案：Parallel并行编程来救场

C#的 Parallel.ForEach 是我们的救星！它能够：

核心技术要点

1. ConcurrentDictionary
   线程安全的字典集合
2. ParallelOptions
   控制并行度，防止资源耗尽
3. 异常处理
   确保单个文件错误不影响整体处理

实战代码：完整可运行的解决方案

准备工作：NuGet包安装

Install-Package iTextSharp
或是
Install-Package iTextSharp-LGPL //这个是更好的选择

完整代码实现

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using iTextSharp.text.pdf.parser;
using iTextSharp.text.pdf;

namespace AppParallelPdf
{
    publicclass ParallelPdfProcessor
    {
        /// 
        /// 并行读取PDF文件并提取文本
        /// 
        /// PDF文件目录
        /// 包含PDF文件名和文本内容的线程安全字典
        public ConcurrentDictionary<string, string> ProcessPdfFilesInParallel(string pdfDirectoryPath)
        {
            //  线程安全字典：多线程环境下的数据存储利器
            var processedPdfTexts = new ConcurrentDictionary<string, string>();

            //  获取目录下所有PDF文件
            string[] pdfFiles = Directory.GetFiles(pdfDirectoryPath, "*.pdf");

            //  核心：使用Parallel.ForEach并行处理
            Parallel.ForEach(pdfFiles, new ParallelOptions
            {
                //  关键配置：限制最大并行度
                // 防止创建过多线程导致系统资源耗尽
                MaxDegreeOfParallelism = Environment.ProcessorCount
            },
            (pdfFilePath) =>
            {
                try
                {
                    // 提取PDF文件名
                    string fileName = System.IO.Path.GetFileName(pdfFilePath);

                    //  核心操作：提取PDF文本内容
                    string pdfText = ExtractPdfText(pdfFilePath);

                    //  线程安全添加：ConcurrentDictionary的威力
                    processedPdfTexts[fileName] = pdfText;

                    Console.WriteLine($" 成功处理文件: {fileName}");
                }
                catch (Exception ex)
                {
                    //  异常处理：单个文件失败不影响整体流程
                    Console.WriteLine($" 处理文件 {pdfFilePath} 时发生错误: {ex.Message}");
                }
            });

            return processedPdfTexts;
        }

        /// 
        /// 提取PDF文本内容的核心方法
        /// 
        /// PDF文件路径
        /// PDF文本内容
        private string ExtractPdfText(string pdfPath)
        {
            //  使用iTextSharp读取PDF
            using (PdfReader reader = new PdfReader(pdfPath))
            {
                var textBuilder = new System.Text.StringBuilder();

                //  逐页读取文本内容
                for (int i = 1; i <= reader.NumberOfPages; i++)
                {
                    string pageText = PdfTextExtractor.GetTextFromPage(reader, i);
                    textBuilder.Append(pageText);
                }

                return textBuilder.ToString();
            }
        }

        /// 
        /// PDF文本分析示例：关键词统计
        /// 
        /// 处理后的PDF文本字典
        public void AnalyzePdfTexts(ConcurrentDictionary<string, string> processedPdfTexts)
        {
            //  再次使用并行处理进行文本分析
            Parallel.ForEach(processedPdfTexts, (pdfEntry) =>
            {
                string fileName = pdfEntry.Key;
                string content = pdfEntry.Value;

                //  简单的词数统计示例
                int wordCount = content.Split(new[] { ' ', '\n', '\r' },
                                            StringSplitOptions.RemoveEmptyEntries).Length;

                Console.WriteLine($" 文件 {fileName} 总词数: {wordCount}");
            });
        }
    }
}

namespace AppParallelPdf
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.OutputEncoding = System.Text.Encoding.UTF8;

            Console.WriteLine(" 开始处理PDF文件...");
            var processor = new ParallelPdfProcessor();

            //  指定PDF文件目录
            string pdfDirectory = @"D:\手册\ABB";

            //  开始计时
            var stopwatch = System.Diagnostics.Stopwatch.StartNew();

            //  并行处理PDF文件
            var processedPdfs = processor.ProcessPdfFilesInParallel(pdfDirectory);

            //  分析处理结果
            processor.AnalyzePdfTexts(processedPdfs);

            stopwatch.Stop();

            Console.WriteLine($" 处理完成！总耗时: {stopwatch.ElapsedMilliseconds}ms");
            Console.WriteLine($" 成功处理文件数: {processedPdfs.Count}");
        }
    }
}

代码核心亮点解析

亮点1：智能并行度控制

MaxDegreeOfParallelism = Environment.ProcessorCount

为什么这样设置？

亮点2：线程安全的数据存储

var processedPdfTexts = new ConcurrentDictionary<string, string>();

普通Dictionary的问题：

ConcurrentDictionary的优势：

亮点3：异常隔离处理

try
{
    // 处理单个PDF文件
}
catch (Exception ex)
{
    // 单个文件失败不影响其他文件处理
}

实战意义：

实战避坑指南

坑点1：无限制并行导致内存爆炸

//  错误做法：不限制并行度
Parallel.ForEach(files, (file) => { ... });

//  正确做法：限制并行度
Parallel.ForEach(files, new ParallelOptions 
{ 
    MaxDegreeOfParallelism = Environment.ProcessorCount 
}, (file) => { ... });

坑点2：忘记异常处理

//  一个文件出错，全部停止
Parallel.ForEach(files, (file) => 
{
    ProcessFile(file); // 可能抛异常
});

//  异常隔离，继续处理其他文件
Parallel.ForEach(files, (file) => 
{
    try
    {
        ProcessFile(file);
    }
    catch (Exception ex) 
    {
        LogError(file, ex);
    }
});

坑点3：使用非线程安全集合

//  Dictionary在多线程下会出错
var results = new Dictionary<string, string>();

//  使用线程安全的ConcurrentDictionary
var results = new ConcurrentDictionary<string, string>();

进阶优化技巧

技巧1：自定义任务分割策略

var partitioner = Partitioner.Create(files, true);
Parallel.ForEach(partitioner, (file) => 
{
    // 处理逻辑
});

技巧2：内存优化处理

// 大文件处理时，及时释放内存
using (var fileStream = new FileStream(path, FileMode.Open))
{
    // 处理文件
} // 自动释放资源

技巧3：进度监控

private int processedCount = 0;

Parallel.ForEach(files, (file) => 
{
    ProcessFile(file);

    int current = Interlocked.Increment(ref processedCount);
    Console.WriteLine($"进度: {current}/{files.Length}");
});

实际应用场景

场景1：企业文档数字化

场景2：数据挖掘预处理

场景3：合规性检查

总结：三个核心要点

要点1：并行编程提效显著

使用 Parallel.ForEach 可以将CPU密集型任务的处理效率提升3-10倍，特别适合文件批量处理场景。

要点2：线程安全是关键

选择合适的线程安全集合（如 ConcurrentDictionary ）和正确的异常处理策略，是并行编程成功的基础。

要点3：性能优化需要平衡

合理设置并行度、及时释放资源、监控系统性能，在效率和稳定性之间找到最佳平衡点。

互动时间

问题1 ：你在项目中遇到过哪些适合并行处理的场景？处理效果如何？

问题2 ：除了PDF处理，你还用并行编程解决过什么实际问题？

分享你的经验，让更多C#开发者受益！

觉得这篇文章对你有帮助吗？

关注我，获取更多C#开发实战干货！