성능에 미치는 영향을 사용하여 다른 Java
https://stackoverflow.com/questions/103564
-
01-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
일하고 있는 응용 프로그램에 대 한 디자인 방법을 포함한 매우 많이 사용 instanceof 연산자입니다.는 동안 내가 알기에는 OO 디자인은 일반적으로 피하려고 사용 instanceof, 은 다른 이야기와 이 질문은 순수한 성능과 관련이 있습니다.면이 어떤 성능에 영향을 미칩니까?은만큼 빨리 ==?
예를 들어,내가 기본 클래스와 서브 클래스 10.에서 단 하나 기능하는 기본 클래스,나는 검사에 대한 경우 클래스의 인스턴스의 서브 클래스고 일부는 루틴입니다.
나 다른 방법으로의 생각에는 이를 사용 유형"id"정수 primitive 대신 사용하고,비트 마스크를 나타내는 카테고리의 하위 클래스고 그냥 조금 마스크의 비교를 하위"type id"를 일정한 마스크를 나타내는 카테고리입니다.
가 instanceof 게 최적화되어 JVM 하는 것보다 빠를 수 있는?고 싶은 스틱을 자바이지만 성능 응용 프로그램의 중요합니다.멋진 것이라면 그 사람이 길을 하기 전에 제공할 수 있는 조언.내가 머리가 너무 많거나에 초점을 맞추고 잘못된 것을 최적화?
해결책
현대 JVM/JIC 컴파일러를 제거한 성능의 대부분의 전통적으로 느리게 작업을 포함하여 다른 예외 처리,반사,etc.
로 도널드 Knuth 썼다,"우리가 잊지에 대한 작은 효율성에 대해 말 97%시간의:조 최적화는 모든 악의 뿌리." 성능의 다른 아마도 문제가 되지 않습니다,그래서 당신의 시간을 낭비하지 말고 오는 이국적인 해결 방법이 될 때까지 당신은 확실하는 문제입니다.
다른 팁
접근법
내가 쓴 벤치마크 프로그램 을 평가하는 서로 다른 구현:
instanceof구현(참조)- 객체 지향 통해 추상 클래스고
@Override테스트 방법 - 를 사용하여 자신의 유형 구현
getClass() == _.class구현
내가 사용하는 jmh 를 실행하는 벤치마크 100 워밍업 통화,1000 에서 반복 측정,10 포크.그래서 각 옵션으로 측정되었 10 000 시간이 소요 12:18:57 를 실행하는 벤치마크 전체에서 맥북 프로 macOS10.12.4 및 Java1.8.벤치마크 평균 시간을 측정합의 각 옵션입니다.자세한 내용을 참조하십시오 내 구현 on GitHub.
완전성을 위해:가 이전 버전의 이 대답하고 나의 벤치 마크.
결과
| Operation | Runtime in nanoseconds per operation | Relative to instanceof | |------------|--------------------------------------|------------------------| | INSTANCEOF | 39,598 ± 0,022 ns/op | 100,00 % | | GETCLASS | 39,687 ± 0,021 ns/op | 100,22 % | | TYPE | 46,295 ± 0,026 ns/op | 116,91 % | | OO | 48,078 ± 0,026 ns/op | 121,42 % |
tl;박사
Java1.8 instanceof 는 가장 빠른 방식이지만, getClass() 는 매우 가까운 거리에 있습니다.
나는 그냥 단순한 테스트하십시오 얼마나 다른 성능 비교하는 간단하 s.equals()호출 문자열체만으로는 하나의 글자가 있다.
에 10.000.000 루 instanceOf 준 63-96ms,그리고 문자열을 같게 106-230ms
내가 사용하는 java jvm6.
그래서에는 간단한 시험이 빠르게 해 다른 대신 하나의 문자열이 비교입니다.
를 사용하여 정수이다.equals()신의 문자열의 나에게 동일한 결과,경우에만 사용==나보다 더 빨리 다른 의 20ms(에 10.000.000loop)
항목하는 것이 성능에 미치는 영향을 확인다:
- 의 수는 가능한 클래스에 대한 다른 연산자를 반환 할 수 있습니다 사실
- 의 분포 데이터의 대부분의 다른 작업에서 해결 번 또는 두 번째 시도는?추가할 수 있습니다 당신의 가장으로 돌아갈 가능성이 진정한 작업을 처음이다.
- 배포 환경입니다.에서 실행되 Sun Solaris VM 는 것보다 상당히 다양의 윈도우 JVM.Solaris 에서 실행됩니다'서버의'모드에 의해 기본적으로 윈도우에서 실행됩니다 클라이언트 모드이다.JIT 최적화 Solaris 에서 모든 방법에 액세스할 수 있 같습니다.
성 microbenchmark 는 네 개의 다른 방법을 파견.결과에서 Solaris 은 다음과 같습니다,함께 작은 숫자는 빠르게:
InstanceOf 3156
class== 2925
OO 3083
Id 3067
에 응답하는 마지막 질문:지 않는 프로파일러 알려주고,당신을 보내고 말도 많은 양의 시간에서 instanceof:예,당신은 머리.
기에 대해 궁금해를 최적화하는 뭔가가 필요하지 않 최적화:쓰 알고리즘에서 읽을 수 있는 방법을 실행합니다.실행될 때까지 jit 컴파일러를 얻을 최적화 할 수있는 기회 그 자체입니다.는 경우 다음 문제가 있으로 이 조각의 코드를 사용하여 프로파일러를 당신에게,어디를 얻기 위해 가장 최적화이다.
의 시간에 고도로 최적화하는 컴파일러,추측에 대한 병목 현상이 될 가능성이 완전히 잘못입니다.
고에서 진정한 성령의 이 대답은(I wholeheartly 믿):나는 절대적으로 알 수 없는 방법 instanceof 및==와 관련되면 jit 컴파일러 기회가 있어 그것을 최적화합니다.
내가 잊:지 않을 측정합니다.
가 동일한 질문을하지만,때문에 내가 찾지 못한 성능 메트릭을 위해'사용할 경우 비슷하는 광산,나는 몇 가지 더 많은 예제 코드입니다.에 내 하드웨어 및 Java6&7,의 차이 다른와 스위치에서 반복 10mln
for 10 child classes - instanceof: 1200ms vs switch: 470ms
for 5 child classes - instanceof: 375ms vs switch: 204ms
그래서,다른 것은 정말로 느린,특히 거대한 숫자의한 경우-다른 문 경우,그러나 그 차이점은 무시됩니다 내에서 실제 응용 프로그램입니다.
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()));
}
}
instanceof 이 정말 빠르고,단지 몇 가지 CPU 다.
분명히는 경우,클래스 X 가 없 하위 클래스로드(JVM 알고), instanceof 최적화할 수 있습니다면:
x instanceof X
==> x.getClass()==X.class
==> x.classID == constant_X_ID
주요한 비용은 단지 읽기!
는 경우 X 가 서브 클래스 로드,몇 가지 더 읽은 필요합니다;그들은 가능성이 있는 위치도 추가 비용은 매우 낮은 너무입니다.
좋은 소식을 모두!
instanceof 될 것 보다 더 많은 비용이 많이 드는 간단한 동이 가장 실제 구현을(즉,다른 사람은 정말 필요한과할 수 없습니다 단지 그것을 해결하는 재정의하여 일반적인 방법과 같은 모든 초급 교재뿐만 아니라 데미안은 위의 제안).
그 이유는 무엇입니까?무엇 때문에 아마이 일어날 것은 당신이 몇 가지 인터페이스를 제공하는 몇 가지 기능(예,인터페이스 x,y,z),일부 개체를 조작할 수 있는(또는)구현하는 하나의 인터페이스...직접 사용할 수는 없습니다.예를 들어,내가:
w 것이다:x
A 을 구현합 w
B 확장
C B 확장,구현하 y
D 것이다:C,구현 z
가정 내가 처리하는 인스턴스의 D,개체 d.컴퓨팅(d instanceof x)이 필요하 d.getClass(),루프 인터페이스를 통해 그것을 구현하는지 여부를 알고 하나==x,그리고 그렇게하지 않을 경우 다시 재귀적으로 모든 그들의 조상의...우리의 경우,당신이 할 경우,폭넓은 최초의 탐험 그 나무,수익률이 적어도 8 비교,기 y,z 축을 확장하지 마세요 아무것도...
의 복잡성을 실제 파생 트리가 될 가능성이 높습니다.어떤 경우에,JIT 최적화할 수 있습니다 그것의 대부분의 경우는 거리에 해결할 수 없는 사전에 d 되는 것으로,가능한 모든 경우의 인스턴스가 확장되는 x.현실적으로,그러나,당신이 통하는 나무동의 대부분의 시간입니다.
는 경우는 문제가 되는 것이 좋을 사용하여 처리기 지도를 대신,연결 콘크리트 클래스의 객체를 폐쇄는 않습니다.그것을 제거 트리 순회상의 찬성에 직접 매핑을 사용합니다.그러나,주의하는 경우 설정에 대한 처리기 C.class 내체 위 d 인식되지 않습니다.
여기에는 제 2 센트,나는 그들 도움말...
'다른'는 실제로는 연산자는,다음과 같+또는-그리고 그것은 그것의 자신의 JVM 바이트 코드는 명령입니다.그것이 있어야 많이 빠릅니다.
내가 해야하지 않는 경우에 당신은 스위치를 테스트하는 경우 객체를 인스턴스의 일부 subsclass,다음 당신의 디자인해야 할 수 있습니다.밀어 고려 하위 클래스-특정한 행동으로 아래 하위 자체.
Instanceof 가 매우 빠릅니다.귀결하는 바이트 코드는 데 사용되는 클래스에 대한 참조는 비교입니다.려고 몇 백만 instanceofs 루프에서 자신에 대한 참조하십시오.
데미안과 바울이 언급하는 좋은점; 그러나, 의 코드를 실행하느냐에 따라 달라 어떻게 당신이 원하는 데이터를 사용하여...
나의 작은 데이터를 객체에 사용할 수 있는 많은 방법이 있습니다.을 따르는 경우는 재정의(다형)접근,당신의 개체만 사용할 수 있습니다"하나의 방법".
이것은 어디에서...
당신이 사용할 수 있는 더블 디스패치(로에 방문 패턴)요청하는 각 개체를"전화"통과 자체--이 해결됩니다 유형의 개체입니다. 그러나 (다)당신은 클래스가 필요할 수 있는"물건을"으로 가능한 모든 하위.
내가 사용하는 것을 선호하는 전략 패턴,등록 할 수 있습니다 전략에 대한 각 하위 당신이 원하는 처리합니다.가는 다음과 같습니다.이것은 단지는 데 도움이에 대한 정확한 유형은 일치하지만,이점이 있는 확장 가능-타사 참여자를 추가할 수 있는 자신의 유형 및 처리기입니다.(이것은 좋은 위한 동적인 프레임워크는 다음과 같 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);
}
}
instanceof 은 매우 효율적이,그래서 당신의 성능을 가능성이 고통 받고 있습니다.그러나,많이 사용하여 다른 건의 디자인 문제입니다.
는 경우 사용할 수 있습 xClass==String.class 이가 빠릅니다.참고:당신이 필요가 없는 다른 대한 최종 클래스입니다.
그것은 말하기 어렵게 특정한 JVM 을 구현하의 인스턴스가 있지만,대부분의 경우 객체를 비교하는 구조체와 수업뿐만 아니라 모든 개체 구조체에 대한 포인터가 있는 클래스 구조체를 인스턴스의.그래서 실제로는 다른 대
if (o instanceof java.lang.String)
수도 있으로 빠른 속도로 다음과 같은 C 코드
if (objectStruct->iAmInstanceOf == &java_lang_String_class)
고 가정하면 JIT 컴파일러가 장소에서는 괜찮은 직업입니다.
을 고려하는 것 이것은에 액세스 포인터를 받고,포인터에서 특정 오프셋 포인터와 비교하는 이 포인터는(기본적으로 동일 테스트~32 비트 숫자가 동일),나는 말을 운영할 수 있는 실제로 매우 빠르다.
그것은 필요가 없지만,그것에 많 JVM.그러나는 경우,이 될 것을 병목 현상에서 동작하는 코드,나는 고려한 JVM 을 구현하시기 바랍니다.심지어 하나가 없는 JIT 컴파일러와만 해석해야 하는 코드를 할 수 있는 다른 테스트에서는 거의 없습니다.
InstanceOf 경고 가난한 객체 지향적 디자인.
현재 Jvm 을 의미한다 instanceOf 하의 성능을 걱정합니다.당신은 자신을 찾는 그것을 사용하는 많은,특히 핵심 기능,그것을 가능하게 시간을 보면 디자인이다.성능(과 단순성/유지보수)의 이익 refactoring 더 나은 디자인 것보다 실제적인 프로세서 사이클에서 보낸 실제 instanceOf 전화입니다.
매우 작은 단순한 프로그래밍 예입니다.
if (SomeObject instanceOf Integer) {
[do something]
}
if (SomeObject instanceOf Double) {
[do something different]
}
가난한 건축 더 나은 선택을 위한 것이었을 것입 SomeObject 부모의 클래스 두 아동 클래스가 각각 아동 클래스를 재정의하는 방법(doSomething)이 코드는 이와 같:
Someobject.doSomething();
나는 당신을 다시 얻을에서 다른 성능입니다.그러나 방법으로 문제를 방지하기 위해(또는 그 부족)모두를 만드는 것이 부모 인터페이스는 모든 서브 클래스에있는 당신이해야 할 instanceof.인터페이스는 수정 모든 는 방법에 하위 클래스에 대한 할 필요가 있는 다른 확인합니다.는 방법에게는 적용되지 않는 특정 서브 클래스는 단순히 제공하는 더미의 구현에 이 방법입니다.지 않은 경우 오해하는 문제점,이 방법이 이 문제는 과거에.
일반적으로는 이유는"다른"연산자입니다 frowned 같은 경우에는(여기서 다른 검사에 대한 서브 클래스의 이 기본 클래스)이기 때문에 당신은 무엇을 해야 하는 이동 작업으로 방법 및 overridding 그에 대한 해당 서브 클래스.예를 들어 있는 경우:
if (o instanceof Class1)
doThis();
else if (o instanceof Class2)
doThat();
//...
대체할 수 있는
o.doEverything();
다음의 구현"doEverything()"에 Class1call"doThis()",그리고 Class2call"doThat()",그리고.
현대 Java 버전을 다른 연산자는 빠르게 간단한 방법으로 호출합니다.이는 다음을 의미합니다.
if(a instanceof AnyObject){
}
로 빠르게:
if(a.getType() == XYZ){
}
다른 것은 필요하신 경우에는 폭포가 많 instanceof.다음 스위치 단지 전화 번 getType()빠릅니다.
는 경우 속도는 당신의 유일한 목표는 다음을 사용하여 int 상수를 식별하는 서브 클래스는 것 면도 시간을 밀리초 단위
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;
}
끔찍한 OO 디자인,하지만 당신의 성능 분석이 나타냅니다 이것은 당신이 병목 현상은 어쩌면.내 코드는 디스패치 코드는 소액의 10%행 시간이 어쩌면에 기여하는 1%총 속도 개선합니다.
나는 성능 테스트를 작성 기반으로 jmh-java 벤치마-원형:2.21.JDK 는 소프트웨어 및 버전은 1.8.0_212.테스트 기계 mac 프로입니다.테스트 결과는:
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();
}
}
측정해야 합/프로필이면 그것은 정말 성능 문제에서 귀하의 프로젝트입니다.는 경우 그것은 내가 권하고 싶 재설계-가능한 경우.나는 확신을 이길 수 없는 플랫폼의 기본 구현(서면에서 C).도 고려해야 합니다 여러 상속 이 경우.
에게 말해야 합 더 문제에 대하여,어쩌면 당신이 사용할 수 있는 연관 스토어,예를 들어,지도<Class, Object=""> 는 경우에만 관심이 있는 콘크리트 형식입니다.
과 관련하여 피터 Lawrey 의 참고할 필요가 없는 다른 대한 최종 클래스고 사용할 수 있는 평등한 참조하십시오.지막 클래스를 확장할 수 없습니다,그들은 보장하지 않으로 동일한 agent.만 사용하 x.getClass()==SomeFinal.class 또는 그것의 읽는 경우에 당신은 절대적으로 긍정적인 거기에 하나의 클래스 로더에서 플레이 해당 섹션의 코드입니다.
나는 또한 선호에 열거형 접근 방식이지만 내가 사용하여 추상적인 기본 클래스를 강제로 서브 클래스를 구현하는 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 반환 값은 변경되지 않습니다.대체 코드
seq = seq.head();
나에게는 속도에서 269ms 을 169ms 는 사실에도 불구하고,거기에 몇 가지 아주 무거운 일들이 일어나고,루프에서 같은 문자열을 두 배 변환입니다.그것은 물론 가능하는 경우 속도가 더해를 제거하는 조건점 이상을 제거하고 다른 운영자는 자체;하지만 제 생각에 그것을 언급 할 가치가있다.
당신에 초점을 맞추고 잘못된 것입니다.의 차이 다른와는 다른 방법을 확인하는 동일한 것은 아마도 되지 않을 측정합니다.면 성능이 중요한 다 Java 은 아마 잘못된 언어입니다.주요한 이유는 당신이 통제할 수 없는 경우 VM 하기로 결정해 가고 싶은 쓰레기를 수집,취할 수 있는 CPU 에 100%몇 초안에 큰 프로그램(MagicDraw10 한다).지 않는 한 당신의 제어에 있는 모든 컴퓨터 프로그램에서 실행할 수 없습니다 보장하는 버전의 JVM 에있을 것입니다,그리고 많은 나이가 들었다 중요한 속도가 문제입니다.는 경우 그것은 작은 응용 프로그램될 수 있습으로 확인 Java,하지만 당신은 끊임없이 읽고 폐기 데이터를 다음 이 을 때는 알 GC 있습니다.
