堆和栈的区别 (stack and heap)
 
一般认为在c中分为这几个存储区 
 1栈 - 有编译器自动分配释放 
 2堆 - 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收 
 3全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 程序结束释放。 
 4另外还有一个专门放常量的地方。 - 程序结束释放
 
在函数体中定义的变量通常是在栈上，用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区（静态区）,在所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static表示只在该函数体内有效。另外，函数中的 “adgfdf “这样的字符串存放在常量区。 
 比如： 
 int a = 0; 全局初始化区 
 char *p1; 全局未初始化区 
 main() 
 { 
 int b; 栈 
 char s[] = “abc “;栈 
 char *p2; 栈 
 char *p3 = “123456 “; 123456\0在常量区，p3在栈上。 
 static int c =0； 全局（静态）初始化区 
 p1 = (char *)malloc(10); 
 p2 = (char *)malloc(20); 
 分配得来得10和20字节的区域就在堆区。 
 strcpy(p1, “123456 “); 123456\0放在常量区，编译器可能会将它与p3所指向的 “12345 
 6 “优化成一块。 
 }
 
还有就是函数调用时会在栈上有一系列的保留现场及传递参数的操作。栈的空间大小有限定，vc的缺省是2M。栈不够用的情况一般是程序中分配了大量数组和递归函数层次太深。有一点必须知道，当一个函数调用完返回后它会释放该函数中所有的栈空间。栈是由编译器自动管理的，不用你操心。堆是动态分配内存的，并且你可以分配使用很大的内存。但是用不好会产生内存泄漏。并且频繁地malloc和free会产生内存碎片（有点类似磁盘碎片），因为c分配动态内存时是寻找匹配的内存的。而用栈则不会产生碎片。在栈上存取数据比通过指针在堆上存取数据快些。
 
一般大家说的堆栈和栈是一样的，就是栈(stack)，而说堆时才是堆heap. 
 栈是先入后出的，一般是由高地址向低地址生长。 
 
堆(heap)和栈(stack)是C/C++编程不可避免会碰到的两个基本概念。首先，这两个概念都可以在讲数据结构的书中找到，他们都是基本的数据结构，虽然栈更为简单一些。在具体的C/C++编程框架中，这两个概念并不是并行的。对底层机器代码的研究可以揭示，栈是机器系统提供的数据结构，而堆则是C/C++函数库提供的。具体地说，现代计算机(串行执行机制)，都直接在代码底层支持栈的数据结构。这体现在，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作。这种机制的特点是效率高，支持的数据有限，一般是整数，指针，浮点数等系统直接支持的数据类型，并不直接支持其他的数据结构。因为栈的这种特点，对栈的使用在程序中是非常频繁的。对子程序的调用就是直接利用栈完成的。机器的call指令里隐含了把返回地址推入栈，然后跳转至子程序地址的操作，而子程序中的ret指令则隐含从堆栈中弹出返回地址并跳转之的操作。C/C++中的自动变量是直接利用栈的例子，这也就是为什么当函数返回时，该函数的自动变量自动失效的原因(因为 颜换指戳说饔们暗 状态)。 
 
和栈不同，堆的数据结构并不是由系统(无论是机器系统还是操作系统)支持的，而是由函数库提供的。基本的malloc/realloc/free函数维护了一套内部的堆数据结构。当程序使用这些函数去获得新的内存空间时，这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以使用的内存空间，则试图利用系统调用来动态增加程序数据段的内存大小，新分配得到的空间首先被组织进内部堆中去，然后再以适当的形式返回给调用者。当程序释放分配的内存空间时，这片内存空间被返回内部堆结构中，可能会被适当的处理(比如和其他空闲空间合并成更大的空闲空间)，以更适合下一次内存分配申请。这套复杂的分配机制实际上相当于一个内存分配的缓冲池(Cache)，使用这套机制有如下若干原因： 
 
系统调用可能不支持任意大小的内存分配。有些系统的系统调用只支持固定大小及其倍数的内存请求(按页分配)；这样的话对于大量的小内存分类来说会造成浪费。 
系统调用申请内存可能是代价昂贵的。系统调用可能涉及用户态和核心态的转换。 
没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片。 
 
