heap

栈是存放函数调用过程中的临时变量的！ 堆是程序运行过程中动态申请的内存的存放处的！比如new的对象就在堆上在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因。按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的. 静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.栈式存储分配也可称为动态存储分配,栈式存储分配要求在过程的入口处必须知道所有的存储要求,而堆式存储分配则专门负责在编译时或运行时模块入口处都无法确定存储要求的数据结构的内存分配。从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的，栈主要是用来执行程序的.

引用：http://www.blogjava.net/cjren/archive/2006/07/06/56989.aspx上午看某文章时候涉及缓冲区溢出的问题，谈到C的栈和堆，有所不懂于是baidu了一下发现论坛上的解释都较为凌乱，google一下后发现国外大学的Lecture Notes 中有不少的说明，下面简单的摘录三段，一是c中的，二是对于java的，三是从os角度看的。Stack vs Heap AllocationHow the memory of the computer is organized for a running program? When a program is loaded into memory, it is organized into three areas of memory, called segments: the text segment, stack segment, and heap segment. The text segment (sometimes also called the code segment) is where the compiled code of the program itself resides. This is the machine language representation of the program steps to be carried out, including all functions making up the program, both user defined and system.The remaining two areas of system memory is where storage may be allocated by the compiler for data storage. The stack is where memory is allocated for automatic variables within functions. A stack is a Last In First Out (LIFO) storage device where new storage is allocated and deallocated at only one ``end"", called the Top of the stack. This can be seen in Figure 14.13. figure14.13.gifWhen a program begins executing in the function main(), space is allocated on the stack for all variables declared within main(), as seen in Figure 14.13(a). If main() calls a function, func1(), additional storage is allocated for the variables in func1() at the top of the stack as shown in Figure 14.13(b). Notice that the parameters passed by main() to func1() are also stored on the stack. If func1() were to call any additional functions, storage would be allocated at the new Top of stack as seen in the figure. When func1() returns, storage for its local variables is deallocated, and the Top of the stack returns to to position shown in Figure 14.13(c). If main() were to call another function, storage would be allocated for that function at the Top shown in the figure. As can be seen, the memory allocated in the stack area is used and reused during program execution. It should be clear that memory allocated in this area will contain garbage values left over from previous usage.The heap segment provides more stable storage of data for a program; memory allocated in the heap remains in existence for the duration of a program. Therefore, global variables (storage class external), and static variables are allocated on the heap. The memory allocated in the heap area, if initialized to zero at program start, remains zero until the program makes use of it. Thus, the heap area need not contain garbage.小结：Stack: automatic variables within functionsHeap: global variables (storage class external), and static variables============================In java 情况如下(1) The stack is the program memory area, so all your primitive type variables and the memory adress of your objects are written on the stack. It is a fast access valuable memory area.The heap is where the VM keeps the objects, and it is a huge amount of memory. When you create an object, the VM puts the object in the HEAP and puts the adress of the object created on the STACK.(2) There are two kinds of memory used in Java. These are called stack memory and heap memory. Stack memory stores primitive types and the addresses of objects. The object values are stored in heap memory. An object reference on the stack is only an address that refers to the place in heap memory where that object is kept. It is useful to know that these two different kinds of memory exist in Java. Stack memory is the program"s memory, and heap memory resides outside of the program.这好像有点跟C的不同（相反）。引入一点垃圾回收机制的知识 When you need a new object, Java allocates the required memory. When you are done with an object, the memory is reclaimed for you automatically via Java"s garbage collection facility. Garbage collection runs as a thread in the background, looking for objects that no longer have a usable reference. When it finds them, it destroys them and reclaims the memory. The implementation of garbage collection varies between Java Virtual Machines. They generally follow the same process, however. First, the garbage collector gets a snapshot of all running threads and all loaded classes. Then, all objects that are referred to by this thread set are marked as current. The process stops when all objects that it is possible to reach have been marked and the rest have been discarded. In order to help the Virtual Machine, it is a good idea to remove your references to unneeded objects. This is often done by simply setting your reference to null: Test t = new Test(); t.someAction(); // all done t = null;小结：Stack: Primitive data types(primitive types), the addresses of objects(=references).Heap: objects.===============================================从系统的角度看 stack（栈）和heap(堆）Dynamic Data Structures: The HeapA typical personal computer or workstation today has somewhere between 16 and 64 megabytes of RAM installed. Using a technique called virtual memory, the system can swap pieces of memory on and off the machine"s hard disk to create an illusion for the CPU that it has much more memory, for example 200 to 500 megabytes. While this illusion is complete as far as the CPU is concerned, it can sometimes slow things down tremendously from the user"s perspective. Despite this drawback, virtual memory is an extremely useful technique for "increasing" the amount of RAM in a machine in an inexpensive way. Let"s assume for the sake of this discussion that a typical computer has a total memory space of, for example, 50 megabytes (regardless of whether that memory is implemented in real RAM or in virtual memory).The operating system on the machine is in charge of the 50-megabyte memory space. The operating system uses the space in several different ways, as shown here: c-heap.gifThe operating system and several applications, along with their global variables and stack spaces, all consume portions of memory. When a program completes execution, it releases its memory for reuse by other programs. Note that part of the memory space remains unused at any given time.This is, of course, an idealization, but the basic principles are correct. As you can see, memory holds the executable code for the different applications currently running on the machine, along with the executable code for the operating system itself. Each application has certain global variables associated with it. These variables also consume memory. Finally, each application uses an area of memory called the stack, which holds all local variables and parameters used by any function. The stack also remembers the order in which functions are called so that function returns occur correctly. Each time a function is called, its local variables and parameters are "pushed onto" the stack. When the function returns, these locals and parameters are "popped." Because of this, the size of a program"s stack fluctuates constantly as the program is running, but it has some maximum size.As a program finishes execution, the operating system unloads it, its globals and its stack space from memory. A new program can make use of that space at a later time. In this way, the memory in a computer system is constantly "recycled" and reused by programs as they execute and complete.In general, perhaps 50 percent of the computer"s total memory space might be unused at any given moment. The operating system owns and manages the unused memory, and it is collectively known as the heap. The heap is extremely important because it is available for use by applications during execution using the C functions malloc (memory allocate) and free. The heap allows programs to allocate memory exactly when they need it during the execution of a program, rather than pre-allocating it with a specifically-sized array declaration.

