「java内存可见」java内存可见性关键字

本篇文章给大家谈谈java内存可见，以及java内存可见性关键字对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、JAVA的自动内存管理是怎么回事
• 2、哪位能描述一下 java 中内存的分区情况和各类变量在内存中的存贮情况。
• 3、java里的totalMemory()、maxMemory()、freeMemory()究竟是什么。。。
• 4、java内存模型，年轻代为什么分为8比1
• 5、Java内存结构与模型

JAVA的自动内存管理是怎么回事

1、Java的内存管理就是对象的分配和释放问题。

在Java中，程序员需要通过关键字new为每个对象申请内存空间 (基本类型除外)，所有的对象都在堆 (Heap)中分配空间。

对象的释放是由GC决定和执行的。

在Java中，内存的分配是由程序完成的，而内存的释放是有GC完成的，这种收支两条线的方法简化了程序员的工作。但也加重了JVM的工作。这也是Java程序运行速度较慢的原因之一。

GC释放空间方法：

监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等。当该对象不再被引用时，释放对象。

2、内存管理结构

Java使用有向图的方式进行内存管理，对于程序的每一个时刻，我们都有一个有向图表示JVM的内存分配情况。

将对象考虑为有向图的顶点，将引用关系考虑为图的有向边，有向边从引用者指向被引对象。另外，每个线程对象可以作为一个图的起始顶点，例如大多程序从main进程开始执行，那么该图就是以main进程顶点开始的一棵根树。在这个有向图中，根顶点可达的对象都是有效对象，GC将不回收这些对象。如果某个对象 (连通子图)与这个根顶点不可达(注意，该图为有向图)，那么我们认为这个(这些)对象不再被引用，可以被GC回收。

3、使用有向图方式管理内存的优缺点

Java使用有向图的方式进行内存管理，可以消除引用循环的问题，例如有三个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的。

这种方式的优点是管理内存的精度很高，但是效率较低。

++：

另外一种常用的内存管理技术是使用计数器，例如COM模型采用计数器方式管理构件，它与有向图相比，精度行低(很难处理循环引用的问题)，但执行效率很高。

★ Java的内存泄露

Java虽然由GC来回收内存，但也是存在泄露问题的，只是比C++小一点。

1、与C++的比较

c++所有对象的分配和回收都需要由用户来管理。即需要管理点，也需要管理边。若存在不可达的点，无法在回收分配给那个点的内存，导致内存泄露。存在无用的对象引用，自然也会导致内存泄露。

Java由GC来管理内存回收，GC将回收不可达的对象占用的内存空间。所以，Java需要考虑的内存泄露问题主要是那些被引用但无用的对象——即指要管理边就可以。被引用但无用的对象，程序引用了该对象，但后续不会再使用它。它占用的内存空间就浪费了。

如果存在对象的引用，这个对象就被定义为“活动的”，同时不会被释放。

2、Java内存泄露处理

处理Java的内存泄露问题：确认该对象不再会被使用。

典型的做法——

把对象数据成员设为null

从集合中移除该对象

注意，当局部变量不需要时，不需明显的设为null，因为一个方法执行完毕时，这些引用会自动被清理。

例子：

List myList=new ArrayList();

for (int i=1;i100; i++)

{

Object o=new Object();

myList.add(o);

o=null;

}

//此时，所有的Object对象都没有被释放，因为变量myList引用这些对象。

当myList后来不再用到，将之设为null，释放所有它引用的对象。之后GC便会回收这些对象占用的内存。

★ 对GC操作

对GC的操作并不一定能达到管理内存的效果。

GC对于程序员来说基本是透明的，不可见的。我们只有几个函数可以访问GC，例如运行GC的函数System.gc()，System.。

但是根据Java语言规范定义， System.gc()函数不保证JVM的垃圾收集器一定会执行。因为，不同的JVM实现者可能使用不同的算法管理GC。通常，GC的线程的优先级别较低。