堆和栈的对比 
 
从以上知识可知，栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而栈是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。不同堆分的内存无法互相操作。栈空间分静态分配和动态分配两种。静态分配是编译器完成的，比如自动变量(auto)的分配。动态分配由alloca函数完成。栈的动态分配无需释放(是自动)，也就没有释放函数。为可移植的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/释放内存匹配是良好程序的基本要素。 
 
可以放一块思考 
 堆和栈的生长方向恰好相反， 
 |————–| 低地址 
 
堆
I
^
 
| 栈 | 高地址 
 
所以计算机中的堆和栈经常时放一块讲的 
 
nod 一般不是必要就不要动态创建，最讨厌把new出来的东西当局部变量用，用万了马上delete 的做法. 
 
理由 
 1.栈分配比堆快，只需要一条指令就呢给配所有的局部变量 
 2.栈不会出现内存碎片 
 3。栈对象好管理 
 
当然，某些情况下也要那么写,比如 
 1.对象很大 
 2.对象需要在某个特定的时刻构造或析够 
 3.类只允许对象动态创建,比如VCL的大多数类 
 当然，必须用堆对象时也不能躲避 
 堆内存和栈内存各有什么作用？ 
 堆：顺序随意 
 栈：先进后出 
 堆和栈的区别 
 一、预备知识—程序的内存分配 
 一个由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\0在常量区，p3在栈上。 
 static int c =0； 全局（静态）初始化区 
 p1 = (char *)malloc(10); 
 p2 = (char *)malloc(20); 
 分配得来得10和20字节的区域就在堆区。 
 strcpy(p1, “123456”); 123456\0放在常量区，编译器可能会将它与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是在编译时就确定的；但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。 
 比如： 
 ＃i nclude 
 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个元素有最高的优先权；栈实际上就是满足先进后出的性质的数学或数据结构。虽然堆栈，堆栈的说法是连起来叫，但是他们还是有很大区别的，连着叫只是由于历史的原因。
 
本博客转自什么变量在堆内存里存放，什么变量在栈内存里存放

1、计算机使用内存来记忆或存储计算时使用的数据
 
 
 
· 计算机执行程序时，组成程序的指令和程序所操作的数据都必须存放在某个地方
 
· 这个地方就是计算机的内存（也称为主存或随机访问存储器），类比人类的大脑，内存就是程序员的一切，非常重要
 
 
 
注意：主存和RAM的区别
 
 
 
2、组成计算机内存的单位是bit（位）。binary digit(二进制数字)
 
 
 
8 bit（比特） = 1 byte （字节）
 
10M带宽：10M bps( bit per second )
 
内存分配方式 
 
内存分配方式有三种： 
 
（1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。 
 
（2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 
 
（3）从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。 
 
 
 
常见的内存错误及其对策 
 
发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。有时用户怒气冲冲地把你找来，程序却没有发生任何问题，你一走，错误又发作了。 
 
常见的内存错误及其对策如下： 
 
 
内存分配未成功，却使用了它。 
 
编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。常用解决办法是，在使用内存之前检查指针是否为NULL。如果指针p是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存，应该用if(p==NULL) 或if(p!=NULL)进行防错处理。
 
 
内存分配虽然成功，但是尚未初始化就引用它。 
 
犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误（例如数组）。 
 
内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。所以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦。
 
 
内存分配成功并且已经初始化，但操作越过了内存的边界。 
 
例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for循环语句中，循环次数很容易搞错，导致数组操作越界。
 
 
忘记了释放内存，造成内存泄露。 
 
含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。 
 
动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则肯定有错误（new/delete同理）。
 
 
释放了内存却继续使用它。 
 
有三种情况： 
 
（1）程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。 
 
（2）函数的return语句写错了，注意不要返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁。(return ?) 
 
（3）使用free或delete释放了内存后，没有将指针设置为NULL。导致产生“野指针”。
 
【规则1】用malloc或new申请内存之后，应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存。 
 
