Stop Method

 
import java.io.File; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.net.MalformedURLException; 
import java.net.URI; 
import java.net.URISyntaxException; 
import java.net.URL; 
import java.nio.file.Files; 
import java.nio.file.Paths; 
import java.util.ArrayList; 
import java.util.Calendar; 
import java.util.List; 
import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Future; 
import java.util.regex.Pattern; 
 
import org.junit.*; 
import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 
import static org.junit.Assert.*; 
 
import leadtools.*; 
import leadtools.annotations.engine.*; 
import leadtools.barcode.*; 
import leadtools.caching.*; 
import leadtools.codecs.*; 
import leadtools.document.*; 
import leadtools.document.DocumentMimeTypes.UserGetDocumentStatusHandler; 
import leadtools.document.converter.*; 
import leadtools.document.writer.*; 
import leadtools.ocr.*; 
 
 
public void documentMemoryCacheExample() { 
   // The cache we are using 
   FileCache cache = new FileCache(); 
   cache.setPolicySerializationMode(CacheSerializationMode.JSON); 
   cache.setDataSerializationMode(CacheSerializationMode.JSON); 
   cache.setCacheDirectory("c:\\cache-dir"); 
 
   // The document files we are using 
   String[] documentFiles = { 
         // PDF files are very fast to load and will not use memory cache 
         "C:\\LEADTOOLS23\\Resources\\Images\\leadtools.pdf", 
         // Large Excel files are complex and loading may take some time, they could use 
         // memory cache 
         "C:\\LEADTOOLS23\\Resources\\Images\\large_sheet_5k.xlsx", 
   }; 
 
   // First process without memory cache and obtain some times 
   loadAndProcessDocument(documentFiles, cache); 
 
   // Then process with memory cache 
 
   // Document memory cache options to use 
   DocumentMemoryCacheStartOptions documentMemoryCacheStartOptions = new DocumentMemoryCacheStartOptions(); 
   // Use for documents that take more than 2 seconds to load initially 
 
   documentMemoryCacheStartOptions.setMinimumLoadDuration(2); 
   // No maximum limit on the number of cache items to keep in memory 
   documentMemoryCacheStartOptions.setMaximumItems(0); 
   // Purse items from the cache if not touched for 60 seconds 
   documentMemoryCacheStartOptions.setSlidingExpiration(60); 
   // Check for expired items every 60 seconds 
   documentMemoryCacheStartOptions.setTimerInterval(60); 
 
   // Use it 
   DocumentFactory.getDocumentMemoryCache().start( 
         documentMemoryCacheStartOptions); 
 
   // Run again 
   // For the first document, times should be very close to the since this is a PDF 
   // document and is very fast (less than MinimumLoadDuration) 
   // For the second document, initial times should be the same, but loading all 
   // pages should be much faster 
   loadAndProcessDocument(documentFiles, cache); 
 
   // Clean up 
   DocumentFactory.getDocumentMemoryCache().stop(); 
} 
 
private static void loadAndProcessDocument(String[] documentFiles, 
      ObjectCache cache) { 
   System.out.println("Using memory cache is " + 
         DocumentFactory.getDocumentMemoryCache().isStarted()); 
   String[] documentIds = new String[documentFiles.length]; 
 
   long stopwatch = System.currentTimeMillis(); 
   long elapsed; 
 
   for (int i = 0; i < documentFiles.length; i++) { 
      String documentFile = documentFiles[i]; 
      int pageCount; 
 
      // First try without memory cache and obtain some times 
      stopwatch = System.currentTimeMillis(); 
      LoadDocumentOptions loadOptions = new LoadDocumentOptions(); 
      loadOptions.setCache(cache); 
      LEADDocument document = DocumentFactory.loadFromFile(documentFile, 
            loadOptions); 
      document.getImages().setMaximumImagePixelSize(2048); 
      document.setAutoSaveToCache(false); 
      document.setAutoDeleteFromCache(false); 
      document.saveToCache(); 
      documentIds[i] = document.getDocumentId(); 
      pageCount = document.getPages().size(); 
 
      elapsed = (System.currentTimeMillis() - stopwatch) / 1000; 
      System.out.println("Initial load from " + documentFile + " took ~" + elapsed + " seconds"); 
      // Check if it's in the cache 
      System.out.println("Is using memory cache is " 
            + DocumentFactory.getDocumentMemoryCache().hasDocument(documentIds[i], 
                  false)); 
 
      // Next call LoadFromCache and process a page in multiple threads 
      stopwatch = System.currentTimeMillis(); 
      loadAllPagesInThreads(documentIds[i], pageCount, cache); 
      elapsed = (System.currentTimeMillis() - stopwatch) / 1000; 
      System.out.println("Multi-threaded load of all pages took ~" + elapsed 
            + " seconds"); 
   } 
   // Clean up 
   deleteDocumentsFromCache(documentIds, cache); 
} 
 
private static void loadAllPagesInThreads(String documentId, int pageCount, ObjectCache cache) { 
   int maxDegreeOfParallelism = 4; 
   ExecutorService executorService = Executors.newFixedThreadPool(maxDegreeOfParallelism); 
   try { 
      // Create a list to hold the Future objects representing the processing of each 
      // page 
      List<Future<Void>> futures = new ArrayList<>(); 
      for (int pageNumber = 1; pageNumber <= pageCount; pageNumber++) { 
         final int currentPage = pageNumber; 
         // Submit each page processing task to the executor 
         Future<Void> future = executorService.submit(new Callable<Void>() { 
            @Override 
            public Void call() throws Exception { 
               // Load the document from the cache 
               LoadFromCacheOptions options = new LoadFromCacheOptions(); 
               options.setCache(cache); 
               options.setDocumentId(documentId); 
               LEADDocument document = DocumentFactory.loadFromCache(options); 
               DocumentPage documentPage = document.getPages().get(currentPage - 1); 
               RasterImage image = documentPage.getImage(); 
               return null; 
            } 
         }); 
         futures.add(future); 
      } 
      // Wait for all tasks to complete 
      for (Future<Void> future : futures) { 
         future.get(); 
      } 
   } catch (Exception e) { 
      e.printStackTrace(); 
   } finally { 
      // Shut down the executor service 
      executorService.shutdown(); 
   } 
} 
 
private static void deleteDocumentsFromCache(String[] documentIds, 
      ObjectCache cache) { 
   for (String documentId : documentIds) { 
      LoadFromCacheOptions loadOptions = new LoadFromCacheOptions(); 
      loadOptions.setCache(cache); 
      loadOptions.setDocumentId(documentId); 
      DocumentFactory.deleteFromCache(loadOptions); 
   } 
}