哪个更快：while（1）或while（2）？

这是一位高级经理提出的面试问题。

哪个更快？

while(1) {
    // Some code
}

要么

while(2) {
    //Some code
}

我说这两者具有相同的执行速度，因为内部表达式while最终应求值为trueor false。在这种情况下，两个true条件都求和，并且条件内部没有额外的条件指令while。因此，两者将具有相同的执行速度，我更喜欢while（1）。

但是面试官充满信心地说：“检查您的基础知识。while(1)比更快while(2)。” （他没有测试我的信心）

这是真的？

另请参见：“ for（;;）”是否比“ while（TRUE）”更快？如果没有，人们为什么要使用它？

两个循环都是无限的，但是我们可以看到哪个循环每次迭代需要更多的指令/资源。

使用gcc，我编译了以下两个程序以进行不同程度的优化：

int main(void) {
    while(1) {}
    return 0;
}

int main(void) {
    while(2) {}
    return 0;
}

即使没有优化（-O0），两个程序的生成程序集也是相同的。因此，两个循环之间没有速度差异。

供参考，这是生成的程序集（使用 gcc main.c -S -masm=intel与优化标志一起使用）：

与-O0：

    .file   "main.c"
    .intel_syntax noprefix
    .def    __main; .scl    2;  .type   32; .endef
    .text
    .globl  main
    .def    main;   .scl    2;  .type   32; .endef
    .seh_proc   main
main:
    push    rbp
    .seh_pushreg    rbp
    mov rbp, rsp
    .seh_setframe   rbp, 0
    sub rsp, 32
    .seh_stackalloc 32
    .seh_endprologue
    call    __main
.L2:
    jmp .L2
    .seh_endproc
    .ident  "GCC: (tdm64-2) 4.8.1"

与-O1：

    .file   "main.c"
    .intel_syntax noprefix
    .def    __main; .scl    2;  .type   32; .endef
    .text
    .globl  main
    .def    main;   .scl    2;  .type   32; .endef
    .seh_proc   main
main:
    sub rsp, 40
    .seh_stackalloc 40
    .seh_endprologue
    call    __main
.L2:
    jmp .L2
    .seh_endproc
    .ident  "GCC: (tdm64-2) 4.8.1"

使用-O2和-O3（相同的输出）：

    .file   "main.c"
    .intel_syntax noprefix
    .def    __main; .scl    2;  .type   32; .endef
    .section    .text.startup,"x"
    .p2align 4,,15
    .globl  main
    .def    main;   .scl    2;  .type   32; .endef
    .seh_proc   main
main:
    sub rsp, 40
    .seh_stackalloc 40
    .seh_endprologue
    call    __main
.L2:
    jmp .L2
    .seh_endproc
    .ident  "GCC: (tdm64-2) 4.8.1"

实际上，对于每个优化级别，为循环生成的程序集都是相同的：

 .L2:
    jmp .L2
    .seh_endproc
    .ident  "GCC: (tdm64-2) 4.8.1"

重要的位是：

.L2:
    jmp .L2

我不能很好地阅读汇编，但这显然是一个无条件循环。该jmp指令无条件地将程序重置为.L2标签，甚至不将值与true进行比较，当然，立即再次进行重置，直到程序以某种方式结束。这直接对应于C / C ++代码：

L2:
    goto L2;

编辑：

有趣的是，即使没有优化，下面的循环jmp在汇编中也会产生完全相同的输出（无条件）：

while(42) {}

while(1==1) {}

while(2==2) {}

while(4<7) {}

while(3==3 && 4==4) {}

while(8-9 < 0) {}

while(4.3 * 3e4 >= 2 << 6) {}

while(-0.1 + 02) {}

甚至令我惊讶的是：

#include<math.h>

while(sqrt(7)) {}

while(hypot(3,4)) {}

用户定义的函数使事情变得更加有趣：

int x(void) {
    return 1;
}

