为什么 i=i+1 比 i++ 快？答案

【问题标题】：Why is i=i+1 faster than i++?为什么 i=i+1 比 i++ 快？
【发布时间】：2012-08-25 20:42:35
【问题描述】：

在 Flash 中测试这段代码：

var i:int = 0;
for (var j:int = 0; j < 5000000; j++)
{
    i=i+1;
}// use about 300ms.

i = 0;
for (var j:int = 0; j < 5000000; j++)
{
    i++;
}// use about 400ms

i = 0;
for (var j:int = 0; j < 5000000; j++)
{
    ++i;
}// use about 400ms too

为什么i=i+1 在 ActionScript 3 中更快，而在其他版本中却较慢？

对不起，我犯了一些错误。上面的代码使用相同的时间。但是如果放到函数里面，结果就不一样了。

var i:int;
var j:int;
var startTime:Number;

function func1():void
{
    i = i + 1;
}

function func2():void
{
    i++;
}

startTime = getTimer();
i = 0;
for (j = 0; j < 10000000; j++)
{
    func1();
}
trace(getTimer() - startTime);//5 times:631,628,641,628,632

startTime = getTimer();
i = 0;
for (j = 0; j < 10000000; j++)
{
    func2();
}
trace(getTimer() - startTime);//5 times:800,814,791,832,777

【问题讨论】：

你能否将循环长度乘以 10，并确保确实存在差异？
你说的“别人慢”是什么意思？其他编程语言？哪些？
一个小注解：如果您有一个发布/调试版本（FlashIDE 中的“允许调试”设置），这很重要，并且结果也可能在发布和调试播放器中有所不同。 jacksondunstan.com 对多个玩家进行了大量非常深入的性能测试。

标签： performance actionscript-3 post-increment pre-increment

【解决方案1】：

循环所在的位置会对性能产生很大影响。如果您的循环在函数内部，Flash 将使用本地寄存器执行计算。包含i++ 的循环因此产生以下操作码：

000013 inclocal_i (REG_2)  ; increment i 
000015 inclocal_i (REG_3)  ; increment j
000017 getlocal (REG_3)    ; push j onto stack
000018 pushint 5000000     ; push 5000000 onto stack
000020 iflt -12            ; jump backward if less than

包含i = i + 1 的循环产生以下内容：

000013 getlocal (REG_2)    ; push i onto stack
000014 pushbyte 1          ; push 1 onto stack
000016 add                 ; add the two
000017 convert_i           ; coerce to integer
000018 setlocal (REG_2)    ; save i back to register 2
000019 inclocal_i (REG_3)  
000021 getlocal (REG_3)
000022 pushint 5000000
000024 iflt -16

i++ 比 i = i + 1 快，因为 inclocal_i 直接修改寄存器，无需将寄存器加载到堆栈中并保存回来。

当您将循环放在框架脚本中时，它的效率会大大降低。 Flash 会将声明的变量存储为类变量。访问这些需要更多的工作。 i++ 循环结果如下：

000017 getlocal (REG_0, this)   ; push this onto stack
000018 dup                      ; duplicate it
000019 setlocal (REG_2)         ; save this to register 2
000020 getproperty i            ; get property "i"
000022 increment_i              ; add one to it
000023 setlocal (REG_3)         ; save result to register 3
000024 getlocal (REG_2)         ; get this from register 2
000025 getlocal (REG_3)         ; get value from register 3
000026 setproperty i            ; set property "i"
000028 kill (REG_3)             ; kill register 2
000030 kill (REG_2)             ; kill register 3
000032 getlocal (REG_0, this)   ; do the same thing with j...
000033 dup
000034 setlocal (REG_2)
000035 getproperty j
000037 increment_i
000038 setlocal (REG_3)
000039 getlocal (REG_2)
000040 getlocal (REG_3)
000041 setproperty j
000043 kill (REG_3)
000045 kill (REG_2)
000047 getlocal (REG_0, this)
000048 getproperty j
000050 pushint 5000000
000052 iflt -40

i = i + 1 版本稍短：

000017 getlocal (REG_0, this)   ; push this onto stack
000018 getlocal (REG_0, this)   ; push this onto stack
000019 getproperty i            ; get property "i"
000021 pushbyte 1               ; push 1 onto stack
000023 add                      ; add the two
000024 initproperty i           ; save result to property "i"
000026 getlocal (REG_0, this)   ; increment j...
000027 dup
000028 setlocal (REG_2)
000029 getproperty j
000031 increment_i
000032 setlocal (REG_3)
000033 getlocal (REG_2)
000034 getlocal (REG_3)
000035 setproperty j
000037 kill (REG_3)
000039 kill (REG_2)
000041 getlocal (REG_0, this)
000042 getproperty j
000044 pushint 5000000
000046 iflt -34

【讨论】：