简单来说， SetMaxHeap 提供了一种可以设置固定触发阈值的 GC （Garbage Collection垃圾回收）方式 官方源码链接 https://go-review.googlesource.com/c/go/+/227767/3 大量临时对象分配导致的 GC 触发频率过高， GC 后实际存活的对象较少， 或者机器内存较充足，希望使用剩余内存，降低 GC 频率的场景 GC 会 STW （ Stop The World ），对于时延敏感场景，在一个周期内连续触发两轮 GC ，那么 STW 和 GC 占用的 CPU 资源都会造成很大的影响， SetMaxHeap 并不一定是完美的，在某些场景下做了些权衡，官方也在进行相关的实验，当前方案仍没有合入主版本。 先看下如果没有 SetMaxHeap ，对于如上所述的场景的解决方案 这里简单说下 GC 的几个值的含义，可通过 GODEBUG=gctrace=1 获得如下数据 这里只关注 128->132->67 MB 135 MB goal ， 分别为 GC开始时内存使用量 -> GC标记完成时内存使用量 -> GC标记完成时的存活内存量 本轮GC标记完成时的 预期 内存使用量（上一轮 GC 完成时确定） 引用 GC peace设计文档 中的一张图来说明 对应关系如下： 简单说下 GC pacing （信用机制） GC pacing 有两个目标， 那么当一轮 GC 完成时，如何只根据本轮 GC 存活量去实现这两个小目标呢？ 这里实际是根据当前的一些数据或状态去 预估 “未来”，所有会存在些误差 首先确定 gc Goal goal = memstats.heap_marked + memstats.heap_marked*uint64(gcpercent)/100 heap_marked 为本轮 GC 存活量， gcpercent 默认为 100 ，可以通过环境变量 GOGC=100 或者 debug.SetGCPercent(100) 来设置 那么默认情况下 goal = 2 * heap_marked gc_trigger 是与 goal 相关的一个值（ gc_trigger 大约为 goal 的 90% 左右），每轮 GC 标记完成时，会根据 |Ha-Hg| 和实际使用的 cpu 资源 动态调整 gc_trigger 与 goal 的差值 goal 与 gc_trigger 的差值即为，为 GC 期间分配的对象所预留的空间 GC pacing 还会预估下一轮 GC 发生时，需要扫描对象对象的总量，进而换算为下一轮 GC 所需的工作量，进而计算出 mark assist 的值 本轮 GC 触发（ gc_trigger ），到本轮的 goal 期间，需要尽力完成 GC mark 标记操作，所以当 GC 期间，某个 goroutine 分配大量内存时，就会被拉去做 mark assist 工作，先进行 GC mark 标记赚取足够的信用值后，才能分配对应大小的对象 根据本轮 GC 存活的内存量（ heap_marked ）和下一轮 GC 触发的阈值（ gc_trigger ）计算 sweep assist 的值，本轮 GC 完成，到下一轮 GC 触发（ gc_trigger ）时，需要尽力完成 sweep 清扫操作 预估下一轮 GC 所需的工作量的方式如下： 继续分析文章开头的问题，如何充分利用剩余内存，降低 GC 频率和 GC 对 CPU 的资源消耗 如上图可以看出， GC 后，存活的对象为 2GB 左右，如果将 gcpercent 设置为 400 ，那么就可以将下一轮 GC 触发阈值提升到 10GB 左右 前面一轮看起来很好，提升了 GC 触发的阈值到 10GB ，但是如果某一轮 GC 后的存活对象到达 2.5GB 的时候，那么下一轮 GC 触发的阈值，将会超过内存阈值，造成 OOM （ Out of Memory ），进而导致程序崩溃。 可以通过 GOGC=off 或者 debug.SetGCPercent(-1) 来关闭 GC 可以通过进程外监控内存使用状态，使用信号触发的方式通知程序，或 ReadMemStats 、或 linkname runtime.heapRetained 等方式进行堆内存使用的监测 可以通过调用 runtime.GC() 或者 debug.FreeOSMemory() 来手动进行 GC 。 这里还需要说几个事情来解释这个方案所存在的问题 通过 GOGC=off 或者 debug.SetGCPercent(-1) 是如何关闭 GC 的？ gc 4 @1.006s 0%: 0.033+5.6+0.024 ms clock, 0.27+4.4/11/25+0.19 ms cpu, 428->428->16 MB, 17592186044415 MB goal, 8 P (forced) 通过 GC trace 可以看出，上面所说的 goal 变成了一个很诡异的值 17592186044415 实际上关闭 GC 后， Go 会将 goal 设置为一个极大值 ^uint64(0) ，那么对应的 GC 触发阈值也被调成了一个极大值，这种处理方式看起来也没什么问题，将阈值调大，预期永远不会再触发 GC 那么如果在关闭 GC 的情况下，手动调用 runtime.GC() 会导致什么呢？ 由于 goal 和 gc_trigger 被设置成了极大值， mark assist 和 sweep assist 也会按照这个错误的值去计算，导致工作量预估错误，这一点可以从 trace 中进行证明 可以看到很诡异的 trace 图，这里不做深究，该方案与 GC pacing 信用机制不兼容 记住，不要在关闭 GC 的情况下手动触发 GC ，至少在当前 Go1.14 版本中仍存在这个问题 SetMaxHeap 的实现原理，简单来说是强行控制了 goal 的值 注： SetMaxHeap ，本质上是一个软限制，并不能解决 极端场景 下的 OOM ，可以配合内存监控和 debug.FreeOSMemory() 使用 SetMaxHeap 控制的是堆内存大小， Go 中除了堆内存还分配了如下内存，所以实际使用过程中，与实际硬件内存阈值之间需要留有一部分余量。 对于文章开始所述问题，使用 SetMaxHeap 后，预期的 GC 过程大概是这个样子 简单用法1 该方法简单粗暴，直接将 goal 设置为了固定值 注：通过上文所讲，触发 GC 实际上是 gc_trigger ，所以当阈值设置为 12GB 时，会提前一点触发 GC ，这里为了描述方便，近似认为 gc_trigger=goal 简单用法2 当不关闭 GC 时， SetMaxHeap 的逻辑是， goal 仍按照 gcpercent 进行计算，当 goal 小于 SetMaxHeap 阈值时不进行处理；当 goal 大于 SetMaxHeap 阈值时，将 goal 限制为 SetMaxHeap 阈值 注：通过上文所讲，触发 GC 实际上是 gc_trigger ，所以当阈值设置为 12GB 时，会提前一点触发 GC ，这里为了描述方便，近似认为 gc_trigger=goal 切换到 go1.14 分支，作者选择了 git checkout go1.14.5 选择官方提供的 cherry-pick 方式(可能需要梯子，文件改动不多，我后面会列出具体改动) git fetch "https://go.googlesource.com/go" refs/changes/67/227767/3 && git cherry-pick FETCH_HEAD 需要重新编译Go源码 注意点： 下面源码中的官方注释说的比较清楚，在一些关键位置加入了中文注释 入参bytes为要设置的阈值 notify 简单理解为 GC 的策略 发生变化时会向 channel 发送通知，后续源码可以看出“策略”具体指哪些内容 返回值为本次设置之前的 MaxHeap 值 $GOROOT/src/runtime/debug/garbage.go $GOROOT/src/runtime/mgc.go 注：作者尽量用通俗易懂的语言去解释 Go 的一些机制和 SetMaxHeap 功能，可能有些描述与实现细节不完全一致，如有错误还请指出

需要帮你做设计吗

1、用 iptables 的 owner 模块，给 --pid-owner 加上 MARK，然后 tc 里针对这个 MARK 做限速 现在的服务器上，基本已经普及了 SMP ，更进一步的，内核已经在自动发现支持 SMP 的时候，在 iptables 里把 owner 模块的 pid/cmd/sid 三个 match 都...

正确的有：A、B、D。 C错，malloc函数分配的内存空间不在stack上，而是在heap（堆）上。

1. accumulate几乎可用于指任何事物量的增加，侧重连续不断地，一点一滴地聚积。如：He accumulated a good library. 积累了丰富的藏书。However, as the evidence began to accumulate, experts from the Zoo felt obliged to investigate. 然而，随着迹象开始积聚，伦敦动物园的专家们感到有必要进行调查了。2. amass 强调大量的聚集，常用于财富、信息、所有物等的聚集，这种积累可能一下子完成，也可能在短期内完成，也可能在比较长的时间内完成，但是数量总是很大的。如：People tend to amass possessions, sometimes without being aware of doing so. 人们倾向于积攒东西，有的并未意识到这样做。3. collect普通用词，多用于指物，侧重指有区别地作选择或有安排有计划地把零散物集中起来。如：He"s collecting money for the blind. 他在为盲人募款。Collecting stamps is a hobby of mine. 集邮是我的一个爱好。All I hope is we can collect more fund for it. 我只希望我们能为此筹集更多资金。4. gather 普通用词，指人或物或抽象事物都可用。侧重于围绕一个中心的集合、聚集。如：We would all gather there on Friday evenings. 星期五晚上我们都在那里聚会。The lords and ladies were all gathered at the palace. 贵族老爷和夫人都聚集在皇宫里。She gathered up her things and left. 她收拾好她的东西就走了。5. heap 主要指把东西堆集，尤其指沙、石、煤、草、谷物等堆高，不强调整齐。如：Mother heaped delicious food on the plate. 母亲在盘子里堆满了好吃的东西。The barn of the used-to-be-poor farmer is now heaped with grain. 过去很贫穷的农民的谷仓里现在堆满了粮食。6. pile 着重指比较整齐地把东西堆积在一起。如：She piled the books on the table. 她把书堆在桌子上。

stack还指栈

这个是从堆里面申请了一块内存，内存大小是Student的大小加1K如果你的 char *str是Student的成员那么str本身所占用的内存是属于Student的对象的内存但是str所指向的内存在那里，是要看你如何给 str赋值的，你找找如下的语句：stu->str=但是我看你的程序多申请了1K内存，感觉就是准备让str指向这里的。

jvm有自己的垃圾回收机制，可以自动回收的，万一不行 重新装一下jdk啊

栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其 操作方式类似于数据结构中的栈。 堆区（heap） — 一般由程序员分配释放，malloc free 分配和释放的就是堆区的空间

