Supplier封装了获取值的功能,可以实现多种不同的获取值的方式,创建Supplier可以使用Suppliers类的静态方法来实现,该方法提供了多种获取值的方式,具体为:
该接口提供了get方法用于获取值,注意其中get方法并不能传递参数信息,所以如果需要传递参数信息的话则不适用该接口。
public interface Supplier<T> extends java.util.function.Supplier<T> {
T get();
}
该种调用方式为最简单的实现方式,在调用get
方法时会直接将传递的instance返回。
public static <T> Supplier<T> ofInstance(@Nullable T instance) {
return new SupplierOfInstance<T>(instance);
}
private static class SupplierOfInstance<T> implements Supplier<T>, Serializable {
final @Nullable T instance;
SupplierOfInstance(@Nullable T instance) {
this.instance = instance;
}
@Override
public T get() {
return instance;
}
}
该方法返回的Supplier
会通过传递的delegate
参数来获取值并缓存,之后再次调用get
方法时会直接将缓存中的值返回。
public static Supplier memoize(Supplier delegate) {
if (delegate instanceof NonSerializableMemoizingSupplier
|| delegate instanceof MemoizingSupplier) {
return delegate;
}
return delegate instanceof Serializable
? new MemoizingSupplier(delegate)
: new NonSerializableMemoizingSupplier(delegate);
}
// 具体的Supplier类
static class NonSerializableMemoizingSupplier implements Supplier {
volatile Supplier delegate; // 代理类
volatile boolean initialized; //记录是否已经获取过值了
@Nullable T value; //缓存的结果信息
NonSerializableMemoizingSupplier(Supplier delegate) {
this.delegate = checkNotNull(delegate);
}
@Override
public T get() {
// 根据initialized实现的双重检查
if (!initialized) {
synchronized (this) {
if (!initialized) {
T t = delegate.get(); // 只会在初始化的时候调用delegate的get方法一次
value = t;
initialized = true;
delegate = null; // 释放delegate 因为后面用不到了
return t;
}
}
}
return value;
}
}
该方法会根据指定的duration
和 unit
每隔指定时间调用delegate
的get
方法一次,相当于是定时刷新结果值。
public static Supplier memoizeWithExpiration(
Supplier delegate, long duration, TimeUnit unit) {
return new ExpiringMemoizingSupplier(delegate, duration, unit);
}
// 具体的ExpiringMemoizingSupplier实现
static class ExpiringMemoizingSupplier implements Supplier, Serializable {
final Supplier delegate; // 具体获取结果的代理类
final long durationNanos; // 刷新结果间隔的纳秒值
transient volatile @Nullable T value; // 缓存的结果信息
transient volatile long expirationNanos; // 0表示还没有初始化 否则表示下一次过期的时间
ExpiringMemoizingSupplier(Supplier delegate, long duration, TimeUnit unit) {
this.delegate = checkNotNull(delegate);
this.durationNanos = unit.toNanos(duration);
checkArgument(duration > 0, "duration (%s %s) must be > 0", duration, unit);
}
@Override
public T get() {
long nanos = expirationNanos;
long now = Platform.systemNanoTime();
if (nanos == 0 || now - nanos >= 0) {
synchronized (this) {
if (nanos == expirationNanos) { // 双重检查防止重复加载
T t = delegate.get();
value = t;
nanos = now + durationNanos;
expirationNanos = (nanos == 0) ? 1 : nanos;
return t;
}
}
}
return value;
}
}
该方法会以synchronized
的方式实现线程安全的调用,并且每次都会执行delegate的get方法来获取值。
public static Supplier synchronizedSupplier(Supplier delegate) {
return new ThreadSafeSupplier(delegate);
}
private static class ThreadSafeSupplier implements Supplier, Serializable {
final Supplier delegate;
ThreadSafeSupplier(Supplier delegate) {
this.delegate = checkNotNull(delegate);
}
@Override
public T get() {
synchronized (delegate) { // 基于synchronized实现的线程安全
return delegate.get(); // 每次都会调用get方法来获取值
}
}
}
每次获取值都会调用delegate
的get
方法,并且使用传递的function
对返回值进行处理。
public static Supplier compose(Function super F, T> function, Supplier supplier) {
return new SupplierComposition<>(function, supplier);
}
private static class SupplierComposition implements Supplier, Serializable {
final Function super F, T> function;
final Supplier delegate;
SupplierComposition(Function super F, T> function, Supplier delegate) {
this.function = checkNotNull(function);
this.delegate= checkNotNull(delegate);
}
@Override
public T get() {
return function.apply(delegate.get()); // 每次都会执行delegate的get方法并且使用function进行处理
}
}