public Result()
{
base.\u002Ector();
Result result = this;
this.fCount = new AtomicInteger();
this.fIgnoreCount = new AtomicInteger();
this.fFailures = Collections.synchronizedList((List) new ArrayList());
this.fRunTime = 0L;
}
public int computeItemSimilarities(int degreeOfParallelism, int maxDurationInHours, SimilarItemsWriter writer)
{
ExecutorService executorService = Executors.newFixedThreadPool(degreeOfParallelism + 1);
Output output = null;
try {
writer.open();
DataModel dataModel = getRecommender().getDataModel();
BlockingQueue<long[]> itemsIDsInBatches = queueItemIDsInBatches(dataModel, batchSize);
BlockingQueue<List<SimilarItems>> results = new LinkedBlockingQueue<List<SimilarItems>>();
AtomicInteger numActiveWorkers = new AtomicInteger(degreeOfParallelism);
for (int n = 0; n < degreeOfParallelism; n++) {
executorService.execute(new SimilarItemsWorker(n, itemsIDsInBatches, results, numActiveWorkers));
}
output = new Output(results, writer, numActiveWorkers);
executorService.execute(output);
} catch (Exception e) {
throw new IOException(e);
} finally {
executorService.shutdown();
try {
bool succeeded = executorService.awaitTermination(maxDurationInHours, TimeUnit.HOURS);
if (!succeeded) {
throw new RuntimeException("Unable to complete the computation in " + maxDurationInHours + " hours!");
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
Closeables.close(writer, false);
}
return output.getNumSimilaritiesProcessed();
}
SimilarItemsWorker(int number, BlockingQueue<long[]> itemIDBatches, BlockingQueue<List<SimilarItems>> results,
AtomicInteger numActiveWorkers) {
this.number = number;
this.itemIDBatches = itemIDBatches;
this.results = results;
this.numActiveWorkers = numActiveWorkers;
}
Output(BlockingQueue<List<SimilarItems>> results, SimilarItemsWriter writer, AtomicInteger numActiveWorkers) {
this.results = results;
this.writer = writer;
this.numActiveWorkers = numActiveWorkers;
}