/HEAP (Set Heap Size)/HEAP:reserve[,commit]The /HEAP option sets the size of the heap in bytes. This option is only for use when building an .exe file.The reserve argument specifies the total heap allocation in virtual memory. The default heap size is 1 MB. The linker rounds up the specified value to the nearest 4 bytes.The optional commit argument is subject to interpretation by the operating system. In Windows NT/Windows 2000, it specifies the amount of physical memory to allocate at a time. Committed virtual memory causes space to be reserved in the paging file. A higher commit value saves time when the application needs more heap space, but increases the memory requirements and possibly the startup time.Specify the reserve and commit values in decimal or C-language notation.This functionality is also available via a module definition file with HEAPSIZE.To set this linker option in the Visual Studio development environment Open the project"s Property Pages dialog box. For details, see Setting Visual C++ Project Properties. Click the Linker folder. Click the System property page. Modify the Heap Commit Size property.

　　CCS5.2默认情况下堆栈的大小都为0x400，在Project->Properties->Build->C200 Linker->Basic Options下设置。设置完堆栈的大小后，还要在cmd文件中分配堆栈存储空间的 段的位置和大小，栈空间的段名为.stack用于函数中的临时变量，堆空间的段名为.sysmem用于c语言malloc函数分配内存，malloc最大可分配内存为Project->Properties->Build ->C200 Linker->Basic Options下设置的大小减2。cmd文件中的堆栈段的大小不能小于Project->Properties->Build->C200 Linker->Basic Options下设置的大小。一般来讲不用 变动栈空间的大小和位置，如果函数中需要大的空间就申请堆空间。堆空间可以指定为外部内存，但要注意在第一次malloc函数调用之前一定要初始化外部内存。否则malloc能执行成功但是空间指向未定。　　heap大小限制为32k word即0x10000。

高效过滤膜（HEAP）主要是对排除放射性微粒而使用的过滤尘埃的设备，其主要特点是滤材很薄，而且又采用了折叠形，所以过滤面积比迎风气流的面积要大十几倍，从而大大降低了阻力，使滤纸的过滤器的使用有了可能。最早是应用于原子能工业过滤放射性尘埃，所有的滤纸材质均为植物纤维加兰石棉纤维，因为兰石棉纤维很细，直径在0.1~1um之间，最近几年出现用玻璃纤维滤纸代替兰石棉纤维（由于兰石棉纤维有致癌作用），也有用合成纤维滤纸，可以过滤0.3um~0.1um微粒，可过滤灭菌，所以这种滤膜（是一种化学微孔滤膜）有极高的捕集效滤和表面集尘效滤，也可以用来捕集放射性尘埃，但是阻力高，抗张强度低，成本高，使用不便，高效率过滤膜，可以用作末端净化。 而静电除尘不能用于末端净化，要与阻尘式高效过滤器组合使用才能发挥更大的效果。

垃圾收集器（GC）会监视每个在堆（Heap）上的对象，如果该对象已经没有指向他的引用，那么GC就会做好回收内存的准备（但并不是立即回收），等到对内存不够的时候就会进行回收，这也就是Java为什么效率比较低的一个重要原因，具体的在Thinking in Java中作者讲解的很详细

eclipse修改heap size:用eclipse 开发，在用ant编译我的web工程时，碰到java.lang.OutOfMemoryError: Java heap space异常。解决办法：1.window->preferences->java->installed jres->edit jre把default vm arguments 的参数设为-Xms64m -Xmx512方法2。在window的环境变量中添加JAVA_OPTS=-Xms64m -Xmx512m

heap指的是堆，heap-based就是“基于堆”。

es节点的默认的heap内存大小是 1G 大小，在实际生产中，很容易导致内存溢出而导致进程被kill掉。所以我们一般会自己配置自己的，以前的版本可以通过 export ES_HEAP_SIZE=10g 或者 ./bin/elasticsearch -Xmx10g -Xms10g 来设置自己的堆内存的大小，但版本在 6.2.x 开始，就不支持这种设置了，反正笔者就没有设置成功过。 既然一般度友给出的方法不好使，只能去官网查了。 官网地址： https://www.elastic.co/guide/en/elasticsearch/reference/current/heap-size.html 设置最大和最小的堆内存都为 2GB

堆和栈的区别：　　一、堆栈空间分配区别：　　1、栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈；　　2、堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。　　二、堆栈缓存方式区别：　　1、栈使用的是一级缓存， 通常都是被调用时处于存储空间中，调用完毕立即释放；　　2、堆是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。　　三、堆栈数据结构区别：　　堆（数据结构）：堆可以被看成是一棵树，如：堆排序；　　栈（数据结构）：一种先进后出的数据结构。

pile. 指的是一堆同类的东西一起堆在一起 而heap指的是一堆同类的而且是整齐的堆放在一起

在java虚拟机未运行的情况下进入cmd，运行以下命令,其中的*号替换成你想要设置的数值java -Xms***m -Xmx***m

he 高爆弹ap 钝头穿甲弹sabot 脱壳尾翼稳定穿甲弹

What is the stack? It"s a special region of your computer"s memory that stores temporary variables created by each function (including the main() function). The stack is a "LIFO" (last in, first out) data structure, that is managed and optimized by the CPU quite closely. Every time a function declares a new variable, it is "pushed" onto the stack. Then every time a function exits, all of the variables pushed onto the stack by that function, are freed (that is to say, they are deleted). Once a stack variable is freed, that region of memory becomes available for other stack variables. The advantage of using the stack to store variables, is that memory is managed for you. You don"t have to allocate memory by hand, or free it once you don"t need it any more. What"s more, because the CPU organizes stack memory so efficiently, reading from and writing to stack variables is very fast. Another feature of the stack to keep in mind, is that there is a limit (varies with OS) on the size of variables that can be stored on the stack. This is not the case for variables allocated on the heap . https://www.gribblelab.org/CBootCamp/7_Memory_Stack_vs_Heap.html The heap is a region of your computer"s memory that is not managed automatically for you, and is not as tightly managed by the CPU. It is a more free-floating region of memory (and is larger). To allocate memory on the heap, you must use malloc() or calloc() , which are built-in C functions. Once you have allocated memory on the heap, you are responsible for using free() to deallocate that memory once you don"t need it any more. If you fail to do this, your program will have what is known as a memory leak . That is, memory on the heap will still be set aside (and won"t be available to other processes). As we will see in the debugging section, there is a tool called valgrind that can help you detect memory leaks. Unlike the stack, the heap does not have size restrictions on variable size (apart from the obvious physical limitations of your computer). Heap memory is slightly slower to be read from and written to, because one has to use pointers to access memory on the heap. We will talk about pointers shortly. Unlike the stack, variables created on the heap are accessible by any function, anywhere in your program. Heap variables are essentially global in scope. When should you use the heap, and when should you use the stack? If you need to allocate a large block of memory (e.g. a large array, or a big struct), and you need to keep that variable around a long time (like a global), then you should allocate it on the heap. If you are dealing with realtively small variables that only need to persist as long as the function using them is alive, then you should use the stack, it"s easier and faster. If you need variables like arrays and structs that can change size dynamically (e.g. arrays that can grow or shrink as needed) then you will likely need to allocate them on the heap, and use dynamic memory allocation functions like malloc() , calloc() , realloc() and free() to manage that memory "by hand". We will talk about dynamically allocated data structures after we talk about pointers. https://www.gribblelab.org/CBootCamp/7_Memory_Stack_vs_Heap.html http://net-informations.com/faq/net/stack-heap.htm 想要看到更多玮哥的学习笔记、考试复习资料、面试准备资料？想要看到IBM工作时期的技术积累和国外初创公司的经验总结？ 敬请关注： 玮哥的博客 —— CSDN的传送门 玮哥的博客 —— 的传送门 玮哥的博客 —— 博客园的传送门

Go 提供了 container/heap 这个包来实现堆的操作。堆实际上是一个树的结构，每个元素的值都是它的子树中最小的，因此根节点 index = 0 的值是最小的，即最小堆。 堆也是实现优先队列 Priority Queue 的常用方式。 堆中元素的类型需要实现 heap.Interface 这个接口： 其中 sort.Interface 包括 Len() , Less , Swap 方法： 一个完整的示例如下： 注意注释中的一句话 Push 和 Pop 方法需要使用指针，因为它们会修改 slice 的长度，而不仅仅只内容 。 Leetcode 692. Top K Frequent Words 也可以使用 Go 语言通过构造 PriorityQueue 来实现：

都是heaped 来自金山词霸

