[java] Java 성능에서 예외의 영향은 무엇입니까?

예외가 어떻게 구현되는지에 달려 있습니다. 가장 간단한 방법은 setjmp 및 longjmp를 사용하는 것입니다. 즉, CPU의 모든 레지스터가 스택에 기록되고 (이미 시간이 걸린다) 다른 데이터를 만들어야 할 수도 있습니다.이 모든 것은 이미 try 문에서 발생합니다. throw 문은 스택을 해제하고 모든 레지스터의 값 (및 VM에서 가능한 다른 값)을 복원해야합니다. 따라서 try와 throw는 똑같이 느리고 꽤 느립니다. 그러나 예외가 발생하지 않으면 try 블록을 종료하는 데는 대부분의 경우 시간이 걸리지 않습니다 (메소드가 있으면 스택에 모든 것이 배치되므로 자동으로 정리됩니다).

썬과 다른 사람들은 이것이 차선책 일 수 있으며 물론 VM이 시간이 지남에 따라 더 빨라지고 빨라진다는 것을 인식했습니다. 예외를 구현하는 또 다른 방법이 있습니다. 실제로 빠르게 번개를 시도 할 수 있습니다 (실제로는 전혀 시도하지 않습니다-클래스가 VM에 의해로드 될 때 이미 필요한 모든 작업이 수행됨). . 어떤 새 JVM이이 새롭고 더 나은 기술을 사용하는지 모르겠습니다 …

…하지만 나중에 코드를 작성하여 특정 시스템의 하나의 JVM에서만 실행되도록 Java로 작성하고 있습니까? 다른 플랫폼이나 다른 JVM 버전 (다른 공급 업체의 경우)에서 실행될 수 있다면 누가 빠른 구현을 사용한다고 누가 말합니까? 빠른 것은 느린 것보다 복잡하고 모든 시스템에서 쉽게 가능하지는 않습니다. 휴대용 상태를 유지하고 싶습니까? 그렇다면 빠른 예외에 의존하지 마십시오.

또한 try 블록 내에서 수행하는 작업에 큰 차이를 만듭니다. try 블록을 열고이 try 블록 내에서 어떤 메소드도 호출하지 않으면 try 블록은 매우 빠릅니다. JIT는 실제로 간단한 던져처럼 던지기를 처리 할 수 ​​있기 때문입니다. 예외가 발생하면 스택 상태를 저장할 필요도없고 스택을 해제 할 필요도 없습니다 (캐치 처리기로만 이동하면 됨). 그러나 이것은 당신이 일반적으로하는 것이 아닙니다. 일반적으로 try 블록을 연 다음 예외가 발생할 수있는 메소드를 호출하십시오. 그리고 메소드 내에서 try 블록을 사용하더라도 다른 메소드를 호출하지 않는 어떤 종류의 메소드입니까? 그냥 숫자를 계산합니까? 그렇다면 예외가 무엇입니까? 프로그램 흐름을 조절하는 훨씬 더 우아한 방법이 있습니다. 단순한 수학 이외의 다른 것에는

다음 테스트 코드를 참조하십시오.

public class Test {
    int value;


    public int getValue() {
        return value;
    }

    public void reset() {
        value = 0;
    }

    // Calculates without exception
    public void method1(int i) {
        value = ((value + i) / i) << 1;
        // Will never be true
        if ((i & 0xFFFFFFF) == 1000000000) {
            System.out.println("You'll never see this!");
        }
    }

    // Could in theory throw one, but never will
    public void method2(int i) throws Exception {
        value = ((value + i) / i) << 1;
        // Will never be true
        if ((i & 0xFFFFFFF) == 1000000000) {
            throw new Exception();
        }
    }

    // This one will regularly throw one
    public void method3(int i) throws Exception {
        value = ((value + i) / i) << 1;
        // i & 1 is equally fast to calculate as i & 0xFFFFFFF; it is both
        // an AND operation between two integers. The size of the number plays
        // no role. AND on 32 BIT always ANDs all 32 bits
        if ((i & 0x1) == 1) {
            throw new Exception();
        }
    }