JVM调用GC的策略有很多种，有的是内存使用到达一定程度时，GC才开始工作，也有定时执行的，有的是平缓执行GC，有的是中断式执行GC。但通常来说，我们不需要关心这些。除非在一些特定的场合，GC的执行影响应用程序的性能，例如对于基于Web的实时系统，如网络游戏等，用户不希望GC突然中断应用程序执行而进行垃圾回收，那么我们需要调整GC的参数，让GC能够通过平缓的方式释放内存，例如将垃圾回收分解为一系列的小步骤执行，Sun提供的HotSpot JVM就支持这一特性。

★ 内存泄露检测

市场上已有几种专业检查Java内存泄漏的工具，它们的基本工作原理大同小异，都是通过监测Java程序运行时，所有对象的申请、释放等动作，将内存管理的所有信息进行统计、分析、可视化。开发人员将根据这些信息判断程序是否有内存泄漏问题。这些工具包括Optimizeit Profiler，JProbe Profiler，JinSight , Rational 公司的Purify等。

在运行过程中，我们可以随时观察内存的使用情况，通过这种方式，我们可以很快找到那些长期不被释放，并且不再使用的对象。我们通过检查这些对象的生存周期，确认其是否为内存泄露。

★ 软引用

特点：只有当内存不够的时候才回收这类内存，同时又保证在Java抛出OutOfMemory异常之前，被设置为null。

保证最大限度的使用内存而不引起OutOfMemory异常。

在某些时候对软引用的使用会降低应用的运行效率与性能，例如：应用软引用的对象的初始化过程较为耗时，或者对象的状态在程序的运行过程中发生了变化，都会给重新创建对象与初始化对象带来不同程度的麻烦。

用途：

可以用于实现一些常用资源的缓存，实现Cache的功能

处理一些占用内存大而且声明周期较长，但使用并不频繁的对象时应尽量应用该技术

★ java程序设计中有关内存管理的经验

1．最基本的建议是尽早释放无用对象的引用。如：

...

A a = new A();

//应用a对象

a = null; //当使用对象a之后主动将其设置为空

….

注：如果a 是方法的返回值，不要做这样的处理，否则你从该方法中得到的返回值永远为空，而且这种错误不易被发现、排除

2．尽量少用finalize函数。它会加大GC的工作量。

3．如果需要使用经常用到的图片，可以使用soft应用类型。它尽可能把图片保存在内存中

4．注意集合数据类型，包括数组、树、图、链表等数据结构，这些数据结构对GC来说，回收更为复杂。

5．尽量避免在类的默认构造器中创建、初始化大量的对象，防止在调用其自类的构造器时造成不必要的内存资源浪费

6．尽量避免强制系统做垃圾内存的回收，增长系统做垃圾回收的最终时间

7．尽量避免显式申请数组空间

8．尽量做远程方法调用类应用开发时使用瞬间值变量，除非远程调用端需要获取该瞬间值变量的值。

9．尽量在合适的场景下使用对象池技术以提高系统性能。

哪位能描述一下 java 中内存的分区情况和各类变量在内存中的存贮情况。

Java内存分配与管理是Java的核心技术之一，一般Java在内存分配时会涉及到以下区域：

◆寄存器：我们在程序中无法控制

◆栈：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中

◆堆：存放用new产生的数据

◆静态域：存放在对象中用static定义的静态成员

◆常量池：存放常量

◆非RAM存储：硬盘等永久存储空间

Java内存分配中的栈

在函数中定义的一些基本类型的变量数据和对象的引用变量都在函数的栈内存中分配。

当在一段代码块定义一个变量时，Java就在栈中 为这个变量分配内存空间，当该变量退出该作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

Java内存分配中的堆

堆内存用来存放由new创建的对象和数组。 在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。

在堆中产生了一个数组或对象后，还可以 在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。  引用变量就相当于是 为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。引用变量就相当于是为数组或者对象起的一个名称。

引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配，即使程序 运行到使用 new 产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用，但仍 然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉）。这也是 Java 比较占内存的原因。

实际上，栈中的变量指向堆内存中的变量，这就是Java中的指针！

常量池 (constant pool)

常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。除了包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值(final)还包含一些以文本形式出现的符号引用，比如：

