> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Parallelverarbeitung unter Windows
> Führen Sie die Parallelverarbeitung von ABBYY FineReader Engine unter Windows mit MultiProcessingParams, BatchProcessor oder einem Pool von OutprocLoader-Instanzen aus, die als Out-of-Process-Server geladen wurden.
Grundsätzlich gibt es drei Möglichkeiten, Multiprocessing mit ABBYY FineReader Engine einzusetzen:
Zum einen können Sie ein [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekt verwenden und die Eigenschaft [MultiProcessingParams](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/properties#multiprocessingparams) des Engine-Objekts auf die entsprechenden Werte setzen.
ABBYY FineReader Engine unterstützt zwei verschiedene Objekte, die Multiprocessing mit einer einzelnen Engine-Instanz ermöglichen. Dabei handelt es sich um das [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument)-Objekt (siehe [Verarbeitung mit dem FRDocument-Objekt](/de/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing/parallel-processing-in-windows#frdocument)) und das [BatchProcessor](/de/fine-reader/engine/api-reference/batch-processor/batchprocessor)-Objekt (siehe [Verarbeitung mit dem Batch Processor](/de/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing/parallel-processing-in-windows#batchprocessor)).
Zum anderen können Sie mehrere Instanzen von Engine mithilfe von COM als Out-of-Process-Server laden (unter Verwendung des Objekts [OutprocLoader](/de/fine-reader/engine/api-reference/engine-loaders/outprocloader)) und jede Instanz in ihrem eigenen Prozess verwenden. Siehe [Verarbeitung mit einem Pool von Engines](/de/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing/parallel-processing-in-windows#outprocloader).
Bitte beachten Sie, dass die Parallelverarbeitung mehr RAM als die sequenzielle Verarbeitung erfordert. Die allgemeine Empfehlung für eine Workstation lautet 350 MB \* (Anzahl der Kerne) + 450 MB RAM, und wenn Sie Dokumente auf Arabisch oder in [CJK-Sprachen](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-cjk-languages#cjk) verarbeiten, 850 MB \* (Anzahl der Kerne) + 750 MB RAM.
## Anwendungsszenarien
Wir gehen davon aus, dass Sie eine große Anzahl von Dokumenten verarbeiten. Dabei müssen jedoch auch die Ergebnisse berücksichtigt werden, die Sie erhalten möchten, damit Sie den besten Ansatz für die Umsetzung Ihrer Aufgabe wählen können. Folgende Szenarien sind dabei zu beachten:
* Konvertierung mehrseitiger Dokumente mit vielen Seiten. Dazu gehören in der Regel Bücher, lange Berichte usw. In diesem Fall können Sie die Seiten des Dokuments parallel erkennen, anschließend die Synthese im Hauptprozess durchführen und danach erneut parallel exportieren. Wenn Sie einen Pool von Engines verwenden, können Sie auch mehrere mehrseitige Dokumente gleichzeitig verarbeiten. Dabei kann der Speicherverbrauch jedoch sehr hoch sein und sogar zu „Nicht genügend Speicher“-Fehlern führen.
* Konvertierung einer großen Anzahl einseitiger Dokumente. Dies ist der Fall, wenn Sie Rechnungen, Verträge, Briefe usw. verarbeiten. Die Parallelverarbeitung ist in dieser Situation am einfachsten, da einseitige Dokumente nicht voneinander abhängen und nicht gleichzeitig große Speichermengen benötigen.
* Verarbeitung einer großen Anzahl von Bildern und Durchsuchen dieser Bilder nach benötigten Informationen oder sonstige Verarbeitung der Erkennungsergebnisse. Möglicherweise müssen Sie die meisten davon nicht in ein bearbeitbares Format konvertieren, sodass die Geschwindigkeit von Synthese und Export keine Rolle spielt. Der Vorgang, der in mehreren Prozessen ausgeführt wird, besteht darin, die Layout-Blöcke zu durchlaufen und auf die Erkennungsergebnisse für Textblöcke zuzugreifen.
Wenn Sie die Parallelverarbeitung für den Export verwenden möchten, beachten Sie, dass diese Funktion nur für den Export in PDF (außer im Modus `TextOnly`) und in das Format PPTX unterstützt wird.
## Empfehlungen und Einschränkungen
* Für die Parallelverarbeitung mehrseitiger Dokumente empfehlen wir die Verwendung von FRDocument. Dies ist die am einfachsten zu implementierende Multiprocessing-Methode, da Sie keine zusätzlichen Schnittstellen implementieren müssen.
Öffnen, Vorverarbeitung, Analyse und Erkennung werden parallel durchgeführt; die Dokumentsynthese erfolgt sequenziell im Hauptprozess, anschließend werden der Export in PDF (außer im TextOnly-Modus) und in das PPTX-Format parallel durchgeführt.
* Für die Verarbeitung vieler einseitiger Dokumente, die von einer Quelle (z. B. einem Scanner) empfangen werden, empfehlen wir BatchProcessor.
Der Vorteil dieser Methode besteht darin, dass sie sich verwenden lässt, wenn Sie die Anzahl der Dokumente nicht im Voraus kennen, die Dokumente unterschiedliche Typen haben können und direkt nach ihrem Eintreffen verarbeitet werden müssen. Der Nachteil besteht darin, dass sie mehr Implementierungsaufwand erfordert: Sie müssen Schnittstellen für einen Datei-Adapter und eine benutzerdefinierte Bildquelle implementieren.
Alle Verarbeitungsstufen werden parallel ausgeführt, da bei einseitigen Dokumenten die Seiten- und Dokumentsynthese für jede Seite separat erfolgen.
Paralleler Export wird in Szenarien mit Batch Processor nicht unterstützt.
* Um viele einseitige Dokumente vollständig parallel zu verarbeiten, können Sie einen Pool von Engines verwenden, die mithilfe von COM in separaten Prozessen geladen werden. Diese Methode ist hinsichtlich der Geschwindigkeit am effizientesten und beseitigt automatisch alle Schwierigkeiten im Zusammenhang mit Multithreading: Alle Operationen mit den Objekten von ABBYY FineReader Engine werden mittels COM serialisiert. Sie hat jedoch einige Einschränkungen:
* aufgrund der Verwendung von COM müssen Sie FREngine.dll registrieren;
* wenn Ihr Code in C++ geschrieben ist, erfordert die Arbeit mit COM mehr Routinecode als beispielsweise in C#;
* in diesem Fall läuft die Verarbeitung in einem anderen Prozess ab, sodass Sie Bilder nicht aus dem Speicher öffnen können, und das Durchlaufen der Erkennungsergebnisse dauert länger, da jede Anforderung an einen anderen Prozess und wieder zurück übergeben werden muss;
* und schließlich bedeutet das Laden mehrerer Engine-Instanzen einen höheren Speicherverbrauch, insbesondere da in diesem Fall alle Verarbeitungsstufen parallel ausgeführt werden und mehrere Synthesevorgänge gleichzeitig ablaufen können, was den Speicherverbrauch weiter erhöht.
* Um die Ereignisse abzufangen und zu verarbeiten, die während der Parallelverarbeitung auftreten, können Sie die Schnittstelle [IParallelProcessingCallback](/de/fine-reader/engine/api-reference/supplementary-objects-and-methods/iparallelprocessingcallback) verwenden. Diese Schnittstelle kann bei der Handhabung problematischer Situationen sehr nützlich sein. Wenn beispielsweise ein Timeout-Fehler auftritt, bietet die Schnittstelle [IParallelProcessingCallback](/de/fine-reader/engine/api-reference/supplementary-objects-and-methods/iparallelprocessingcallback) je nach Benutzerpräferenzen mehrere Lösungen für das Problem. Weitere Informationen finden Sie unter [IParallelProcessingCallback::OnWaitIntervalExceeded](/de/fine-reader/engine/api-reference/supplementary-objects-and-methods/iparallelprocessingcallback/onwaitintervalexceeded-method).
Ereignisse, die während der Parallelverarbeitung einer Seite auftreten, werden in Ereignisse für das gesamte Dokument umgewandelt.
## Ergebnisse der Geschwindigkeitstests
In der folgenden Tabelle sind die Ergebnisse der Performance-Tests dargestellt.
| | Einseitige Dokumente | Ein mehrseitiges Dokument | Durchsuchen der Ergebnisse ohne Export |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------- | ------------------------- | -------------------------------------- |
| Sequentielle Verarbeitung | 60 | 51 | 87 |
| Verarbeitung mit FRDocument | 41 | 117 | 57 |
| Verarbeitung mit FRDocument (mit [PageFlushingPolicy](/de/fine-reader/engine/api-reference/document-related-objects/frdocument#pageflushingpolicy) = PFP\_KeepInMemory) | 55 | 141 | 82 |
| Verarbeitung mit Batch Processor | 99 | 115 | 294 |
| Verarbeitung mit einem Pool von Engines | 165 | 10 | 102 |
Als Prozessor im Testrechner kam ein Intel® Core™ i5-4440 (3,10 GHz, 4 physische Kerne) zum Einsatz, der Arbeitsspeicher betrug 8 GB RAM, und die Anzahl der gleichzeitig ausgeführten Prozesse lag bei 4. Die Performance wurde mit 300 englischsprachigen Bildern und den Einstellungen des vordefinierten Profils [DocumentArchiving\_Speed](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles#documentarchiving_speed) getestet. Die Zahlen in der Tabelle geben die Anzahl der pro Minute verarbeiteten Seiten an. In den Szenarien „einseitige Dokumente“ und „ein mehrseitiges Dokument“ werden die Dokumente in das PDF-Format exportiert.
## Verarbeitung mit dem FRDocument-Objekt
Die Anzahl der auszuführenden Prozesse wird automatisch anhand der Anzahl der verfügbaren physischen oder logischen CPU-Kerne, der Anzahl der in der Lizenz verfügbaren freien CPU-Kerne und der Anzahl der Seiten im Dokument bestimmt. Gehen Sie wie folgt vor, um den Multiprocessing-Modus zu aktivieren:
1. Legen Sie den Wert der Eigenschaft MultiProcessingMode des Unterobjekts [MultiProcessingParams](/de/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) des Objekts [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/properties#multiprocessingparams) fest. Die Parallelverarbeitung wird verwendet, wenn diese Eigenschaft auf MPM\_Parallel oder MPM\_Auto gesetzt ist und sowohl die Anzahl der Seiten im Dokument als auch die Anzahl der verfügbaren CPU-Kerne größer als eins ist.
2. Stellen Sie die Anzahl der auszuführenden Prozesse mit der Eigenschaft RecognitionProcessesCount ein und geben Sie bei Bedarf die Werte weiterer Eigenschaften an.
Nach dem Konfigurieren der Multiprocessing-Einstellungen können Sie das Standardverfahren für die Arbeit mit [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument) verwenden. ABBYY FineReader Engine startet automatisch mehrere Erkennungsprozesse, wenn Sie eine der folgenden Methoden des FRDocument-Objekts aufrufen:
* [AddImageFile](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefile-method), [AddImageFileFromMemory](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilefrommemory-method), [AddImageFileFromStream](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilefromstream-method), [AddImageFileWithPassword](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpassword-method), [AddImageFileWithPasswordCallback](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpasswordcallback-method)
* [Preprocess](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/preprocess-method), [PreprocessPages](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/preprocesspages-method)
* [Analyze](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/analyze-method), [AnalyzePages](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/analyzepages-method)
* [Recognize](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/recognize-method), [RecognizePages](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/recognizepages-method)
* [Process](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method), [ProcessPages](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/processpages-method)
* [Export](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/export-method), [ExportPages](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/exportpages-method), [ExportToMemory](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/exporttomemory-method) — nur für den Export in PDF (außer im TextOnly-Modus) und in das PPTX-Format
Für jede Seite des Dokuments wird eine neue Verarbeitungsaufgabe erstellt, die an einen der Erkennungsprozesse übergeben wird. Sobald ein Erkennungsprozess die Aufgabe abgeschlossen hat, erhält er die nächste Verarbeitungsaufgabe. Dies wird fortgesetzt, bis alle Aufgaben verarbeitet sind.
```csharp theme={null}
// Das Dokument erstellen
FREngine.IFRDocument document = engine.CreateFRDocument();
// Dem Dokument Seiten hinzufügen
for( int index = 0; index < filesNumber; index++ ) {
string imagePath = filePaths[index];
document.AddImageFile( imagePath, null, null );
}
// Multiprocessing-Parameter einrichten
engine.MultiProcessingParams.MultiProcessingMode = FREngine.MultiProcessingModeEnum.MPM_Parallel;
engine.MultiProcessingParams.RecognitionProcessesCount = coresNumber;
// Parameter für die Dokumentverarbeitung erstellen und einrichten
FREngine.IDocumentProcessingParams documentProcessingParams = engine.CreateDocumentProcessingParams();
...
// Dokument verarbeiten
document.Process( documentProcessingParams );
// Dokument wie gewohnt synthetisieren und exportieren, mit den Ergebnissen arbeiten usw.
...
```
Das Distribution-Paket von ABBYY FineReader Engine enthält das Demotool [MultiProcessingRecognition](/de/fine-reader/engine/guided-tour/samples#multiprocessingrecognition), das den Geschwindigkeitsvorteil bei der Verwendung der Multiprocessing-Erkennung mit dem FRDocument-Objekt demonstriert und eine Implementierung enthält, die Sie als Ausgangspunkt für die Entwicklung Ihrer eigenen Anwendung verwenden können.
## Verarbeitung mit dem Batch Processor
Wenn der Batch Processor initialisiert wird, werden asynchrone Erkennungsprozesse gestartet und konfiguriert. Anschließend bezieht der Prozessor Bilddateien aus einer benutzerdefinierten Bildquelle. Für jede Seite der Bilddatei wird eine neue Verarbeitungsaufgabe erstellt, die an einen der Erkennungsprozesse übergeben wird. Wenn alle Aufgaben für eine Datei zur Verarbeitung übergeben wurden, aber noch nicht alle Erkennungsprozesse ausgelastet sind, wird die nächste Bilddatei aus der Bild-Warteschlange der Quelle entnommen und zur Verarbeitung übergeben. Dies wird fortgesetzt, bis die erste Bildseite konvertiert und an den Benutzer zurückgegeben wurde. Die Seiten werden dem Benutzer in der Reihenfolge zurückgegeben, in der sie aus der Bildquelle entnommen wurden.
Gehen Sie wie folgt vor, um Multiprocessing mit dem Batch Processor einzurichten:
1. Implementieren Sie die Schnittstellen [IImageSource](/de/fine-reader/engine/api-reference/batch-processor/iimagesource) und [IFileAdapter](/de/fine-reader/engine/api-reference/batch-processor/ifileadapter), die Zugriff auf die Bildquelle und die darin enthaltenen Dateien bereitstellen.
2. \[optional] Implementieren Sie die Schnittstelle [IAsyncProcessingCallback](/de/fine-reader/engine/api-reference/batch-processor/iasyncprocessingcallback), um die Verarbeitung zu steuern. Mit den Methoden dieser Schnittstelle können Sie Fehler behandeln und/oder die Verarbeitung abbrechen.
3. \[optional] Richten Sie Multiprocessing mithilfe des Unterobjekts [MultiProcessingParams](/de/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) des Objekts [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/properties#multiprocessingparams) ein. Beachten Sie, dass die Eigenschaft MultiProcessingMode nicht gesetzt werden muss, da bei der Arbeit mit dem Batch Processor standardmäßig Parallelverarbeitung verwendet wird. Passen Sie die Anzahl der auszuführenden Prozesse mithilfe der Eigenschaft RecognitionProcessesCount an und geben Sie bei Bedarf Werte für weitere Eigenschaften an.
4. Rufen Sie die Methode [CreateBatchProcessor](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) des Engine-Objekts auf, um das BatchProcessor-Objekt zu erhalten.
5. Rufen Sie die Methode [Start](/de/fine-reader/engine/api-reference/batch-processor/batchprocessor/start-method) dieses Objekts auf, um den Prozessor zu initialisieren und asynchrone Erkennungsprozesse zu starten. Beim Aufruf dieser Methode können Sie die Bildquelle angeben und Referenzen auf die Schnittstelle IAsyncProcessingCallback sowie Parameterobjekte übergeben.
6. Rufen Sie die Methode GetNextProcessedPage in einer Schleife auf, bis sie 0 zurückgibt. Das bedeutet, dass sich keine Bilder mehr in der Quelle befinden und alle verarbeiteten Bilder an den Benutzer zurückgegeben wurden.
Die von der Methode GetNextProcessedPage zurückgegebene Seite existiert bis zum nächsten Aufruf dieser Methode. Wenn Sie diese Seite daher speichern möchten, müssen Sie sie entweder mithilfe der Methoden des Objekts [FRPage](/de/fine-reader/engine/api-reference/document-related-objects/frpage) speichern oder sie mithilfe der Methode [IFRDocument::AddPage](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addpage-method) zu einem vorhandenen Document hinzufügen, BEVOR GetNextProcessedPage das nächste Mal aufgerufen wird.
```csharp theme={null}
// Batch Processor erstellen
FREngine.IBatchProcessor batchProcessor = engine.CreateBatchProcessor();
// Multiprocessing-Parameter einrichten
engine.MultiProcessingParams.RecognitionProcessesCount = coresNumber;
// Den Prozessor initialisieren
FREngine.IImageSource imageSource = new CImageSource; // die Klasse wird vom Benutzer implementiert
batchProcessor.Start( imageSource, null, null, null );
// Verarbeitung starten
while( true ) {
FREngine.IFRPage page = batchProcessor.GetNextProcessedPage();
if( page == null ) {
break; // es gibt keine weiteren Seiten, Ende der Verarbeitung
}
// etwas mit der Seite tun
page.Synthesize( null );
page.Export("D:\\sample.pdf", FREngine.FileExportFormatEnum.FEF_PDF, null);
}
```
Das ABBYY FineReader Engine-Distribution-Paket enthält das Beispiel [BatchProcessing](/de/fine-reader/engine/guided-tour/samples#batchprocessing), das zeigt, wie der Batch Processor verwendet wird, sowie das Demo-Tool [BatchProcessingRecognition](/de/fine-reader/engine/guided-tour/samples#batchprocessingrecognition), das den Geschwindigkeitsvorteil der Multiprocessing-Erkennung mit dem Batch Processor zeigt.
## Verarbeitung mit einem Pool von Engines
In diesem Multiprocessing-Szenario verwenden Sie mehrere Instanzen von Engine, die out-of-process geladen werden. Innerhalb jedes Worker-Threads kann das Verfahren nahezu genauso ablaufen wie bei der Verarbeitung mit nur einem einzigen Thread. Es wird jedoch empfohlen, eine benutzerdefinierte Bildquelle zu implementieren, die die Bilder mithilfe eines Synchronisierungsobjekts auf die Threads verteilt und sicherstellt, dass jedes Bild genau einmal verarbeitet wird.
Um das [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekt out-of-process zu laden, verwenden Sie das [OutprocLoader](/de/fine-reader/engine/api-reference/engine-loaders/outprocloader)-Objekt, das die [IEngineLoader](/de/fine-reader/engine/api-reference/engine-loaders/iengineloader)-Schnittstelle implementiert. Wenn Sie es mit speziellen Konten verwenden, sind möglicherweise Berechtigungen erforderlich, um OutprocLoader für diese Konten auszuführen.
```csharp theme={null}
// Erstellen Sie für jeden Thread ein separates OutprocLoader-Objekt und laden Sie eine Instanz von Engine
IEngineLoader engineLoader = new FREngine.OutprocLoader();
IEngine engine = engineLoader.InitializeEngine( customerProjectId, LicensePath, LicensePassword, "", "", false );
// Engine wurde in einem separaten Prozess geladen
try {
...
} finally {
engineLoader.ExplicitlyUnload(); // Sie kann entladen werden, wenn sie nicht mehr benötigt wird
engineLoader = null;
GC.Collect();
GC.WaitForPendingFinalizers();
}
```
Außerdem können Sie über die [IHostProcessControl](/de/fine-reader/engine/api-reference/engine-loaders/ihostprocesscontrol)-Schnittstelle die Priorität eines Hostprozesses verwalten und steuern, ob er noch aktiv ist.
* Kontoberechtigungen können mit dem Dienstprogramm DCOM Config eingerichtet werden (geben Sie entweder DCOMCNFG in die Befehlszeile ein oder wählen Sie Systemsteuerung > Verwaltung > Komponentendienste). Suchen Sie in der Konsolenstruktur den Ordner Komponentendienste > Computer > Arbeitsplatz > DCOM-Konfiguration, klicken Sie mit der rechten Maustaste auf ABBYY FineReader Engine 12.5 Loader (Local Server), und klicken Sie auf Properties. Ein Dialogfeld wird geöffnet. Klicken Sie auf die Registerkarte Security. Klicken Sie unter Launch Permissions auf Customize und dann auf Edit, um die Konten festzulegen, die die Anwendung starten dürfen.
Beachten Sie, dass auf einem 64-Bit-Betriebssystem die registrierte DCOM-Anwendung in der 32-Bit-MMC-Konsole verfügbar ist, die mit der folgenden Befehlszeile gestartet werden kann:
```
"mmc comexp.msc /32"
```
* Um `FREngine.dll` bei der Installation Ihrer Anwendung auf einem Computer des Endbenutzers zu registrieren, verwenden Sie das Dienstprogramm `regsvr32`. Wenn Sie ein 64-Bit-Betriebssystem verwenden, wird standardmäßig die 64-Bit-Version von `regsvr32` ausgeführt. Verwenden Sie die folgende Befehlszeile:
```csharp theme={null}
regsvr32 /s /n /i:"" ""
```
* Wenn Sie Engine als Out-of-Process-Server implementieren, legen Sie den sequenziellen Modus der Dokumentverarbeitung fest, indem Sie die Eigenschaft MultiProcessingMode des Objekts [MultiProcessingParams](/de/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) auf MPM\_Sequential setzen.
Das Distribution-Paket von ABBYY FineReader Engine enthält das Beispiel [EnginesPool](/de/fine-reader/engine/guided-tour/samples#enginespool), das den Geschwindigkeitsvorteil bei der Verwendung eines Pools von Engines zeigt und eine sofort einsatzbereite Implementierung bereitstellt, die als Ausgangspunkt für Ihre eigene Anwendung dienen kann. Ausführliche Informationen zur Implementierung einer benutzerdefinierten Bildquelle, zur Behandlung von Ausnahmen und zur Steuerung der CPU-Kernauslastung finden Sie im Quellcode dieses Beispiels.
## Siehe auch
[FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument)
[BatchProcessor](/de/fine-reader/engine/api-reference/batch-processor/batchprocessor)
[MultiProcessingParams](/de/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams)
[Dokumentseiten durchlaufen](/de/fine-reader/engine/guided-tour/advanced-techniques/iterating-document-pages)
[Verschiedene Möglichkeiten zum Laden des Engine-Objekts](/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine)
[Verwenden von ABBYY FineReader Engine in Multithread-Serveranwendungen](/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/using-in-server-applications)