while(x()) {}

#include<math.h>

double x(void) {
    return sqrt(7);
}

while(x()) {}

在-O0，这两个示例实际上称为x为每个迭代并执行比较。

第一个示例（返回1）：

.L4:
    call    x
    testl   %eax, %eax
    jne .L4
    movl    $0, %eax
    addq    $32, %rsp
    popq    %rbp
    ret
    .seh_endproc
    .ident  "GCC: (tdm64-2) 4.8.1"

第二个示例（返回sqrt(7)）：

.L4:
    call    x
    xorpd   %xmm1, %xmm1
    ucomisd %xmm1, %xmm0
    jp  .L4
    xorpd   %xmm1, %xmm1
    ucomisd %xmm1, %xmm0
    jne .L4
    movl    $0, %eax
    addq    $32, %rsp
    popq    %rbp
    ret
    .seh_endproc
    .ident  "GCC: (tdm64-2) 4.8.1"

但是，在-O1以上版本中，它们都产生与先前示例相同的程序集（无条件jmp返回到先前的标签）。

TL; DR

在GCC下，不同的循环被编译为相同的程序集。编译器将评估常量值，并且不会执行任何实际的比较。

这个故事的寓意是：

• C ++源代码和CPU指令之间存在翻译层，并且这一层对性能具有重要意义。
• 因此，不能仅通过查看源代码来评估性能。
• 编译器应该足够聪明以优化这种琐碎的情况。在绝大多数情况下，程序员不应浪费时间思考它们。

是的，while(1)就是速度远远超过while(2)，供人阅读！如果我看到while(1)在一个陌生的代码库中的话，我会立即知道作者的意图，而我的眼球可以继续到下一行。

如果我看到的话while(2)，我可能会停下脚步，试图弄清楚作者为什么不写信while(1)。作者的手指在键盘上打滑了吗？此代码库的维护者是否将while(n)晦涩的注释机制用作使循环看起来不同的注释机制？在某些损坏的静态分析工具中，是否存在针对伪造警告的粗略解决方法？还是我正在读取生成的代码的线索？这是由于错误的“查找并替换所有”，错误的合并或宇宙射线导致的错误吗？也许这行代码应该做的事情大不相同。也许应该阅读while(w)或阅读while(x2)。我最好在文件的历史记录中找到作者，然后向他们发送“ WTF”电子邮件...现在，我已经打破了我的思维范围。while(2)while(1) 会花一秒钟的时间！

我很夸张，但只有一点点。代码的可读性非常重要。值得在采访中提及！

现有答案显示了由特定编译器为具有特定选项集的特定目标生成的代码，不能完全回答该问题-除非在该特定上下文中提出该问题（“使用gcc 4.7.2 for x86_64更快是否带有默认选项？”。

就语言定义而言，抽象机中 while (1)对整数常数求值1，while (2)并对整数常数求值2。在这两种情况下，将结果均等为零。语言标准绝对没有说明这两种构造的相对性能。

我可以想象，一个极幼稚的编译器可能会为这两种形式生成不同的机器代码，至少在编译时不要求优化。

另一方面，当C编译器出现在需要常量表达式的上下文中时，它们绝对必须在编译时评估某些常量表达式。例如，这：

int n = 4;
switch (n) {
    case 2+2: break;
    case 4:   break;
}

需要诊断；惰性编译器无法将评估推迟2+2到执行时间。由于编译器必须具有在编译时评估常数表达式的能力，因此即使没有必要，也没有充分的理由不使用该功能。

C标准（N1570 6.8.5p4）表示

迭代语句使称为循环体的语句重复执行，直到控制表达式比较等于0。

因此相关的常数表达式是1 == 0和2 == 0，两者都int取值0。（这些比较在while循环的语义中是隐式的；它们不作为实际的C表达式存在。）