我比我更喜欢你的回答 :) 你是如何获得操作码的？你只是以某种方式修改了 mm.cfg 吗？
我写了一个AS3反汇编程序。您可以通过以下方式查看：flaczki.net46.net/codedump。可能很难进行性能优化。
谢谢你，太棒了！我正在将一些内容转换为 HTML5/JS，所以我不得不稍微依赖 AS3 的东西，但我肯定会尽快将其存档。
非常感谢！很有用！

【解决方案2】：

我无法复制这种行为，这三个对我来说似乎几乎是同一时间

Attempt 1
loop 1: 378
loop 2: 396
loop 3: 382

Attempt 2
loop 1: 380
loop 2: 361
loop 3: 361

Attempt 3
loop 1: 375
loop 2: 373
loop 3: 355

将循环增加 10 倍我得到了这些时间：

Attempt 1
loop 1: 3707
loop 2: 3663
loop 3: 3653

Attempt 2
loop 1: 3722
loop 2: 3632
loop 3: 3711

[TestLoopSpeed.as]

package
{
    import flash.display.Sprite;
    import flash.utils.getTimer;

    public class TestLoopSpeed extends Sprite
    {
        public function TestLoopSpeed()
        {
            var timeNow:Number = getTimer();
            var i:int = 0;

            var startOne:Number = getTimer();
            for (var j:int = 0; j < 5000000; j++)
            {
                i=i+1;
            }
            var endOne:Number = getTimer();


            var startTwo:Number = getTimer();
            i = 0;
            for (var j:int = 0; j < 5000000; j++)
            {
                i++;
            }
            var endTwo:Number = getTimer();

            var startThree:Number = getTimer();
            i = 0;
            for (var j:int = 0; j < 5000000; j++)
            {
                ++i;
            }
            var endThree:Number = getTimer();

            trace("loop 1: " + (endOne - startOne));
            trace("loop 2: " + (endTwo - startTwo));
            trace("loop 3: " + (endThree - startThree));
        }
    }
}

据我了解，i++ 最终等价于 i = i+1;例外情况是，如果在该行上发生赋值，则将使用 i 的当前值，并且稍后的指令会将 i 加一。 ++i 只是意味着在对这一行进行任何其他操作之前将 i 加 1。最终，我认为这些选项中的任何一个都不会真正影响性能，从我所做的每一次测试来看，闪存进程在任何给定时刻的 CPU 调度比任何给定的运算符都具有更大的影响。

如果我用来测试的代码有问题，请指出。

编辑

更新了代码以包含 while 循环选项，但仍然没有看到任何看似积极的显着差异：

loop 1: 3695
loop 2: 3698
loop 3: 3690
loop 4: 3711

loop 1: 3758
loop 2: 3651
loop 3: 3707
loop 4: 3676

[TestLoopSpeed.as] 更新了精美的 while 循环预增量操作

package
{
    import flash.display.Sprite;
    import flash.utils.getTimer;

    public class TestLoopSpeed extends Sprite
    {
        public function TestLoopSpeed()
        {
            var timeNow:Number = getTimer();
            var i:int = 0;

            var startOne:Number = getTimer();
            for (var j:int = 0; j < 50000000; j++)
            {
                i=i+1;
            }
            var endOne:Number = getTimer();


            var startTwo:Number = getTimer();
            i = 0;
            for (var j:int = 0; j < 50000000; j++)
            {
                i++;
            }
            var endTwo:Number = getTimer();

            var startThree:Number = getTimer();
            i = 0;
            for (var j:int = 0; j < 50000000; j++)
            {
                ++i;
            }
            var endThree:Number = getTimer();

            var startFour:Number = getTimer();
            i = 0;
            var j:int = -1;
            while (++j < 50000000)
            {
                ++i;
            }
            var endFour:Number = getTimer();

            trace("loop 1: " + (endOne - startOne));
            trace("loop 2: " + (endTwo - startTwo));
            trace("loop 3: " + (endThree - startThree));
            trace("loop 4: " + (endFour - startFour));
        }
    }
}

【讨论】：

【解决方案3】：

++ 和 -- 运算符被设计为类似于用于增量和减量的汇编代码，但现在它不应该对编译器的进步产生太大影响。 See section increase and decrease

这可能是实现中的更改或 actionscript 虚拟机中的临时 regression。

【讨论】：

【解决方案4】：

我没有回复您的问题，但以下是我尝试过的所有循环中最快的。

import flash.utils.getTimer;

var t:int = getTimer();
var i:int = 0, j:int = -1;
while (++j < 5000000) {
    i += 1;
}
trace(getTimer()-t)

这给了我 83 毫秒。

【讨论】：

【解决方案5】：

我建议不要使用i++;，而是使用++i;，因为它比你提到的都快。

看看这个很好的解释：What is more efficient i++ or ++i?

【讨论】：

值得一提的是，变量在每次操作后都不会保持相同的值，这意味着如果不更改使用该变量的代码，它们就不能互换。