编写一个程序，该程序可以永久运行，并在运行时间越长的时候就在堆上分配越来越多的内存，至少要等到达到操作系统对可分配内存量的限制为止。

许多内核实际上不会保留分配给您的内存，除非您将其用于某些事物，所以如果您的程序是C语言或其他低级语言，则必须确保在每个页面上都写一些东西。如果您使用的是解释语言，则可能不必担心这一点。

最短的代码胜出。

Funge-98（cfunge），1个字节

9

我本该早些发布，但决定对其进行测试，并且花了一些时间才能使我的计算机恢复可用状态。cfunge将Funge堆栈存储在操作系统的堆上（通过以较小的内存限制运行该程序很容易验证，这是我应该早做的事情！），从而使堆栈无限增长（就像该程序一样，它只是9反复推送；默认情况下，从行尾换行回头的Funge程序将永远分配内存。该程序可能还可以在某些Befunge-93实现中使用。

更有趣的：

"NULL #(4

这是我的第一个想法，并且是一个不依赖于Funge堆栈的无限分配（尽管它也会炸毁Funge堆栈）。首先，该"命令将程序其余部分的副本推入堆栈（它是一个字符串，并且程序自动换行，因此，右引号也用作开引号）。然后N反射（默认情况下没有意义），导致程序向后运行。将"再次运行，并推动程序堆栈-反过来想这一次，与N在堆栈的顶部-然后程序环绕，加载库有4个字母的域名（4(;该NULL库的一部分cfunge的标准库）。NULL定义所有大写字母以进行反射，因此，L反射#跳过返回时的库加载，4将我们不关心的垃圾推入堆栈，并从头开始重复整个程序。鉴于多次加载一个库会产生影响，并且要求该库的命令列表对于该库的每个副本都必须存储一次（这是Funge-98的语义所隐含的），因此它会通过非堆栈存储泄漏内存（相对于语言而不是OS定义“堆”的另一种方法）。

Brainfuck，5个字节

+[>+]

这就需要一个对磁带长度没有限制的解释器。

Bash + coreutils，5个

要么

红宝石，5岁

`yes`

yes产生无尽的输出。把yes在反引号告诉shell来捕获所有输出，然后执行该输出的命令。Bash将继续为该无休止的字符串分配内存，直到堆用完。当然，结果输出最终将是无效命令，但在此之前我们应该用光内存。

感谢@GB指出这也是红宝石的通配符。

Python，16个字节

保持嵌套a直到出现错误：

a=0
while 1:a=a,

前几个迭代（如元组）如下所示：

0
(0,)
((0,),)
(((0,),),)

等等等等。

> <>（Fish），1个字节

0

在这里尝试！

0 实际上可以代替任何十六进制数1-f。

说明

0在> <>中，只需为鱼游动创建一个1x1代码箱。它会不断0向堆栈中添加一个，然后向右游动，这会循环返回到0，并将其再次添加到堆栈中。这将永远持续下去。

Java 101字节

class A{public void finalize(){new A();new A();}public static void main(String[]a){for(new A();;);}}

创建并丢弃对象后，将主程序捕获到一个无限循环中。垃圾收集通过为每个删除的对象创建2个对象来完成泄漏的工作

Perl，12个字节

{$"x=9;redo}

在perl中， x运算符在左侧带有一个字符串，在右侧带有一个数字，产生一个重复的字符串。因此"abc" x 3评估为"abcabcabc"。

的x=操作者变异左边参数，具有重复它的内容多次其右手侧表示的结果置换其左边的变量的内容。

Perl具有许多奇怪的内置变量名称，其中一个是$"，其初始值为一个空格。

该redo运营商跳转到封闭的开始{}。

第一次完成x=运算符时，它将值$"从" "“ 更改为" "，这是9位。

第二次x=操作员完成后，将的值更改$"为" "，这是81位。

第三次 $"成为一个729字节长的空格字符串。

我认为您可以看到问题所在:)。

sed，5个字节

打高尔夫球

H;G;D

用法（任何输入都可以）

sed 'H;G;D' <<<""

讲解

#Append a newline to the contents of the hold space, 
#and then append the contents of the pattern space to that of the hold space.
H

#Append a newline to the contents of the pattern space, 
#and then append the contents of the hold space to that of the pattern space. 
G

#Delete text in the pattern space up to the first newline, 
#and restart cycle with the resultant pattern space.
D

屏幕截图

在线尝试！

Haskell，23个 19字节

main=print$sum[0..]

打印无限列表的总和

C ++（使用g ++编译器），27 23 15字节

感谢Neop帮助我删除4个字节

该解决方案实际上不会泄漏任何内存，因为它会分配堆栈中的所有内容，从而导致堆栈溢出。它只是无限递归的。每次递归都会导致分配一些内存，直到堆栈溢出为止。

main(){main();}

替代解决方案

此解决方案实际上会泄漏内存。

main(){for(;;new int);}

Valgrind输出

这是Valgrind的输出，它在运行时间结束几秒钟后终止了程序。您可以看到它肯定是在泄漏内存。

==2582== LEAK SUMMARY:
==2582==    definitely lost: 15,104,008 bytes in 3,776,002 blocks
==2582==    indirectly lost: 0 bytes in 0 blocks
==2582==      possibly lost: 16 bytes in 4 blocks
==2582==    still reachable: 4 bytes in 1 blocks
==2582==         suppressed: 0 bytes in 0 blocks

JAVA， 81 79 78字节

JAVA（热点） 71 70字节

我发布时比其他Java回答短（81个，后来是79个字节）：

class A{public static void main(String[]a){String x="1";for(;;)x+=x.intern();}}

如@OlivierGrégoire所建议，可以再保存一个字节：

class A{public static void main(String[]a){for(String x="1";;)x+=x.intern();}}

放置x+=x.intern()为for循环增量将无济于事，因为仍然需要使用分号来结束for语句。

正如@ETHproductions所建议的，也可以使用x+=x作品：

class A{public static void main(String[]a){String x="1";for(;;)x+=x;}}

这也可以从@OlivierGrégoire的技巧中受益：

class A{public static void main(String[]a){for(String x="1";;)x+=x;}}

我对此的唯一担忧是，不能保证在堆上分配数据，因为高效的JVM可以轻松地实现x永远不会逃脱本地功能。使用intern()避免了这种担忧，因为实习字符串最终最终存储在静态字段中。但是，HotSpot确实会生成OutOfMemoryError为该代码，因此我想它还可以。

更新：@Olivier Gregoire还指出，x+=x代码可以运行，StringIndexOutOfBoundsException而不是OOM在有大量内存可用时运行。这是因为Java使用32位int类型来索引数组（而String只是的数组char）。这不会影响x+=x.intern()解决方案，因为后者所需的内存在字符串的长度上是平方的，因此应该按比例分配到2 ^ 62个分配字节。

Perl 6、13个字节

@= eager 0..*

说明：

@ = 将结果存储到未命名的数组中

eager 使以下列表渴望

0 .. * 从零开始的无限范围

///，7个字节

/a/aa/a

不断替换a为aa，广告恶心。

Python 3，16个字节

i=9
while 1:i*=i

这是由于Python 3对整数大小没有限制；取而代之的是，整数会占用系统可以处理的内存（如果我对这的理解有误，请纠正我）。

Rust，46个字节

fn main(){loop{std::mem::forget(Box::new(1))}}

注意这个Rust程序的有趣之处，泄漏堆分配直到内存不足？

没错，没有不安全的障碍。Rust以安全代码保证了内存安全（不读取未初始化的数据，释放后读取，释放两次等），但是内存泄漏被认为是绝对安全的。甚至还有一个显式函数使编译器忘记RAII清除超出范围的变量，我在这里使用它。

TI-83十六进制组件，7字节

PROGRAM:M
:AsmPrgm
:EF6A4E
:C3959D
:C9

无限期创建appvar，直到ERR:MEMORYOS抛出。用运行Asm(prgmM)。我将每对十六进制数字都视为一个字节。

Python，8个字节

2**9**99

该OP已经允许不技术上运行“永远”程序的技术细节，但分配更多的内存比任何一台计算机可能可能处理。这不是一个googolplex（可能是10**10**10011个字节），但是天真的，该数的对数以2为底

>>> 9**99.
2.9512665430652752e+94

即10 ^ 94位代表它。WolframAlpha认为它比深网大10 ^ 76（请记住，宇宙中大约有10 ^ 80个原子）。

为什么问2而不是9？差别不大（使用9只会将位数增加的倍数log2(9) = 3.2，甚至不会改变指数）。但另一方面，由于计算更简单，因此使用2可以使程序运行更快。这意味着它会立即填满内存，而不是9版本，这会由于需要进行计算而花费更长的时间。没必要，但是如果您想“测试”这个（我确实做了），那就很好了。

果冻，3 2 字节

-1字节的感谢丹尼斯（W换行）

Wß

链接（即函数或方法）也可以用作完整程序，将其输入递归包装到列表中。

输入从零开始，因此第一遍创建列表[0]
，第二遍进行此操作[[0]]
，第三遍进行此操作[[[0]]]
，依此类推...

之前的3个BYTER，泄漏速度更快：

;Ẇß

将其输入的所有非空连续子列表递归连接到其输入。
[0]-> [0,[0]]-> [0,[0],[0],[[0]],[0,[0]]]依此类推...

Java 7，106字节

class A{public void finalize(){for(;;)Thread.yield();}public static void main(String[]a){for(;;)new A();}}

少打高尔夫球

class A{
    @Override
    public void finalize(){
        for(;;) {
            Thread.yield();
        }
    }
    public static void main(String[]a){
        for(;;){
            new A();
        }
    }
}

finalize当垃圾回收确定不再有对该对象的引用时，垃圾回收器将在对象上调用该方法。我只是简单地重新定义了该方法以使其永远循环，所以垃圾收集器从不真正释放内存。在main循环中，我创建了永远不会清除的新对象，因此最终将耗尽所有可用内存。

Java 7（有趣的替代方法），216字节

import sun.misc.*;class A{public static void main(String[]a)throws Exception{java.lang.reflect.Field f=Unsafe.class.getDeclaredField("theUnsafe");f.setAccessible(1>0);for(;;)((Unsafe)f.get(null)).allocateMemory(9);}}

少打高尔夫球

import sun.misc.*;
class A{
    public static void main(String[]a)throws Exception{
        java.lang.reflect.Field f=Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe u = (Unsafe)f.get(null);
        for(;;) {
            u.allocateMemory(9);
        }
    }
}

这比其他任何事情都有趣。该答案利用Unsafe了未公开的内部API Sun库。您可能需要更改编译器设置，以允许使用受限的API。Unsafe.allocateMemory分配指定数量的字节（不进行任何边界检查），该字节不在堆上，也不在Java的垃圾收集器管理下，因此该内存将一直存在，直到您调用Unsafe.freeMemory或jvm内存不足为止。

Haskell，24个字节

f x=f$x*x
main=pure$!f 9

Haskell的主要问题是克服惰性。main需要具有某种IO类型，因此简单地调用main=f 9将不起作用。使用main=pure(f 9)将类型f 9提升为IO类型。但是，使用like main=pure 9这样的构造不会做任何事情，不会在任何9地方返回或显示，而是将其丢弃，因此无需评估的参数pure，因此main=pure(f 9)不会导致f未调用的任何内存被分配。为了执行评估，需要$!操作员。它只是将函数应用于自变量，但首先评估自变量。因此，使用main=pure$!f 9评估f并因此连续分配更多的内存。

dc，7个字节

[ddx]dx

[ddx]将包含“ ddx”的字符串压入堆栈。dx复制它，然后将其作为代码执行（在堆栈上保留一个副本）。执行时，它会制作两个副本，然后执行一个副本，每次都在堆栈上再保留一个副本。

Haskell（使用ghc 8.0.1），11个字节

m@main=m>>m

非尾递归。main称自己，然后又称自己。

C（linux），23个字节

main(){while(sbrk(9));}

sbrk()将数据段的顶部增加给定的字节数，从而有效地增加分配给程序的内存量-至少如在输出VIRT字段中报告的那样top。这仅在Linux上有效-macOS实施显然是一种仿真，最多只能分配4MB。

所以有一个更一般的答案：

C，25个字节

main(){while(malloc(9));}

我在macOS活动监视器上观看了它。它一路上升到大约48GB，然后该进程最终收到了SIGKILL信号。FWIW我的macbook pro有16GB。据报告，大多数使用的内存已压缩。

请注意，该问题实际上要求将每个分配写入其中，此处未明确发生。但是，重要的是要注意，对于每个malloc(9)调用，分配的不仅仅是9个用户请求的字节。对于分配的每个块，都会有一个malloc标头，该标头也是从堆上的某个位置分配的，必须由malloc()内部函数写入。

Perl，4个字节

do$0

在当前的解释器中执行自身。完成后，执行返回到调用脚本，该脚本需要调用堆栈。

球拍，13个字节

(let l()(l)1)

我不确定我的答案是否属于这个问题。请让我知道是否应该删除此答案。

JavaScript的22 21 17 16 15字节

for(a=0;;)a=[a]

通过将列表包装在另一个列表中，节省了4个字节，就像@Jonathan Allan的Jelly答案一样。

@ETHProductions节省了1个字节

备用解决方案15字节（仅适用于正确的尾部调用）

f=a=>f([a]);f()

Ruby，11个字节

loop{$*<<9}

保持推9到$*，这是一个数组最初保持在命令行参数Ruby进程。

05AB1E，2个字节

[A

在线尝试！ 只会继续努力abcdefghijklmnopqrstuvwyxz入栈中，直到永恒。

所有可能的2字节解决方案：

[  # Infinite loop.
 A # Push alphabet.
 0 # Push 0.
 1 # Push 1.
 2 # Push 2.
 3 # Push 3.
 4 # Push 4.
 5 # Push 5.
 6 # Push 6.
 7 # Push 7.
 8 # Push 8.
 9 # Push 9.
 T # Push 10.
 X # Push 1.
 Y # Push 2.
 ® # Push -1.
 ¶ # Push \n.
 º # Push len(stack) > 0, so 0 once then 1 for eternity.
 ð # Push a space.
 õ # Push an empty string.
 ¾ # Push 0.
 ¯ # Push [].
 M # Push -inf.
 ) # Wrap current stack in an array.

Python，35个字节

def f(a=[]):a.append(a)
while 1:f()

a 永远不会释放，只会变得更大，直到您击中 MemoryError

您可以在Python Tutor上查看执行。

TI-BASIC，8

:Lbl A
:While 1
:Goto A

（所有1字节令牌和两个换行符）

这会不断泄漏内存，因为结构化的控制流（如While预期会被ans关闭）End会将某些内容推入堆栈（而不是OS堆栈，即堆内存中的单独堆栈）以进行跟踪。但是在这里，我们习惯于Goto离开循环（因此不End执行任何操作以将其从堆栈中删除），While再次可见，将其再次推入，等等。因此，它一直在推入它们，直到您得到ERR:MEMORY