com.moon.core.lang.ref.ReferenceUtil Maven / Gradle / Ivy

Go to download
package com.moon.core.lang.ref;

import com.moon.core.lang.ThrowUtil;

import java.lang.ref.*;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.function.Supplier;

/**
 * @author moonsky
 */
public final class ReferenceUtil {

    private ReferenceUtil() { ThrowUtil.noInstanceError(); }

    /**
     * 返回引用的值，如果值为 null，则执行 supplier，并返回 supplier 的返回值
     * 当 supplier 的返回值本来就是 null 时，这儿用引用值为 null 判断并不严谨
     * 实际上用 isEnqueued 判断更为妥当，但 isEnqueued 只有在有队列的情况下，
     * 被回收之后才会为 true，否则无论是否被回收均为 false
     *
     * @param reference
     * @param supplier
     * @param 
     * @return
     */
    public static  T getOrDefault(Reference reference, Supplier supplier) {
        if (reference != null) {
            T ret = reference.get();
            if (ret != null) {
                return ret;
            }
        }
        return supplier.get();
    }

    public static  T getOrDefault(Reference reference, T defaultValue) {
        if (reference != null) {
            T ret = reference.get();
            if (ret != null) {
                return ret;
            }
        }
        return defaultValue;
    }

    public static  Reference ref(T data) { return weak(data); }

    public static  Reference ref(T data, ReferenceQueue queue) { return weak(data, queue); }

    public static  Reference weak(T obj) { return new WeakReference<>(obj); }

    public static  Reference weak(T obj, ReferenceQueue queue) {
        return new WeakReference(obj, queue);
    }

    public static  Reference soft(T obj) { return new SoftReference<>(obj); }

    public static  Reference soft(T obj, ReferenceQueue queue) {
        return new SoftReference(obj, queue);
    }

    public static  PhantomReference phantom(T data, ReferenceQueue queue) {
        return new PhantomReference(data, queue);
    }

    public static  WeakHashMap weakMap() { return new WeakHashMap<>(); }

    public static  WeakHashMap weakMap(int initCapacity) { return new WeakHashMap<>(initCapacity); }

    public static  WeakHashMap weakMap(Map m) { return new WeakHashMap<>(m); }

    public static  WeakHashMap manageMap() { return WeakMapManager.manage(weakMap()); }

    public static  WeakHashMap manageMap(int initCapacity) {
        return WeakMapManager.manage(weakMap(initCapacity));
    }

    public static  WeakHashMap manageMap(Map m) {
        return WeakMapManager.manage(weakMap(m));
    }
}