堆(heap)和栈(stack)有什么区别??简单的可以理解为： heap：是由malloc之类函数分配的空间所在地。地址是由低向高增长的。 stack：是自动分配变量，以及函数调用的时候所使用的一些空间。地址是由高向低减少的。 预备知识—程序的内存分配 一个由c/C++编译的程序占用的内存分为以下几个部分 1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。 3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放 5、程序代码区—存放函数体的二进制代码。 二、例子程序 这是一个前辈写的，非常详细 //main.cpp int a = 0; 全局初始化区 char *p1; 全局未初始化区 main() { int b; 栈 char s[] = "abc"; 栈 char *p2; 栈 char *p3 = "123456"; 123456在常量区，p3在栈上。 static int c =0； 全局（静态）初始化区 p1 = (char *)malloc(10); p2 = (char *)malloc(20); 分配得来得10和20字节的区域就在堆区。 strcpy(p1, "123456"); 123456放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。 } 二、堆和栈的理论知识 2.1申请方式 stack: 由系统自动分配。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间 heap: 需要程序员自己申请，并指明大小，在c中malloc函数 如p1 = (char *)malloc(10); 在C++中用new运算符 如p2 = (char *)malloc(10); 但是注意p1、p2本身是在栈中的。 2.2 申请后系统的响应 栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。 堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时， 会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。 2.3申请大小的限制 栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。 堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。 2.4申请效率的比较： 栈由系统自动分配，速度较快。但程序员是无法控制的。 堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便. 另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度， 也最灵活 2.5堆和栈中的存储内容 栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。 堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。 2.6存取效率的比较 char s1[] = "aaaaaaaaaaaaaaa"; char *s2 = "bbbbbbbbbbbbbbbbb"; aaaaaaaaaaa是在运行时刻赋值的； 而bbbbbbbbbbb是在编译时就确定的； 但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。 比如： #include void main() { char a = 1; char c[] = "1234567890"; char *p ="1234567890"; a = c[1]; a = p[1]; return; } 对应的汇编代码 10: a = c[1]; 00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh] 0040106A 88 4D FC mov byte ptr [ebp-4],cl 11: a = p[1]; 0040106D 8B 55 EC mov edx,dword ptr [ebp-14h] 00401070 8A 42 01 mov al,byte ptr [edx+1] 00401073 88 45 FC mov byte ptr [ebp-4],al 第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指edx中，在根据edx读取字符，显然慢了。 ? 2.7小结： 堆和栈的区别可以用如下的比喻来看出： 使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。 使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。 堆和栈的区别主要分： 操作系统方面的堆和栈，如上面说的那些，不多说了。 还有就是数据结构方面的堆和栈，这些都是不同的概念。这里的堆实际上指的就是（满足堆性质的）优先队列的一种数据结构，第1个元素有最高的优先权；栈实际上就是满足先进后出的性质的数学或数据结构。 虽然堆栈，堆栈的说法是连起来叫，但是他们还是有很大区别的，连着叫只是由于历史的原因针值读.以上解释是从百度知道问答上转过来的，这两个概念模糊了很久，现在明白了为什么当时计算机专业开“数据结构”了，呵呵，有时间还要补补！

这个嘛一定有的

heap是堆，stack是栈。前者的空间是手动申请和释放的，后者的空间是系统自动分配和释放的。

堆就是用数组实现的二叉树，所以它没有使用父指针或者子指针。堆根据“堆属性”来排序，“堆属性”决定了树中节点的位置。 堆的常用方法： 堆分为两种： 最大堆 和 最小堆 ，两者的差别在于节点的排序方式。 在最大堆中，父节点的值比每一个子节点的值都要大。在最小堆中，父节点的值比每一个子节点的值都要小。这就是所谓的“堆属性”，并且这个属性对堆中的每一个节点都成立。 例子： 这是一个最大堆，，因为每一个父节点的值都比其子节点要大。 10 比 7 和 2 都大。 7 比 5 和 1 都大。 根据这一属性，那么最大堆总是将其中的最大值存放在树的根节点。而对于最小堆，根节点中的元素总是树中的最小值。堆属性非常有用，因为堆常常被当做优先队列使用，因为可以快速地访问到“最重要”的元素。 堆并不能取代二叉搜索树，它们之间有相似之处也有一些不同。我们来看一下两者的主要差别： 节点的顺序。 在二叉搜索树中，左子节点必须比父节点小，右子节点必须必比父节点大。但是在堆中并非如此。在最大堆中两个子节点都必须比父节点小，而在最小堆中，它们都必须比父节点大。 内存占用。 普通树占用的内存空间比它们存储的数据要多。你必须为节点对象以及左/右子节点指针分配内存。堆仅仅使用一个数据来存储数组，且不使用指针。 平衡。 二叉搜索树必须是“平衡”的情况下，其大部分操作的复杂度才能达到 O(log n) 。你可以按任意顺序位置插入/删除数据，或者使用 AVL 树或者红黑树，但是在堆中实际上不需要整棵树都是有序的。我们只需要满足堆属性即可，所以在堆中平衡不是问题。因为堆中数据的组织方式可以保证 O(log n) 的性能。 搜索。 在二叉树中搜索会很快，但是在堆中搜索会很慢。在堆中搜索不是第一优先级，因为使用堆的目的是将最大（或者最小）的节点放在最前面，从而快速的进行相关插入、删除操作。 用数组来实现树相关的数据结构也许看起来有点古怪，但是它在时间和空间上都是很高效的。 我们准备将上面例子中的树这样存储： 就这么多！我们除了一个简单的数组以外，不需要任何额外的空间。 如果我们不允许使用指针，那么我们怎么知道哪一个节点是父节点，哪一个节点是它的子节点呢？问得好！节点在数组中的位置index 和它的父节点以及子节点的索引之间有一个映射关系。 如果 i 是节点的索引，那么下面的公式就给出了它的父节点和子节点在数组中的位置： 注意 right(i) 就是简单的 left(i) + 1 。左右节点总是处于相邻的位置。 我们将写公式放到前面的例子中验证一下。 复习一下，在最大堆中，父节点的值总是要大于（或者等于）其子节点的值。这意味下面的公式对数组中任意一个索引 i 都成立： 可以用上面的例子来验证一下这个堆属性。 如你所见，这些公式允许我们不使用指针就可以找到任何一个节点的父节点或者子节点。事情比简单的去掉指针要复杂，但这就是交易：我们节约了空间，但是要进行更多计算。幸好这些计算很快并且只需要 O(1) 的时间。 理解数组索引和节点位置之间的关系非常重要。这里有一个更大的堆，它有15个节点被分成了4层： 图片中的数字不是节点的值，而是存储这个节点的数组索引！这里是数组索引和树的层级之间的关系： 由上图可以看到，数组中父节点总是在子节点的前面。 注意这个方案与一些限制。你可以在普通二叉树中按照下面的方式组织数据，但是在堆中不可以： 在堆中，在当前层级所有的节点都已经填满之前不允许开是下一层的填充，所以堆总是有这样的形状： 小测验，假设我们有这样一个数组： 这是一个有效的堆吗？答案是 yes ！一个从低到高有序排列的数组是以有效的最小堆，我们可以将这个堆画出来： 堆属性适用于每一个节点，因为父节点总是比它的字节点小。（你也可以验证一下：一个从高到低有序排列的数组是一个有效的最大堆） 如果你好奇，这里有更多的公式描述了堆的一些确定属性。你不需要知道这些，但它们有时会派上用场。 可以直接跳过此部分！ 树的 高度 是指从树的根节点到最低的叶节点所需要的步数，或者更正式的定义：高度是指节点之间的边的最大值。一个高度为 h 的堆有 h+1 层。 下面这个对的高度是3，所以它有4层： 如果一个堆有 n 个节点，那么它的高度是 h = floor(log2(n)) 。这是因为我们总是要将这一层完全填满以后才会填充新的一层。上面的例子有 15 个节点，所以它的高度是 floor(log2(15)) = floor(3.91) = 3 。 如果最下面的一层已经填满，那么那一层包含 2^h 个节点。树中这一层以上所有的节点数目为 2^h - 1 。同样是上面这个例子，最下面的一层有8个节点，实际上就是 2^3 = 8 。前面的三层一共包含7的节点，即： 2^3 - 1 = 8 - 1 = 7 。 所以整个堆中的节点数目为：* 2^(h+1) - 1*。上面的例子中， 2^4 - 1 = 16 - 1 = 15 叶节点总是位于数组的 floor(n/2) 和 n-1 之间。 有两个原始操作用于保证插入或删除节点以后堆是一个有效的最大堆或者最小堆： shiftUp 或者 shiftDown 是一个递归的过程，所以它的时间复杂度是 O(log n) 。 基于这两个原始操作还有一些其他的操作： 上面所有的操作的时间复杂度都是 O(log n) ，因为 shiftUp 和 shiftDown 都很费时。还有少数一些操作需要更多的时间： 堆还有一个 peek() 方法，不用删除节点就返回最大值（最大堆）或者最小值（最小堆）。时间复杂度 O(1) 。 我们通过一个插入例子来看看插入操作的细节。我们将数字 16 插入到这个堆中： 堆的数组是： [ 10, 7, 2, 5, 1 ] 。 第一股是将新的元素插入到数组的尾部。数组变成： 相应的树变成了： 16 被添加最后一行的第一个空位。 不行的是，现在堆属性不满足，因为 2 在 16 的上面，我们需要将大的数字在上面（这是一个最大堆） 为了恢复堆属性，我们需要交换 16 和 2 。 现在还没有完成，因为 10 也比 16 小。我们继续交换我们的插入元素和它的父节点，直到它的父节点比它大或者我们到达树的顶部。这就是所谓的 shift-up ，每一次插入操作后都需要进行。它将一个太大或者太小的数字“浮起”到树的顶部。 最后我们得到的堆： 现在每一个父节点都比它的子节点大。 我们将这个树中的 (10) 删除： 现在顶部有一个空的节点，怎么处理？ 当插入节点的时候，我们将新的值返给数组的尾部。现在我们来做相反的事情：我们取出数组中的最后一个元素，将它放到树的顶部，然后再修复堆属性。 现在来看怎么 shift-down (1) 。为了保持最大堆的堆属性，我们需要树的顶部是最大的数据。现在有两个数字可用于交换 7 和 2 。我们选择这两者中的较大者称为最大值放在树的顶部，所以交换 7 和 1 ，现在树变成了： 继续堆化直到该节点没有任何子节点或者它比两个子节点都要大为止。对于我们的堆，我们只需要再有一次交换就恢复了堆属性： 绝大多数时候你需要删除的是堆的根节点，因为这就是堆的设计用途。 但是，删除任意节点也很有用。这是 remove() 的通用版本，它可能会使用到 shiftDown 和 shiftUp 。 我们还是用前面的例子，删除 (7) : [图片上传失败...(image-d46ac4-1534077058042)] 对应的数组是 你知道，移除一个元素会破坏最大堆或者最小堆属性。我们需要将删除的元素和最后一个元素交换： 最后一个元素就是我们需要返回的元素；然后调用 removeLast() 来将它删除。 (1) 比它的子节点小，所以需要 shiftDown() 来修复。 然而，shift down 不是我们要处理的唯一情况。也有可能我们需要 shift up。考虑一下从下面的堆中删除 (5) 会发生什么： 现在 (5) 和 (8) 交换了。因为 (8) 比它的父节点大，我们需要 shiftUp() 。