幼稚的编译器可能会为这两种构造生成不同的代码。例如，对于第一种方法，它可以生成无条件的无限循环（1作为特殊情况进行处理），对于第二种方法，它可以生成与等效的显式运行时比较2 != 0。但是我从未遇到过实际会以这种方式运行的C编译器，而且我严重怀疑这种编译器是否存在。

大多数编译器（我很想说所有具有生产质量的编译器）都具有请求其他优化的选项。在这种选择下，任何编译器为这两种形式生成不同代码的可能性均更低。

如果您的编译器为这两种构造生成了不同的代码，请首先检查不同的代码序列实际上是否具有不同的性能。如果是这样，请尝试使用优化选项（如果有）再次进行编译。如果它们仍然不同，则将错误报告提交给编译器供应商。在不符合C标准的意义上，它不是（不必要）错误，但几乎可以肯定，这是一个应纠正的问题。

底线：while (1)和while(2) 几乎肯定有同样的表现。它们具有完全相同的语义，没有充分的理由让任何编译器不生成相同的代码。

尽管它是完全合法的编译器生成速度更快的代码while(1)比对while(2)，这是同样的法律对编译器生成速度更快的代码while(1)比另一个发生while(1)在相同的程序。

（在您询问的问题中还暗含了另一个问题：您如何与坚持不正确的技术观点的面试官打交道。对于Workplace网站，这可能是个好问题）。

等一下。面试官，他长得像这个家伙吗？

面试官本人未能通过面试，这是非常糟糕的，如果该公司的其他程序员“通过”了该测试该怎么办？

号评估的声明1 == 0，并2 == 0 应同样快。我们可以想象一个较差的编译器实现，其中一个可能比另一个更快。但是，没有充分的理由说明为什么一个比另一个要快。

即使在某些情况下该声明为真，也不应基于对晦涩（在这种情况下为令人毛骨悚然）琐事的知识来评估程序员。不用担心这次采访，最好的办法就是走开。

免责声明：这不是原始的Dilbert卡通。这仅仅是一个混搭。

您的解释是正确的。除了技术知识外，这似乎是一个测试您的自信心的问题。

顺便说一句，如果你回答

这两段代码的速度一样快，因为它们都需要花费无限的时间才能完成

面试官会说

但是while (1)每秒可以进行更多次迭代；你能解释为什么吗？（这是胡扯；请再次测试您的信心）

因此，通过像您一样回答，可以节省一些时间，否则您将无法浪费时间讨论这个坏问题。

这是由我的系统（MS Visual Studio 2012）上的编译器生成的示例代码，其中关闭了优化功能：

yyy:
    xor eax, eax
    cmp eax, 1     (or 2, depending on your code)
    je xxx
    jmp yyy
xxx:
    ...

启用优化功能后：

xxx:
    jmp xxx

因此，至少使用优化的编译器，生成的代码完全相同。

该问题最可能的解释是，访问员认为处理器逐个检查数字的各个位，直到达到非零值为止：

1 = 00000001
2 = 00000010

如果“为零？” 算法从数字的右侧开始，必须检查每个位，直到达到非零位为止，while(1) { }循环每次迭代必须检查的位是循环的两倍while(2) { }。

这需要一个关于计算机如何工作的非常错误的思维模型，但是它确实有其自己的内部逻辑。一种检查方法是询问是否while(-1) { }或while(3) { }将同样快，或者甚至while(32) { }会 更慢。

当然，我不知道这位经理的真正意图，但是我提出了一个完全不同的观点：在团队中雇用新成员时，了解他如何应对冲突情况很有用。

他们使您陷入冲突。如果是这样，那么他们很聪明，问题也很好。对于某些行业，例如银行业，将您的问题发布到Stack Overflow可能是拒绝的原因。

但是我当然不知道，我只是提出一种选择。

我认为可以从“高级经理的要求”中找到线索。这个人显然在他成为经理时就停止了编程，然后花了几年时间才成为高级经理。从没有对编程失去兴趣，但是从那以后再也没有写过一行。因此，他的参考不是像一些答案所提到的“那里有任何像样的编译器”，而是“ 20到30年前与这个人一起工作的编译器”。

