什么是堆栈和堆？

堆栈是为执行线程预留的暂存空间。调用函数时，将在堆栈顶部保留一个块，用于存放局部变量和一些簿记数据。当该函数返回时，该块将变为未使用状态，并且可以在下次调用该函数时使用。堆栈始终按LIFO（后进先出）顺序保留；最近保留的块始终是要释放的下一个块。这使得跟踪堆栈非常简单。从堆栈中释放一个块无非就是调整一个指针。
堆是为动态分配预留的内存。与堆栈不同，堆中的块分配和释放没有强制模式。您可以随时分配一个块，并随时释放它。这使跟踪在任何给定时间分配或释放堆的哪些部分变得更加复杂。有许多自定义堆分配器可用于针对不同的使用模式调整堆性能。
每个线程都有一个堆栈，而应用程序通常只有一个堆（尽管对于不同类型的分配有多个堆并不少见）。
要直接回答您的问题：
它们在多大程度上受操作系统或语言运行时的控制？
创建线程时，操作系统会为每个系统级线程分配堆栈。通常，语言运行库会调用OS来为应用程序分配堆。
他们的范围是什么？
堆栈连接到线程，因此当线程退出时，堆栈将被回收。通常，堆是在运行时在应用程序启动时分配的，并在应用程序（技术上已退出）退出时被回收。
什么决定了它们的大小？
创建线程时设置堆栈的大小。堆的大小是在应用程序启动时设置的，但是可以随需要的空间而增长（分配器从操作系统请求更多的内存）。
是什么使速度更快？
堆栈速度更快，因为访问模式使从中分配内存和取消分配内存变得微不足道（指针/整数只是递增或递减），而堆的分配或释放则涉及到更为复杂的簿记工作。同样，堆栈中的每个字节都倾向于被非常频繁地重用，这意味着它倾向于被映射到处理器的高速缓存中，从而使其非常快。堆的另一个性能问题是，通常是全局资源的堆通常必须是多线程安全的，即，每个分配和释放都必须（通常）与程序中的“所有”其他堆访问同步。
清晰的演示：
图片来源：vikashazrati.wordpress.com
|
堆栈：
就像堆一样存储在计算机RAM中。
在堆栈上创建的变量将超出范围并自动释放。
与堆中的变量相比，分配要快得多。
用实际的堆栈数据结构实现。
存储用于参数传递的本地数据，返回地址。
当使用过多的堆栈时（可能来自无限或太深的递归，非常大的分配），可能会导致堆栈溢出。
可以在没有指针的情况下使用在堆栈上创建的数据。
如果您确切地知道在编译之前需要分配多少数据并且它不会太大，则可以使用堆栈。
通常，程序启动时已经确定了最大大小。
堆：
像堆栈一样存储在计算机RAM中。
在C ++中，必须手动销毁堆上的变量，并且切勿超出范围。使用delete，delete []或free释放数据。
与堆栈上的变量相比，分配速度较慢。
按需使用以分配数据块以供程序使用。
当有很多分配和释放时，可能会产生碎片。
在C ++或C中，在堆上创建的数据将由指针指向，并分别使用new或malloc进行分配。
如果请求分配过多的缓冲区，可能会导致分配失败。
如果您不确切知道运行时需要多少数据，或者是否需要分配大量数据，则可以使用堆。
负责内存泄漏。
例：
int foo（）
{
char * pBuffer; // <-尚未分配任何东西（不包括指针本身，后者在堆栈中分配）。
bool b = true； //分配在堆栈上。
如果（b）
{
//在堆栈上创建500个字节
字符缓冲区[500];
//在堆上创建500个字节
pBuffer =新字符[500];
} // <-缓冲区在这里释放，pBuffer不在
} // <---哎呀，这是内存泄漏，我应该调用delete [] pBuffer;
|
最重要的一点是，堆和堆栈是内存分配方式的通用术语。它们可以以许多不同的方式实现，并且这些术语适用于基本概念。
在一堆物品中，物品按照放置在另一个物品上的顺序排列在另一个物品的顶部，并且您只能删除顶部的物品（不会把整个事情推翻）。
堆栈的简单性在于您不需要维护一个表，该表包含分配的内存的每个部分的记录。您唯一需要的状态信息是指向堆栈末尾的单个指针。要分配和取消分配，您只需递增和递减该单个指针。注意：有时可以将堆栈实现为从内存部分的顶部开始，然后向下扩展而不是向上扩展。
在堆中，项的放置方式没有特定的顺序。因为没有清晰的“顶部”项目，所以您可以按任何顺序进入和移除项目。
堆分配需要完整记录分配的内存和未分配的内存，并进行一些开销维护以减少碎片，找到足够大以适合请求的大小的连续内存段，依此类推。可以随时释放内存以留下可用空间。有时，内存分配器将执行维护任务，例如通过移动分配的内存来对内存进行碎片整理或垃圾回收-在运行时识别内存不再在作用域中并对其进行分配。
这些映像在描述堆栈和堆中分配和释放内存的两种方式方面应该做得相当不错。好吃
它们在多大程度上受操作系统或语言运行时的控制？
如前所述，堆和堆栈是通用术语，可以通过多种方式实现。计算机程序通常具有称为调用堆栈的堆栈，该堆栈存储与当前功能有关的信息，例如指向从哪个函数调用的指针以及任何局部变量。由于函数先调用其他函数然后返回，所以堆栈会不断增长和缩小，以保存来自函数的信息，直到调用堆栈为止。一个程序实际上并没有对它的运行时控制。它由编程语言，操作系统甚至系统架构决定。
堆是用于动态且随机分配的任何内存的通用术语。即出现故障。内存通常由OS分配，应用程序调用API函数进行此分配。管理动态分配的内存需要相当大的开销，通常由所使用的编程语言或环境的运行时代码来处理。
他们的范围是什么？
调用栈是一个低级的概念，从编程的意义上讲它与“作用域”无关。如果您分解一些代码，则会看到指向堆栈部分的相对指针样式引用，但是就高级语言而言，该语言强加了自己的作用域规则。但是，堆栈的一个重要方面是，一旦函数返回，该函数本地的任何内容都会立即从堆栈中释放出来。鉴于您的编程语言是如何工作的，因此可以按照您期望的方式工作。在堆中，也很难定义。范围是操作系统公开的任何内容，但是您的编程语言可能会添加有关其在应用程序中的“作用域”的规则。处理器体系结构和操作系统使用虚拟寻址，虚拟寻址将处理器转换为物理地址，并且存在页面错误等。它们跟踪哪些页面属于哪些应用程序。但是，您根本不需要担心这一点，因为您只需使用编程语言用来分配和释放内存的任何方法，并检查错误（如果分配/释放由于任何原因而失败）。
什么决定了它们的大小？
同样，它取决于语言，编译器，操作系统和体系结构。堆栈通常是预先分配的，因为根据定义，它必须是连续的内存。语言编译器或操作系统确定其大小。您不会在堆栈上存储大量数据，因此它将足够大，以至于永远不要完全使用它，除非发生不必要的无穷递归（因此，“堆栈溢出”）或其他异常的编程决策。
堆是可以动态分配的任何事物的通用术语。根据您看待它的方式，它会不断变化的大小。在现代处理器和操作系统中，它的确切工作方式无论如何都是非常抽象的，因此您通常不必担心它的内在工作方式，除非（在允许它的语言中）不得使用您尚未分配或已释放的内存。
是什么使速度更快？
堆栈速度更快，因为所有可用内存始终是连续的。无需维护所有可用内存段的列表，只需一个指向堆栈当前顶部的指针即可。为此，编译器通常将此指针存储在特殊的快速寄存器中。更重要的是，堆栈上的后续操作通常集中在内存的非常近的区域中，这在非常低的水平上有利于通过处理器上的处理器进行优化缓存。
|
（我将此答案从另一个或多或少是这个问题的重复的问题上移开了。）
您问题的答案是特定于实现的，并且可能因编译器和处理器体系结构而异。但是，这是一个简化的说明。
堆栈和堆都是从底层操作系统分配的内存区域（通常是虚拟内存，按需映射到物理内存）。
在多线程环境中，每个线程将具有其自己的完全独立的堆栈，但它们将共享堆。并发访问必须在堆上进行控制，而在堆栈上则不可能。
堆
堆包含已用和可用块的链接列表。堆上的新分配（通过new或malloc）是通过从一个空闲块中创建一个合适的块来满足的。这需要更新堆上的块列表。有关堆上块的元信息通常也存储在堆上每个块前面的小区域中。
随着堆的增长，通常将新块从低地址分配到高地址。因此，您可以将堆视为存储块堆，随着分配的内存，存储块的大小会增加。如果堆对于分配而言太小，则通常可以通过从底层操作系统获取更多内存来增加大小。
分配和释放许多小块可能会使堆处于这样一种状态，即在已使用的块之间散布着许多小空闲块。分配一个大块的请求可能会失败，因为即使这些空闲块的组合大小可能足够大，也没有一个空闲块足以满足分配请求。这称为堆碎片。
当与空闲块相邻的已用块被释放时，新的空闲块可以与相邻的空闲块合并以创建更大的空闲块，从而有效地减少了堆的碎片。
堆栈
堆栈通常与CPU上一个名为堆栈指针的特殊寄存器紧密配合使用。最初，堆栈指针指向堆栈的顶部（堆栈中的最高地址）。
CPU具有用于将值压入堆栈并从堆栈弹出的特殊指令。每次推送将值存储在堆栈指针的当前位置，并减小堆栈指针。 pop检索堆栈指针所指向的值，然后增加堆栈指针（不要因向堆栈中添加值会减少堆栈指针，而删除值会增加堆栈指针这一事实而感到困惑。请记住，堆栈会增长为底端）。存储和检索的值是CPU寄存器的值。
调用函数时，CPU使用特殊指令来推送当前指令指针，即在堆栈上执行的代码的地址。然后，通过设置CPU跳转到该功能。
指令指针指向所调用函数的地址。稍后，当函数返回时，旧的指令指针会从堆栈中弹出，并在调用函数后立即在代码处恢复执行。
输入函数后，将减少堆栈指针，以在堆栈上为本地（自动）变量分配更多空间。如果函数具有一个局部32位变量，则在堆栈上预留4个字节。当函数返回时，将堆栈指针移回以释放分配的区域。
如果函数具有参数，则在调用函数之前将它们压入堆栈。函数中的代码然后可以从当前堆栈指针向上浏览堆栈以找到这些值。
嵌套函数调用的工作方式就像一种魅力。每个新的调用将分配函数参数，局部变量的返回地址和空间，并且这些激活记录可以堆叠用于嵌套调用，并在函数返回时以正确的方式展开。
由于堆栈是有限的内存块，因此您可能会通过调用过多的嵌套函数和/或为局部变量分配过多的空间而导致堆栈溢出。通常，用于堆栈的存储区的设置方式是，在堆栈底部（最低地址）以下进行写入将触发CPU陷阱或异常。然后，运行时可以捕获这种异常情况，并将其转换为某种堆栈溢出异常。
可以在堆而不是堆栈上分配函数吗？
否，函数（即本地或自动变量）的激活记录分配在堆栈上，该记录不仅用于存储这些变量，还用于跟踪嵌套的函数调用。
堆的管理方式实际上取决于运行时环境。 C使用malloc，C ++使用new，但是许多其他语言具有垃圾回收。
但是，堆栈是与处理器体系结构紧密相关的更底层的功能。在没有足够空间的情况下增长堆并不难，因为它可以在处理堆的库调用中实现。但是，堆栈的增长通常是不可能的，因为只有在为时已晚时才发现堆栈溢出。并关闭执行线程是唯一可行的选择。
|
在下面的C＃代码中
公共无效Method1（）
{
int i = 4;
整数y = 2;
class1 cls1 =新的class1（）;
}
这是管理内存的方式
仅需要持续函数调用的局部变量就进入堆栈。堆用于变量，这些变量的寿命我们并不是很早就知道，但是我们希望它们能持续一段时间。在大多数语言中，至关重要的是，我们要在编译时知道要将变量存储在堆栈中的大小。
对象（随着我们更新它们的大小而变化）在堆上，因为我们在创建时不知道它们将持续多长时间。在许多语言中，都是对垃圾堆进行垃圾收集，以查找不再具有任何引用的对象（例如cls1对象）。
在Java中，大多数对象直接进入堆。在C / C ++之类的语言中，当不处理指针时，结构和类通常可以保留在堆栈中。
更多信息可以在这里找到：
堆栈和堆内存分配之间的区别«timmurphy.org
和这里：
在堆栈和堆上创建对象
本文是上述图片的来源：六个重要的.NET概念：堆栈，堆，值类型，引用类型，装箱和拆箱-CodeProject
但请注意，其中可能包含一些错误。
|
堆栈
当您调用一个函数时，该函数的参数以及其他一些开销会放在堆栈上。一些信息（例如返回目的地）也存储在此处。
当您在函数内声明变量时，该变量也分配在堆栈上。
取消分配栈非常简单，因为您总是以相反的顺序进行分配。输入函数时会添加堆栈内容，退出函数时会删除相应的数据。这意味着除非您调用许多调用许多其他函数的函数（或创建递归解决方案），否则您往往会停留在堆栈的较小区域内。
堆
堆是用于将创建的数据动态放置的位置的通用名称。如果您不知道程序将要创建多少个太空飞船，则很可能使用新的（或malloc或等效的）运算符来创建每个太空飞船。这种分配将持续一段时间，因此很可能我们将以与创建它们不同的顺序释放事物。
因此，堆要复杂得多，因为最终会出现一些未使用的内存区域与块相互交错的情况-内存碎片化了。寻找所需大小的可用内存是一个难题。这就是为什么应该避免使用堆的原因（尽管仍然经常使用它）。
实作
堆栈和堆的实现通常取决于运行时/ OS。通常，性能至关重要的游戏和其他应用程序会创建自己的内存解决方案，这些解决方案会从堆中获取大量内存，然后在内部进行分配，以避免依赖OS来获取内存。
仅当您的内存使用量与常规使用情况大不相同时（例如，对于您在一次大型操作中加载一个关卡并在另一次大型操作中可以占用全部内存的游戏），这才是实用的。
内存中的物理位置
这与您想像的不太相关，因为有一种称为虚拟内存的技术，该技术使您的程序认为您可以访问物理数据在其他地方（甚至在硬盘上）的某个地址。随着调用树的深入，您为堆栈获取的地址将按升序排列。堆的地址是不可预测的（即特定于隐含的），并且坦率地说并不重要。
|
为了澄清，此答案的信息不正确（托马斯在评论后将其答案固定，很酷:)）。其他答案只是避免解释静态分配的含义。因此，我将在下面解释三种主要的分配形式，以及它们通常与堆，堆栈和数据段的关系。我还将在C / C ++和Python中显示一些示例，以帮助人们理解。
未在堆栈上分配“静态”（又称静态分配）变量。不要这么假设-许多人这样做只是因为“静态”听起来很像“堆栈”。它们实际上既不存在于堆栈中，也不存在于堆中。是所谓的数据段的一部分。
但是，通常最好考虑“范围”和“生存期”，而不是“堆栈”和“堆”。
范围是指代码的哪些部分可以访问变量。通常，我们认为本地范围（只能由当前函数访问）与全局范围（可以在任何地方访问）相比，尽管范围会变得更加复杂。
生存期是指在程序执行期间何时分配和释放变量。通常我们认为静态分配（可变会在程序的整个过程中持续存在，这对于在多个函数调用中存储相同信息很有用）与自动分配（变量仅在单次调用函数期间保持不变，使其对存储仅在您的过程中使用的信息有用）功能，可以在完成后就丢弃）与动态分配（变量的持续时间在运行时定义，而不是像静态或自动那样在编译时定义）。
尽管大多数编译器和解释器在使用堆栈，堆等方面都类似地实现了此行为，但只要行为正确，编译器有时可能会破坏这些约定。例如，由于优化，即使大多数局部变量存在于堆栈中，局部变量也可能仅存在于寄存器中或被完全删除。正如一些评论中指出的那样，您可以自由地实现一个甚至不使用堆栈或堆，而是使用其他一些存储机制的编译器（很少用，因为堆栈和堆非常有用）。
我将提供一些简单的带注释的C代码来说明所有这些。最好的学习方法是在调试器下运行程序并观察行为。如果您想阅读python，请跳到答案的结尾:)
//首次加载程序/ DLL时在数据段中静态分配
//当程序/ DLL退出时释放
//范围-可以从代码中的任何位置访问
int someGlobalVariable;
//首次加载程序时在数据段中静态分配
//当程序/ DLL退出时释放
//范围-可以从此特定代码文件中的任何位置访问
static int someStaticVariable;
//每次调用MyFunction时，都会在堆栈上分配“ someArgument”
//当MyFunction返回时，“ someArgument”被释放
//范围-只能在MyFunction（）中访问
void MyFunction（int someArgument）{
//首次加载程序时在数据段中静态分配
//当程序/ DLL退出时释放
//范围-只能在MyFunction（）中访问
static int someLocalStaticVariable;
//每次调用MyFunction时都分配在堆栈上
//当MyFunction返回时释放
//范围-只能在MyFunction（）中访问
int someLocalVariable;
//每次调用MyFunction时，在堆栈上分配一个* pointer *
//当MyFunction返回时，该指针被释放
//作用域-只能在MyFunction（）中访问指针
int * someDynamicVariable;
//此行导致在堆中分配整数的空间
//执行此行时。请注意，这不是开始
//调用MyFunction（），就像自动变量一样
//范围-只有MyFunction（）中的代码才能访问该空间
// *通过此特定变量*。
//但是，如果您将地址传递到其他地方，则该代码
//也可以访问
someDynamicVariable = new int;
//此行为堆中的整数释放空间。
//如果我们不写它，内存将被“泄漏”。
//注意堆栈和堆之间的根本区别
//必须对堆进行管理。堆栈是为我们管理的。
删除someDynamicVariable;
//在其他情况下，您无需取消分配此堆空间，
//可以将地址存储在更永久的位置，以便以后使用。
//有些语言甚至为您处理了释放问题...但是
//总是需要在某种机制下在运行时进行维护。
//当函数返回时，someArgument，someLocalVariable
//和指针someDynamicVariable被释放。
// someDynamicVariable指向的空间已经
//在返回之前释放。
返回;
}
//请注意someGlobalVariable，someStaticVariable和
// someLocalStaticVariable继续存在，但不存在
//释放，直到程序退出。
为什么区分生命周期和作用域很重要的一个特别令人毛骨悚然的示例是变量可以具有局部作用域，但具有静态生命周期-例如，上面的代码示例中的“ someLocalStaticVariable”。这些变量会使我们常见但非正式的命名习惯非常混乱。例如，当我们说“本地”时，通常是指“本地范围的自动分配的变量”，而当我们说“全局”时，通常是指“全局范围的静态分配的变量”。不幸的是，当涉及到“文件范围内的静态分配的变量”之类的事情时，许多人只是说……“呵呵”。
C / C ++中的某些语法选择会加剧此问题-例如，由于以下所示的语法，许多人认为全局变量不是“静态”的。
int var1; //具有全局作用域和静态分配
static int var2; //具有文件范围和静态分配
int main（）{返回0；}
请注意，在上面的声明中添加关键字“ static”可防止var2具有全局作用域。但是，全局var1具有静态分配。这不是直观！因此，在描述范围时，我尽量不要使用“静态”一词，而应说“文件”或“文件受限”范围之类的东西。但是，许多人使用短语“静态”或“静态作用域”来描述只能从一个代码文件访问的变量。在生命周期的上下文中，“静态”始终表示变量在程序启动时分配，并在程序退出时释放。
有些人认为这些概念是C / C ++特有的。他们不是。例如，下面的Python示例说明了所有三种分配类型（在解释性语言中可能存在一些细微的差异，我将不在这里介绍）。
从datetime导入datetime
动物类：
_FavoriteFood ='未定义'＃_FavoriteFood是静态分配的
def PetAnimal（自己）：
curTime = datetime.time（datetime.now（））＃curTime自动分配
print（“谢谢你抚摸我。但是它是” + str（curTime）+“，你应该喂我。我最喜欢的食物是” + self._FavoriteFood）
猫（动物）类：
_FavoriteFood ='tuna'＃注意，由于我们进行了覆盖，Cat类具有自己的静态分配的_FavoriteFood变量，与Animal的不同
狗类（动物）：
_FavoriteFood ='steak'＃同样，Dog类获得其自己的静态变量。重要说明-这个静态变量在Dog的所有实例之间共享，因此它不是动态的！
如果__name__ ==“ __main__”：
晶须= Cat（）＃动态分配
fido = Dog（）＃动态分配
rinTinTin = Dog（）＃动态分配
whickers.PetAnimal（）
fido.PetAnimal（）
rinTinTin.PetAnimal（）
Dog._FavoriteFood ='milkbones'
whickers.PetAnimal（）
fido.PetAnimal（）
rinTinTin.PetAnimal（）
＃输出为：
＃谢谢你抚摸我。但这是13：05：02.255000，您应该喂我。我最喜欢的食物是金枪鱼
＃谢谢你抚摸我。但这是13：05：02.255000，您应该喂我。我最喜欢的食物是牛排
＃谢谢你抚摸我。但这是13：05：02.255000，您应该喂我。我最喜欢的食物是牛排
＃谢谢你抚摸我。但这是13：05：02.255000，您应该喂我。我最喜欢的食物是金枪鱼
＃谢谢你抚摸我。但这是13：05：02.255000，您应该喂我。我最喜欢的食物是牛奶
＃谢谢你抚摸我。但这是13：05：02.256000，您应该喂我。我最喜欢的食物是牛奶
|
其他人已经很好地回答了大招，因此我将介绍一些细节。
堆栈和堆不必是单数。您拥有多个堆栈的常见情况是，如果一个进程中有多个线程。在这种情况下，每个线程都有自己的堆栈。您也可以有多个堆，例如某些DLL配置可能导致从不同堆分配不同的DLL，这就是为什么释放不同库分配的内存通常不是一个好主意的原因。
在C语言中，您可以通过使用alloca来获得可变长度分配的好处，该分配在堆栈上进行分配，而不是在堆上进行分配。此内存无法在您的return语句中保留下来，但对于暂存缓冲区很有用。
在Windows上使用不多的巨大临时缓冲区并不是免费的。这是因为编译器将生成一个堆栈探测循环，每次进入您的函数以确保堆栈存在时都会调用该循环（因为Windows在堆栈末尾使用单个保护页来检测何时需要增大堆栈。如果您访问的内存超出了堆栈末尾的一页，则会崩溃。例：
无效myfunction（）
{
char big [10000000];
//做一些仅在前99％的时间中用于前1K的操作。
}
|
其他人直接回答了您的问题，但是当试图了解堆栈和堆时，我认为考虑传统UNIX进程（没有线程和基于mmap（）的分配器）的内存布局会有所帮助。内存管理词汇表网页上有此内存布局的图表。
传统上，堆栈和堆位于进程的虚拟地址空间的相对两端。堆栈在访问时会自动增长，直至达到内核设置的大小（可以使用setrlimit（RLIMIT_STACK，...）进行调整）。当内存分配器调用brk（）或sbrk（）系统调用，将更多的物理内存页面映射到进程的虚拟地址空间时，堆就会增长。
在没有虚拟内存的系统（例如某些嵌入式系统）中，通常使用相同的基本布局，只是堆栈和堆的大小固定不变。但是，在其他嵌入式系统（例如基于Microchip PIC微控制器的嵌入式系统）中，程序堆栈是单独的内存块，数据移动指令无法对其进行寻址，并且只能通过程序流指令（调用，返回等）。其他体系结构（例如Intel Itanium处理器）具有多个堆栈。从这个意义上讲，堆栈是CPU体系结构的元素。
|
堆栈是一部分可以通过几种关键的汇编语言指令来操作的内存，例如“ pop”（从堆栈中删除并返回值）和“ push”（将值推入堆栈），但也可以调用（调用子例程-这压入地址以返回到堆栈）并返回（从子例程返回-这将地址从堆栈中弹出并跳转到该地址）。它是堆栈指针寄存器下方的内存区域，可以根据需要进行设置。堆栈还用于将参数传递给子例程，还用于在调用子例程之前将值保留在寄存器中。
堆是操作系统通常通过诸如malloc之类的syscall分配给应用程序的一部分内存。在现代OS上，此内存是只有调用进程才能访问的一组页面。
堆栈的大小是在运行时确定的，通常在程序启动后不会增长。在C程序中，堆栈必须足够大以容纳每个函数中声明的每个变量。堆将根据需要动态增长，但是操作系统最终会进行调用（它通常会使堆增长超过malloc请求的值，因此至少将来的某些malloc不需要返回内核来完成）获得更多内存。此行为通常可以自定义）
因为在启动程序之前已经分配了堆栈，所以您不需要使用malloc就可以使用堆栈，因此那是一个小优点。在实践中，很难预测在具有虚拟内存子系统的现代操作系统中哪些将是快的，哪些将是慢的，因为页面的实现方式和存储位置是实现细节。
|
什么是堆栈？
堆栈是一堆物体，通常是整齐排列的物体。
计算体系结构中的堆栈是存储器的区域，在其中以后进先出的方式添加或删除数据。
在多线程应用程序中，每个线程将具有自己的堆栈。
什么是堆？
堆是随意堆放的东西的不整洁集合。
在计算体系结构中，堆是由操作系统或内存管理器库自动管理的动态分配内存区域。
在程序执行期间定期对堆上的内存进行分配，释放和调整大小，这可能导致称为碎片的问题。
当在内存对象之间分配的很小的空间太小而无法容纳其他内存对象时，就会发生碎片。
最终结果是无法用于进一步的内存分配的堆空间的百分比。
两者一起
在多线程应用程序中，每个线程将具有自己的堆栈。但是，所有不同的线程将共享堆。
因为不同的线程在多线程应用程序中共享堆，所以这也意味着线程之间必须进行某种协调，以便它们不会尝试访问和操作堆中相同的内存同一时间。
哪个更快-堆栈还是堆？又为什么呢
堆栈比堆快得多。
这是因为在堆栈上分配内存的方式。
在堆栈上分配内存就像向上移动堆栈指针一样简单。
对于刚接触编程的人来说，使用堆栈可能是个好主意，因为它比较容易。
因为堆栈很小，所以当您确切知道数据将需要多少内存时，或者如果您知道数据的大小很小时，您可能希望使用它。
当您知道您的数据将需要大量内存，或者您不确定需要多少内存（例如动态数组）时，最好使用堆。
Java内存模型
堆栈是存储局部变量（包括方法参数）的内存区域。当涉及对象变量时，这些仅仅是对堆上实际对象的引用（指针）。
每次实例化一个对象时，都会将一堆堆内存放在一边以保存该对象的数据（状态）。由于对象可以包含其他对象，因此其中的某些数据实际上可以保存对这些嵌套对象的引用。
|
我认为许多其他人在这个问题上给了您大多数正确的答案。
但是，遗漏的一个细节是“堆”实际上应该称为“免费存储”。产生这种区别的原因是原始的免费存储区是通过称为“二项式堆”的数据结构实现的。因此，从早期实现的malloc（）/ free（）进行分配是从堆进行分配。但是，在当今的今天，大多数免费存储都是使用非常复杂的数据结构实现的，这些数据结构不是二项式堆。
|
您可以使用堆栈做一些有趣的事情。例如，您具有诸如alloca之类的功能（假设您可以绕过有关其使用的大量警告），这是一种malloc形式，专门使用堆栈而不是堆来存储。
也就是说，基于堆栈的内存错误是我遇到过的最严重的错误。如果使用堆内存，并且超出了分配的块的边界，则触发分段错误的机会就很大。 （不是100％：您的块可能偶然与您先前分配的另一个相邻。）但是，由于在堆栈上创建的变量始终彼此相邻，因此越界写入可以更改另一个变量的值。我了解到，每当我感到程序停止遵守逻辑规则时，它就有可能是缓冲区溢出。
|
简单来说，堆栈是创建局部变量的地方。同样，每次调用子例程时，程序计数器（指向下一条机器指令的指针）和任何重要的寄存器，有时参数都被压入堆栈。然后，子例程中的所有局部变量都被压入堆栈（并从那里使用）。子例程完成后，所有东西将从堆栈中弹出。 PC和注册数据将被获取并放回弹出位置，因此程序可以继续进行。
堆是进行动态内存分配的内存区域（显式“新”或“分配”调用）。它是一种特殊的数据结构，可以跟踪大小不同的内存块及其分配状态。
在“经典”系统中，RAM的布局使得堆栈指针从内存的底部开始，堆指针从内存的顶部开始，并且它们相互靠近。如果它们重叠，则说明内存不足。但是，这不适用于现代的多线程OS。每个线程必须具有自己的堆栈，并且可以动态创建这些堆栈。
|
来自WikiAnwser。
叠放
当一个函数或方法调用另一个函数，然后又调用另一个函数等时，所有这些函数的执行将保持挂起状态，直到最后一个函数返回其值为止。
挂起的函数调用链是堆栈，因为堆栈中的元素（函数调用）相互依赖。
在异常处理和线程执行中，堆栈是重要的考虑因素。
堆
堆只是程序用于存储变量的内存。
堆的元素（变量）彼此之间没有依赖性，并且始终可以随时随地进行访问。
|
叠放
快速访问
不必显式取消分配变量
CPU有效管理空间，内存不会碎片化
仅局部变量
堆栈大小限制（取决于OS）
变量无法调整大小
堆
变量可以全局访问
内存大小无限制
（相对）访问速度较慢
无法保证有效利用空间，随着时间的流逝，随着分配内存块然后释放内存，内存可能会变得碎片化
您必须管理内存（您负责分配和释放变量）
可以使用realloc（）调整变量的大小
|
简而言之
堆栈用于存储静态内存，堆用于存储动态内存，两者均存储在计算机的RAM中。
详细
堆栈
堆栈是一个“ LIFO”（后进先出）数据结构，该结构由CPU非常紧密地管理和优化。每当函数声明一个新变量时，它都会“推送”到堆栈中。然后，每次函数退出时，该函数压入堆栈的所有变量都将被释放（也就是说，它们将被删除）。释放堆栈变量后，该内存区域可用于其他堆栈变量。
使用堆栈存储变量的优点是可以为您管理内存。您不必手动分配内存，也可以在不再需要它时释放它。此外，由于CPU如此高效地组织堆栈存储器，因此读取和写入堆栈变量的速度非常快。
在这里可以找到更多。
堆
堆是计算机内存中不会自动为您管理的区域，并且不受CPU严格管理。它是内存中更自由浮动的区域（并且更大）。要在堆上分配内存，必须使用内置的C函数malloc（）或calloc（）。在堆上分配内存后，一旦不再需要使用free（）负责分配该内存。
如果不这样做，程序将发生所谓的内存泄漏。也就是说，堆上的内存仍将被保留（并且其他进程将无法使用）。正如我们将在调试部分中看到的那样，有一个名为Valgrind的工具可以帮助您检测内存泄漏。
与堆栈不同，堆对可变大小没有大小限制（除了计算机的明显物理限制之外）。堆内存的读取和写入速度稍慢，因为必须使用指针来访问堆上的内存。我们将在短期内讨论指针。
不像堆叠堆中创建的变量可由程序中任何位置的任何函数访问。堆变量本质上是全局范围的。
在这里可以找到更多。
在堆栈上分配的变量直接存储到内存中，并且对该内存的访问非常快，并且在编译程序时会处理其分配。当一个函数或方法调用另一个函数，然后又调用另一个函数等时，所有这些函数的执行将保持挂起状态，直到最后一个函数返回其值为止。堆栈始终按LIFO顺序保留，最近保留的块始终是要释放的下一个块。这使得跟踪堆栈真的非常简单，从堆栈中释放一个块只不过是调整一个指针而已。
堆上分配的变量在运行时分配了内存，访问该内存的速度稍慢，但是堆大小仅受虚拟内存大小的限制。堆中的元素彼此之间没有依赖性，并且始终可以随时随地进行随机访问。您可以随时分配一个块，并随时释放它。这使跟踪在任何给定时间分配或释放堆的哪些部分变得更加复杂。
如果您确切知道在编译之前需要分配多少数据，并且它不会太大，则可以使用堆栈。如果您不确切知道运行时将需要多少数据，或者是否需要分配大量数据，则可以使用堆。
在多线程情况下，每个线程将拥有其自己的完全独立的堆栈，但它们将共享堆。堆栈是特定于线程的，堆是特定于应用程序的。在异常处理和线程执行中，堆栈是重要的考虑因素。
每个线程都有一个堆栈，而应用程序通常只有一个堆（尽管对于不同类型的分配有多个堆并不少见）。
在运行时，如果应用程序需要更多的堆，则可以从可用内存中分配内存，如果堆栈需要内存，则可以从可用内存中为应用程序分配的内存中分配内存。
甚至，这里和这里都给出了更多细节。
现在来回答您的问题。
它们在多大程度上受操作系统或语言运行时的控制？
创建线程时，操作系统会为每个系统级线程分配堆栈。通常，语言运行库会调用OS来为应用程序分配堆。
在这里可以找到更多。
他们的范围是什么？
已经放在顶部。
“可以使用堆栈，前提是您知道在编译之前需要分配多少数据，并且它不会太大。如果您不知道在运行时确切需要多少数据，或者您需要分配大量数据。”
在这里可以找到更多。
什么决定了它们的大小？
创建线程时，堆栈大小由OS设置。堆的大小是在应用程序启动时设置的，但是它可以根据需要的空间而增长（分配器从操作系统请求更多的内存）。
是什么使速度更快？
堆栈分配要快得多，因为它真正要做的只是移动堆栈指针。使用内存池，您可以从堆分配中获得可比的性能，但这会带来一点点复杂性和麻烦。
另外，堆栈与堆不仅是性能方面的考虑，而且还需要考虑性能。它还告诉您很多有关对象的预期寿命的信息。
可以从这里找到详细信息。
|
好吧，简单地说，它们的意思是有序而不是有序...！
堆放：在堆放物品中，东西相互叠放，这意味着将更快，更高效地进行处理！...
所以总会有一个索引来指向特定的项目，而且处理也会更快，项目之间也有关系！...
堆：没有顺序，处理会变慢，并且值被乱七八糟，没有特定的顺序或索引。。。有随机性，并且它们之间没有关系。
我还创建了下面的图像，以显示它们的外观：
|
虚拟内存中每个进程的堆栈，堆和数据：
|
在1980年代，UNIX像小兔子一样传播，大公司也自己滚动。
埃克森美孚（Exxon）和一个失去历史的品牌一样拥有一个。
内存的布局方式由许多实现者决定。
一个典型的C程序平放在内存中
通过更改brk（）值来增加机会。
通常，HEAP刚好低于此brk值
brk的增加会增加可用堆的数量。
单个STACK通常是HEAP之下的一块区域，这是一块内存
直到下一个固定的内存块的顶部，才包含任何值。
下一个块通常是CODE，可能会被堆栈数据覆盖
在那个时代著名的黑客之一中。
一个典型的内存块是BSS（零块）值）
偶然地没有在一个制造商的产品中归零。
另一个是包含初始化值的DATA，包括字符串和数字。
第三个是包含CRT（C运行时），主要，函数和库的CODE。
UNIX中虚拟内存的出现改变了许多限制。
没有客观原因可以说明这些块必须是连续的，
或大小固定，或现在以特定方式订购。
当然，在UNIX出现之前，Multics不受这些限制。
这是一个示意图，显示了那个时代的一种存储器布局。
|
几分钱：我认为，以图形方式绘制内存并且更简单会很好：
箭头-通常在线程创建API中通过参数显示增长堆栈和堆的位置，进程堆栈大小的限制（在OS中定义），线程堆栈大小的限制。堆通常受进程最大虚拟内存大小限制，例如32位2-4 GB。
如此简单的方式：进程堆是进程及其内部所有线程的通用对象，通常在诸如malloc（）之类的情况下用于内存分配。
堆栈是快速存储器，用于在通常情况下存储函数返回指针和变量，并作为函数调用中的参数（局部函数变量）进行处理。
|
由于有些答案很挑剔，所以我将贡献自己的一份力量。
令人惊讶的是，没有人提到，不仅在异类语言（PostScript）或平台（Intel Itanium）中，而且在光纤，绿色线程中都发现了多个（即与正在运行的OS级线程的数量无关）调用堆栈。以及协程的一些实现。
纤维，生丝和协程在许多方面都相似，这导致很多混乱。光纤和绿色线程之间的区别在于，前者使用协作式多任务处理，而后者则可以采用协作式或抢占式（或什至两者）。有关纤维和协程之间的区别，请参见此处。
无论如何，光纤，绿色线程和协程的目的是在一个OS级线程中同时执行多个功能，但不能并行执行（有关区别，请参见此SO问题），从而相互之间来回传递控制以有组织的方式。
使用纤维，绿线或协程时，通常每个功能都有单独的堆栈。 （从技术上讲，每个函数不仅是堆栈，而且整个执行上下文是每个函数。最重要的是，CPU寄存器。）对于每个线程，堆栈与同时运行的函数一样多，并且线程在执行每个函数之间切换根据您程序的逻辑。当函数运行到末尾时，其堆栈将被破坏。因此，堆栈的数量和生存期是动态的，而不是由OS级线程的数量决定的！
请注意，我说“通常每个函数有一个单独的堆栈”。协程既有堆栈实现又有堆栈实现。最著名的堆栈式C ++实现是Boost.Coroutine和Microsoft PPL的async / await。 （但是，C ++ 17提出的C ++可恢复函数（又称“异步并等待”）很可能使用无堆栈协程。）
即将向C ++标准库提出光纤建议。另外，还有一些第三方库。绿色线程在Python和Ruby等语言中极为流行。
|
我已经分享了一些要点，尽管要点已经涵盖了。
叠放
快速访问。
存储在RAM中。
函数调用与传递的局部变量和函数参数一起加载到此处。
当程序超出范围时，将自动释放空间。
存储在顺序存储器中。
堆
相对较慢地访问堆栈。
存储在RAM中。
动态创建的变量存储在此处，以后需要使用后释放分配的内存。
存储在完成内存分配的任何位置，始终由指针访问。
有趣的注意事项：
如果将函数调用存储在堆中，则会导致2个混乱点：
由于堆栈中的顺序存储，因此执行速度更快。堆中的存储会导致大量时间消耗，从而使整个程序的执行速度变慢。
如果函数存储在堆中（指针指向的混乱存储），则将无法返回到调用者地址（由于内存中的顺序存储，所以堆栈可以返回）。
|
哇！这么多答案，我认为其中没有一个答案正确...
1）它们在哪里和什么（物理上在真实计算机的内存中）？
堆栈是从分配给程序映像的最高内存地址开始的内存，然后从那里递减值。它保留用于调用的函数参数以及函数中使用的所有临时变量。
有两个堆：公共堆和私有堆。
私有堆从程序中代码的最后一个字节之后的16字节边界（对于64位程序）或8字节边界（对于32位程序）开始，然后增加从那里的价值。也称为默认堆。
如果私有堆太大，则它将与堆栈区域重叠；如果私有堆太大，则堆栈将与堆栈重叠。由于堆栈从较高的地址开始，然后一直向下移动至较低的地址，因此通过适当的修改，您可以使堆栈变大，以至于溢出专用堆区域并重叠代码区域。然后，诀窍是要重叠足够的代码区域，以便可以将其连接到代码中。这样做有些棘手，而且您可能会遇到程序崩溃的风险，但是它既简单又有效。
公共堆位于程序映像空间之外的自己的内存空间中。如果内存资源稀缺，则该内存将被虹吸到硬盘上。
2）它们在多大程度上受操作系统或语言运行时的控制？
堆栈是由程序员控制的，私有堆是由OS管理的，而公共堆是不受任何人控制的，因为它是OS服务-您发出请求，然后授予或拒绝它们。
2b）他们的范围是什么？
它们对程序都是全局的，但是其内容可以是私有的，公共的或全局的。
2c）是什么决定了每个尺寸？
堆栈和专用堆的大小由编译器运行时选项确定。公共堆在运行时使用size参数初始化。
2d）是什么使速度更快？
它们的设计目的不是很快，它们的目的是有用的。程序员如何利用它们确定它们是“快速”还是“慢速”
参考：
https://norasandler.com/2019/02/18/Write-a-Compiler-10.html
https://docs.microsoft.com/zh-CN/windows/desktop/api/heapapi/nf-heapapi-getprocessheap
https://docs.microsoft.com/zh-CN/windows/desktop/api/heapapi/nf-heapapi-heapcreate
|
许多答案在概念上都是正确的，但我们必须注意，硬件（即微处理器）需要一个堆栈来允许调用子例程（汇编语言中的CALL）。 （OOP家伙会称之为方法）
在堆栈上，您保存返回地址并调用→推入/退出→弹出直接在硬件中进行管理。
您可以使用堆栈来传递参数..即使它比使用寄存器要慢（微处理器专家或一本好的1980年代BIOS书籍都会这样）。
没有堆栈，微处理器将无法工作。 （我们无法想象没有子例程/函数的程序，即使是汇编语言）
没有堆就可以。 （汇编语言程序可以在没有堆的情况下工作，因为堆是OS概念，而malloc是OS / Lib调用。
堆栈使用速度更快，因为：
是硬件，甚至push / pop都非常有效。
malloc需要进入内核模式，使用锁/信号量（或其他同步原语）执行一些代码，并管理一些跟踪分配所需的结构。
|
堆是由操作系统或内存管理器库自动管理的动态分配内存区域。您可以随时分配一个块，并随时释放它。堆分配需要完整记录分配的内存和未分配的内存，并进行一些开销维护以减少碎片，找到足够大以适合请求的大小的连续内存段，依此类推。可以随时释放内存以留下可用空间。随着堆的增长，通常将新块从低地址分配到高地址。因此，您可以将堆视为存储块堆，随着分配的内存，存储块的大小会增加。如果堆对于分配而言太小，则通常可以通过从底层操作系统获取更多内存来增加大小。从堆分配的内存将保持分配状态，直到发生以下情况之一：
内存已释放
程序终止
堆栈：
就像堆一样存储在计算机RAM中。
在堆栈上创建的变量将超出范围并自动释放。
与堆中的变量相比，分配要快得多。
存储用于参数传递的本地数据，返回地址。
当使用过多堆栈时（大多数情况下可能会产生堆栈溢出）
从无限或太深的递归，非常大的分配）。
如果您确切知道需要多少数据，则可以使用堆栈
在编译时间之前分配，并且不会太大。
通常在程序执行时已经确定了最大大小
开始。
堆：
像堆栈一样存储在计算机RAM中。
在C ++中，必须手动销毁堆上的变量，并且永远不要
超出范围。
使用delete，delete []或free释放数据。
与堆栈上的变量相比，分配速度较慢。
按需使用以分配数据块以供程序使用。
当分配很多时可能会产生碎片
释放。
在C ++或C中，在堆上创建的数据将由指针指向
并分别用new或malloc分配。
如果请求太大的缓冲区可能会导致分配失败
被分配。
您如果您不知道确切多少数据，将使用堆
将在运行时或需要分配大量数据时使用。
负责内存泄漏。
|
堆栈本质上是一个易于访问的内存，仅管理其项目
作为一个很好的堆栈。只有事先知道尺寸的物品才能进入堆栈。数字，字符串，布尔值就是这种情况。
堆是您无法预先确定项目的内存
确切的尺寸和结构。由于对象和数组可以被突变和
在运行时更改时，它们必须进入堆。
资料来源：Academind
|
CPU堆栈和堆在物理上与CPU和寄存器与内存的工作方式，机器汇编语言的工作方式有关，而不与高级语言本身有关，即使这些语言可以决定什么。
所有现代CPU都遵循“相同”微处理器理论：它们全部基于所谓的“寄存器”，而有些则用于“堆栈”以获得性能。从一开始，所有CPU都有堆栈寄存器，据我所知，它们一直都在这里。汇编语言自开始以来就是相同的，尽管有所不同...直到Microsoft及其中间语言（IL）才改变了范例，使其具有OO虚拟机汇编语言。因此，将来我们将能够拥有一些CLI / CIL CPU（MS的一个项目）。
CPU具有堆栈寄存器以加快内存访问速度，但与使用其他寄存器以获得对进程的所有可用内存的完全访问权限相比，它们受到限制。这就是为什么我们谈论堆栈和堆分配的原因。
总而言之，总的来说，堆是缓慢且缓慢的，并且用于“全局”实例和对象内容，因为堆栈又小又快，并且用于“局部”变量和引用（隐藏指针以忘记管理它们）。
因此，当我们在方法中使用new关键字时，将在堆栈中创建引用（一个int），但如果记得，则将在堆中创建对象及其所有内容（值类型和对象）。但是局部基本值类型和数组是在堆栈中创建的。
内存访问的区别在于单元引用级别：寻址堆（进程的整体存储器）在处理CPU寄存器方面需要更多的复杂性，而堆栈在寻址方面要“本地”得多，因为CPU栈我记得，寄存器用作基址。
这就是为什么当我们有很长或无限的递归调用或循环时，我们很快就会出现堆栈溢出，而又不会冻结现代计算机上的系统的情况。
.NET中的C＃堆与堆栈
堆叠与堆：了解差异
将静态类内存分配存储在C＃中
什么是堆栈和堆？
https://zh.wikipedia.org/wiki/内存管理
https://zh.wikipedia.org/wiki/Stack_register
汇编语言资源：
汇编编程教程
英特尔®64和IA-32架构软件开发人员手册
|
感谢您进行了很好的讨论，但是作为一个真正的菜鸟，我想知道将指令保存在哪里？在开始阶段，科学家们在两种架构之间做出决定（冯·纽曼（von NEUMANN）将所有内容都视为数据，而哈佛（HARVARD）则将内存区域用于指令，而另一区域用于数据）。最终，我们采用了冯·诺依曼（von Neumann）的设计，现在一切都被认为是“相同的”。当我学习汇编时，这使我很难
https://www.cs.virginia.edu/~evans/cs216/guides/x86.html
因为他们谈论寄存器和堆栈指针。
以上所有内容都谈到了DATA。我的猜测是，由于指令是具有特定内存占用空间的已定义事物，因此它将进入堆栈，因此汇编中讨论的所有“那些”寄存器都位于堆栈中。当然，然后是面向对象的程序设计，其中指令和数据混合成一个动态的结构，因此指令现在也将保留在堆中吗？
|
高度活跃的问题。赢得10个声誉才能回答这个问题。信誉要求有助于保护该问题免受垃圾邮件和非答复活动的侵害。
不是您要找的答案？浏览其他标记为内存管理堆栈语言不可知的堆动态内存分配的问题，或者询问您自己的问题。