如何解决我可以在运行时查询 lambda 函数的生命周期吗?
我知道 Java 编译器会根据上下文和闭包为 lambda 函数生成不同的类。当我接收 lambda 作为参数时(使用 Consumer<>
类),我可以知道参数的生命周期吗?
例如,我有以下 Observable
类,它保持对其观察的弱引用。
class Observable {
private final List<WeakReference<Consumer<Object>>> observables = new ArrayList<>();
private Object obj;
public Observable(Object obj){
this.obj = obj;
}
public void observe(Consumer<Object> cons){
this.observables.add(new WeakReference<>(cons));
}
public void set(Object obj){
this.obj = obj;
// notify observes
for(WeakReference<Consumer<Object>> cons : this.observables){
if(cons.get() != null)
cons.get().accept(this.obj);
// clearing the non-existing observes from the list is ommited for simplicity
}
}
}
现在我是这样使用的。
public class Main {
public static void main(String[] args) {
Object c = new Object();
Observable obs = new Observable(c);
new ContainingClass(obs);
obs.set(c);
System.gc();
obs.set(c);
}
}
代码只是创建了对象及其观察者,并创建了观察者的ContainingClass
(定义如下)。然后对象设置一次,垃圾收集器显式调用(因此创建的 ContainingClass 被删除)并再次设置对象。
现在,只要 lambda 是特定于实例的(引用 this 或其实例方法),它就只会被调用一次(因为它被 GC 销毁了)。
public class ContainingClass {
public ContainingClass(Observable obs){
obs.observe(this::myMethod);
}
private void myMethod(Object obj) {
System.out.println("Hello here");
}
}
public class ContainingClass {
private Object obj;
public ContainingClass(Observable obs){
obs.observe(obj -> {
this.obj = obj;
System.out.println("Hello here");
});
}
}
但是当 lambda 变为静态时,它会被调用两次,即使在 GC 之后也是如此。
public class ContainingClass {
public ContainingClass(Observable obs){
obs.observe((obj) -> System.out.println("Hello here"));
}
}
对这个 lambda 的引用永远不会被销毁,因此每次创建 ContainingClass
实例时都会添加为观察者。结果,它会一直卡在观察者中,直到程序结束。
有没有办法检测到这一点并至少显示一个警告,即永远不会删除 lambda?
我发现的一件事是,具有实例生命周期的 lambda 具有 arg$1
属性,因此我可以询问属性的数量。
public void observe(Consumer<Object> cons){
if(cons.getClass().getDeclaredFields().length == 0)
System.out.println("It is static lifetime lambda");
this.observables.add(new WeakReference<>(cons));
}
这是一种通用方法吗?可能会出现这种情况不起作用的情况吗?
解决方法
您的问题类似于this question,因此此处的答案也适用。
静态嵌套类有一个可以检查的标志:
Modifier.isStatic(clazz.getModifiers()) // returns true if a class is static,false if not
,
我认为一个很好的解决方案是@Olivier 提示的:您可以使用 remove
方法返回一个对象,该方法在调用时从列表中删除您的 Consumer
,如下例所示:
@FunctionalInterface
public interface Registration {
void remove();
}
class Observable {
private final List<Consumer<Object>> observables = new ArrayList<>();
private Object obj;
public Observable(Object obj) {
this.obj = obj;
}
public Registration observe(Consumer<Object> cons) {
this.observables.add(cons);
return () -> this.observables.remove(cons);
}
public void set(Object obj) {
[...]
}
}
另一种方法是检查 lambda 所属的类是否是静态的,正如@kutschkem 所建议的那样,但如果有好的选择,我不喜欢诉诸内省。
正如@shalk 已经指出的那样,依赖 WeakReference
来处理 GC 会导致不需要的行为,因为无法确保您的 Consumer
没有在某处被引用(可能是错误的)否则。
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。