◆类和接口的全限定名；

◆字段的名称和描述符；

◆方法和名称和描述符。

虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和，包括直接常量（string,integer和 floating point常量）和对其他类型，字段和方法的符号引用。

对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的， 对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引 用。说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了。

在程序执行的时候,常量池 会储存在Method Area,而不是堆中。

堆与栈

Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、 anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存 大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态 分配内存，存取速度较慢。

栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是 确定的，缺乏灵活性。栈中主要存放一些基本类型的变量数据（int, short, long, byte, float, double, boolean, char）和对象句柄(引用)。

栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：

1. int a = 3;

2. int b = 3；

编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。

这时，如果再令 a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响 到b的值。

要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。

String是一个特殊的包装类数据。可以用：

String str = new String("abc");

String str = "abc";

两种的形式来创建，第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。而第二种是先在栈中创建一个对String类的对象引用变量str，然后通过符号引用去字符串常量池 里找有没有"abc",如果没有，则将"abc"存放进字符串常量池 ，并令str指向”abc”，如果已经有”abc” 则直接令str指向“abc”。

比较类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。

1．String str1 = "abc";

2．String str2 = "abc";

3．System.out.println(str1==str2); //true

可以看出str1和str2是指向同一个对象的。

1．String str1 =new String ("abc");

2．String str2 =new String ("abc");

3．System.out.println(str1==str2); // false

用new的方式是生成不同的对象。每一次生成一个。

因此用第二种方式创建多个”abc”字符串,在内存中 其实只存在一个对象而已. 这种写法有利与节省内存空间. 同时它可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。

另 一方面, 要注意: 我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的 对象。只有通过new()方法才能保证每次都创建一个新的对象。

由于String类的immutable性质，当String变量需要经常变换 其值时，应该考虑使用StringBuffer类，以提高程序效率。

1. 首先String不属于8种基本数据类型，String是一个对象。因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。

