Como Controlar o Uso de Memória de OCR Paralelo em C#
Cada página processada em paralelo pelo IronOCR aloca sua própria instância nativa do motor Tesseract. Para lotes grandes - centenas de páginas de um PDF escaneado ou uma pasta de imagens - o consumo de memória aumenta linearmente com o número de páginas simultâneas. A propriedade IronTesseract.MaxDegreeOfParallelism limita quantas páginas são OCRadas ao mesmo tempo dentro de uma única chamada Read, e IronTesseract.MultiThreaded altera para processamento totalmente sequencial quando definido para false.
Defina uma única propriedade para limitar quantas páginas IronOCR lê de uma vez, mantendo a memória máxima dentro de um orçamento conhecido.
-
1Instale o IronOCR com NuGet Package Manager
-
2Copie e execute este trecho de código.
var ocr = new IronOcr.IronTesseract { MaxDegreeOfParallelism = 4 };Dim ocr = New IronOcr.IronTesseract With { .MaxDegreeOfParallelism = 4 }Dim ocr = New IronOcr.IronTesseract With { .MaxDegreeOfParallelism = 4 } -
3Implante para testar em seu ambiente de produção.
Comece a usar o IronOCR em seu projeto hoje com uma avaliação gratuita
Fluxo de trabalho mínimo (5 etapas)
- Instale o IronOCR via NuGet para controlar o paralelismo do OCR
- Crie uma instância de
IronTesseract - Defina
MaxDegreeOfParallelismpara o limite desejado - Carregue páginas em um
OcrInput - Chame
Read- apenas o número limitado de páginas processam simultaneamente
Por Que a Memória do OCR Aumenta Durante Lotes Grandes?
Quando MultiThreaded é true, que é o padrão, IronOCR processa páginas em paralelo. Cada página simultânea inicia sua própria instância nativa do motor Tesseract que mantém buffers de imagem, modelos de reconhecimento e estado intermediário em memória não gerenciada.
A memória máxima de uma chamada Read tem, portanto, duas partes, e apenas uma delas está sob seu controle:
- Um custo fixo para o próprio documento, que cresce com o número de páginas independentemente de como são programadas.
- Um custo marginal para cada página lida simultaneamente, um motor nativo para cada uma.
MaxDegreeOfParallelism age apenas sobre o segundo termo. Essa distinção importa: em um documento longo, o custo fixo pode ser a maior parte, então limitar o paralelismo reduz substancialmente a memória máxima sem nunca levá-la a zero.
Em ambientes containerizados - Docker com limites fixos --memory, pods do Kubernetes com cotas de recursos - o termo marginal é o que transforma um trabalho em um erro de memória insuficiente, porque escala com o número de processadores lógicos do host, e não com qualquer coisa que você tenha configurado. Em servidores bare-metal, isso causa troca de memória e degrada a taxa de processamento. Nós limitamos o paralelismo para manter o conjunto de trabalho máximo dentro de um orçamento conhecido.
Quanto de Memória Cada Página Simultânea Utiliza?
Medido em relação à carga de trabalho de referência abaixo, esses dois termos resultam em:
pico ≈ custo fixo do documento + (custo por motor × simultaneidade)
Use os números medidos como ponto de partida e meça sua própria carga de trabalho para refiná-los - ambos os termos mudam com DPI, complexidade da página, comprimento do documento e pacote de idiomas.
Como Isso Foi Medido?
- Cada configuração foi executada em seu próprio processo com o pacote de idioma EnglishFast, após um aquecimento de uma página, cinco vezes.
- Memória é a mediana dessas execuções; a taxa de processamento é a mais rápida.
Os processos separados importam porque a memória máxima é um ponto alto que nunca é redefinido - uma segunda configuração medida no mesmo processo reportaria novamente o pico da primeira. A taxa de processamento usa a execução mais rápida em vez da mediana porque outros trabalhos na máquina só podem desacelerar uma leitura, nunca acelerá-la.
O corpus é "Experiências em Pesquisa de Biodiversidade: Um Curso de Campo" por Thea B. Gessler, Universidade Estadual de Iowa - um PDF denso de texto com 49 páginas, disponível para download para que os resultados possam ser reproduzidos. As mesmas execuções também confirmaram todas as linhas da tabela de precedência mais abaixo nesta página.
Quais Foram os Resultados?
| MaxDegreeOfParallelism | Memória máxima | Custo marginal por página adicionada | Taxa de processamento |
|---|---|---|---|
Sequencial - MultiThreaded = false | 782 MB | baseline | 0,77 páginas/s |
| 2 | 859 MB | +77 MB | 1,32 páginas/s |
| 4 | 1008 MB | +75 MB | 2,09 páginas/s |
| 8 | 1279 MB | +68 MB | 2,56 páginas/s |
| 16 - o padrão nesta máquina | 1829 MB | +69 MB | 3,01 páginas/s |
Testado em: CPU de laptop x64 de 8 núcleos / 16 threads · 1,9 GHz · 16 GB RAM · Windows 11 x64 · .NET 8 · IronOCR 2026.8.1 · último verificado em agosto de 2026
A primeira linha desativa totalmente o paralelismo; a última é o que você obtém ao não definir nada. Memória máxima é o maior valor que o processo atingiu em qualquer momento. Custo marginal por página adicionada é a memória extra que cada página simultânea adicional custa em relação à linha acima - permanece estável em toda a coluna, e essa estabilidade é o que torna o modelo digno de planejamento.
Onde Começam os Retornos Decrescentes?
A memória cresce constantemente com a simultaneidade. A taxa de processamento não - os ganhos se achatam enquanto o custo de memória continua subindo na mesma taxa. Compare as duas últimas linhas: a coluna de memória aumenta muito mais rapidamente entre elas do que a coluna de taxa de processamento.
Essa é a descoberta prática: o padrão raramente é a melhor troca para trabalho em lotes. Ele é otimizado para latência em um único documento, não para espaço. Se você está processando documentos em massa em um host com memória limitada, um limite explícito abaixo da contagem de processadores lógicos geralmente custa muito pouco em velocidade e economiza muita memória. Meça onde o ponto de inflexão ocorre em seus próprios documentos, pois ele muda com a complexidade da página.
Como Posso Limitar Quantas Páginas São Lidas de Uma Vez?
Defina IronTesseract.MaxDegreeOfParallelism para o número máximo de páginas que devem processar simultaneamente dentro de uma única chamada Read. Se deixado sozinho, o padrão é Environment.ProcessorCount.
using IronOcr;
using System;
var ocr = new IronTesseract();
// Cap concurrency at 2 pages. Each concurrent page holds its own native
// engine, so this bounds peak memory for every Read on this instance.
ocr.MaxDegreeOfParallelism = 2;
// The cap applies per Read call, however many pages the document has.
using var input = new OcrInput();
input.LoadPdf("500-page-archive.pdf");
OcrResult result = ocr.Read(input);
Console.WriteLine(result.Text.Length);using IronOcr;
using System;
var ocr = new IronTesseract();
// Cap concurrency at 2 pages. Each concurrent page holds its own native
// engine, so this bounds peak memory for every Read on this instance.
ocr.MaxDegreeOfParallelism = 2;
// The cap applies per Read call, however many pages the document has.
using var input = new OcrInput();
input.LoadPdf("500-page-archive.pdf");
OcrResult result = ocr.Read(input);
Console.WriteLine(result.Text.Length);Imports IronOcr
Imports System
Dim ocr = New IronTesseract()
' Cap concurrency at 2 pages. Each concurrent page holds its own native
' engine, so this bounds peak memory for every Read on this instance.
ocr.MaxDegreeOfParallelism = 2
' The cap applies per Read call, however many pages the document has.
Using input = New OcrInput()
input.LoadPdf("500-page-archive.pdf")
Dim result As OcrResult = ocr.Read(input)
Console.WriteLine(result.Text.Length)
End UsingImports IronOcr
Imports System
Dim ocr = New IronTesseract()
' Cap concurrency at 2 pages. Each concurrent page holds its own native
' engine, so this bounds peak memory for every Read on this instance.
ocr.MaxDegreeOfParallelism = 2
' The cap applies per Read call, however many pages the document has.
Using input = New OcrInput()
input.LoadPdf("500-page-archive.pdf")
Dim result As OcrResult = ocr.Read(input)
Console.WriteLine(result.Text.Length)
End UsingQual Valor Devo Escolher?
Dimensione-o contra o modelo de duas partes acima em vez de escolher um número:
custo fixo do documento + custo por motor × MaxDegreeOfParallelism ≤ orçamento de memória para OCR
Para preencher os dois custos para seus próprios documentos, leia um arquivo representativo duas vezes - uma vez com MultiThreaded definido para false, uma vez com MaxDegreeOfParallelism = 2 - e registre o conjunto de trabalho máximo cada vez. A execução sequencial lhe dá o custo fixo; a diferença entre os dois lhe dá o custo de um motor adicional. Os números de referência para ambos estão na tabela acima.
Duas coisas valem a pena notar quando você o aplica. O termo fixo escala com o comprimento do documento, então um arquivo longo não se comportará como a amostra medida acima. E deixe espaço para o runtime .NET, o heap gerenciado e qualquer outra coisa no processo - reservar cerca de 40% do limite do container é um ponto de partida razoável.
Hosts generosos em memória podem deixar o padrão no lugar. Host restritos devem definir um limite explicitamente, e como mostram os números de retornos decrescentes acima, esse limite normalmente custa muito menos taxa de processamento do que suas economias de memória sugerem.
MaxDegreeOfParallelism limita páginas em uma única chamada Read. Se o seu próprio código também executa vários documentos de uma vez, os dois se multiplicam - quatro documentos simultâneos contra um padrão de 16 é 64 motores, não 16. Limite ambas as camadas. Veja o Memória Máxima Durante OCR em Massa para o padrão de ciclo externo.Como Posso Ler Páginas Sequencialmente?
Defina MultiThreaded para false. Esta é a opção de menor memória, porque apenas um motor nativo está ativo de cada vez. A troca é a taxa de processamento: um lote leva aproximadamente N vezes mais tempo do que com N trabalhadores simultâneos.
using IronOcr;
var ocr = new IronTesseract();
// One page at a time. Overrides MaxDegreeOfParallelism, whatever it is set to.
ocr.MultiThreaded = false;
using var input = new OcrInput();
input.LoadPdf("scans.pdf");
OcrResult result = ocr.Read(input);using IronOcr;
var ocr = new IronTesseract();
// One page at a time. Overrides MaxDegreeOfParallelism, whatever it is set to.
ocr.MultiThreaded = false;
using var input = new OcrInput();
input.LoadPdf("scans.pdf");
OcrResult result = ocr.Read(input);Imports IronOcr
Dim ocr = New IronTesseract()
' One page at a time. Overrides MaxDegreeOfParallelism, whatever it is set to.
ocr.MultiThreaded = False
Using input = New OcrInput()
input.LoadPdf("scans.pdf")
Dim result As OcrResult = ocr.Read(input)
End UsingImports IronOcr
Dim ocr = New IronTesseract()
' One page at a time. Overrides MaxDegreeOfParallelism, whatever it is set to.
ocr.MultiThreaded = False
Using input = New OcrInput()
input.LoadPdf("scans.pdf")
Dim result As OcrResult = ocr.Read(input)
End UsingMultiThreaded não tinha efeito antes deste lançamento - agora é uma configuração ativa. O código que o definia para false esperando uma não-ação agora lerá sequencialmente após a atualização, sem aviso do compilador e sem exceção. Revise os usos existentes se a taxa de processamento cair inesperadamente.Como As Duas Propriedades Interagem?
| MultiThreaded | MaxDegreeOfParallelism | Concorrência efetiva |
|---|---|---|
true (padrão) | Não definido | Environment.ProcessorCount |
true | Um número positivo | Esse número de páginas simultâneas |
true | 0 ou negativo | Volta para Environment.ProcessorCount |
false | Qualquer valor | 1 - sequencial, MaxDegreeOfParallelism é ignorado |
Environment.ProcessorCount relata processadores lógicos, não núcleos físicos. Em uma máquina com multithreading simultâneo, o padrão é o dobro da contagem de núcleos - uma CPU de 8 núcleos tem como padrão 16 páginas simultâneas, não 8. Dimensione seu orçamento de memória contra a contagem lógica.Posso Limitar a Memória Durante a Detecção de Orientação de Página?
A nova sobrecarga de OcrInput.DetectPageOrientation aceita um parâmetro maxDegreeOfParallelism que limita quantas páginas têm sua orientação detectada simultaneamente. Valores não positivos retornam para Environment.ProcessorCount. A sobrecarga de um único argumento é inalterada e continua sendo compatível com o código-fonte e binário.
using IronOcr;
using System;
using var input = new OcrInput();
input.LoadPdf("rotated-scans.pdf");
// Analyse at most 2 pages at once. Orientation detection runs before the
// OCR read, so capping it here prevents a spike ahead of the real workload.
var results = input.DetectPageOrientation(
OrientationDetectionMode.Fast,
maxDegreeOfParallelism: 2);
// One result per page, in page order.
foreach (var result in results)
{
Console.WriteLine($"Page {result.PageNumber}: {result.RotationAngle}");
}using IronOcr;
using System;
using var input = new OcrInput();
input.LoadPdf("rotated-scans.pdf");
// Analyse at most 2 pages at once. Orientation detection runs before the
// OCR read, so capping it here prevents a spike ahead of the real workload.
var results = input.DetectPageOrientation(
OrientationDetectionMode.Fast,
maxDegreeOfParallelism: 2);
// One result per page, in page order.
foreach (var result in results)
{
Console.WriteLine($"Page {result.PageNumber}: {result.RotationAngle}");
}Imports IronOcr
Imports System
Using input = New OcrInput()
input.LoadPdf("rotated-scans.pdf")
' Analyse at most 2 pages at once. Orientation detection runs before the
' OCR read, so capping it here prevents a spike ahead of the real workload.
Dim results = input.DetectPageOrientation(OrientationDetectionMode.Fast, maxDegreeOfParallelism := 2)
' One result per page, in page order.
For Each result In results
Console.WriteLine($"Page {result.PageNumber}: {result.RotationAngle}")
Next
End UsingImports IronOcr
Imports System
Using input = New OcrInput()
input.LoadPdf("rotated-scans.pdf")
' Analyse at most 2 pages at once. Orientation detection runs before the
' OCR read, so capping it here prevents a spike ahead of the real workload.
Dim results = input.DetectPageOrientation(OrientationDetectionMode.Fast, maxDegreeOfParallelism := 2)
' One result per page, in page order.
For Each result In results
Console.WriteLine($"Page {result.PageNumber}: {result.RotationAngle}")
Next
End UsingModo Fast reutiliza um motor por thread de trabalho em vez de alocar um por página, o que reduz ainda mais a memória máxima. Isso importa quando a detecção de orientação ocorre como uma etapa de pré-processamento antes da leitura do OCR principal, pois limitar o paralelismo aqui evita um pico de memória antes que a carga de trabalho real comece.
O OCR Paralelo Ainda Falha em Lotes Grandes?
Versões anteriores podiam lançar um AccessViolationException fatal durante OCR paralelo ou em grande volume devido ao acesso inseguro entre threads ao estado nativo do Tesseract. Essa exceção é irrecuperável - ela termina o processo sem oportunidade de captura. Agora está resolvido. As soluções alternativas anteriores, uma instância IronTesseract por thread e um documento por vez, não são mais necessárias: o motor isola o estado nativo por trabalhador corretamente, e MaxDegreeOfParallelism fornece um limite oficial que substitui esses padrões ad-hoc.
Quando Devo Ajustar Essas Configurações?
- Container ou executor CI com limite de memória - defina
MaxDegreeOfParallelismpara manter a memória máxima dentro do limite. - Processamento em lote de milhares de páginas - reduza
MaxDegreeOfParallelismpara evitar erros de memória insuficientes. A taxa de processamento diminui proporcionalmente, mas o trabalho é concluído em vez de falhar. - Menor memória possível - defina
MultiThreadedparafalsepara modo sequencial. Um motor, uma página de cada vez. - Máxima taxa de processamento - deixe ambos nos padrões para que o motor use todos os núcleos disponíveis. Veja o exemplo de multithreading para rapidez.
- Ajuste de precisão versus velocidade - esse é um eixo diferente. O guia para afinar o Tesseract para rapidez cobre as trocas de precisão e rapidez, enquanto esta página cobre as trocas de memória e taxa de processamento.
Para preocupações com assíncronas e responsividade, como manter uma interface do usuário responsiva durante a leitura OCR, veja o guia de OCR assíncrono, que possui ReadAsync e OcrReadTask. Esta página cobre a limitação de recursos: mantendo o consumo de memória previsível independentemente do tamanho do lote.
Explore o guia de configuração do IronTesseract para a superfície completa de propriedades, carregando entradas de PDF e carregando entradas de imagem para padrões de uso de OcrInput, e detecção de orientação de página para o método DetectPageOrientation e sua nova sobrecarga de paralelismo.
Explore as opções de licenciamento do IronOCR para migrar de teste para produção.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.