1.accumulate 几乎可用于指任何事物量的增加,侧重连续不断地,一点一滴地聚积.如： He accumulated a good library. 积累了丰富的藏书. However,as the evidence began to accumulate,experts from the Zoo felt obliged to investigate. 然而,随着迹象开始积聚,伦敦动物园的专家们感到有必要进行调查了. 2.amass 强调大量的聚集,常用于财富、信息、所有物等的聚集,这种积累可能一下子完成,也可能在短期内完成,也可能在比较长的时间内完成,但是数量总是很大的.如： People tend to amass possessions,sometimes without being aware of doing so. 人们倾向于积攒东西,有的并未意识到这样做. 3.collect 普通用词,多用于指物,侧重指有区别地作选择或有安排有计划地把零散物集中起来.如： He"s collecting money for the blind. 他在为盲人募款. Collecting stamps is a hobby of mine. 集邮是我的一个爱好. All I hope is we can collect more fund for it. 我只希望我们能为此筹集更多资金. 4.gather 普通用词,指人或物或抽象事物都可用.侧重于围绕一个中心的集合、聚集.如： We would all gather there on Friday evenings. 星期五晚上我们都在那里聚会. The lords and ladies were all gathered at the palace. 贵族老爷和夫人都聚集在皇宫里. She gathered up her things and left. 她收拾好她的东西就走了. 5.heap 主要指把东西堆集,尤其指沙、石、煤、草、谷物等堆高,不强调整齐.如： Mother heaped delicious food on the plate. 母亲在盘子里堆满了好吃的东西. The barn of the used-to-be-poor farmer is now heaped with grain. 过去很贫穷的农民的谷仓里现在堆满了粮食. 6.pile 着重指比较整齐地把东西堆积在一起.如： She piled the books on the table. 她把书堆在桌子上.

程序的运行场所是内存，栈和堆是进程的虚拟内存中的两部分区域。当程序被执行时，程序代码，你所创建的变量、常量等都会被压入栈空间里，栈是程序代码的执行区域。栈的内存地址是连续的且被一一记录，所以说当你创建了一个变量(比如int var = 1)，我们就可以通过var这个变量来访问变量的内容。在这里，var就存放在栈中，它的地址已经默认被编译器计算好了，调用过程也不需要你涉及到有关地址的操作。更直观的感受是数组，数组里的元素在栈里面是连续排放的，相邻两个元素的地址相差1。而堆是不同于栈的另一部分区域，系统会给每个程序分配一部分栈空间让他们能够运行起来，问题就是栈空间必然存在不够用的问题，而堆不属于程序，堆是独立的，是公用的。只要你malloc(sizeof(SIZE_YOU_WANT))，就可以得到相应一部分的堆空间。有栈，为什么用堆？：：栈里面的东西有生命周期，说俗点就是变量作用域，你在函数内部创建一个变量，函数调用结束这个变量就没了。而堆里面的东西独立于你的程序，malloc()之后，除非你free()掉，否则一直存在。为什么用堆少？：：麻烦！有什么要注意？：：堆里面申请的东西，是随机分配的，不像栈里面的地址都已经计算好了。所以申请了堆空间之后一定要创建一个指针保存你说申请到的堆空间的地址。不然就找不到你申请的空间了。既然涉及到指针，请注意用之前检查一下指针空不空的问题。堆空间的东西申请好，在用完之后一定要free()掉，以防止堆溢出。说到安全性，还真是挺麻烦的。（纯手打）

东风heap是什么意思？东风heap汽车的品牌的符号，所以说东风汽车也是非常多的，如果想买东风汽车的话，那么也看到品牌，如果喜欢的话，比牌啊！

栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。堆是栈的一个组成元素

1.heap是堆，stack是栈。2.stack的空间由操作系统自动分配和释放，heap的空间是手动申请和释放的，heap常用new关键字来分配。3.stack空间有限，heap的空间是很大的自由区。在Java中，若只是声明一个对象，则先在栈内存中为其分配地址空间，若再new一下，实例化它，则在堆内存中为其分配地址。4.举例：数据类型 变量名；这样定义的东西在栈区。如：Object a =null; 只在栈内存中分配空间new 数据类型();或者malloc(长度); 这样定义的东西就在堆区如：Object b =new Object(); 则在堆内存中分配空间