2. new String()和new String(”")都是申明一个新的空字符串，是空串不是null；

3. String str=”kvill”；String str=new String (”kvill”)的区别

示例：

1．String s0="kvill";

2．String s1="kvill";

3．String s2="kv" + "ill";

4．System.out.println( s0==s1 );

5．System.out.println( s0==s2 );

结果为：

true

true

首先，我们要知结果为道Java 会确保一个字符串常量只有一个拷贝。

因为例子中的 s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字 符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中” kvill”的一个引用。所以我们得出s0==s1==s2；用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

示例：

6．String s0="kvill";

7．String s1=new String("kvill");

8．String s2="kv" + new String("ill");

9．System.out.println( s0==s1 );

10．System.out.println( s0==s2 );

11．System.out.println( s1==s2 );

结果为：

false

false

false

例2中s0还是常量池 中"kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分 new String(”ill”)所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。

4. String.intern()：

再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的 intern()方法就是扩充常量池的 一个方法；当一个String实例str调用intern()方法时，Java 查找常量池中 是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常 量池中增加一个Unicode等于str的字符串并返回它的引用；看示例就清楚了

示例：

1．String s0= "kvill";

2．String s1=new String("kvill");

3．String s2=new String("kvill");

4．System.out.println( s0==s1 );

5．System.out.println( "**********" );

6．s1.intern();

7．s2=s2.intern(); //把常量池中"kvill"的引用赋给s2

8．System.out.println( s0==s1);

9．System.out.println( s0==s1.intern() );

10．System.out.println( s0==s2 );

结果为：

false

false //虽然执行了s1.intern(),但它的返回值没有赋给s1

true //说明s1.intern()返回的是常量池中"kvill"的引用

true

最后我再破除一个错误的理解：有人说，“使用 String.intern() 方法则可以将一个 String 类的保存到一个全局 String 表中 ，如果具有相同值的 Unicode 字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中”如果我把他说的这个全局的 String 表理解为常量池的话，他的最后一句话，”如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：

示例：

1．String s1=new String("kvill");

2．String s2=s1.intern();

3．System.out.println( s1==s1.intern() );

4．System.out.println( s1+" "+s2 );

5．System.out.println( s2==s1.intern() );

结果：

1． false

2． kvill kvill

3． true

在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一 个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。

s1==s1.intern() 为false说明原来的”kvill”仍然存在；s2现在为常量池中”kvill”的地址，所以有s2==s1.intern()为true。

5. 关于equals()和==:

这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是 比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。

6. 关于String是不可变的

这一说又要说很多，大家只 要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”; 就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” ” 生成 “kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的”不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原 因了，因为StringBuffer是可改变的。

下面是一些String相关的常见问题：

String中的final用法和理解

final StringBuffer a = new StringBuffer("111");

final StringBuffer b = new StringBuffer("222");

a=b;//此句编译不通过

final StringBuffer a = new StringBuffer("111");

a.append("222");// 编译通过

可见，final只对引用的"值"(即内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象 的变化，final是不负责的。

String常量池问题的几个例子

下面是几个常见例子的比较分析和理解：

String a = "a1";

String b = "a" + 1;

System.out.println((a == b)); //result = true

String a = "atrue";

String b = "a" + "true";

System.out.println((a == b)); //result = true

String a = "a3.4";

String b = "a" + 3.4;

System.out.println((a == b)); //result = true

分析：JVM对于字符串常量的"+"号连接，将程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值，拿"a" + 1来说，经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。

String a = "ab";

String bb = "b";

String b = "a" + bb;

System.out.println((a == b)); //result = false

分析：JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a" + bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b。所以上面程序的结果也就为false。

String a = "ab";

final String bb = "b";

String b = "a" + bb;

System.out.println((a == b)); //result = true

分析：和[3]中唯一不同的是bb字符串加了final修饰，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量 池中或嵌入到它的字节码流中。所以此时的"a" + bb和"a" + "b"效果是一样的。故上面程序的结果为true。

String a = "ab";

final String bb = getBB();

String b = "a" + bb;

System.out.println((a == b)); //result = false

private static String getBB() {

return "b";

}

分析：JVM对于字符串引用bb，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"a"来动态连接并分配地址为b，故上面 程序的结果为false。

通过上面4个例子可以得出得知：

String  s  =  "a" + "b" + "c";

就等价于String s = "abc";

String  a  =  "a";

String  b  =  "b";

String  c  =  "c";

String  s  =   a  +  b  +  c;

这个就不一样了，最终结果等于：

1．StringBuffer temp = new StringBuffer();

2．temp.append(a).append(b).append(c);

3．String s = temp.toString();

由上面的分析结果，可就不难推断出String 采用连接运算符（+）效率低下原因分析，形如这样的代码：

public class Test {

public static void main(String args[]) {

String s = null;

for(int i = 0; i  100; i++) {

s += "a";

}

}

}

每做一次 + 就产生个StringBuilder对象，然后append后就扔掉。下次循环再到达时重新产生个StringBuilder对象，然后 append 字符串，如此循环直至结束。如果我们直接采用 StringBuilder 对象进行 append 的话，我们可以节省 N - 1 次创建和销毁对象的时间。所以对于在循环中要进行字符串连接的应用，一般都是用StringBuffer或StringBulider对象来进行 append操作。

String对象的intern方法理解和分析：

1．public class Test4 {

2．    private static String a = "ab";

3．    public static void main(String[] args){

4．        String s1 = "a";

5．        String s2 = "b";

6．        String s = s1 + s2;

7．        System.out.println(s == a);//false

8．        System.out.println(s.intern() == a);//true

9．    }

10．}

这里用到Java里面是一个常量池的问题。对于s1+s2操作，其实是在堆里面重新创建了一个新的对象,s保存的是这个新对象在堆空间的的内容，所 以s与a的值是不相等的。而当调用s.intern()方法，却可以返回s在常量池中的地址值，因为a的值存储在常量池中，故s.intern和a的值相等。

总结

栈中用来存放一些原始数据类型的局部变量数据和对象的引用(String,数组.对象等等)但不存放对象内容

堆中存放使用new关键字创建的对象.

字符串是一个特殊包装类,其引用是存放在栈里的,而对象内容必须根据创建方式不同定(常量池和堆).有的是编译期就已经创建好，存放在字符串常 量池中，而有的是运行时才被创建.使用new关键字，存放在堆中。

java里的totalMemory()、maxMemory()、freeMemory()究竟是什么。。。

这里我不解释你写的程序的作用，而是给你介绍一下JAVA虚拟机是如何使用内存的，希望对你有所帮助。

我们知道，JAVA程序本身是不能直接在计算机上运行的，它需要依赖于硬件基础之上的操作系统和JVM（JAVA虚拟机）。JAVA程序启动时JVM都会分配一个初始内存和最大内存给这个应用程序。这个初始内存和最大内存在一定程度上会影响应用程序的性能。

JVM其实就是操作系统上的一个普通程序（进程名叫java，这个程序可以解释执行class文件，系统中当前运行了多少个java程序就会有多少个java进程）。当java进程启动时会首先分配一块堆内存（最小内存），以后每当java程序要求JVM（java进程）分配内存时，JVM就会在预先分配的那块内存上为java程序分配内存，当预先分配的那块内存用完时，JVM会再向操作系统要内存（物理内存），但是JVM不会无限制的向操作系统要内存，当它占用的实际内存达到一个预定值（最大可用内存）时，如果java程序还向JVM要内存，并且JVM无法通过垃圾回收机制回收当前堆中的内存来为java程序服务时，它就会给程序抛出异常：java.lang.OutOfMemoryError。其中内存回收时机并不是在用掉内存达到最大可用内存时才进行，它的运行时机是不确定的。可见JVM的最大可用内存就是java程序能够使用的最大内存。例如：我们把某JAVA程序的JVM最大可用内存设为200M，而我们的物理内存是1G。这种情况下，我们的java程序最多能使用200M内存，虽然我们可能还有800M的内存可用，但是当我们的程序用掉200M后，如果再要内存，JVM不会因为我们还有800M的内存而为我们分配内存，它会抛出java.lang.OutOfMemoryError异常。

java内存模型，年轻代为什么分为8比1

了解java内存模型对深入了解jvm有很多好处。JMM通过控制主内存与每个线程的本地内存之间的交互，来为开发者提供内存可见性保证。

Java内存结构与模型

一 java内存结构

Heap(堆) 实例分配的地方 通过 Xms与 Xmx来设置

MethodArea(方法区域) 类的信息及静态变量 对应是Permanet Generation 通过 XX PermSize来设置

JavaStack(java的栈) 虚拟机只会直接对Javastack执行两种操作 以帧为单位的压栈或出栈 通过 Xss来设置 若不够会抛出StackOverflowError

ProgramCounter(程序计数器) 每一个线程都有它自己的PC寄存器 也是该线程启动时创建的 PC寄存器的内容总是指向下一条将被执行指令的饿地址 这里的地址可以是一个本地指针 也可以是在方法区中相对应于该方法起始指令的偏移量

Nativemethodstack(本地方法栈) 保存native方法进入区域的地址

当中Heap和MethodArea是被所有线程的共享使用的

而Javastack Programcounter和Nativemethodstack是以线程为粒度的 每个线程独自拥有自己的部分

二 内存模型

由以上可以知道java内存分为main memory和线程的Working Memory 就会涉及到这两种内存数据同步以及多个线程操作时数据一致性和可见性的问题 这就不可避免要加锁了 在java中可采用如下的形式

  synchronized关键字或使用ncurrent locks中的锁

  volatile关键字 Volatile表示的是线程每次操作都是在主内存中进行 这只能保证其可见性 而不能保证其的原子性 要有原子性还得加锁

  final变量(基本类型 类类型还是可以改值的)

三 如何保证线程安全

每个线程只操作自有的数据 这个可能性要小

设计的类无数据成员 也就没有共享变量 要有可用是 final或volatile

lishixinzhi/Article/program/Java/hx/201311/26489

java内存可见的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java内存可见性关键字、java内存可见的信息别忘了在本站进行查找喔。