    public static void main(String[] args) {
        int i;
        long l;
        Test t = new Test();

        l = System.currentTimeMillis();
        t.reset();
        for (i = 1; i < 100000000; i++) {
            t.method1(i);
        }
        l = System.currentTimeMillis() - l;
        System.out.println(
            "method1 took " + l + " ms, result was " + t.getValue()
        );

        l = System.currentTimeMillis();
        t.reset();
        for (i = 1; i < 100000000; i++) {
            try {
                t.method2(i);
            } catch (Exception e) {
                System.out.println("You'll never see this!");
            }
        }
        l = System.currentTimeMillis() - l;
        System.out.println(
            "method2 took " + l + " ms, result was " + t.getValue()
        );

        l = System.currentTimeMillis();
        t.reset();
        for (i = 1; i < 100000000; i++) {
            try {
                t.method3(i);
            } catch (Exception e) {
                // Do nothing here, as we will get here
            }
        }
        l = System.currentTimeMillis() - l;
        System.out.println(
            "method3 took " + l + " ms, result was " + t.getValue()
        );
    }
}

결과:

method1 took 972 ms, result was 2
method2 took 1003 ms, result was 2
method3 took 66716 ms, result was 2

try 블록의 속도 저하가 너무 작아 백그라운드 프로세스와 같은 혼란스러운 요소를 배제 할 수 없습니다. 그러나 catch 블록은 모든 것을 죽였고 66 배 느리게 만들었습니다!

내가 말했듯이 try / catch를 넣고 같은 방법 (method3) 내에서 모두 던지면 결과가 나쁘지 않지만 이것은 내가 의존하지 않는 특별한 JIT 최적화입니다. 그리고이 최적화를 사용할 때도 던지기는 여전히 느립니다. 그래서 나는 당신이 여기서 무엇을하려고하는지 모르겠지만 try / catch / throw를 사용하는 것보다 확실히 더 좋은 방법이 있습니다.

답변

method1 took 1733 ms, result was 2
method2 took 1248 ms, result was 2
method3 took 83997 ms, result was 2
method4 took 1692 ms, result was 2
method5 took 60946 ms, result was 2
method6 took 25746 ms, result was 2

// This one will regularly throw one
public void method4(int i) throws NoStackTraceThrowable {
    value = ((value + i) / i) << 1;
    // i & 1 is equally fast to calculate as i & 0xFFFFFFF; it is both
    // an AND operation between two integers. The size of the number plays
    // no role. AND on 32 BIT always ANDs all 32 bits
    if ((i & 0x1) == 1) {
        throw new NoStackTraceThrowable();
    }
}

// This one will regularly throw one
public void method5(int i) throws NoStackTraceRuntimeException {
    value = ((value + i) / i) << 1;
    // i & 1 is equally fast to calculate as i & 0xFFFFFFF; it is both
    // an AND operation between two integers. The size of the number plays
    // no role. AND on 32 BIT always ANDs all 32 bits
    if ((i & 0x1) == 1) {
        throw new NoStackTraceRuntimeException();
    }
}

public static void main(String[] args) {
    int i;
    long l;
    Test t = new Test();

    l = System.currentTimeMillis();
    t.reset();
    for (i = 1; i < 100000000; i++) {
        try {
            t.method4(i);
        } catch (NoStackTraceThrowable e) {
            // Do nothing here, as we will get here
        }
    }
    l = System.currentTimeMillis() - l;
    System.out.println( "method4 took " + l + " ms, result was " + t.getValue() );


    l = System.currentTimeMillis();
    t.reset();
    for (i = 1; i < 100000000; i++) {
        try {
            t.method5(i);
        } catch (RuntimeException e) {
            // Do nothing here, as we will get here
        }
    }
    l = System.currentTimeMillis() - l;
    System.out.println( "method5 took " + l + " ms, result was " + t.getValue() );
}

method1 took 883 ms, result was 2
method2 took 882 ms, result was 2
method3 took 32270 ms, result was 2 // throws Exception
method4 took 8114 ms, result was 2 // throws NoStackTraceThrowable
method5 took 8086 ms, result was 2 // throws NoStackTraceRuntimeException

public class NoStackTraceThrowable extends Throwable {
    public NoStackTraceThrowable() {
        super("my special throwable", null, false, false);
    }
}