　　在JVM中 内存分为两个部分 Stack(栈)和Heap(堆) 这里 我们从JVM的内存管理原理的角度来认识Stack和Heap 并通过这些原理认清Java中静态方法和静态属性的问题 　　一般 JVM的内存分为两部分 Stack和Heap 　　Stack(栈)是JVM的内存指令区 Stack管理很简单 push一定长度字节的数据或者指令 Stack指针压栈相应的字节位移;pop一定字节长度数据或者指令 Stack指针弹栈 Stack的速度很快 管理很简单 并且每次操作的数据或者指令字节长度是已知的 所以Java 基本数据类型 Java 指令代码 常量都保存在Stack中 　　Heap(堆)是JVM的内存数据区 Heap 的管理很复杂 每次分配不定长的内存空间 专门用来保存对象的实例 在Heap 中分配一定的内存来保存对象实例 实际上也只是保存对象实例的属性值 属性的类型和对象本身的类型标记等 并不保存对象的方法(方法是指令 保存在Stack中) 在Heap 中分配一定的内存保存对象实例和对象的序列化比较类似 而对象实例在Heap 中分配好以后 需要在Stack中保存一个 字节的Heap 内存地址 用来定位该对象实例在Heap 中的位置 便于找到该对象实例 　　由于Stack的内存管理是顺序分配的 而且定长 不存在内存回收问题;而Heap 则是随机分配内存 不定长度 存在内存分配和回收的问题;因此在JVM中另有一个GC进程 定期扫描Heap 它根据Stack中保存的 字节对象地址扫描Heap 定位Heap 中这些对象 进行一些优化(例如合并空闲内存块什么的) 并且假设Heap 中没有扫描到的区域都是空闲的 统统refresh(实际上是把Stack中丢失了对象地址的无用对象清除了) 这就是垃圾收集的过程;关于垃圾收集的更深入讲解请参考 CTO之前的文章《JVM内存模型及垃圾收集策略解析》 　　 　　 JVM的体系结构 　　我们首先要搞清楚的是什么是数据以及什么是指令 然后要搞清楚对象的方法和对象的属性分别保存在哪里 　　 )方法本身是指令的操作码部分 保存在Stack中; 　　 )方法内部变量作为指令的操作数部分 跟在指令的操作码之后 保存在Stack中(实际上是简单类型保存在Stack中 对象类型在Stack中保存地址 在Heap 中保存值);上述的指令操作码和指令操作数构成了完整的Java 指令 　　 )对象实例包括其属性值作为数据 保存在数据区Heap 中 　　非静态的对象属性作为对象实例的一部分保存在Heap 中 而对象实例必须通过Stack中保存的地址指针才能访问到 因此能否访问到对象实例以及它的非静态属性值完全取决于能否获得对象实例在Stack中的地址指针 　　 非静态方法和静态方法的区别 　　非静态方法有一个和静态方法很重大的不同 非静态方法有一个隐含的传入参数 该参数是JVM给它的 和我们怎么写代码无关 这个隐含的参数就是对象实例在Stack中的地址指针 因此非静态方法(在Stack中的指令代码)总是可以找到自己的专用数据(在Heap 中的对象属性值) 当然非静态方法也必须获得该隐含参数 因此非静态方法在调用前 必须先new一个对象实例 获得Stack中的地址指针 否则JVM将无法将隐含参数传给非静态方法 　　静态方法无此隐含参数 因此也不需要new对象 只要class文件被ClassLoader load进入JVM的Stack 该静态方法即可被调用 当然此时静态方法是存取不到Heap 中的对象属性的 　　总结一下该过程 当一个class文件被ClassLoader load进入JVM后 方法指令保存在Stack中 此时Heap 区没有数据 然后程序技术器开始执行指令 如果是静态方法 直接依次执行指令代码 当然此时指令代码是不能访问Heap 数据区的;如果是非静态方法 由于隐含参数没有值 会报错 因此在非静态方法执行前 要先new对象 在Heap 中分配数据 并把Stack中的地址指针交给非静态方法 这样程序技术器依次执行指令 而指令代码此时能够访问到Heap 数据区了 　　 静态属性和动态属性 　　前面提到对象实例以及动态属性都是保存在Heap 中的 而Heap 必须通过Stack中的地址指针才能够被指令(类的方法)访问到 因此可以推断出 静态属性是保存在Stack中的 而不同于动态属性保存在Heap 中 正因为都是在Stack中 而Stack中指令和数据都是定长的 因此很容易算出偏移量 也因此不管什么指令(类的方法) 都可以访问到类的静态属性 也正因为静态属性被保存在Stack中 所以具有了全局属性 lishixinzhi/Article/program/Java/hx/201311/26460

heap作名词时，加of表示有一堆...heap of+名词，表示一堆...

heap[英][hi:p][美][hip]n.堆，堆积; <口>许多，大量; <俚>破车; vt.扔成一堆; 完全填满，灌满; 大量或奢侈的赠予; 第三人称单数：heaps复数：heaps现在分词：heaping过去式：heaped过去分词：heaped双语例句He has dug up the tiles that cover the floor and left them in a heap.他把地上铺的瓷砖掀了起来，堆成一堆。

1、内存条有灰尘，造成系统不稳定。可以把内存条、内存条金手指和内存条卡槽都清洁一下。2、显卡有灰尘、显卡散热不良或显卡驱动问题。把显卡风扇上的灰尘、显卡金手指和显卡卡槽都清洁一下；然后把显卡驱动换成显卡公司自带的驱动程序，不要乱升级驱动程序。显卡驱动程序出问题的情况最大。

到可以正常上网的电脑制作u启动盘，然后下载一个系统镜像，重装吧：1、将u盘制作成【u深度u盘启动盘】，接着前往相关网站下载win系统存到u盘启动盘，重启电脑等待出现开机画面按下启动快捷键，选择u盘启动进入到u深度主菜单，选取“【02】u深度WIN8 PE标准版(新机器)”选项，按下回车键确认2、在pe装机工具中选择win镜像放在c盘中，点击确定3、此时在弹出的提示窗口直接点击“确定”按钮4、随后安装工具开始工作，我们需要耐心等待几分钟5、完成后，弹跳出的提示框会提示是否立即重启，这个时候我们直接点击立即重启就即可。6、此时就可以拔除u盘了，重启系统开始进行安装，我们无需进行操作，等待安装完成即可。

我刚刚升级 也出现了这个情况 找了好久 后来不打开 edge 看优酷视频 就没有问题 暂时用ie 顶住

中国真的是一群外国男人的天堂戳破丝绸”首先,一些中国女孩误解“弯曲的坚果”实际上是1,倾斜的坚果不在G块你看在这个“设备运行良好”，倾斜的坚果也有早泄的症状,阳痿,如果“烟囱到井”可能会导致一些问题2,倾斜的坚果还指出国家,欧洲和美国,更不用说还有许多其他位置的倾斜的坚果,可能会有一些你从未听说过“农民地区”4日在北京工作倾斜的坚果,外国学生,旅游,无赖的5成正比,“混合”并不是所有的都很好,也有“混合“哈士奇”6是高于国内,欧美国家大的性开放。3，但实际上是一种态度胡闹,世界各地的人们,如果你整天泡在“中国”的兴起,劝你三思.4,倾斜的坚果和中国人结婚,在几个,真的能嫁给你可以活到让你获得绿卡,他们没有时间去酒吧,八个基本,倾斜的坚果他们应该有自己的酒吧文化,但据我所知一些外国人想在中国“酒吧”的妹妹想让我睡觉。总之倾斜的坚果一杯啤酒能喝5个小时,和东北的兄弟咱5瓶1分钟到十,不认为倾斜的坚果和交流,西方风格,西方风格是你的文化,你口中的言语文字和外国男朋友或者女朋友没有任何关系。

很好骗的都是

一个字------------贱

没听过这种说法

被认为是只有性没有爱好上手的战利品

因为本分女孩花少量钱或者不花钱就可以睡

他可能认为中国女孩挺简单，或者实际吧

这种说法是不正确的，也是不公平的。首先，我们应该尊重每个人的个人身份和尊严，不应该将他们归为“easy girl”或“cheap girl”这样的类别。这种分类不仅是对个人的不尊重，也是对整个社会群体的不尊重。其次，我们应该避免使用歧视性语言来描述特定的群体或个人。这种描述不仅是不礼貌的，而且可能会引起不必要的争议和冲突。最后，我们应该努力推动社会进步和文化交流，促进不同文化之间的理解和融合，为构建和谐、包容的社会做出积极的贡献。

所谓的“易女孩”应该限制在城市酒吧的女性。他们大多数受过良好的教育，已经看到许多国家。说英语好的中外女孩没有什么区别。也就是说，主要看对方的综合条件，与该地区没有什么大的关系，而且永远不会被添加或奉承，因为对方是外国人。另外，出国走走，你会明白外国月亮的时间是圆的。所有的外国人对中国有一点了解是深受中国未来震惊。虽然亚洲女孩一般对外国人很有吸引力，但如果你保持特殊的独立和平等，你肯定会赢得他们的尊敬。中国女孩之所以“容易”，主要是因为她们的教育有限她们的思想相对简单（或邪恶，他们正被婚姻移民的邪恶和天真的目标所左右）。但不要形成一种成见，我也有一个朋友的中国女朋友在一家投资银行工作，智慧有内涵。外国男男女女在找对象时是一样的标准，中国男生想泡宝宝也能学会幽默感（当然，英语笑话怎么能成为一个障碍）+一个数字就可以了。中国的女性如果你的公司、你的工作、学校、甚至生命，会看到一些女孩/女人的外表/美/甚至色相勾引男同事，男上司认为，男同学和男朋友，然后他们想得到的利益和目的（公共，私人的），那么，对于那些真的不要依赖所谓的色彩（色相）赢得了中国女人，公平吗？如果不了解内部信息的网民盲目地掩盖和雇佣男性女白领，那只会对真正诚实、勤奋工作的中国女性不公平。

