三元运算符的速度是if-else块的两倍？
我到处读到三元运算符应该比它的等效if - else块快或者至少相同。
然而，我做了以下测试，发现事实并非如此：
Random r = new Random();
int[] array = new int[20000000];
for(int i = 0; i < array.Length; i++)
{
array[i] = r.Next(int.MinValue, int.MaxValue);
}
Array.Sort(array);
long value = 0;
DateTime begin = DateTime.UtcNow;
foreach (int i in array)
{
if (i > 0)
{
value += 2;
}
else
{
value += 3;
}
// if-else block above takes on average 85 ms
// OR I can use a ternary operator:
// value += i > 0 ? 2 : 3; // takes 157 ms
}
DateTime end = DateTime.UtcNow;
MessageBox.Show("Measured time: " + (end-begin).TotalMilliseconds + " ms.\r\nResult = " + value.ToString());
我的电脑花了85毫秒来运行上面的代码。但是，如果我注释掉if - else块，并取消注释三元运算符行，则需要大约157毫秒。
为什么会这样？
10 个答案:
答案 0 :(得分：372)
要回答这个问题，我们将检查X86和X64 JIT为每种情况生成的汇编代码。
X86，if / then
32: foreach (int i in array)
0000007c 33 D2 xor edx,edx
0000007e 83 7E 04 00 cmp dword ptr [esi+4],0
00000082 7E 1C jle 000000A0
00000084 8B 44 96 08 mov eax,dword ptr [esi+edx*4+8]
33: {
34: if (i > 0)
00000088 85 C0 test eax,eax
0000008a 7E 08 jle 00000094
35: {
36: value += 2;
0000008c 83 C3 02 add ebx,2
0000008f 83 D7 00 adc edi,0
00000092 EB 06 jmp 0000009A
37: }
38: else
39: {
40: value += 3;
00000094 83 C3 03 add ebx,3
00000097 83 D7 00 adc edi,0
0000009a 42 inc edx
32: foreach (int i in array)
0000009b 39 56 04 cmp dword ptr [esi+4],edx
0000009e 7F E4 jg 00000084
30: for (int x = 0; x < iterations; x++)
000000a0 41 inc ecx
000000a1 3B 4D F0 cmp ecx,dword ptr [ebp-10h]
000000a4 7C D6 jl 0000007C
X86，三元
59: foreach (int i in array)
00000075 33 F6 xor esi,esi
00000077 83 7F 04 00 cmp dword ptr [edi+4],0
0000007b 7E 2D jle 000000AA
0000007d 8B 44 B7 08 mov eax,dword ptr [edi+esi*4+8]
60: {
61: value += i > 0 ? 2 : 3;
00000081 85 C0 test eax,eax
00000083 7F 07 jg 0000008C
00000085 BA 03 00 00 00 mov edx,3
0000008a EB 05 jmp 00000091
0000008c BA 02 00 00 00 mov edx,2
00000091 8B C3 mov eax,ebx
00000093 8B 4D EC mov ecx,dword ptr [ebp-14h]
00000096 8B DA mov ebx,edx
00000098 C1 FB 1F sar ebx,1Fh
0000009b 03 C2 add eax,edx
0000009d 13 CB adc ecx,ebx
0000009f 89 4D EC mov dword ptr [ebp-14h],ecx
000000a2 8B D8 mov ebx,eax
000000a4 46 inc esi
59: foreach (int i in array)
000000a5 39 77 04 cmp dword ptr [edi+4],esi
000000a8 7F D3 jg 0000007D
57: for (int x = 0; x < iterations; x++)
000000aa FF 45 E4 inc dword ptr [ebp-1Ch]
000000ad 8B 45 E4 mov eax,dword ptr [ebp-1Ch]
000000b0 3B 45 F0 cmp eax,dword ptr [ebp-10h]
000000b3 7C C0 jl 00000075
X64，if / then
32: foreach (int i in array)
00000059 4C 8B 4F 08 mov r9,qword ptr [rdi+8]
0000005d 0F 1F 00 nop dword ptr [rax]
00000060 45 85 C9 test r9d,r9d
00000063 7E 2B jle 0000000000000090
00000065 33 D2 xor edx,edx
00000067 45 33 C0 xor r8d,r8d
0000006a 4C 8B 57 08 mov r10,qword ptr [rdi+8]
0000006e 66 90 xchg ax,ax
00000070 42 8B 44 07 10 mov eax,dword ptr [rdi+r8+10h]
33: {
34: if (i > 0)
00000075 85 C0 test eax,eax
00000077 7E 07 jle 0000000000000080
35: {
36: value += 2;
00000079 48 83 C5 02 add rbp,2
0000007d EB 05 jmp 0000000000000084
0000007f 90 nop
37: }
38: else
39: {
40: value += 3;
00000080 48 83 C5 03 add rbp,3
00000084 FF C2 inc edx
00000086 49 83 C0 04 add r8,4
32: foreach (int i in array)
0000008a 41 3B D2 cmp edx,r10d
0000008d 7C E1 jl 0000000000000070
0000008f 90 nop
30: for (int x = 0; x < iterations; x++)
00000090 FF C1 inc ecx
00000092 41 3B CC cmp ecx,r12d
00000095 7C C9 jl 0000000000000060
X64，三元
59: foreach (int i in array)
00000044 4C 8B 4F 08 mov r9,qword ptr [rdi+8]
00000048 45 85 C9 test r9d,r9d
0000004b 7E 2F jle 000000000000007C
0000004d 45 33 C0 xor r8d,r8d
00000050 33 D2 xor edx,edx
00000052 4C 8B 57 08 mov r10,qword ptr [rdi+8]
00000056 8B 44 17 10 mov eax,dword ptr [rdi+rdx+10h]
60: {
61: value += i > 0 ? 2 : 3;
0000005a 85 C0 test eax,eax
0000005c 7F 07 jg 0000000000000065
0000005e B8 03 00 00 00 mov eax,3
00000063 EB 05 jmp 000000000000006A
00000065 B8 02 00 00 00 mov eax,2
0000006a 48 63 C0 movsxd rax,eax
0000006d 4C 03 E0 add r12,rax
00000070 41 FF C0 inc r8d
00000073 48 83 C2 04 add rdx,4
59: foreach (int i in array)
00000077 45 3B C2 cmp r8d,r10d
0000007a 7C DA jl 0000000000000056
57: for (int x = 0; x < iterations; x++)
0000007c FF C1 inc ecx
0000007e 3B CD cmp ecx,ebp
00000080 7C C6 jl 0000000000000048
首先：为什么X86代码比X64慢？
这是由于代码的以下特征：
- X64有几个额外的寄存器，每个寄存器为64位。这允许X64 JIT完全使用寄存器来执行内部循环，而不是从数组中加载
i，而X86 JIT在循环中放置了几个堆栈操作（内存访问）。 -
value是一个64位整数，在X86上需要2个机器指令（add后跟adc），但在X64（add）上只需要1个。< / LI>第二：为什么X86和X64上的三元运算符速度较慢？
这是由于影响JIT优化器的操作顺序的细微差别。要JIT三元运算符，而不是在
另一方面，X86 JIT受到更大程度的影响，因为在内部循环中添加新的中间值会导致它“溢出”另一个值，导致内部循环中至少有2次额外的内存访问（请参阅X86三元代码中对2机器指令本身中直接编码3和add，JIT创建一个中间变量（在寄存器中）来保存结果。然后，在将该寄存器添加到value之前，将该寄存器从32位符号扩展到64位。由于所有这些都在X64的寄存器中执行，尽管三元运算符的复杂性显着增加，但净影响在某种程度上最小化。[ebp-14h]的访问。
答案 1 :(得分：63)
编辑：所有变更......见下文。
我无法在x64 CLR上重现您的结果，但我可以在x86上。在x64上，我可以看到条件运算符和if / else之间的小差异（小于10％），但它比你看到的要小得多。
我做了以下可能的改变：
- 在控制台应用中运行
- 使用
/o+ /debug-构建，并在调试器外部运行 - 运行两段代码以对其进行JIT，然后多次运行以获得更高的准确性
- 使用
Stopwatch
/platform:x64的结果（没有“忽略”行）：
if/else with 1 iterations: 17ms
conditional with 1 iterations: 19ms
if/else with 1000 iterations: 17875ms
conditional with 1000 iterations: 19089ms
/platform:x86的结果（没有“忽略”行）：
if/else with 1 iterations: 18ms
conditional with 1 iterations: 49ms
if/else with 1000 iterations: 17901ms
conditional with 1000 iterations: 47710ms
我的系统详情：
- x64 i7-2720QM CPU @ 2.20GHz
- 64位Windows 8
- .NET 4.5
与以前不同，我认为你 看到了真正的差异 - 而这与x86 JIT有关。我不想确切地说 造成了什么差异 - 我可以稍后更新帖子，如果我可以打算再使用cordbg更多细节：）
有趣的是，如果不首先对数组进行排序，我最终会得到大约4.5倍的测试，至少在x64上。我的猜测是这与分支预测有关。
代码：
using System;
using System.Diagnostics;
class Test
{
static void Main()
{
Random r = new Random(0);
int[] array = new int[20000000];
for(int i = 0; i < array.Length; i++)
{
array[i] = r.Next(int.MinValue, int.MaxValue);
}
Array.Sort(array);
// JIT everything...
RunIfElse(array, 1);
RunConditional(array, 1);
// Now really time it
RunIfElse(array, 1000);
RunConditional(array, 1000);
}
static void RunIfElse(int[] array, int iterations)
{
long value = 0;
Stopwatch sw = Stopwatch.StartNew();
for (int x = 0; x < iterations; x++)
{
foreach (int i in array)
{
if (i > 0)
{
value += 2;
}
else
{
value += 3;
}
}
}
sw.Stop();
Console.WriteLine("if/else with {0} iterations: {1}ms",
iterations,
sw.ElapsedMilliseconds);
// Just to avoid optimizing everything away
Console.WriteLine("Value (ignore): {0}", value);
}
static void RunConditional(int[] array, int iterations)
{
long value = 0;
Stopwatch sw = Stopwatch.StartNew();
for (int x = 0; x < iterations; x++)
{
foreach (int i in array)
{
value += i > 0 ? 2 : 3;
}
}
sw.Stop();
Console.WriteLine("conditional with {0} iterations: {1}ms",
iterations,
sw.ElapsedMilliseconds);
// Just to avoid optimizing everything away
Console.WriteLine("Value (ignore): {0}", value);
}
}
答案 2 :(得分：43)
差异确实与if / else vs ternary没什么关系。
看看jitted disassemblies（我不会在这里重新讨论，请参阅@ 280Z28的回答），结果证明你比较苹果和橘子。在一种情况下，您使用常量值创建两个不同的+=操作，您选择哪个操作取决于条件，而在另一种情况下，您创建一个+=，其中值要添加< / em>取决于条件。
如果你想真正比较if / else vs ternary，这将是一个更公平的比较（现在两者同样“慢”，或者我们甚至可以说三元更快一点）：
int diff;
if (i > 0)
diff = 2;
else
diff = 3;
value += diff;
VS
value += i > 0 ? 2 : 3;
现在if/else的反汇编变为如下所示。请注意，这比三元情况要差一些，因为它也会使用循环变量（i）的寄存器退出。
if (i > 0)
0000009d cmp dword ptr [ebp-20h],0
000000a1 jle 000000AD
{
diff = 2;
000000a3 mov dword ptr [ebp-24h],2
000000aa nop
000000ab jmp 000000B4
}
else
{
diff = 3;
000000ad mov dword ptr [ebp-24h],3
}
value += diff;
000000b4 mov eax,dword ptr [ebp-18h]
000000b7 mov edx,dword ptr [ebp-14h]
000000ba mov ecx,dword ptr [ebp-24h]
000000bd mov ebx,ecx
000000bf sar ebx,1Fh
000000c2 add eax,ecx
000000c4 adc edx,ebx
000000c6 mov dword ptr [ebp-18h],eax
000000c9 mov dword ptr [ebp-14h],edx
000000cc inc dword ptr [ebp-28h]
答案 3 :(得分：9)
修改：
添加了一个可以使用if-else语句但不能使用条件运算符的示例。
在回答之前，请先看看Lippert先生博客上的[Which is faster?]。我认为Mr. Ersönmez's answer在这里是最正确的。
我想提到一些我们应该用高级编程语言记住的东西。
首先，我从未听说条件运算符应该更快或者在C♯中if-else语句的性能相同。
原因很简单，如果if-else语句没有操作怎么办：
if (i > 0)
{
value += 2;
}
else
{
}
条件运算符的要求是任何一方都必须有值，而在C♯中，它还要求:的两边都具有相同的类型。这只是使它与if-else语句不同。因此，您的问题成为一个问题，询问如何生成机器代码的指令，以便性能的差异。
使用条件运算符，语义上是：
无论评估表达式是什么，都有一个值。
但是使用if-else声明：
如果表达式被评估为true，请执行某些操作;如果没有，做另一件事。
if-else语句不一定涉及一个值。您的假设只能通过优化来实现。
另一个证明它们之间区别的例子如下：
var array1=new[] { 1, 2, 3 };
var array2=new[] { 5, 6, 7 };
if(i>0)
array1[1]=4;
else
array2[2]=4;
上面的代码编译，然而，用条件运算符替换if-else语句就不会编译：
var array1=new[] { 1, 2, 3 };
var array2=new[] { 5, 6, 7 };
(i>0?array1[1]:array2[2])=4; // incorrect usage
当你做同样的事情时，条件运算符和if-else语句在概念上是相同的，在C 中使用条件运算符可能更快，因为C更接近于程序集该平台。
对于您提供的原始代码，条件运算符用于foreach循环，这会弄乱它们以查看它们之间的差异。所以我建议使用以下代码：
public static class TestClass {
public static void TestConditionalOperator(int i) {
long value=0;
value+=i>0?2:3;
}
public static void TestIfElse(int i) {
long value=0;
if(i>0) {
value+=2;
}
else {
value+=3;
}
}
public static void TestMethod() {
TestConditionalOperator(0);
TestIfElse(0);
}
}
以下是优化而不是IL的两个版本。由于它们很长，我使用的是图像显示，右侧是优化的：
（点击查看完整尺寸的图片。）
在两个版本的代码中，条件运算符的IL看起来比if-else语句短，并且仍然存在最终生成的机器代码的疑问。以下是两种方法的说明，前一种图像是非优化的，后者是优化的：
-
非优化说明（点击查看完整尺寸的图片。）
-
优化说明（点击查看完整尺寸的图片。）
在后者中，黄色块是仅在i<=0时执行的代码，而蓝色块在i>0时执行。在任一版本的指令中，if-else语句都较短。
请注意，对于不同的说明，[CPI]不一定相同。从逻辑上讲，对于相同的指令，更多的指令需要更长的周期。但是如果还考虑了指令获取时间和管道/缓存，那么实际的执行总时间取决于处理器。处理器还可以预测分支。
现代处理器拥有更多核心，事情可能更复杂。如果您是英特尔处理器用户，可能需要查看[Intel® 64 and IA-32 Architectures Optimization Reference Manual]。
我不知道是否存在硬件实现的CLR，但如果是，则使用条件运算符可能会更快，因为IL显然更少。
注意：所有机器代码都是x86。
答案 4 :(得分：7)
我做了Jon Skeet所做的事情，经历了1次迭代和1000次迭代，得到了OP和Jon的不同结果。在我的三元组中，三元组的速度稍快一些。以下是确切的代码：
static void runIfElse(int[] array, int iterations)
{
long value = 0;
Stopwatch ifElse = new Stopwatch();
ifElse.Start();
for (int c = 0; c < iterations; c++)
{
foreach (int i in array)
{
if (i > 0)
{
value += 2;
}
else
{
value += 3;
}
}
}
ifElse.Stop();
Console.WriteLine(String.Format("Elapsed time for If-Else: {0}", ifElse.Elapsed));
}
static void runTernary(int[] array, int iterations)
{
long value = 0;
Stopwatch ternary = new Stopwatch();
ternary.Start();
for (int c = 0; c < iterations; c++)
{
foreach (int i in array)
{
value += i > 0 ? 2 : 3;
}
}
ternary.Stop();
Console.WriteLine(String.Format("Elapsed time for Ternary: {0}", ternary.Elapsed));
}
static void Main(string[] args)
{
Random r = new Random();
int[] array = new int[20000000];
for (int i = 0; i < array.Length; i++)
{
array[i] = r.Next(int.MinValue, int.MaxValue);
}
Array.Sort(array);
long value = 0;
runIfElse(array, 1);
runTernary(array, 1);
runIfElse(array, 1000);
runTernary(array, 1000);
Console.ReadLine();
}
我的程序输出：
If-Else的经过时间：00：00：00.0140543
三元的经过时间：00：00：00.0136723
If-Else的经过时间：00：00：14.0167870
三元的经过时间：00：00：13.9418520
以毫秒为单位的另一次运行：
If-Else的经过时间：20
三元的经过时间：19
If-Else的经过时间：13854
三元的经过时间：13610
这是在64位XP中运行，我在没有调试的情况下运行。
编辑 - 在x86中运行：
使用x86有很大的不同。这是在没有调试的情况下完成的，并且在与之前相同的xp 64位机器上，但是为x86 CPU构建。这看起来更像是OP。
If-Else的经过时间：18
三元的经过时间：35
If-Else的经过时间：20512
三元的经过时间：32673
答案 5 :(得分：5)
生成的汇编代码将讲述故事：
a = (b > c) ? 1 : 0;
生成：
mov edx, DWORD PTR a[rip]
mov eax, DWORD PTR b[rip]
cmp edx, eax
setg al
鉴于：
if (a > b) printf("a");
else printf("b");
生成：
mov edx, DWORD PTR a[rip]
mov eax, DWORD PTR b[rip]
cmp edx, eax
jle .L4
;printf a
jmp .L5
.L4:
;printf b
.L5:
因此，三元可以更短更快，因为使用更少的指令而没有跳跃如果你正在寻找真/假。如果使用1和0以外的值，则将获得与if / else相同的代码，例如：
a = (b > c) ? 2 : 3;
生成：
mov edx, DWORD PTR b[rip]
mov eax, DWORD PTR c[rip]
cmp edx, eax
jle .L6
mov eax, 2
jmp .L7
.L6:
mov eax, 3
.L7:
与if / else。
相同答案 6 :(得分：4)
在没有调试ctrl + F5的情况下运行似乎调试器显着减慢了ifs和ternary的速度，但似乎它使得三元运算符的速度变慢了。
当我运行以下代码时，这是我的结果。我认为小毫秒差异是由编译器优化max = max并将其删除引起的，但可能不会对三元运算符进行优化。如果有人可以检查装配并确认这将是非常棒的。
--Run #1--
Type | Milliseconds
Ternary 706
If 704
%: .9972
--Run #2--
Type | Milliseconds
Ternary 707
If 704
%: .9958
--Run #3--
Type | Milliseconds
Ternary 706
If 704
%: .9972
代码
for (int t = 1; t != 10; t++)
{
var s = new System.Diagnostics.Stopwatch();
var r = new Random(123456789); //r
int[] randomSet = new int[1000]; //a
for (int i = 0; i < 1000; i++) //n
randomSet[i] = r.Next(); //dom
long _ternary = 0; //store
long _if = 0; //time
int max = 0; //result
s.Start();
for (int q = 0; q < 1000000; q++)
{
for (int i = 0; i < 1000; i++)
max = max > randomSet[i] ? max : randomSet[i];
}
s.Stop();
_ternary = s.ElapsedMilliseconds;
max = 0;
s = new System.Diagnostics.Stopwatch();
s.Start();
for (int q = 0; q < 1000000; q++)
{
for (int i = 0; i < 1000; i++)
if (max > randomSet[i])
max = max; // I think the compiler may remove this but not for the ternary causing the speed difference.
else
max = randomSet[i];
}
s.Stop();
_if = s.ElapsedMilliseconds;
Console.WriteLine("--Run #" + t+"--");
Console.WriteLine("Type | Milliseconds\nTernary {0}\nIf {1}\n%: {2}", _ternary, _if,((decimal)_if/(decimal)_ternary).ToString("#.####"));
}
答案 7 :(得分：4)
查看生成的IL，其中的操作少于if / else语句（复制和粘贴@ JonSkeet的代码）。但是，这并不意味着它应该是一个更快的过程！
总结IL的差异，if / else方法转换为与C＃代码读取几乎相同（在分支内执行添加），而条件代码将2或3加载到堆栈上（取决于value）然后将其添加到条件之外的值。
另一个区别是使用的分支指令。 if / else方法使用brtrue（如果为true则为分支）跳过第一个条件，使用无条件分支从if语句的第一个跳出。条件代码使用bgt（分支，如果大于）而不是brtrue，这可能是一个较慢的比较。
另外（刚刚阅读了关于分支预测），分支可能会有较小的性能损失。条件分支在分支中只有1条指令但if / else有7条。这也解释了为什么使用long和int之间存在差异，因为更改为int会将if / else分支中的指令数减少1 （使预读更少）
答案 8 :(得分：1)
在下面的代码中，如果/ else似乎比三元运算符快大约1.4倍。但是，我发现引入一个临时变量可以减少三元运算符的运行时间约1.4倍：
If / Else：98 ms
三元：141毫秒
温度变化的三元组：100毫秒
using System;
using System.Diagnostics;
namespace ConsoleApplicationTestIfElseVsTernaryOperator
{
class Program
{
static void Main(string[] args)
{
Random r = new Random(0);
int[] array = new int[20000000];
for (int i = 0; i < array.Length; i++)
{
array[i] = r.Next(int.MinValue, int.MaxValue);
}
Array.Sort(array);
long value;
Stopwatch stopwatch = new Stopwatch();
value = 0;
stopwatch.Restart();
foreach (int i in array)
{
if (i > 0)
{
value += 2;
}
else
{
value += 3;
}
// 98 ms
}
stopwatch.Stop();
Console.WriteLine("If/Else: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");
value = 0;
stopwatch.Restart();
foreach (int i in array)
{
value += (i > 0) ? 2 : 3;
// 141 ms
}
stopwatch.Stop();
Console.WriteLine("Ternary: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");
value = 0;
int tempVar = 0;
stopwatch.Restart();
foreach (int i in array)
{
tempVar = (i > 0) ? 2 : 3;
value += tempVar;
// 100ms
}
stopwatch.Stop();
Console.WriteLine("Ternary with temp var: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");
Console.ReadKey(true);
}
}
}
答案 9 :(得分：0)
太多好的答案，但我发现了一些有趣的事情，非常简单的更改会产生影响。进行以下更改后，要执行if-else和三元运算符将花费相同的时间。
而不是在行下书写
value += i > 0 ? 2 : 3;
我用了这个
int a = i > 0 ? 2 : 3;
value += a;
以下答案之一还提到写三元运算符的不好方法。
我希望这会帮助您编写三元运算符，而不用考虑哪个更好。
嵌套三元运算符： 我发现嵌套三元运算符和多个if else块也将花费相同的时间来执行。
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？