dagger.internal.DoubleCheck Maven / Gradle / Ivy
Show all versions of dagger Show documentation
/*
* Copyright (C) 2016 The Dagger Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package dagger.internal;
import static dagger.internal.Preconditions.checkNotNull;
import dagger.Lazy;
import javax.inject.Provider;
/**
* A {@link Lazy} and {@link Provider} implementation that memoizes the value returned from a
* delegate using the double-check idiom described in Item 71 of Effective Java 2.
*/
public final class DoubleCheck implements Provider, Lazy {
private static final Object UNINITIALIZED = new Object();
private volatile Provider provider;
private volatile Object instance = UNINITIALIZED;
private DoubleCheck(Provider provider) {
assert provider != null;
this.provider = provider;
}
@SuppressWarnings("unchecked") // cast only happens when result comes from the provider
@Override
public T get() {
Object result = instance;
if (result == UNINITIALIZED) {
synchronized (this) {
result = instance;
if (result == UNINITIALIZED) {
result = provider.get();
/* Get the current instance and test to see if the call to provider.get() has resulted
* in a recursive call. If it returns the same instance, we'll allow it, but if the
* instances differ, throw. */
Object currentInstance = instance;
if (currentInstance != UNINITIALIZED && currentInstance != result) {
throw new IllegalStateException("Scoped provider was invoked recursively returning "
+ "different results: " + currentInstance + " & " + result + ". This is likely "
+ "due to a circular dependency.");
}
instance = result;
/* Null out the reference to the provider. We are never going to need it again, so we
* can make it eligible for GC. */
provider = null;
}
}
}
return (T) result;
}
/** Returns a {@link Provider} that caches the value from the given delegate provider. */
// This method is declared this way instead of " Provider provider(Provider delegate)"
// to work around an Eclipse type inference bug: https://github.com/google/dagger/issues/949.
public static , T> Provider provider(P delegate) {
checkNotNull(delegate);
if (delegate instanceof DoubleCheck) {
/* This should be a rare case, but if we have a scoped @Binds that delegates to a scoped
* binding, we shouldn't cache the value again. */
return delegate;
}
return new DoubleCheck(delegate);
}
/** Returns a {@link Lazy} that caches the value from the given provider. */
// This method is declared this way instead of " Lazy lazy(Provider delegate)"
// to work around an Eclipse type inference bug: https://github.com/google/dagger/issues/949.
public static , T> Lazy lazy(P provider) {
if (provider instanceof Lazy) {
@SuppressWarnings("unchecked")
final Lazy lazy = (Lazy) provider;
// Avoids memoizing a value that is already memoized.
// NOTE: There is a pathological case where Provider may implement Lazy, but P and L
// are different types using covariant return on get(). Right now this is used with
// DoubleCheck exclusively, which is implemented such that P and L are always
// the same, so it will be fine for that case.
return lazy;
}
return new DoubleCheck(checkNotNull(provider));
}
}