【规则2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。 
 
【规则3】避免数组或指针的下标越界，特别要当心发生“多1”或者“少1”操作。 
 
【规则4】动态内存的申请与释放必须配对，防止内存泄漏。 
 
【规则5】用free或delete释放了内存之后，立即将指针设置为NULL，防止产生“野指针”。 
 
 
 
· 动态内存会被自动释放吗？ 
 
函数体内的局部变量在函数结束时自动消亡。很多人误以为示例是正确的。理由是p是局部的指针变量，它消亡的时候会让它所指的动态内存一起完蛋。这是错觉！
 
void Func(void)

{ 

char p = (char ) malloc(100);

// 动态内存会自动释放吗？ 

} 
 
我们发现指针有一些“似是而非”的特征：
 
 
 
（1）指针消亡了，并不表示它所指的内存会被自动释放。 
 
（2）内存被释放了，并不表示指针会消亡或者成了NULL指针。 
 
这表明释放内存并不是一件可以草率对待的事。也许有人不服气，一定要找出可以草率行事的理由： 
 
如果程序终止了运行，一切指针都会消亡，动态内存会被操作系统回收。既然如此，在程序临终前，就可以不必释放内存、不必将指针设置为NULL了。终于可以偷懒而不会发生错误了吧？ 想得美。如果别人把那段程序取出来用到其它地方怎么办？ 
 
 
 
·  内存耗尽怎么办？ 
 
如果在申请动态内存时找不到足够大的内存块，malloc和new将返回NULL指针，宣告内存申请失败。通常有三种方式处理“内存耗尽”问题。 
 
（1）判断指针是否为NULL，如果是则马上用return语句终止本函数。例如： 
 
void Func(void) 

{ 
        A *a = new A; 

        if(a == NULL) 

        { 

                return; 

        } 

… 

}
 
（2）判断指针是否为NULL，如果是则马上用exit(1)终止整个程序的运行。例如： 
 
void Func(void) 

{ 

        A *a = new A; 

        if(a == NULL) 

        { 

        cout << “Memory Exhausted” << endl; 

        exit(1); 

        } 

… 

}
 
（3）为new和malloc设置异常处理函数。例如Visual C++可以用_set_new_hander函数为new设置用户自己定义的异常处理函数，也可以让malloc享用与new相同的异常处理函数。
 
上述（1）（2）方式使用最普遍。如果一个函数内有多处需要申请动态内存，那么方式（1）就显得力不从心（释放内存很麻烦），应该用方式（2）来处理。 很多人不忍心用exit(1)，问：“不编写出错处理程序，让操作系统自己解决行不行？” 
 
不行。如果发生“内存耗尽”这样的事情，一般说来应用程序已经无药可救。如果不用exit(1) 把坏程序杀死，它可能会害死操作系统。道理如同：如果不把歹徒击毙，歹徒在老死之前会犯下更多的罪。
 
有一个很重要的现象要告诉大家。对于32位以上的应用程序而言，无论怎样使用malloc与new，几乎不可能导致“内存耗尽”。我在Windows 98下用Visual C++编写了测试程序，见示例。这个程序会无休止地运行下去，根本不会终止。因为32位操作系统支持“虚存”，内存用完了，自动用硬盘空间顶替。我只听到硬盘嘎吱嘎吱地响，Window 98已经累得对键盘、鼠标毫无反应。 我可以得出这么一个结论：对于32位以上的应用程序，“内存耗尽”错误处理程序毫无用处。这下可把Unix和Windows程序员们乐坏了：反正错误处理程序不起作用，我就不写了，省了很多麻烦。 必须强调：不加错误处理将导致程序的质量很差，千万不可因小失大。
 
void main(void) 

{ 

        float *p = NULL; 

        while(TRUE) 

        { 

        p = new float[1000000]; 

        cout << “eat memory” << endl; 

        if(p==NULL) 

               exit(1); 

        } 

} 

 
 

java内存模型
 
