Java中的强引用，软引用，弱引用，虚引用有什么用？

static class Entry extends WeakReference<ThreadLocal>
{
     /* The value assocaiated with this ThreadLocal.*/
    Object value;
    Entry(ThreadLocal k,Object v)
    {
        super(k);
        value = v;
    }
}

public Method getMethod(String name, Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException {
        // be very careful not to change the stack depth of this
        // checkMemberAccess call for security reasons
        // see java.lang.SecurityManager.checkMemberAccess
        checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
        Method method = getMethod0(name, parameterTypes);
        if (method == null) {
            throw new NoSuchMethodException(getName() + "." + 
            name + argumentTypesToString(parameterTypes));
        }
        return method;
    }

  private Method getMethod0(String name, Class<?>[] parameterTypes) {
        // Note: the intent is that the search algorithm this routine
        // uses be equivalent to the ordering imposed by
        // privateGetPublicMethods(). It fetches only the declared
        // public methods for each class, however, to reduce the
        // number of Method objects which have to be created for the
        // common case where the method being requested is declared in
        // the class which is being queried.
        Method res;
        // Search declared public methods
        if ((res = searchMethods(privateGetDeclaredMethods(true),
                                 name,
                                 parameterTypes)) != null) {
            return res;
        }
        // Search superclass's methods
        if (!isInterface()) {
            Class<? super T> c = getSuperclass();
            if (c != null) {
                if ((res = c.getMethod0(name, parameterTypes)) != null) {
                    return res;
                }
            }
        }
        // Search superinterfaces' methods
        Class<?>[] interfaces = getInterfaces();
        for (int i = 0; i < interfaces.length; i++) {
            Class<?> c = interfaces[i];
            if ((res = c.getMethod0(name, parameterTypes)) != null) {
                return res;
            }
        }
        // Not found
        return null;
    }

/**
 * 获取类中声明方法的具体实现
 * @param publicOnly 是否只获取public方法
 * @return 方法数组
 */
private Method[] privateGetDeclaredMethods(boolean publicOnly) {
    // 等待系统内部类初始化完成，系统属性(sun.reflect.noCaches)被解析完成
    checkInitted();
    Method[] res = null;
    // 根据用户指定的系统属性sun.reflect.noCaches值来决定是否使用缓存，默认使用缓存
    if (useCaches) {
        // 清空缓存，将缓存的declaredFields、declaredMethods、annotations等设置为null
        clearCachesOnClassRedefinition();
        // 如果只获取public方法
        if (publicOnly) {
            // 如果declaredPublicFields缓存可用，则直接从缓存中获取
            if (declaredPublicMethods != null) {
                res = (Method[]) declaredPublicMethods.get();
            }
        } else {
            // 如果declaredMethods缓存可用，则直接从缓存中获取
            if (declaredMethods != null) {
                res = (Method[]) declaredMethods.get();
            }
        }
        if (res != null) return res;
    }
    // 不使用缓存，则需要调用本地方法进行获取
    res = getDeclaredMethods0(publicOnly);
    // 如果可以使用缓存，则设置缓存，以备下次使用
    if (useCaches) {
        if (publicOnly) {
            declaredPublicMethods = new SoftReference(res);
        } else {
            declaredMethods = new SoftReference(res);
        }
    }
    return res;
}

if(publicOnly){
// 如果declaredPublicFields缓存可用，则直接从缓存中获取
if(declaredPublicMethods != null){
                res =(Method[]) declaredPublicMethods.get();
}
}else{
// 如果declaredMethods缓存可用，则直接从缓存中获取
if(declaredMethods != null){
                res =(Method[]) declaredMethods.get();
}
}