当时，由于“中央微型计算机”的CPU时间非常宝贵，因此程序员花费了大量时间尝试各种方法来使代码更快，更高效。就像人们编写编译器一样。我猜想他公司当时提供的唯一编译器是根据“经常遇到的可以优化的语句”进行优化的，并且在遇到while（1）并评估所有内容时采取了一些捷径其他，包括一阵子（2）。有过这样的经历可以解释他的立场和对它的信心。

录用的最佳方法可能是使高级经理带走并在“ 顺利编程的过去”上给您2-3分钟的课程，然后再顺利地引导他进入下一个面试主题。（适当的时机在这里很重要-太快了，您打断了故事-太慢了，您被标记为专注力不足的人）。在面试结束时一定要告诉他，您将非常有兴趣了解有关此主题的更多信息。

您应该问他他是如何得出这个结论的。在任何合适的编译器下，两者都可以编译为相同的asm指令。因此，他也应该告诉您编译器开始。即使这样，您也必须非常了解编译器和平台，才能进行理论上的猜测。最后，实际上这并不重要，因为还有其他外部因素，例如内存碎片或系统负载，对循环的影响远不止这些细节。

出于这个问题，我应该补充一点，我记得C委员会的Doug Gwyn写道，一些没有优化程序通过的早期C编译器将在汇编中生成一个测试while(1)（相比之下for(;;)，没有）。

我会通过提供此历史记录来回答采访者，然后说，即使我很惊讶任何编译器这样做，编译器也可能会：

• 没有优化器通过编译器生成两个测试while(1)和while(2)
• 通过优化器传递，将指示编译器进行优化（无条件跳转），while(1)因为它们被认为是惯用的。这将需要while(2)进行测试，因此会使两者之间的性能有所不同。

我当然会向面试官补充，不要考虑while(1)，while(2)并且相同的构造是低质量优化的标志，因为它们是等效的构造。

对这个问题的另一种看法是看您是否有勇气告诉您的经理他/她错了！以及您如何交流。

我的第一个本能是生成程序集输出，以向管理器显示任何体面的编译器都应处理它，如果不这样做，则将为此提交下一个补丁：）

看到这么多人深入研究这个问题，就确切地说明了为什么这很可能是一个测试，以了解您要对事物进行微优化的速度有多快。

我的答案是；没关系，我只关注我们正在解决的业务问题。毕竟，这就是我要付的钱。

而且，我while(1) {}之所以选择它是因为它更常见，而其他队友则不需要花时间去弄清楚为什么有人会选择高于1的数字。

现在去写一些代码。;-)

如果您担心优化，则应使用

for (;;)

因为那没有测试。（讽刺模式）

在我看来，这是那些被掩盖为技术问题的行为面试问题之一。一些公司这样做-他们会问一个技术问题，任何有能力的程序员都应该很容易回答这个问题，但是当受访者给出正确答案时，受访者会告诉他们他们错了。

该公司希望了解您在这种情况下的反应。由于自我怀疑或担心让面试官感到沮丧，您是否安静地坐在那里并且不力求答案是正确的？还是您愿意挑战您知道是错误的权威人士？他们想看看您是否愿意坚持自己的信念，以及是否可以以机智和尊重的方式做到这一点。

当这种废话可能有所作为时，我曾经对C和Assembly代码进行编程。当确实有所作为时，我们在汇编中编写了它。

如果有人问我这个问题，我会重复Donald Knuth 1974年著名的关于过早优化的报价，如果面试官不笑不笑又走下去，他就会走。

也许面试官故意提出这样愚蠢的问题，并希望您提出3分：

