我对异常速度和以编程方式检查数据的看法。

许多类都有字符串到值的转换器(扫描器/解析器)，也有受人尊敬和知名的库;)

通常有形式

class Example {
public static Example Parse(String input) throws AnyRuntimeParsigException
...
}

异常名称只是例子，通常是未选中的(运行时)，所以抛出声明只是我的图片

有时存在第二种形式:

public static Example Parse(String input, Example defaultValue)

不扔

当第二个文件不可用时(或者程序员读的文档太少，只使用第一个文件)，用正则表达式编写这样的代码。正则表达式很酷，政治正确等:

Xxxxx.regex(".....pattern", src);
if(ImTotallySure)
{
  Example v = Example.Parse(src);
}

使用这段代码，程序员没有异常成本。BUT具有相当高的代价的正则表达式ALWAYS与小的代价异常有时。

我几乎总是在这种情况下使用

try { parse } catch(ParsingException ) // concrete exception from javadoc
{
}

没有分析堆栈跟踪等，我相信在你的讲座后相当快。

不要害怕例外情况

即使抛出异常并不慢，对于正常的程序流抛出异常仍然是一个坏主意。使用这种方式，它是类似于GOTO…

我想这并没有真正回答问题。我想抛出异常的“传统”智慧在早期的java版本(< 1.4)中是正确的。创建异常需要虚拟机创建整个堆栈跟踪。从那时起，在VM中发生了很多变化，以加快速度，这可能是已经改进的一个领域。

前段时间，我写了一个类来测试将字符串转换为整数的相对性能，使用两种方法:(1)调用Integer.parseInt()并捕获异常，或者(2)用正则表达式匹配字符串并仅在匹配成功时调用parseInt()。我以最有效的方式使用正则表达式(即，在终止循环之前创建Pattern和Matcher对象)，并且我没有打印或保存异常的堆栈跟踪。

对于一个包含10,000个字符串的列表，如果它们都是有效数字，那么parseInt()方法的速度是regex方法的四倍。但如果只有80%的字符串是有效的，则regex的速度是parseInt()的两倍。如果20%是有效的，这意味着异常在80%的时间内被抛出和捕获，则regex的速度大约是parseInt()的20倍。

我对结果感到惊讶，因为regex方法处理了两次有效字符串:一次用于匹配，另一次用于parseInt()。但是抛出和捕获异常完全弥补了这一点。这种情况在现实世界中不太可能经常发生，但如果发生了，您绝对不应该使用异常捕获技术。但如果您只是验证用户输入或类似的东西，务必使用parseInt()方法。

我对异常速度和以编程方式检查数据的看法。

许多类都有字符串到值的转换器(扫描器/解析器)，也有受人尊敬和知名的库;)

通常有形式

class Example {
public static Example Parse(String input) throws AnyRuntimeParsigException
...
}

异常名称只是例子，通常是未选中的(运行时)，所以抛出声明只是我的图片

有时存在第二种形式:

public static Example Parse(String input, Example defaultValue)

不扔

当第二个文件不可用时(或者程序员读的文档太少，只使用第一个文件)，用正则表达式编写这样的代码。正则表达式很酷，政治正确等:

Xxxxx.regex(".....pattern", src);
if(ImTotallySure)
{
  Example v = Example.Parse(src);
}

使用这段代码，程序员没有异常成本。BUT具有相当高的代价的正则表达式ALWAYS与小的代价异常有时。

我几乎总是在这种情况下使用

try { parse } catch(ParsingException ) // concrete exception from javadoc
{
}

没有分析堆栈跟踪等，我相信在你的讲座后相当快。

不要害怕例外情况

为什么异常回报率会比正常回报率慢呢?

只要不将堆栈跟踪输出到终端，将其保存到一个文件或类似的文件中，catch块就不会比其他代码块做更多的工作。所以，我无法想象为什么“throw new my_cool_error()”应该这么慢。

好问题，我期待关于这个话题的进一步信息!

It depends how exceptions are implemented. The simplest way is using setjmp and longjmp. That means all registers of the CPU are written to the stack (which already takes some time) and possibly some other data needs to be created... all this already happens in the try statement. The throw statement needs to unwind the stack and restore the values of all registers (and possible other values in the VM). So try and throw are equally slow, and that is pretty slow, however if no exception is thrown, exiting the try block takes no time whatsoever in most cases (as everything is put on the stack which cleans up automatically if the method exists).

Sun和其他人认识到，这可能是次优的，当然随着时间的推移，虚拟机会变得越来越快。还有另一种实现异常的方法，它使try本身闪电般快(实际上try本身根本不会发生任何事情——当类被VM加载时，需要发生的一切都已经完成了)，并且它使throw不那么慢。我不知道哪个JVM使用了这种新的、更好的技术……

.．.但你是在用Java写代码，所以你的代码以后只能在一个特定系统的一个JVM上运行吗?因为如果它可以在任何其他平台或任何其他JVM版本(可能是任何其他供应商的)上运行，谁说他们也使用快速实现呢?速度快的要比速度慢的复杂得多，而且不容易在所有系统上实现。你想要便携吗?那就不要指望异常会很快。

It also makes a big difference what you do within a try block. If you open a try block and never call any method from within this try block, the try block will be ultra fast, as the JIT can then actually treat a throw like a simple goto. It neither needs to save stack-state nor does it need to unwind the stack if an exception is thrown (it only needs to jump to the catch handlers). However, this is not what you usually do. Usually you open a try block and then call a method that might throw an exception, right? And even if you just use the try block within your method, what kind of method will this be, that does not call any other method? Will it just calculate a number? Then what for do you need exceptions? There are much more elegant ways to regulate program flow. For pretty much anything else but simple math, you will have to call an external method and this already destroys the advantage of a local try block.

请看下面的测试代码:

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 block杀死了一切，让它慢了66倍!

正如我所说，如果将try/catch和throw都放在同一个方法(method3)中，结果不会那么糟糕，但这是我不依赖的特殊JIT优化。即使使用这种优化，抛出仍然非常慢。我不知道你们想做什么，但肯定有比try/catch/throw更好的方法。