下图就是java内存模型，但是一般讨论的时候不会画这个图，一般画的是java内存模型抽象结构图(在下文)。Thread Stack就是java内存模型抽象结构图中的本地内存，Heap就是java内存模型抽象结构图中的主内存。接下来介绍下图中两个线程内存分配的概念。
 
 
java里的堆是运行时的数据区，堆是由垃圾回收来负责的，堆的优势是可以动态的分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的。java的垃圾收集器会自动收走不再使用的数据。缺点是，由于在运行时动态分配内存，因此存取速度相对慢一些。
 
栈的优势是存取速度比heap要快，仅次于计算机里的寄存器。Stack的数据是可以共享的。但是它的缺点是Stack中的数据大小和生存期必须是确定的。缺乏灵活性。Stack中主要存放基本类型的变量。比如int，short，long，float，double，byte，char等。
 
java内存模型要求调用栈和本地变量存放在线程栈上。对象存放在堆上。一个本地变量它也可能是指向对象的引用，引用的这个本地变量是存在线程栈上，但是对象本身是存放在堆上，比如图中的Local variable 1 是本地变量存放在线程栈上，Object 1 是对象存放在堆上。一个对象可能包含方法图中methodOne()和methodTwo()，可能包含本地变量Local variable 1和Local variable 2，这些本地变量是存放在线程栈上，即使这些方法所属的对象存放在堆上，一个对象的成员变量可能会随着这个对象自身存放在堆上，不管这个成员变量是基本类型还是引用类型。静态成员变量跟着类的定义一起存放在堆上，存放在堆上的对象可以被所持有对这个对象引用的线程访问，比如图中Thread Stack中存放了对Object 3 的引用，那么是可以访问Object3的。如果两个线程同时调用同一个对象的同一个方法，它们将会都访问这个对象的成员变量，但是每一个线程都拥有这个成员变量的私有拷贝。
 
计算机架构的简单图示
 
 
首先介绍cpu，现在计算机通常用两个或多个cpu，其中一些cpu还有多核，从这一点我们可以看出，在一个有两个或者多个cpu的计算机上，同时运行多个线程是非常有可能的，而且每个cpu在某一个时刻，运行一个线程是肯定没有问题的。这意味着如果java程序是多线程的，在java程序中每个cpu上一个线程是可能同时并发执行的。
 
介绍完cpu，然后是cpu寄存器(CPU Registers)，每个cpu都包含一系列的寄存器，它们是cpu内存的基础，cpu在寄存器上执行操作的速度远大于在主存上执行的速度，这是因为cpu访问寄存器的速度远大于主存。
 
高速缓存Cache，由于计算机的存储设备与处理器的运算速度之间有几个数量级的差距。所以现在计算机系统都不得不加入一层读写速度都尽可能接近处理器运算速度的高级缓存来作为内存与处理器之间的缓冲，将运算需要使用的数据复制到缓存中，让运算能快速进行，当运算结束后，在从缓存同步到内存中。这样处理器就无需等待缓慢的内存读写。CPU访问缓存层的速度快于访问主存的速度，但通常比访问内部寄存器的速度还是要慢一点。每个CPU可能有一个CPU的缓存层，一个CPU还有多层缓存。在某一时刻一个或多个缓存行可能被读到缓存，一个或多个缓存行可能被刷新回主存。同一时间点可能有很多操作在里面。
 
CPU内存，所有的cpu都可以访问主存，主存通常比cpu的缓存大的多。
 
运作原理
 
通常情况下，当一个cpu需要读取主存的时候它会将主存的部分读取到cpu缓存中。它甚至会将缓存的部分内容读到内部寄存器里，然后在寄存器中执行操作，当cpu需要将结果回写到主存的时候，它会将内部寄存器的值刷新到缓存中，然后在某个时间点将值刷新回主存。
 
 
通过图可以看出java内存模型与硬件架构之间存在一些差异，硬件内存架构它没有区分线程栈和堆，对于硬件而言所有的线程栈和堆都分布在主内存里，部分cpu栈和堆可能出现cpu缓存中和cpu内部的寄存器里面。
 
java内存模型抽象结构图
 