这种说法是不正确的，这是一种带有偏见的观点。首先，我们应该尊重每个人的个人身份和尊严，不应该使用贬低或歧视性的语言。其次，中国是一个拥有悠久历史和文化的国家，其人民拥有着自己独特的价值观和特点，包括勤劳、聪明、善良、友好等等。最后，我们应该以开放、包容的心态看待不同的文化和人群，不应该以偏概全，更不应该以种族、性别、宗教等因素来评判他人。总之，我们应该以平等、尊重、包容的态度看待他人，避免使用歧视性语言，并努力促进平等、公正、包容的社会环境。

歌名：Cheap Thrills，歌手：Sia所属专辑：Sunday Morning Songs, Vol. 2作曲 : Sia Furler/Greg Kurstin作词 : Sia Furler/Greg KurstinCome on, come on快，快，快Turn the radio on快把收音机调到最大It"s Friday night and I won"t be long周五的夜晚不会太漫长Gotta do my hair梳理头发I put my make-up on化好美妆It"s Friday night and I won"t be long周五的夜晚总是一刻千金Til I hit the dance floor陶醉在舞池中肆意狂欢Hit the dance floor载歌载舞，钟鼓乐之I got all I need我已收获我所需的全部No I ain"t got cash不，无关钱财No I ain"t got cash不，无关富贵But I got you baby有你就已足够Baby I don"t need dollar bills to have fun tonight亲爱的，我不要用金钱来换取一时欢乐(I love cheap thrills)简简单单就已足够Baby I don"t need dollar bills to have fun tonight亲爱的，我不要用钱财换来苟且的欢愉(I love cheap thrills)简简单单就是我想要的But I don"t need no money我不需要任何钱财As long as I can feel the beat只要能感受着节奏一起摇摆I don"t need no money钱财乃身外之物As long as I keep dancing只要我能随着音乐一起舞动Come on, come on快，快，快Turn the radio on快把收音机调到最大It"s Saturday night and I won"t be long周六的晚上总是如此短暂Gotta paint my nails涂上亮丽的指甲Put my high heels on踩着我们的恨天高It"s Saturday night and I won"t be long一刻千金，快快开始周六的狂欢之夜Til I hit the dance floor在舞池中肆意狂欢Hit the dance floor载歌载舞，随心摇摆I got all I need我已收获我所需要的全部No I ain"t got cash不，无关钱财No I ain"t got cash不，无关富贵But I got you baby有你就已足够Baby I don"t need dollar bills to have fun tonight宝贝，我不要用钱财换来一时的狂欢(I love cheap thrills)简简单单就已足够Baby I don"t need dollar bills to have fun tonight宝贝。我不要用金钱换来苟且的欢愉(I love cheap thrills)简简单单就是我想要的But I don"t need no money我不需要任何钱财As long as I can feel the beat只要能感受着节奏一起摇摆I don"t need no money钱财乃身外之物As long as I keep dancing只要我能随着音乐一起舞动(I love cheap thrills)简简单单亦是快乐(I love cheap thrills)平平淡淡就已足够But I don"t need no money我不需要任何钱财As long as I can feel the beat只要能感受着节奏一起摇摆I don"t need no money钱财乃身外之物As long as I keep dancing只要我能随着音乐一起舞动Oh, oh哦~Baby I don"t need dollar bills to have fun tonight我不要用钱财换取一时的狂欢(I love cheap thrills)简简单单就已足够Baby I don"t need dollar bills to have fun tonight我不要用金钱换来苟且的欢愉(I love cheap thrills)简简单单就是我想要的But I don"t need no money宝贝，我不需要任何钱财As long as I can feel the beat只要能感受着节奏一起摇摆I don"t need no money钱财乃身外之物As long as I keep dancing只要我能随着音乐一起舞动La, la, la, la, la, la啦啦啦~(I love cheap thrills)简简单单亦是快乐La, la, la, la, la, la啦啦啦~(I love cheap thrills)平平淡淡就已足够La, la, la, la, la, la啦啦啦~(I love cheap thrills)简简单单就是我想要的La, la, la, la, la, la啦啦啦~(I love cheap thrills)简简单单亦是快乐扩展资料：《Cheap Thrills》是澳大利亚女歌手希雅·富勒演唱的歌曲，由希雅·富勒、格雷戈·科斯汀等创作，混音版与牙买加歌手肖恩·保罗合作。创作背景《Cheap Thrills》本为希雅·富勒为蕾哈娜专辑《Anti》所创作。蕾哈娜的经纪人向希雅提出了创作出一首与《Diamonds》（2012年希雅为蕾哈娜创作歌曲）拥有相似感觉的、具有灵魂乐元素乐曲的请求，于是希雅与格雷戈·科斯汀一道创作了此曲。创作完成后，歌曲被寄给了蕾哈娜方，然而却遭到了回拒。随后希雅便将这首歌曲收进了她的第七张录音室专辑中。

歌曲名:Half Life歌手:Imogen Heap专辑:EllipseImogen Heap - Half LifeI knew that I"d get like this againThat"s why I try to keep at bayBe a hundred percentwhen I"m with you and thenA perfect heart"s length awayThe stickler is you"ve playednot one beat wrongYou never promised me anythingEven sat me down,warned me just how they fallAnd I knew the odds were I"d never winAnd here I amIt"s a half lifewith you as my quarterbackA daft lifeMy self-worth measured in text back tempoIt"s been 2 days and 8 minutes too slowThere may well be othersbut I still like to pretendthat I"m the one youreally want to grow old withYou"ve got a schedule to stick toGot a world to keep sweetIt"s so much to everyone all the timeWill you ever slow down?Will I ever come first?The universe contracts decideIt"s a half lifeWith you as my quarterbackA daft lifeIt"s a half lifeWith you as my quarterbackA daft lifeYou know you"ll never be lonelyYou know you"ll always be lovedAnd maybe you"ll never need more than thatOf the sad place that loves,what"s to become of us?Does it even register on your conscience?Along for one last showdownFrom a box in the crowd,air compressed tight to explodeI"m clenching my ticket to the only way outAs you disappear in a puff of smokeIt"s a half lifeWith you as my quarterbackA daft lifehttp://music.baidu.com/song/482829

你用的什么IDE，eclipse？

如果你的语句是 web 服务器里，执行的话，那么修改JAVA参数比如 jboss 的 run.batset JAVA_OPTS=%JAVA_OPTS% -Xms256m -Xmx768m -Xss128k如果是在 eclipse里，那么修改eclipse的eclipse.ini设置。

1打开编译器性能优化 -XX:+AggressiveOpts2增加永生代空间-XX:PermSize=2048m -XX:MaxPermSize=2048m3增加最小最大堆的空间-Xms2048m -Xmx2048m4为新生代增加堆的大小 -Xmn512m5为每个线程设置栈大小 -Xss2m6调整垃圾收集 -XX:+UseParallelOldGC如还不行，继续优化-XX:MaxGCPauseMillis=10-XX:+UseG1GC-XX:CompileThreshold=5-XX:MaxGCPauseMillis=10-XX:MaxHeapFreeRatio=70-XX:+CMSIncrementalPacing-XX:+UseFastAccessorMethods-server最后，移除所有重复的选项，包括launcher.XXMaxPermSize，因为启用了XX:MaxPermSize选项后，这个选项就没用了

那是安装问题吧，4核8G就挺可以了，4G也可以了

