关于Java：如果大量使用匿名内部类，它将对性能产生多大的影响？

java

How huge would anonymous inner class impact performance if it is heavily used?

===结论====

在https://softwareengineering.stackexchange.com/a/149569上找到了很好的读物，其中指出

当前的GC算法实际上已经过优化，可以创建许多寿命很短的小对象，
因此，我认为在项目中大量使用匿名内部类对于性能而言不是什么大事*

================================================ =======================

因为函数不是当前Java(Java7)中的第一类公民，所以使用匿名内部类似乎是实现完整异步应用程序的唯一方法。

我知道它将在某种程度上带来更大的内存占用和负担垃圾收集器，但是我不知道它有多严重？最近，我的同事与我争论，因为我的代码是通过利用匿名内部类以功能样式编写的，他的反对全部是关于性能的。尽管我不同意，但我无法举任何例子来证明自己。我知道groovy都使用匿名类来实现闭包，但是groovy的性能确实比Java差(当然，匿名应该只承担一部分责任，因为groovy也大量使用反射)。

所以我想知道在现实世界中，是否有任何项目会因为性能而放弃匿名类？像秋千这样的UI框架又如何呢？是否大量使用匿名类？

没有匿名，我无法想象如何在Java中优雅地实现异步。我们的项目已经使用了非常丑陋的方法来使类方法作为函数指针工作。我非常讨厌，并希望说服人们匿名上课是正确的方法。

我的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// basically, I use Completion interface to make normal java methods work in async manner

public interface Completion {
void success();

void fail(String reason);
}

void methodA(Completion completion) {

do_some_business_by_calling_remote_service ....

when remote_service_ack_success:
completion.success();
else:
completion.fail(remote_service_error);

}

void methodB() {
methodA(new Completion() {
public void success() {
continue to do something;
}

public void fail(String err) {
handle error
}
});
}

相关讨论

您能否提供一个示例，说明您如何使用匿名类，以及担心什么性能问题？
@ Dolda2000：查看我的更新
您不是第一个有此问题的人：StackOverflow-Java匿名类效率的含义
@ J.P .：不，不一样。您发布的线程的性能没有任何区别，因为使用匿名类或内部类无论如何都不会创建任何对象。我的情况不同，它为每个方法调用创建一个匿名对象，这在同步调用方式中是不必要的
@zx_wing观察javac的出现，在运行时未创建匿名内部类。它们的编译方式与其他内部类相同，不同的是，类名将由编译器它不会在每个方法调用上创建一个新类。
@TwilightSun：感谢您指出。实际上，我的意思是匿名对象。我更新了我的最新评论。
这个辩论性的问题可能会帮助您：stackoverflow.com/questions/2284396/…。我个人认为，内部阶级本身并不是邪恶的。 Java是一种与项目管理有关的语言，而不是与性能有关的语言。因此，如果匿名类和类似程序的功能可以帮助您使项目更加健壮和易于维护，请使用它。
@zx_wing没有"匿名对象"的概念
在Java中，如果要关注性能，请避免创建不必要的对象而不是类。迭代内置数组时，避免使用for(：)的foreach循环，因为它正在创建迭代器对象。避免使用基本类型的对象计数器部分(例如Integer或Boolean)，因为它们会创建对象。而且，等等，我对此的印象是，如果人们非常在乎性能，并尽最大的努力避免Java的馈赠，为什么不放弃Java而是使用C / C。
@TwilightSun：很好。我也将其用作辩论中的论点。
@minhcat_vo：是的，我知道。我只想描述从匿名类创建的对象
@TwilightSun当与数组一起使用时，对于每个都不会创建迭代器。它的编译几乎与常规for循环相同。对于每个对象，仅在与Iterable一起使用时才使用Iterator。
您的项目实现函数指针的当前方式是什么？
@NamSan：简而言之，它实际上是使用反射来调用方法。而不是传递匿名类，而是传递方法名称和参数
您可以确定，反射将比匿名类导致更多的性能下降。匿名类与普通私有内部类在性能上没有什么区别，因为它们基本上是同一回事。如果您不能消除对象实例化，内部类本身将不会导致任何性能下降。但是您必须注意，如果A将匿名对象的实例传递给B，并且B保留了该实例，那么B将引用A，因此，如果B仍处于活动状态，则不会垃圾回收A。
@TwilightSun是的，接口是一种比传递反射更好的"传递函数"的方法。引导时，反射也会创建一个对象。
伙计们，刚在程序员那里读了好书。stackexchange.com/ a / 149569
@zx_wing这是一个确定的答案，Java对象创建/ GC的确通常非常有效。这就是我的观点的基础。当然，您正在为每次调用创建一个新对象，但是语法可能更清晰。通常，除非可维护的代码实际上是一个问题，否则可维护性胜过优化。在这种情况下，它可以忽略不计。

这里基本上有两个问题，它们都与匿名性无关。匿名类与常规内部类实际上没有什么不同，只不过它们没有名称。匿名内部类被编译为常规内部类，而该内部类又与静态嵌套类实际上没有任何不同。

问题1是由于它们是内部的，因此它们保留对封闭类的引用：

1
2
3
4
5
6
7
8
9

class Outer {
interface Inner {}

Inner inner = new Inner() {
{
System.out.println(Outer.this);
}
};
}

这并不是什么大问题，大多数情况下并不是这样，因为您正在执行某些功能，并且希望在内部类中使用外部实例的成员。但是这可能会引起问题，因为只要内部类还活着，就不能对外部类进行垃圾回收。

问题2实际上是它们是一个对象，因此确实您的methodB每次被调用时都会创建一个新对象。

显而易见的解决方案是只创建一次：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class MyProcess {

final Completion myCompletion = new Completion() {
@Override
public void success() {}
@Override
public void fail(String err) {}
}

void methodA(Completion c) {}

void methodB() {
methodA(myCompletion);
}
}

尽管看起来您喜欢的是语法，但实际上并没有解决方案来保留语法并且不同时创建对象。

我的个人观点：如果您不经常调用此方法，我同意语法可以清晰易懂。如果您经常调用它，请切换到单个对象，因为您正在占用过多的存储空间。如果它被调用1000次，那就是1000个对象。对象大小因平台而异，但通常是指向外部实例的指针的最小8或16个字节。虽然影响不大，但是例如可以迅速运行垃圾收集，这可能导致微妙的停滞。

顺便说一句，我又在考虑这个问题，并想到了以下想法：

1
2
3
4
5
6
7
8
9
10
11

Completion myLazyCompletion;

void methodB() {
methodA(myLazyCompletion != null ? myLazyCompletion :
(myLazyCompletion = new Completion() {

// overrides

})
);
}

我会说不要这样做，但是我认为这很有趣。：)

相关讨论