为了屏蔽各种硬件和操作系统的内存访问差异，以实现让java程序在各种平台下都能达到一致的并发效果，Java虚拟机规范中定义了Java内存模型。
 
java内存模型(Java Memory Model, JMM)是一种规范，它规范了java虚拟机与计算机内存是如何协同工作的。它规定了一个线程如何和何时可以看到由其他线程修改过后的共享变量的值。以及在必须时如何同步的访问共享变量 。
 
java内存模型一般指的就是下图。
 
 
线程之间的共享变量存储在主内存里面，每个线程都有一个私有的本地内存，本地内存是java内存模型的抽象概念，它并不是真实存在的。它涵盖了缓存，写缓存区，寄存器以及其他硬件和编译器的优化。本地内存存储了该线程以读或写共享变量拷贝的副本。比如线程A要是用共享变量的副本它首先要拷贝到本地内存A。从更低的层次来说主内存就是硬件内存，是为了获取更好的运行速度，虚拟机及硬件系统可能会让工作内存优先存储于寄存器和高速缓存中。
 
Java内存模型中的线程的工作内存是cpu的寄存器和高速缓存的抽象描述。而JVM静态存储模型就是jvm内存模型它只是对内存的物理划分而已，它只局限于内存，而且只局限于jvm内存。线程之间通信必须要通过主内存(主内存其实是堆内存)。
 
java内存模型-同步的八种操作
 
lock(锁定)：作用于主内存的变量，把一个变量标识为一条线程独占状态。
 
unlock(解锁)：作用于主内存的变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
 
read(读取)：作用于主内存的变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用。
 
load(载入)：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
 
use(使用)：作用于工作内存的变量，把工作内存中的一个变量值转递给执行引擎。
 
assign(赋值)：作用于工作内存的变量，把一个从执行引擎接收到的值赋值给工作内存的变量。
 
store(存储)：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
 
write(写入)：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。
 
java内存模型-同步规则
 
1、如果要把一个变量从主内存中复制到工作内存，就需要按顺序地执行read和load操作，如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。但java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
 
2、不允许read和load、store和write操作之一单独出现
 
3、不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
 
4、不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
 
5、一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
 
6、一个变量在同一时刻只允许一条线程对其进行locd操作，但lock操作可以被同一条线程重复执行多次，多次执行load后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现。
 
7、如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行Load或assign操作初始化变量的值。
 
8、如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
 
9、对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。
 
java内存模型-同步操作与规则图示
 
 
 

 虚拟机内存中主要有
 程序计数器、虚拟机栈、本地方法栈、堆和方法区。
 

 
 
 

 程序计数器和虚拟机栈都是线程“私有”的内存。
 

 程序计数器
 是一块比较下的内存空间，主要村放代码执行的位置。分支、循环、跳转、异常处理、线程恢复等基础功能都需要一来这个计数器来完成。
 

 例如，多线程中，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，他们之间互不影响，独立存储。
 
 

 经常有人把java内存分为堆内存和栈内存。这里所说的栈指的就是
 虚拟机栈
 。虚拟机栈中存放了各种基本数据类型和对象引用。比如int i。这时候机会在栈中分配一个int类型的内存给i，并初始化为零值。本地方法栈和虚拟机栈所发挥的作用是非常相似的，他们之间的区别不过是虚拟机栈为虚拟机执行java方法服务，而本地方法栈则为虚拟机使用到的Native方法服务。
 
 

 堆和方法区是各个线程共享的内存区域
 

 堆
 （Java Heap）是虚拟机所管理的内存中最大的一块，在虚拟机启动时创建。
 此内存区域的唯一目的就是存放对象实例
 ，几乎所有的对象实例都在这里分配内存，但是随着JIT编译器的发展和逃逸分析技术逐渐成熟，栈上分配、标量替换优化技术将会导致一些微妙的变化发生，所有的对象都分配在堆上就变得不是那么绝对了。
 
 

 方法区
 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
 

 运行时常量池
 是方法区的一部分，用于存放编译器生成的各种字面量和符号引用。