@Override @SuppressWarnings({"unchecked"}) public int getOrCreate(boolean o) { if (DependencyTracker.isBypassCaches()) { return calculatable.calculate(owner, o); } else { preCheckDirty(); lock(); try { Object v = load(o); if (v != UNDEFINED) { DependencyTracker.mark(getDependencyNode()); hit(); ExceptionHelper.throwIfExceptionRecordNotExpired(v); return (Integer) v; } DependencyNode callerNode = DependencyTracker.track(getDependencyNode()); try { while (true) { try { return create(o); } catch (ResourceOccupied e) { if (callerNode != null) { throw e; } else { unlock(); try { e.getResource().waitForEndOfModification(); } finally { lock(); } v = load(o); if (v != UNDEFINED) { hit(); ExceptionHelper.throwIfExceptionRecordNotExpired(v); return (Integer) v; } } } } } finally { DependencyTracker.exit(callerNode); } } finally { unlock(); postCheckDirty(); } } }
@SuppressWarnings({"unchecked"}) protected int create(boolean o) { long start = System.nanoTime(); try { int retry = 0; // retry on exception loop while (true) { try { int t = calculatable.calculate(owner, o); // successful invocation => just store the value and return save(o, t); return t; } catch (Exception e) { // We catch Exception here, but not Error and not Throwable. // this is because in case of Error we are likely have no chance even to save // an ExceptionRecord to a storage, so don't even try to do so. // For example in case of OOM (out of memory) it may be impossible to create // even a single new object. CacheExceptionHandler exceptionHandler = getDescriptor().getExceptionHandler(); switch (exceptionHandler.getAction(retry, e)) { case RETRY: retry++; continue; case REMEMBER_AND_RETHROW: save( o, new ExceptionRecord( e, exceptionHandler.getRememberExceptionExpirationTimestamp(e))); // fall through case RETHROW: default: // this method always throws an exception ExceptionHelper.throwCheckedExceptionHack(e); break; } } } } finally { // record calculation time even if calculation fails long end = System.nanoTime(); miss(end - start); } }