Java에서 인스턴스 사용이 성능에 미치는 영향
, 에서는 어플리케이션의 .instanceof★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★instanceof이것은 다른 이야기이며, 이 질문은 순전히 퍼포먼스와 관련되어 있습니다.이치노같은 속도입니다.==
예를 들어 10개의 서브클래스가 있는 베이스 클래스가 있습니다.기본 클래스를 사용하는 단일 함수에서는 해당 클래스가 하위 클래스의 인스턴스인지 확인하고 몇 가지 루틴을 수행합니다.
이 문제를 해결하기 위해 생각한 다른 방법 중 하나는 "type id" 정수 프리미티브를 사용하는 것입니다. 비트 마스크를 사용하여 하위 클래스의 범주를 나타내는 비트 마스크와 하위 클래스의 "type id"를 비교하는 것입니다.
- 이 - 이 - 이 - 이 - 이 - 이- 이- 이- 이- 이- 이- 이- 이- 이- 이- 이- 이-instanceofJVM에 의해 최적화되어 그 이상의 속도를 얻을 수 있을까요?자바에 충실하고 싶지만 앱의 퍼포먼스가 중요합니다.전에 이 일을 해 본 적이 있는 사람이 조언을 해 준다면 멋질 것이다.너무 트집 잡거나 최적화할 수 있는 잘못된 것에 초점을 맞추고 있습니까?
접근
다양한 구현을 평가하기 위한 벤치마크 프로그램을 작성했습니다.
instanceof- 와 and class and and and and and and and and and and and and and an an an an an an an an an an an an an 를 통해 객체
@Override - 자체 유형 구현 사용
getClass() == _.class
jmh를 사용하여 100번의 웜업 호출, 1000번의 측정 중 반복 및 10번의 포크로 벤치마크를 실행했습니다.각 옵션을 10,000회 측정했는데, MacOS 10.12.4 및 Java 1.8이 설치된 MacBook Pro에서 전체 벤치마크를 실행하는 데 12:18:57이 소요됩니다.벤치마크는 각 옵션의 평균 시간을 측정합니다.자세한 내용은 GitHub에서의 구현을 참조하십시오.
완전성을 위해:이 답변에는 이전 버전과 벤치마크 버전이 있습니다.
결과.
| 동작 | 동작당 실행 시간(나노초) | 인스턴스 대비 ||------------|--------------------------------------|------------------------|| InstanceOF | 39,598 ± 0,022 ns/op | 100,00 % || GETCLASS | 39,687 ± 0,021 ns/op | 100,22 % || 타입 | 46,295 ± 0,026 ns/op | 116,91 % || OO | 48,078 ± 0,026 ns/op | 121,42 % |
dr;dr
1.8 1.8 우 ininstanceof 만,getClass()매우 가깝습니다.
최신 JVM/JIT 컴파일러는 인스턴스 처리, 예외 처리, 반영 등을 포함하여 기존의 "느린" 대부분의 작업에서 성능에 미치는 영향을 제거했습니다.
Donald Knuth는 "작은 효율은 잊어버려야 합니다. 예를 들어 97%의 경우 조기 최적화가 모든 악의 근원이라고 할 수 있습니다."라고 썼습니다.인스턴스의 퍼포먼스는 문제가 되지 않을 것입니다.그러므로 문제가 있다고 확신할 때까지 이국적인 회피책을 생각해 내는 데 시간을 낭비하지 마십시오.
instanceOf performance와 문자열 객체에 대한 단순한 s.equals() 호출을 비교하기 위해 간단한 테스트를 수행했습니다.
10.000.000 루프에서 instanceOf는 63~96밀리초, 문자열은 106~230밀리초입니다
java jvm 6을 사용했습니다.
따라서 간단한 테스트에서는 한 문자열 비교 대신 instanceOf를 실행하는 것이 더 빠릅니다.
문자열 대신 Integer의 .timeout()을 사용한 경우에만 동일한 결과를 얻을 수 있었습니다. == i를 사용한 경우에만 instanceOf(10.000.000 루프에서)보다 20ms 빨랐습니다.
퍼포먼스에 미치는 영향을 결정하는 항목은 다음과 같습니다.
- 연산자가 true를 반환할 수 있는 가능한 클래스 수
- 데이터 배포 - 대부분의 운영 인스턴스는 첫 번째 시도 또는 두 번째 시도에서 해결됩니까?진정한 운영으로 돌아갈 가능성이 가장 높은 부분을 우선시해야 합니다.
- 전개 환경Sun Solaris VM에서 실행하는 방법은 Sun의 Windows JVM과 크게 다릅니다.Solaris 는 디폴트로 「서버」모드로 동작하는 한편, Windows 는 클라이언트 모드로 동작합니다.Solaris 에서의 JIT 최적화에서는 모든 메서드액세스가 동일하게 됩니다.
4가지 디스패치 방법용 마이크로벤치마크를 작성했습니다.Solaris의 결과는 다음과 같습니다.작은 쪽이 고속입니다.
InstanceOf 3156
class== 2925
OO 3083
Id 3067
마지막 질문에 대한 답변:프로파일러가 알려주지 않는 한, 다음과 같은 경우에 터무니없이 많은 시간을 소비합니다.네, 트집 잡으시는군요.
최적화할 필요가 없었던 것을 최적화하는 것에 대해 고민하기 전에, 다음과 같이 하십시오.가장 읽기 쉬운 방법으로 알고리즘을 작성하고 실행합니다.jit-compiler가 스스로 최적화할 수 있을 때까지 실행해 주세요.이 코드에 문제가 있는 경우 프로파일러를 사용하여 가장 큰 이점을 얻을 수 있는 장소와 최적화를 지시합니다.
컴파일러가 고도로 최적화되는 시기에는 병목현상에 대한 추측이 완전히 틀릴 수 있습니다.
그리고 이 답변의 진정한 정신은 다음과 같습니다.jit-instance of과 ==의 인스턴스가 최적화될 수 있는 기회를 얻었을 때 어떤 관계가 있는지 전혀 알 수 없습니다.
까먹었어:첫 번째 주행은 측정하지 마십시오.
같은 질문을 받았습니다만, 제 경우와 유사한 사용 사례에 대한 '퍼포먼스 메트릭'을 찾을 수 없었기 때문에 샘플 코드를 몇 가지 더 작성했습니다.하드웨어와 Java 6 및7에서는 instance of과 switch on 10mln 반복의 차이는 다음과 같습니다.
for 10 child classes - instanceof: 1200ms vs switch: 470ms
for 5 child classes - instanceof: 375ms vs switch: 204ms
따라서 instanceof는 매우 느립니다.특히 if-else-if 스테이트먼트의 수가 많은 경우 실제 어플리케이션 내에서는 차이가 거의 없습니다.
import java.util.Date;
public class InstanceOfVsEnum {
public static int c1, c2, c3, c4, c5, c6, c7, c8, c9, cA;
public static class Handler {
public enum Type { Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, TypeA }
protected Handler(Type type) { this.type = type; }
public final Type type;
public static void addHandlerInstanceOf(Handler h) {
if( h instanceof H1) { c1++; }
else if( h instanceof H2) { c2++; }
else if( h instanceof H3) { c3++; }
else if( h instanceof H4) { c4++; }
else if( h instanceof H5) { c5++; }
else if( h instanceof H6) { c6++; }
else if( h instanceof H7) { c7++; }
else if( h instanceof H8) { c8++; }
else if( h instanceof H9) { c9++; }
else if( h instanceof HA) { cA++; }
}
public static void addHandlerSwitch(Handler h) {
switch( h.type ) {
case Type1: c1++; break;
case Type2: c2++; break;
case Type3: c3++; break;
case Type4: c4++; break;
case Type5: c5++; break;
case Type6: c6++; break;
case Type7: c7++; break;
case Type8: c8++; break;
case Type9: c9++; break;
case TypeA: cA++; break;
}
}
}
public static class H1 extends Handler { public H1() { super(Type.Type1); } }
public static class H2 extends Handler { public H2() { super(Type.Type2); } }
public static class H3 extends Handler { public H3() { super(Type.Type3); } }
public static class H4 extends Handler { public H4() { super(Type.Type4); } }
public static class H5 extends Handler { public H5() { super(Type.Type5); } }
public static class H6 extends Handler { public H6() { super(Type.Type6); } }
public static class H7 extends Handler { public H7() { super(Type.Type7); } }
public static class H8 extends Handler { public H8() { super(Type.Type8); } }
public static class H9 extends Handler { public H9() { super(Type.Type9); } }
public static class HA extends Handler { public HA() { super(Type.TypeA); } }
final static int cCycles = 10000000;
public static void main(String[] args) {
H1 h1 = new H1();
H2 h2 = new H2();
H3 h3 = new H3();
H4 h4 = new H4();
H5 h5 = new H5();
H6 h6 = new H6();
H7 h7 = new H7();
H8 h8 = new H8();
H9 h9 = new H9();
HA hA = new HA();
Date dtStart = new Date();
for( int i = 0; i < cCycles; i++ ) {
Handler.addHandlerInstanceOf(h1);
Handler.addHandlerInstanceOf(h2);
Handler.addHandlerInstanceOf(h3);
Handler.addHandlerInstanceOf(h4);
Handler.addHandlerInstanceOf(h5);
Handler.addHandlerInstanceOf(h6);
Handler.addHandlerInstanceOf(h7);
Handler.addHandlerInstanceOf(h8);
Handler.addHandlerInstanceOf(h9);
Handler.addHandlerInstanceOf(hA);
}
System.out.println("Instance of - " + (new Date().getTime() - dtStart.getTime()));
dtStart = new Date();
for( int i = 0; i < cCycles; i++ ) {
Handler.addHandlerSwitch(h1);
Handler.addHandlerSwitch(h2);
Handler.addHandlerSwitch(h3);
Handler.addHandlerSwitch(h4);
Handler.addHandlerSwitch(h5);
Handler.addHandlerSwitch(h6);
Handler.addHandlerSwitch(h7);
Handler.addHandlerSwitch(h8);
Handler.addHandlerSwitch(h9);
Handler.addHandlerSwitch(hA);
}
System.out.println("Switch of - " + (new Date().getTime() - dtStart.getTime()));
}
}
instanceofCPU 사용.
가 「」인는, 「」라고 하는 것 같습니다X하고 있습니다instanceof을 사용하다
x instanceof X
==> x.getClass()==X.class
==> x.classID == constant_X_ID
주요 비용은 읽기입니다!
ifX에는 서브클래스가 로드되어 있어 읽기가 몇 개 더 필요합니다.이러한 서브클래스는 같은 장소에 배치되어 있기 때문에 추가 비용도 매우 저렴합니다.
좋은 소식입니다 여러분!
instanceof는 대부분의 실제 구현에서 단순한 동등한 구현보다 비용이 더 많이 들 것입니다(즉, instanceof가 정말로 필요한 구현에서는 위의 Demian과 마찬가지로 모든 초급 교과서처럼 일반적인 방법을 덮어쓰는 것으로 해결할 수 없습니다).
왜 그런 것일까요?몇 가지 기능(예를 들어 인터페이스 x, y 및 z)을 제공하는 여러 개의 인터페이스와 이러한 인터페이스 중 하나를 구현(또는 구현하지 않음)할 수 있는 조작 대상 개체가 있습니다.직접적이진 않아요예를 들어 다음과 같습니다.
w 확장 x
A는 w를 실장한다.
B는 A를 확장한다.
C는 B를 확장하고 y를 구현합니다.
D는 C를 확장하고 z를 구현합니다.
D의 인스턴스(객체 d)를 처리하고 있다고 가정합니다.컴퓨팅(d instance of x)에는 d.getClass()를 사용하고 구현된 인터페이스를 루프하여 ==에서 x로 되어 있는지 여부를 확인해야 하며, 그렇지 않은 경우 모든 상위 항목에 대해 재귀적으로 다시 확인해야 합니다.이 경우 해당 트리의 너비를 먼저 탐색하면 최소 8개의 비교 결과를 얻을 수 있습니다. y와 z가 아무것도 확장하지 않는다고 가정하면...
실제 파생 트리의 복잡도는 더 높을 수 있습니다.경우에 따라서는 사전에 d를 해결할 수 있으면 JIT가 대부분의 데이터를 최적화할 수 있습니다(모든 경우 x를 확장하는 인스턴스로). 그러나 실제로는 대부분의 시간 동안 이 트리를 통과합니다.
그것이 문제가 된다면 핸들러 맵을 사용하여 오브젝트의 구체적인 클래스와 처리를 하는 클로저를 링크하는 것이 좋습니다.트리 트래버설 단계를 삭제하여 직접 매핑을 클릭합니다.단, C.class에 핸들러를 설정했다면 위의 오브젝트 d가 인식되지 않도록 주의해 주십시오.
여기 내 2센트요, 도움이 됐으면 좋겠네요...
Instanceof는 매우 빠릅니다.이는 클래스 참조 비교에 사용되는 바이트 코드로 요약됩니다.루프에서 몇 백만 개의 인스턴스를 직접 확인해 보십시오.
instance of은 매우 효율적이기 때문에 성능이 저하되지 않습니다.그러나 인스턴스(instance)를 많이 사용하면 설계상의 문제가 발생합니다.
xClass == String.class를 사용할 수 있는 경우 이 속도가 더 빠릅니다.참고: 최종 수업에는 인스턴스가 필요하지 않습니다.
저는 jmh-java-benchmark-archetype: 2.21을 기반으로 퍼포먼스 테스트를 작성합니다.JDK는 openjdk이고 버전은 1.8.0_212입니다.테스트 머신은 mac pro.테스트 결과는 다음과 같습니다.
Benchmark Mode Cnt Score Error Units
MyBenchmark.getClasses thrpt 30 510.818 ± 4.190 ops/us
MyBenchmark.instanceOf thrpt 30 503.826 ± 5.546 ops/us
그 결과 getClass는 instanceOf보다 우수하며 이는 다른 테스트와 반대됩니다.하지만 왜 그런지 모르겠어요.
테스트 코드는 다음과 같습니다.
public class MyBenchmark {
public static final Object a = new LinkedHashMap<String, String>();
@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public boolean instanceOf() {
return a instanceof Map;
}
@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public boolean getClasses() {
return a.getClass() == HashMap.class;
}
public static void main(String[] args) throws RunnerException {
Options opt =
new OptionsBuilder().include(MyBenchmark.class.getSimpleName()).warmupIterations(20).measurementIterations(30).forks(1).build();
new Runner(opt).run();
}
}
일반적으로 이러한 경우(인스턴스가 이 기본 클래스의 서브클래스를 체크하고 있는 경우) "instanceof" 연산자가 눈살을 찌푸리게 되는 이유는 작업을 메서드로 이동하여 적절한 서브클래스로 덮어쓰는 것이 필요하기 때문입니다.예를 들어 다음과 같은 경우:
if (o instanceof Class1)
doThis();
else if (o instanceof Class2)
doThat();
//...
그것을 다음과 같이 대체할 수 있습니다.
o.doEverything();
다음으로 클래스 1에서 "doThis()"를 호출하고 클래스 2에서 "doThat()"을 호출하는 등의 방법으로 "doEverything()"을 구현합니다.
'instanceof'는 실제로 + 또는 -와 같은 연산자로, JVM 바이트 코드 명령이 있는 것으로 알고 있습니다.꽤 빠를 거예요.
어떤 객체가 서브글래스의 인스턴스인지 테스트하는 스위치가 있는 경우 설계를 수정해야 할 수 있습니다.서브클래스 고유의 동작을 서브클래스 자체에 푸시하는 것을 검토해 주십시오.
특정 JVM이 인스턴스를 어떻게 구현하는지 말하기 어렵지만 대부분의 경우 오브젝트는 구조체에 필적하고 클래스도 마찬가지이며 모든 오브젝트 구조에는 인스턴스인 클래스 구조에 대한 포인터가 있습니다.그래서 실제로 의 인스턴스는
if (o instanceof java.lang.String)
다음 C 코드만큼 빠를 수 있습니다.
if (objectStruct->iAmInstanceOf == &java_lang_String_class)
JIT 컴파일러가 배치되어 있고 적절한 작업을 수행한다고 가정합니다.
포인터에 접속하는 것만으로, 포인터가 가리키는 특정 오프셋으로 포인터를 취득해, 이것을 다른 포인터와 비교하는 것(기본적으로 32비트수의 테스트와 같음)을 생각하면, 조작은 매우 고속이라고 말할 수 있습니다.
그러나 JVM에 크게 의존할 필요는 없습니다.그러나 이것이 코드의 병목현상으로 판명될 경우 JVM 구현이 다소 미흡하다고 생각합니다.JIT 컴파일러가 없고 코드만 해석하는 경우에도 거의 순식간에 테스트 인스턴스를 만들 수 있습니다.
Demian과 Paul은 좋은 점을 언급하지만 실행할 코드의 위치는 데이터를 어떻게 사용하는지에 따라 달라집니다.
저는 다양한 용도로 사용할 수 있는 작은 데이터 오브젝트를 매우 좋아합니다.재정의(다형성) 방식을 따를 경우 개체는 "한 방향으로만" 사용할 수 있습니다.
여기서 패턴이...
방문자 패턴과 같이 이중 디스패치를 사용하여 각 오브젝트에 전달 자체를 "호출"하도록 요청할 수 있습니다. 이렇게 하면 오브젝트 유형이 해결됩니다.그러나 가능한 모든 하위 유형으로 "작업"할 수 있는 클래스가 필요합니다.
취급하는 서브타입별로 전략을 등록할 수 있는 전략 패턴을 사용하는 것을 선호합니다.이런 거 있잖아요.이는 정확한 타입 매칭에만 도움이 되지만 확장성이 있다는 장점이 있습니다.서드파티 컨트리뷰터는 독자적인 타입과 핸들러를 추가할 수 있습니다.(이는 새로운 번들을 추가할 수 있는 OSGi와 같은 동적 프레임워크에 적합합니다.)
이게 다른 아이디어에 영감을 주길...
package com.javadude.sample;
import java.util.HashMap;
import java.util.Map;
public class StrategyExample {
static class SomeCommonSuperType {}
static class SubType1 extends SomeCommonSuperType {}
static class SubType2 extends SomeCommonSuperType {}
static class SubType3 extends SomeCommonSuperType {}
static interface Handler<T extends SomeCommonSuperType> {
Object handle(T object);
}
static class HandlerMap {
private Map<Class<? extends SomeCommonSuperType>, Handler<? extends SomeCommonSuperType>> handlers_ =
new HashMap<Class<? extends SomeCommonSuperType>, Handler<? extends SomeCommonSuperType>>();
public <T extends SomeCommonSuperType> void add(Class<T> c, Handler<T> handler) {
handlers_.put(c, handler);
}
@SuppressWarnings("unchecked")
public <T extends SomeCommonSuperType> Object handle(T o) {
return ((Handler<T>) handlers_.get(o.getClass())).handle(o);
}
}
public static void main(String[] args) {
HandlerMap handlerMap = new HandlerMap();
handlerMap.add(SubType1.class, new Handler<SubType1>() {
@Override public Object handle(SubType1 object) {
System.out.println("Handling SubType1");
return null;
} });
handlerMap.add(SubType2.class, new Handler<SubType2>() {
@Override public Object handle(SubType2 object) {
System.out.println("Handling SubType2");
return null;
} });
handlerMap.add(SubType3.class, new Handler<SubType3>() {
@Override public Object handle(SubType3 object) {
System.out.println("Handling SubType3");
return null;
} });
SubType1 subType1 = new SubType1();
handlerMap.handle(subType1);
SubType2 subType2 = new SubType2();
handlerMap.handle(subType2);
SubType3 subType3 = new SubType3();
handlerMap.handle(subType3);
}
}
공연으로 다시 연락드리겠습니다.단, 문제(또는 문제의 결여)를 회피하는 방법은 인스턴스를 실행할 필요가 있는 모든 서브클래스에 대해 부모 인터페이스를 작성하는 것입니다.인터페이스는 instance of check를 수행해야 하는 서브클래스의 모든 메서드의 슈퍼세트가 됩니다.메서드가 특정 서브클래스에 적용되지 않는 경우 이 메서드의 더미 구현을 제공하기만 하면 됩니다.만약 내가 그 문제를 오해하지 않았다면, 나는 과거에 이런 식으로 문제를 해결했다.
최신 Java 버전에서는 단순한 메서드 호출로서 instance of operator가 더 빠릅니다.이것은 다음을 의미합니다.
if(a instanceof AnyObject){
}
다음과 같이 고속화:
if(a.getType() == XYZ){
}
또 하나는 다수의 인스턴스를 캐스케이드할 필요가 있는 경우입니다.getType()을 1회만 호출하는 스위치가 더 빠릅니다.
InstanceOf는 객체 지향 설계가 불량하다는 경고입니다.
현재 JVM은 instanceOf 자체가 성능 문제가 아니라는 것을 의미합니다.특히 핵심 기능을 많이 사용하고 있다면 디자인을 검토해야 할 때입니다.더 나은 설계로 리팩터링함으로써 성능(및 단순성/유지보수성)이 실제 instanceOf call에 소비되는 실제 프로세서 사이클보다 크게 향상됩니다.
아주 작은 간단한 프로그래밍의 예를 들겠습니다.
if (SomeObject instanceOf Integer) {
[do something]
}
if (SomeObject instanceOf Double) {
[do something different]
}
부실한 아키텍처는 SomeObject를 2개의 자녀 클래스의 부모 클래스로 하는 것이 좋습니다.각 자녀 클래스는 메서드(doSomething)를 덮어쓰고 코드는 다음과 같습니다.
Someobject.doSomething();
속도가 유일한 목표인 경우 int 상수를 사용하여 서브클래스를 식별하면 시간을 1밀리초 단축할 수 있습니다.
static final int ID_A = 0;
static final int ID_B = 1;
abstract class Base {
final int id;
Base(int i) { id = i; }
}
class A extends Base {
A() { super(ID_A); }
}
class B extends Base {
B() { super(ID_B); }
}
...
Base obj = ...
switch(obj.id) {
case ID_A: .... break;
case ID_B: .... break;
}
OOO의 디자인은 형편없지만 성능 분석 결과 이곳이 병목현상이 있는 것으로 나타났다면 그럴 수도 있습니다.제 코드에 따르면 디스패치 코드는 총 실행 시간의 10%가 소요되며, 이로 인해 총 속도가 1% 향상될 수 있습니다.
프로젝트의 성능 문제가 실제로 발생할 경우 측정/프로파일을 수행해야 합니다.가능하다면 재설계를 추천합니다.플랫폼의 네이티브 실장(C로 표기)을 능가하는 것은 없을 것입니다.이 경우 다중 상속도 고려해야 합니다.
구체적인 유형에만 관심이 있는 경우 맵 <클래스, 오브젝트> 등 관련 스토어를 사용할 수 있습니다.
최종 수업에는 인스턴스가 필요 없고 참조 평등만 사용할 수 있다는 Peter Lawrey의 노트에 대해서는 주의하세요!최종 클래스는 확장할 수 없지만 동일한 클래스 로더에 의해 로드된다는 보장은 없습니다.코드의 해당 섹션에 대해 실행 중인 클래스로더가 1개뿐이라고 확신하는 경우에만 x.getClass() == SomeFinal.class 또는 해당 ilk를 사용하십시오.
또한 열거형 접근 방식을 선호하지만 추상 기본 클래스를 사용하여 하위 클래스가 다음과 같이 구현하도록 강제할 수 있습니다.getType()방법.
public abstract class Base
{
protected enum TYPE
{
DERIVED_A, DERIVED_B
}
public abstract TYPE getType();
class DerivedA extends Base
{
@Override
public TYPE getType()
{
return TYPE.DERIVED_A;
}
}
class DerivedB extends Base
{
@Override
public TYPE getType()
{
return TYPE.DERIVED_B;
}
}
}
'인스턴스'는 걱정할 만큼 비용이 많이 들지 않는다는 이 페이지의 일반적인 컨센서스에 대한 반례를 제출할 가치가 있다고 생각했다.내부 루프에 (최적화를 위한 어떤 역사적 시도에서) 몇 가지 코드가 있다는 것을 알게 되었습니다.
if (!(seq instanceof SingleItem)) {
seq = seq.head();
}
여기서 SingleItem의 calling head()는 값을 변경하지 않고 반환합니다.코드 치환 방법
seq = seq.head();
269ms에서 169ms로 속도를 높일 수 있습니다.스트링에서 더블로의 변환 등 매우 무거운 일이 루프에서 발생하고 있습니다.물론 속도 향상은 연산자 인스턴스 자체를 제거하는 것보다 조건부 분기를 제거하는 것이 더 큰 원인일 수 있지만, 언급할 가치가 있다고 생각했습니다.
당신은 잘못된 것에 집중하고 있어요.instance of과 같은 것을 체크하는 다른 방법의 차이는 아마 측정조차 할 수 없을 것입니다.성능이 중요한 경우 Java가 잘못된 언어일 수 있습니다.주요 이유는 VM이 가비지를 수집하기로 결정할 때 제어할 수 없기 때문에 대규모 프로그램에서 CPU가 몇 초 동안 100%까지 걸릴 수 있습니다(MagicDraw 10은 이 경우에 매우 적합합니다).모든 컴퓨터를 제어할 수 있는 상태가 아니면 이 프로그램이 어떤 버전의 JVM에서 실행될지 장담할 수 없습니다.구형 컴퓨터에서는 큰 속도 문제가 있었습니다.작은 앱이라면 Java라면 괜찮겠지만, 데이터를 계속 읽고 폐기하고 있으면 GC가 기동하는 것을 알 수 있습니다.
언급URL : https://stackoverflow.com/questions/103564/the-performance-impact-of-using-instanceof-in-java
'source' 카테고리의 다른 글
| 다중 케이스 스테이트먼트 전환 (0) | 2022.12.24 |
|---|---|
| Java에서 열거할 Int를 캐스트합니다. (0) | 2022.12.24 |
| 1인당 및 연간 수익 계산 방법 (0) | 2022.12.12 |
| Java는 정수 언더플로와 오버플로우를 어떻게 처리하며 어떻게 확인합니까? (0) | 2022.12.12 |
| MySQL 1062 - 키 'PRIMAY'에 대한 항목 '0'이 중복 (0) | 2022.12.12 |