1. 基本推理。两个循环都是无限的，很难谈论性能。
2. 有关优化级别的知识。他想听听您是否允许编译器为您做任何优化，这将优化条件，尤其是在该块不为空的情况下。
3. 有关微处理器体系结构的知识。大多数体系结构都有一个特殊的CPU指令，用于与0进行比较（虽然不一定更快）。

这是一个问题：如果您实际上编写一个程序并测量其速度，则两个循环的速度可能会有所不同！为了进行一些合理的比较：

unsigned long i = 0;
while (1) { if (++i == 1000000000) break; }

unsigned long i = 0;
while (2) { if (++i == 1000000000) break; }

加上一些打印时间的代码，一些随机效果（例如循环如何在一两个缓存行中定位）可能会有所不同。一个循环完全有可能完全在一条高速缓存行中，或者在高速缓存行的开始处，或者可能跨越了两条高速缓存行。结果，面试官声称最快的实际上可能是最快的-巧合。

最坏的情况：优化的编译器无法确定循环的作用，但是可以确定执行第二个循环时产生的值与第一个循环所产生的值相同。并为第一个循环生成完整的代码，但不为第二个循环生成完整的代码。

他们都是平等的-一样。

根据规范，任何不为0的东西都被认为是正确的，因此即使不进行任何优化，一个好的编译器也不会为while（1）或while（2）生成任何代码。编译器将为生成一个简单的检查!= 0。

从人们花费大量的时间和精力进行测试，证明和回答这个非常直接的问题来看，Id表示，通过提出问题，两者都变得非常缓慢。

因此，要花更多的时间...

“ while（2）”是荒谬的，因为，

从历史上讲，“ while（1）”和“ while（true）”用于构成一个无限循环，该循环希望根据肯定会发生的条件在循环内的某个阶段调用“ break”。

简单地说，“ 1”总是总为真，因此说“ while（2）”和说“ while（1 +1 == 2）”一样愚蠢，后者也将真为真。

如果您想变得完全傻，请使用：-

while (1 + 5 - 2 - (1 * 3) == 0.5 - 4 + ((9 * 2) / 4)) {
    if (succeed())
        break;
}

我想以为您的编码员输入的错字并不会影响代码的运行，但是如果他故意使用“ 2”只是为了很奇怪，那么在他把怪异的代码全部放入您的代码之前先将其解雇，这使他很难阅读并使用。

那取决于编译器。

如果它优化代码，或者对于特定指令集使用相同数量的指令将1和2评估为true，则执行速度将相同。

在实际情况下，它总是一样快，但是当对它们进行不同的评估时，可以想象一个特定的编译器和一个特定的系统。

我的意思是：这实际上不是与语言（C）相关的问题。

由于希望回答这个问题的人们都希望最快的循环，所以我会回答说，正如其他答案中所述，两者都被同样地编译为相同的汇编代码。不过，您可以使用“循环展开”功能向面试官提出建议；一个do {} while循环，而不是while循环。

注意：您需要确保循环至少始终运行一次。

循环内部应有一个中断条件。

同样对于这种循环，我个人更喜欢使用do {} while（42），因为除0以外的任何整数都可以完成工作。

显而易见的答案是：如前所述，两个片段都将运行同样繁忙的无限循环，这会使程序无限慢。

尽管将C关键字重新定义为宏在技术上会具有未定义的行为，但这是我想到的唯一一种可以使任何代码片段都变得快速的唯一方法：您可以在2个片段上方添加以下行：

#define while(x) sleep(x);

实际上，它的while(1)速度是的两倍（或一半）while(2)。

我能想到为什么while(2)速度会变慢的唯一原因是：

1. 该代码将循环优化为

   cmp eax, 2

2. 当发生减法时，您实际上是在减法

   一个。 00000000 - 00000010 cmp eax, 2

   代替

   b。 00000000 - 00000001 cmp eax, 1

cmp仅设置标志，不设置结果。因此，在最低有效位上，我们知道是否需要借用b。而使用a则必须先进行两次减法运算，然后才能借用。