这个问题的根源是jvm虚拟机的默认Heap大小是64M,可以通过设置其最大和最小值来实现.设置的方法主要是几个.额 换个好点的JDK 另外不同的服务器更改配置的方式不一样 1.可以在windows 更改系统环境变量加上JAVA_OPTS=-Xms64m -Xmx512m2,如果用的tomcat,在windows下,可以在C: omcat5.5.9incatalina.bat 中加上:set JAVA_OPTS=-Xms64m -Xmx256m位置在: rem Guess CATALINA_HOME if not defined 这行的下面加合适.3.如果是linux系统Linux 在{tomcat_home}/bin/catalina.sh的前面，加 set JAVA_OPTS="-Xms64 -Xmx512"java.lang.OutOfMemoryError: Java heap space 使用Java程序从数据库中查询大量的数据时出现异常:java.lang.OutOfMemoryError: Java heap space 在JVM中如果98％的时间是用于GC且可用的 Heap size 不足2％的时候将抛出此异常信息。JVM堆的设置是指java程序运行过程中JVM可以调配使用的内存空间的设置.JVM在启动的时候会自动设置Heap size的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)是物理内存的1/4。可以利用JVM提供的-Xmn -Xms -Xmx等选项可进行设置。例如：java -jar -Xmn16m -Xms64m -Xmx128m MyApp.jar如果Heap Size设置偏小，除了这些异常信息外，还会发现程序的响应速度变慢了。GC占用了更多的时间，而应用分配到的执行时间较少。Heap Size 最大不要超过可用物理内存的80％，一般的要将-Xms和-Xmx选项设置为相同，而-Xmn为1/4的-Xmx值。Heap size的 -Xms -Xmn 设置不要超出物理内存的大小。否则会提示“Error occurred during initialization of VM Could not reserve enough space for object heap”。

Connection con = null;ResultSet rs = null;PreparedStatement pst = null;try {con = DBCon.getConnection();con.setAutoCommit(false);pst = con.prepareStatement(" select * from test ");rs = pst.executeQuery();pst = con.prepareStatement(" insert into test1(t1,t2,t3,t4,t5,t6,t7,t8,t9)values(?,?,?,?,?,?,?,?,?) ");while (rs.next()) {pst.setString(1, rs.getString(1));pst.setString(2, rs.getString(2));pst.setString(3, rs.getString(3));pst.setString(4, rs.getString(4));pst.setString(5, rs.getString(5));pst.setString(6, rs.getString(6));pst.setString(7, rs.getString(7));pst.setString(8, rs.getString(8));pst.setString(9, rs.getString(9));pst.addBatch();}pst.executeBatch();} catch (SQLException e) {// TODO: handle exception} finally {try {rs.close();pst.close();con.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}

那么麻烦干嘛，重新安装JAVA X64

java heap space的意思为“java堆空间”，是JAVA的堆栈设置太小的原因。有这两种解决方法：1、设置环境变量：set JAVA_OPTS= -Xms32m -Xmx512m可以根据自己机器的内存进行更改，但本人测试这种方法并没有解决问题。可能是还有哪里需要设置。2、java -Xms32m -Xmx800m className：就是在执行JAVA类文件时加上这个参数，其中className是需要执行的确类名。这个解决问题了，而且执行的速度比没有设置的时候快很多。如果在测试的时候可能会用Eclispe这时候就需要在Eclipse ->run -arguments中的VM arguments中输入－Xms32m -Xmx800m这个参数就可以了。

java heap space的意思为“java堆空间”，是JAVA的堆栈设置太小的原因。有这两种解决方法：1、设置环境变量：set JAVA_OPTS= -Xms32m -Xmx512m可以根据自己机器的内存进行更改，但本人测试这种方法并没有解决问题。可能是还有哪里需要设置。2、java -Xms32m -Xmx800m className：就是在执行JAVA类文件时加上这个参数，其中className是需要执行的确类名。这个解决问题了，而且执行的速度比没有设置的时候快很多。如果在测试的时候可能会用Eclispe这时候就需要在Eclipse ->run -arguments中的VM arguments中输入－Xms32m -Xmx800m这个参数就可以了。

java heap space的意思为“java堆空间”，是JAVA的堆栈设置太小的原因。有这两种解决方法：1、设置环境变量：set JAVA_OPTS= -Xms32m -Xmx512m可以根据自己机器的内存进行更改，但本人测试这种方法并没有解决问题。可能是还有哪里需要设置。2、java -Xms32m -Xmx800m className：就是在执行JAVA类文件时加上这个参数，其中className是需要执行的确类名。这个解决问题了，而且执行的速度比没有设置的时候快很多。如果在测试的时候可能会用Eclispe这时候就需要在Eclipse ->run -arguments中的VM arguments中输入－Xms32m -Xmx800m这个参数就可以了。

Java堆空间（Heap Space）是指Java程序运行时使用的一块内存空间，用于存储对象实例、数组、常量池等数据。堆空间的大小由JVM决定，并且可以通过调整JVM参数来进行调整。在Java中，每个线程都拥有一个虚拟机栈，用于存储栈帧信息。堆是JVM内存空间中最大的一块，每个对象实例都要分配在堆上，并且在堆上分配的对象实例必须是引用类型，即它们必须指向其他对象或者数组。由于即时编译技术的进步，逃逸分析技术的日渐强大，栈上分配、标量替换优化手段已经导致一些微妙的变化悄然发生，因此虽然Java对象实例都分配在堆上也不是绝对的。但是在多线程环境下，由于线程之间的竞争关系，堆空间的使用仍然是很重要的，需要仔细分析和调整JVM参数来最大化堆空间的使用效率。

StringBuffer支持很大的数据，你这才200M就内存溢出，显然是jvm内存分配不足。1、调大jvn的内存。2、修改程序，用缓存实现，不要一次全部读取出来。分次执行。

一般情况下 建议把文件保存到 本地存储就行了啊 像你说的保存到数据库 还是大文件 这个是必须的吗?

堆空间不够用。需要改tomcat启动参数。把堆空间和方法区控件都扩大。扩多大，看你的项目了。你的项目多大，你的参数又是多少，贴一下，我帮你看看。

你的spark集群的主机的hosts列表中有master对应的ip吗，看看/etc/hosts中有没有一行，如果spark的主机也就是master是本地机器，就用.setMaster("spark://localhost:7077")： 好了； 建议还是用Idea来编spark程序

重新检查下JAVA_HOME，PATH，CLASSPATH。。我安装android Studio的时候也出现过你这情况，设置好了JAVA_HOME，PATH，CLASSPATH之后就能启动了

首先检查代码。看是否有数据集未释放，特别是多个ResultSet这间的嵌套使用。像你这种情况，打开一次数据连接，不要反复的关闭，打开连接，这样很消耗资源的。再你尝试在Eclipse -> Edit JRE -> Default VM Arguments：-Xms256m -Xmx512m

报unhandled event loop exception的错误解决概括：不是eclipse版本问题，是由于一些杀毒的影响，只需把杀毒等一些非必须的进程关掉，问题即解决。

可能是某个地方出现死循环了..也肯能是文件太大了吧.String line = br.readLine(); 把line的定义放在外面试一试额.

在运行java的参数后增加扩展堆内存的参数，不同版本的jdk参数略有不同，你可以百度查找具体参数。一般是：-Xmx2048m

说明图片可能有点大，尝试加大运行时的内存：运行时加上参数 -Xmx1024m另外最好还是要判断下oom的具体原因，OOM可能会发生在不同的存储位置，可以通过具体的设置去增加不同位置内存的占用。关注我的微公号 某鸟碎碎， 发布各种入门教学文章，java编程基础学习内容。

可见的代码上需要一处需要优化，in需要关闭！！！

解决办法：1.window->preferences->java->installed jres->edit jre把default vm arguments 的参数设为-Xms64m -Xmx512方法2。在window的环境变量中添加JAVA_OPTS=-Xms64m -Xmx512m

是不是你启动的Tomcat没有关闭就新建导致的

第一种 环境myeclipse修改在菜单window->preferecces.在JDK对话框中输入-Xms512m -Xmx1024m这个参数就可以了。第二种 tomcat安装版修改方法：第三种 tomcat绿色版修改方法。在bin目录下找到catalina.bat；在:gotHome后输入[html] view plain copy set "JAVA_OPTS=-Xms512m -Xmx1024m"

建议重装系统

1、在D:/apache-tomcat-6.0.18/bin/catalina.bat最前面加入：setJAVA_OPTS=-Xms384m-Xmx384m　　注意：只有startup.bat启动tomcat,设置才能生效，如果利用windows的系统服务启动tomcat服务,上面的设置就不生效了,就是说setJAVA_OPTS=-Xms384m-Xmx384m没起作用　　2、在Eclilpse中修改启动参数，在VMarguments加入了-Xms384m-Xmx384m，设置如下图所示