深入Java核心Java内存分配原理精讲
JAVA内存分配与管理是Java的核心技术之一，之前我们曾介绍过Java的内存管理与内存泄露以及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是一个特殊的包装类数据。可以用：
1.String str = new String("abc");
2.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”)的区别
示例：
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() 创建的字符串不放入常量池中，它们有自己的地址空间。
示例：
1.String s0="kvill";
2.String s1=new String("kvill");
3.String s2="kv" + new String("ill");
4.System.out.println( s0==s1 );
5.System.out.println( s0==s2 );
6.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的字符串并返回它的引用；看示例就清楚了
示例：
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() );
结果：
false
kvill kvill
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常量池问题的几个例子
下面是几个常见例子的比较分析和理解：
1.String a = "a1";
2.String b = "a" + 1;
3.System.out.println((a == b)); //result = true
4.String a = "atrue";
5.String b = "a" + "true";
6.System.out.println((a == b)); //result = true
7.String a = "a3.4";
8.String b = "a" + 3.4;
9.System.out.println((a == b)); //result = true
分析：JVM对于字符串常量的"+"号连接，将程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值，拿"a" + 1来说，经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。
1.String a = "ab";
2.String bb = "b";
3.String b = "a" + bb;
4.System.out.println((a == b)); //result = false
分析：JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a" + bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b。所以上面程序的结果也就为false。
1.String a = "ab";
2.final String bb = "b";
3.String b = "a" + bb;
4.System.out.println((a == b)); //result = true
分析：和[3]中唯一不同的是bb字符串加了final修饰，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的"a" + bb和"a" + "b"效果是一样的。故上面程序的结果为true。
1.String a = "ab";
2.final String bb = getBB();
3.String b = "a" + bb;
4.System.out.println((a == b)); //result = false
5.private static String getBB() {
6.return"b";
7.}
分析：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 采用连接运算符（+）效率低下原因分析，形如这样的代码：
1.public class Test {
2.public static void main(String args[]) {
3.String s = null;
4.for(int i = 0; i < 100; i++) {
5.s += "a";
6.}
7.}
8.}
每做一次 + 就产生个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 1. 有这样一种说法，如今争锋于IT战场的两大势力，MS一族偏重于底层实现，Java 一族偏重于系统架构。说法根据无从考证，但从两大势力各自的社区力量和图书市场已有佳作不难看出，此说法不虚，但掌握Java的底层实现对Java程序员来说是至关重要的，本文介绍了Java中的数据在内存中的存储。 2内存中的堆(stack)与栈(heap) Java程序运行时有6个地方可以存储数据，它们分别是寄存器、栈、堆、静态存储、常量存储和非RAM存储，主要是堆与栈的存储。 【随机存储器：Random Access Memory】 栈与堆都是Java用来在RAM中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。另外，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。 【寄存器位于CPU中】 3Java中数据在内存中的存储 3.1基本数据类型的存储 Java的基本数据类型共有8种，即int,short,long,byte,float,double, boolean,char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a=3；long b=255L；的形式来定义的，称为自动变量。值得注意的是：自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。如int a=3；这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。
java技术面试必问：JVM 内存模型讲解 今天我们就来聊一聊Java内存模型，面试中面试官会通过考察你对jvm的理解更深入得了解你的水平。在了解jvm内存模型前我们先回顾下，java程序的执行过程： java文件在通过java编译器生产.class 字节码文件，然后由jvm中的类加载器加载各个类中的字节码文件，加载完成后由jvm执行引擎执行，在整个加载过程中，jvm用一段空间来存储程序执行期间需要的数据和相关信息，这个空间就叫做jvm内存。 一、JVM 的重要性 首先你应该知道，运行一个 Java 应用程序，我们必须要先安装 JDK 或者 JRE 。这是因为 Java 应用在编译后会变成字节码，然后通过字节码运行在 JVM 中，而 JVM 是JRE 的核心组成部分。 二、优点 JVM 不仅承担了 Java 字节码的分析（JIT compiler）和执行（Runtime），同时也内置了自动内存分配管理机制。这个机制可以大大降低手动分配回收机制可能带来的内存泄露和内存溢出风险，使 Java 开发人员不需要关注每个对象的内存分配以及回收，从而更专注于业务本身。 三、缺点 这个机制在提升 Java 开发效率的同时，也容易使 Java 开发人员过度依赖于自动化，弱化对内存的管理能力，这样系统就很容易发生 JVM 的堆内存异常、垃圾回收（GC）的不合适以及 GC 次数过于频繁等问题，这些都将直接影响到应用服务的性能。 四、内存模型 JVM 内存模型共分为5个区：堆（Heap）、方法区（Method Area）、程序计数器（Program Counter Register）、虚拟机栈（VM Stack）、本地方法栈（Native Method Stack）。 其中，堆（Heap）、方法区（Method Area）为线程共享，程序计数器（Program Counter Register）、虚拟机栈（VM Stack）、本地方法栈（Native Method Stack）为线程隔离。 五、堆（Heap） 堆是 JVM 内存中最大的一块内存空间，该内存被所有线程共享，几乎所有对象和数组都被分配到了堆内存中。 堆被划分为新生代和老年代，新生代又被进一步划分为 Eden 区和 Survivor 区，最后 Survivor 由 From Survivor 和 To Survivor 组成。
7Java多线程机制 7.1单项选择题 1. 线程调用了sleep（）方法后，该线程将进入（）状态。 A. 可运行状态 B. 运行状态 C. 阻塞状态 D. 终止状态 2. 关于java线程，下面说法错误的是（） A. 线程是以CPU为主体的行为 B. java利用线程使整个系统成为异步 C. 创建线程的方法有两种：实现Runnable接口和继承Thread类 D. 新线程一旦被创建，它将自动开始运行 3. 在java中的线程模型包含（） A. 一个虚拟处理器 B. CPU执行的代码 C. 代码操作的数据 D. 以上都是 4.在java语言中，临界区可以是一个语句块，或者是一个方法，并用（）关键字标识。 A. synchronized B. include C. import D. Thread 5. 线程控制方法中，yield()的作用是（） A. 返回当前线程的引用 B. 使比其低的优先级线程执行 C. 强行终止线程 D. 只让给同优先级线程运行 6. 线程同步中，对象的锁在（）情况下持有线程返回 A. 当synchronized()语句块执行完后 B. 当在synchronized()语句块执行中出现例外（exception）时 C. 当持有锁的线程调用该对象的wait()方法时 D. 以上都是 7. 在以下（）情况下，线程就进入可运行状态 A. 线程调用了sleep()方法时 B. 线程调用了join()方法时
C. 线程调用了yield()方法时 D. 以上都是 8. java用（）机制实现了进程之间的异步执行 A. 监视器 B. 虚拟机 C. 多个CPU D. 异步调用 类的方法中，toString()方法的作用是（） A. 只返回线程的名称 B. 返回当前线程所属的线程组的名称 C. 返回当前线程对象 D. 返回线程的名称 语言具有许多优点和特点,下列选项中,哪个反映了Java程序并行机制的特点（） A. 安全性 B. 多线程 C. 跨平台 D. 可移值 11.以下哪个关键字可以用来对对象加互斥锁？（） A. transient B. synchronized C. serialize D. static 12.下面关于进程、线程的说法不正确的是( )。 A．进程是程序的一次动态执行过程。一个进程在其执行过程中，可以产生多个线程——多线程，形成多条执行线索。 B．线程是比进程更小的执行单位，是在一个进程中独立的控制流，即程序内部的控制流。线程本身不能自动运行，栖身于某个进程之中，由进程启动执行。 C．Java多线程的运行与平台无关。 D．对于单处理器系统，多个线程分时间片获取CPU或其他系统资源来运行。对于多处理器系统，线程可以分配到多个处理器中，从而真正的并发执行多任务。 7.2填空题 1.________是java程序的并发机制，它能同步共享数据、处理不同的事件。 2.线程是程序中的一个执行流，一个执行流是由CPU运行程序的代码、__________所形 成的，因此，线程被认为是以CPU为主体的行为。 3.线程的终止一般可以通过两种方法实现：自然撤销或者是__________. 4.线程模型在java中是由__________类进行定义和描述的。 5.线程的创建有两种方法：实现_________接口和继承Thread类。 6.多线程程序设计的含义是可以将程序任务分成几个________的子任务。 7.按照线程的模型，一个具体的线程也是由虚拟的CPU、代码与数据组成，其中代码与数 据构成了___________,线程的行为由它决定。 8.ava中，新建的线程调用start()方法、如(),将使线程的状态从New(新建状态)转换为 _________。 9.多线程是java程序的________机制，它能同步共享数据，处理不同事件。 10.进程是由代码、数据、内核状态和一组寄存器组成，而线程是表示程序运行状态的
一、 JVM简介 JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。JVM工作原理和特点主要是指操作系统装入JVM是通过jdk中Java.exe来完成, 首先来说一下JVM工作原理中的jdk这个东西, .JVM 在整个jdk中处于最底层,负责于操作系统的交互,用来屏蔽操作系统环境,提供一个完整的Java运行环境,因此也就虚拟计算机. 操作系统装入JVM是通过jdk中Java.exe来完成。 通过下面4步来完成JVM环境. 1.创建JVM装载环境和配置 2.装载JVM.dll 3.初始化JVM.dll并挂界到JNIENV(JNI调用接口)实例 4.调用JNIEnv实例装载并处理class类。 对于JVM自身的物理结构，我们可以从下图了解：
JVM的一个重要的特征就是它的自动内存管理机制，在执行一段Java代码的时候，会把它所管理的内存划分 成几个不同的数据区域，其中包括： 1. 程序计数器，众所周知，JVM的多线程是通过线程轮流切换并 分配CPU执行时间的方式来实现的，那么每一个线程在切换 后都必须记住它所执行的字节码的行号，以便线程在得到CPU 时间时进行恢复，这个计数器用于记录正在执行的字节码指令的地址，这里要强调的是“字节码”，如果执行的是Native方法，那么这个计数器应该为null； 2.
3. Java计算栈，可以说整个Java程序的执行就是一个出栈入栈 的过程，JVM会为每一个线程创建一个计算栈，用于记录线程中方法的调用和变量的创建，由于在计算栈里分配的内存出栈后立即被抛弃，因此在计算栈里不存在垃圾回收，如果线程请求的栈深度大于JVM允许的深度，会抛出StackOverflowError 异常，在内存耗尽时会抛出OutOfMemoryError异常； 4. Native方法栈，JVM在调用操作系统本地方法的时候会使用到 这个栈； 5. Java堆，由于每个线程分配到的计算栈容量有限，对于可能会 占据大量内存的对象，则会被分配到Java堆中，在栈中包含了指向该对象内存的地址；对于一个Java程序来说，只有一个Java堆，也就是说，所有线程共享一个堆中的对象；由于Java堆不受线程的控制，如果在一个方法结束之后立即回收这个方法使用到的对象，并不能保证其他线程是否正在使用该对象；因此堆中对象的回收由JVM的垃圾收集器统一管理，和某一个线程无关；在HotSpot虚拟机中Java堆被划分为三代：o新生代，正常情况下新创建的对象会被分配到新生代，但如果对象占据的内存足够大以致超过了新生代的容量限 制，也可能被分配到老年代；新生代对象的一个特点是最 新、且生命周期不长，被回收的可能性高；
JA V A内存分析指引 2010-07 1 环境说明 根据一般项目部署情况，生产环境以WebSphere5和WebSphere6为主，本文中所涉及环境变量也主要采用WebSphere的相关环境变量。 WebSphere5安装目录（默认）： Windows：C:\Program Files\WebSphere\AppServer AIX：/usr/WebSphere/ AppServer WebSphere5日志路径 Windows:C:\Program Files\WebSphere\AppServer\logs\server1 AIX: /usr/WebSphere/ AppServer/logs/server1 WebSphere6安装目录(默认)： Windows：C:\Program Files\IBM\WebSphere\AppServer AIX：/usr/IBM/WebSphere/AppServer WebSphere6日志路径： Windows:C:\Program Files\IBM\WebSphere\AppServer\profiles\AppSrv01\logs\server1 AIX: /usr/IBM/WebSphere/AppServer/profiles/AppSrv01/logs/server1 2 内存溢出原理 内存溢出是指应用系统中存在无法回收的内存或使用的内存过多，最终使得程序运行要用到的内存大于虚拟机能提供的最大内存。 为了解决Java中内存溢出问题，我们首先必须了解Java是如何管理内存的。Java的内存管理就是对象的分配和释放问题。在Java中，内存的分配是由程序完成的，而内存的释放是由垃圾收集器(Garbage Collection，GC)完成的。 Java的内存垃圾回收机制是从程序的主要运行对象开始检查引用链，当遍历一遍后发现没有被引用的孤立对象就作为垃圾回收。GC为了能够正确释放对象，必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都需要进行监控。监视对象状态是为了更加准确地、及时地释放对象，而释放对象的根本原则就是该对象不再被引用。
目录 java虚拟机内存管理机制（一）：JVM内存管理总结【分享】收藏 (1) java虚拟机内存管理机制（二）：了解JVM的内存管理与垃圾回收收藏 (5) java虚拟机内存管理机制（三）：我主管写的一些jvm内存管理知识收藏 (8) java虚拟机内存管理机制（一）：JVM内存管理总结【分享】收藏 近期看了看Java内存泄露的一些案例，跟原来的几个哥们讨论了一下，深入研究发现JVM 里面还是有不少以前不知道的细节，这里稍微剖析一下。先看一看JVM的内部结构—— 如图所示，JVM主要包括两个子系统和两个组件。两个子系统分别是Class loader子系统和Execution engine(执行引擎) 子系统；两个组件分别是Runtime data area (运行时数据区域)组件和Native interface(本地接口)组件。 Class loader子系统的作用：根据给定的全限定名类名(如https://www.doczj.com/doc/6f9076551.html,ng.Object)来装载class文件的内容到Runtime data area中的method area(方法区域)。Java程序员可以extends https://www.doczj.com/doc/6f9076551.html,ng.ClassLoader类来写自己的Class loader。
Execution engine子系统的作用：执行classes中的指令。任何JVM specification实现(JDK)的核心都是Execution engine，不同的JDK例如Sun 的JDK 和IBM的JDK好坏主要就取决于他们各自实现的Execution engine的好坏。 Native interface组件：与native libraries交互，是其它编程语言交互的接口。当调用native方法的时候，就进入了一个全新的并且不再受虚拟机限制的世界，所以也很容易出现JVM无法控制的native heap OutOfMemory。 Runtime Data Area组件：这就是我们常说的JVM的内存了。它主要分为五个部分—— 1、Heap (堆)：一个Java虚拟实例中只存在一个堆空间 2、Method Area(方法区域)：被装载的class的信息存储在Method area的内存中。当虚拟机装载某个类型时，它使用类装载器定位相应的class文件，然后读入这个class文件内容并把它传输到虚拟机中。 3、Java Stack(java的栈)：虚拟机只会直接对Java stack执行两种操作：以帧为单位的压栈或出栈 4、Program Counter(程序计数器)：每一个线程都有它自己的PC寄存器，也是该线程启动时创建的。PC寄存器的内容总是指向下一条将被执行指令的饿地址，这里的地址可以是一个本地指针，也可以是在方法区中相对应于该方法起始指令的偏移量。 5、Native method stack(本地方法栈)：保存native方法进入区域的地址 以上五部分只有Heap 和Method Area是被所有线程的共享使用的；而Java stack, Program counter 和Native method stack是以线程为粒度的，每个线程独自拥有自己的部分。 了解JVM的系统结构，再来看看JVM内存回收问题了—— Sun的JVM Generational Collecting(垃圾回收)原理是这样的：把对象分为年青代(Young)、年老代(Tenured)、持久代(Perm)，对不同生命周期的对象使用不同的算法。(基于对对象生命周期分析)
本文由我司收集整编，推荐下载，如有疑问，请与我司联系 Java 内存区域划分、内存分配原理 2014/11/16 2448 运行时数据区域 Java 虚拟机在执行Java 的过程中会把管理的内存划分为若干个不同的数据区域。这些区域有各自的用途，以及创建和销毁的时间，有的区域随着虚拟机进程 的启动而存在，而有的区域则依赖线程的启动和结束而创建和销毁。 Java 虚拟机包括下面几个运行时数据区域： 程序计数器 程序计数器是一块较小的区域，它的作用可以看做是当前线程所执行的字节码的行号指示器。在虚拟机的模型里，字节码指示器就是通过改变程序计数器的值 来指定下一条需要执行的指令。分支，循环等基础功能就是依赖程序计数器来完成的。 由于java 虚拟机的多线程是通过轮流切换并分配处理器执行时间来完成，一个处理器同一时间只会执行一条线程中的指令。为了线程恢复后能够恢复正确的 执行位置，每条线程都需要一个独立的程序计数器，以确保线程之间互不影响。因 此程序计数器是“线程私有”的内存。 如果虚拟机正在执行的是一个Java 方法，则计数器指定的是字节码指令对应的地址，如果正在执行的是一个本地方法，则计数器指定问空undefined。程序计数器区域是Java 虚拟机中唯一没有定义OutOfMemory 异常的区域。 Java 虚拟机栈 和程序计数器一样也是线程私有的，生命周期与线程相同。虚拟机栈描述的是Java 方法执行的内存模型：每个方法被执行的时候都会创建一个栈帧用于存储局部变量表，操作栈，动态链接，方法出口等信息。每一个方法被调用的过程就对应 一个栈帧在虚拟机栈中从入栈到出栈的过程。
JVM调优总结 基本回收算法 1.引用计数（Reference Counting） 比较古老的回收算法。原理是此对象有一个引用，即增加一个计数，删除一个引用则减少一个计数。垃圾回收时，只用收集计数为0的对象。此算法最致命的是无法处理循环引用的问题。 2.标记-清除（Mark-Sweep） 此算法执行分两阶段。第一阶段从引用根节点开始标记所有被引用的对象，第二阶段遍历整个堆，把未标记的对象清除。此算法需要暂停整个应用，同时，会产生内存碎片。 3.复制（Copying） 此算法把内存空间划为两个相等的区域，每次只使用其中一个区域。垃圾回收时，遍历当前使用区域，把正在使用中的对象复制到另外一个区域中。此算法每次只处理正在使用中的对象，因此复制成本比较小，同时复制过去以后还能进行相应的内存整理，不会出现“碎片”问题。当然，此算法的缺点也是很明显的，就是需要两倍内存空间。 4.标记-整理（Mark-Compact） 此算法结合了“标记-清除”和“复制”两个算法的优点。也是分两阶段，第一阶段从根节点开始标记所有被引用对象，第二阶段遍历整个堆，把清除未标记对象并且把存活对象“压缩”到堆的其中一块，按顺序排放。此算法避免了“标记-清除”的碎片问题，同时也避免了“复制”算法的空间问题。 5.增量收集（Incremental Collecting） 实施垃圾回收算法，即：在应用进行的同时进行垃圾回收。不知道什么原因JDK5.0中的收集器没有使用这种算法的。 6.分代（Generational Collecting） 基于对对象生命周期分析后得出的垃圾回收算法。把对象分为年轻代、年老代、持久代，对不同生命周期的对象使用不同的算法（上述方式中的一个）进行回收。现在的垃圾回收器（从J2SE1.2开始）都是使用此算法的。 分代垃圾回收详述 如上图所示，为Java堆中的各代分布 Young（年轻代） 年轻代分三个区。一个Eden区，两个Survivor区。大部分对象在Eden区中生成。当Eden区满时，还存活的对象将被复制到Survivor区（两个中的一个），当这个Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，当这个Survivor区也满了的时候，从第一个Survivor区复制过来的并且此时还存活的对象，将被复制“年老区(Tenured)”。需要注意，Survivor的两个区是对称的，没先后关系，所以
在C 中实现JAVA的存储管理机制 众所周知，JAVA语言最明显的优势在于用它设计的程序可以广泛地运行于互联网上所有安装了VM解释器的计算机上。然而，如今JAVA之所以在市场上如此流行，还得益于它的另一卖点：它提供了安全可靠和使用方便的存储管理机制。这是部分编程人员将它与其前身 C 语言对比后所得出的结论。本文将针对两种语言的内存（以对象为单位）使用机制，通过从灵活性、易用性和效率三个方面的比较，来证明这样一个事实：在C 中可以实现与JAVA一样的存储管理机制。 注：① C 的“指针使用”一列中并未列出形如*Instance的使用，因为这样做的实质不是指针使用； ②“指针复制”是指使得两个对象今后使用相同的一块内存区域，任何对此区域的修改同时会反映到这两个对象上； ③“内容复制”则指拷贝两个对象各自的存储区域，拷贝后内容相同，但各自保留自己的存储区，以后对任一者的修改不会影响另一者。 从上表可以看出，除了对象销毁机制以外，JAVA的对象其实是从C 中的对象和指针共同继承而来的。 但是，很多极力提倡JAVA语言的人似乎没有意识到这种关系。他们批评C 指针的概念太难被初学者接受。的确，对初学者来说，接受计算机存储器和指针的概念并不是轻而易举的事。事实上，很多程序员都经历过这样一个迷惘的阶段。但这并不意味着存在一种对存储器的解释可以完全避免“指针”这一概念——在JAVA语言中也是如此。现在有很多讲解JAVA语言的.教材，但真正能够从头到尾不出现“指针”或者类似概念（不包括抨击 C 语言时的使用）的，又有几本呢？ 特别地，JAVA初学者由于理解的障碍，经常提出像这样的问题：“为什么像int、
实例变量和类变量内存分配 Java向程序员许下一个承诺：无需关心内存回收，java提供了优秀的垃圾回收机制来回收已经分配的内存。大部分开发者肆无忌惮的挥霍着java程序的内存分配，从而造成java程序的运行效率低下！ java内存管理分为两方面： 1，内存的分配：指创建java对象时，jvm为该对象在堆内存中所分配的内存空间。 2，内存的回收：指当该java对象失去引用，变成垃圾时，jvm的垃圾回收机制自动清理该对象，并回收该对象占用的内存。 jvm的垃圾回收机制由一条后台线程完成。不断分配内存使得系统中内存减少，从而降低程序运行性能。大量分配内存的回收使得垃圾回收负担加重，降低程序运行性能。 一，实例变量和类变量（静态变量） java程序的变量大体可分为成员变量和局部变量。 其中局部变量有3类：形参、方法内的局部变量、代码块内的局部变量。 局部变量被存储在方法的栈内存中，生存周期随方法或代码块的结束而消亡。 在类内定义的变量被称为成员变量。没使用static修饰的称为成员变量，用static修饰的称为静态变量或类变量。 1.1实例变量和类变量的属性 在同一个jvm中，每个类只对应一个Class对象，但每个类可以创建多个java对象。 【其实类也是一个对象，所有类都是Class实例，每个类初始化后，系统都会为该类创建一个对应的Class实例，程序可以通过反射来获取某个类所对应的Class实例（Person.class 或Class.forName(“Person”)）】 因此同一个jvm中的一个类的类变量只需要一块内存空间；但对实例变量而言，该类每创建一次实例，就需要为该实例变量分配一块内存空间。 非静态函数需要通过对象调用，静态函数既可以通过类名调用，也可以通过对象调用，其实用对象调用静态函数，底层还是用类名调用来实现的！ 1.2实例变量的初始化时机 对实例变量而言，它属于java对象本身，每次创建java对象时都需要为实例变量分配内存空间，并执行初始化。
使用IBM 性能分析工具解决生产环境中的性能问题（javacore） 上一篇 / 下一篇 2012-06-01 14:14:01 / 个人分类：javacore 查看( 655 ) / 评论( 0 ) / 评分( 0 / 0 ) https://www.doczj.com/doc/6f9076551.html,/developerworks/cn/java/j-lo-javacore/index.html 序言 企业级应用系统软件通常有着对并发数和响应时间的要求，这就要求大量的用户能在高响应时间内完成业务操作。这两个性能指标往往 决定着一个应用系统软件能否成功上线，而这也决定了一个项目最终能否验收成功，能否得到客户认同，能否继续在一个行业发展壮大 下去。由此可见性能对于一个应用系统的重要性，当然这似乎也成了软件行业的不可言说的痛——绝大多数的应用系统在上线之前， 项目组成员都要经历一个脱胎换骨的过程。 生产环境的建立包含众多方面，如存储规划、操作系统参数调整、数据库调优、应用系统调优等等。这几方面互相影响，只有经过不断 的调整优化，才能达到资源的最大利用率，满足客户对系统吞吐量和响应时间的要求。在无数次的实践经验中，很多软件专家能够达成 一致的是：应用系统本身的优化是至关重要的，否则即使有再大的内存，也会被消耗殆尽，尤其是产生OOM（Out Of Memory）的错 误的时候，它会贪婪地吃掉你的内存空间，直到系统宕机。 内存泄露—难啃的骨头 产生OOM 的原因有很多种，大体上可以简单地分为两种情况，一种就是物理内存确实有限，发生这种情况时，我们很容易找到原因，但是它一般不会发生在实际的生产环境中。因为生产环境往往有足以满足应用系统要求的配置，这在项目最初就是根据系统要求进行购 置的。 另外一种引起OOM 的原因就是应用系统本身对资源的的不恰当使用、配置，引起内存使用持续增加，最终导致JVM Heap Memory 被耗尽，如没有正确释放JDBC 的Connection Pool 中的对象，使用Cache 时没有限制Cache 的大小等等。本文并不针对各种情 况做讨论，而是以一个项目案例为背景，探索解决这类问题的方式方法，并总结一些最佳实践，供广大开发工程师借鉴参考。 项目背景介绍 项目背景： 1. 内网用户500 人，需要同时在线进行业务操作（中午休息一小时，晚6 点下班）。 2. 生产环境采用传统的主从式，未做Cluster ，提供HA 高可用性。 3. 服务器为AIX P570，8U，16G，但是只有一半的资源，即4U，8G 供新系统使用。 项目三月初上线，此前笔者与架构师曾去客户现场简单部署过一两次，主要是软件的安装，应用的部署，测一下应用是不是能够跑起来，算作是上线前的准备工作。应用上线（试运行）当天，项目组全体入住客户现场，看着用户登录数不断攀升，大家心里都没有底，高峰 时候到了440，系统开始有点反应变慢，不过还是扛下来了，最后归结为目前的资源有限，等把另一半资源划过来，就肯定没问题了。（须知增加资源，调优的工作大部分都要重新做一遍，系统级、数据库级等等，这也是后面为什么建议如果资源可用，最好一步到位的
J a v a第七单元练习题 J a v a多线程机制 The latest revision on November 22, 2020
7Java多线程机制 7.1单项选择题 1. 线程调用了sleep（）方法后，该线程将进入（）状态。 A. 可运行状态 B. 运行状态 C. 阻塞状态 D. 终止状态 2. 关于java线程，下面说法错误的是（） A. 线程是以CPU为主体的行为 B. java利用线程使整个系统成为异步 C. 创建线程的方法有两种：实现Runnable接口和继承Thread类 D. 新线程一旦被创建，它将自动开始运行 3. 在java中的线程模型包含（） A. 一个虚拟处理器 B. CPU执行的代码 C. 代码操作的数据 D. 以上都是 4.在java语言中，临界区可以是一个语句块，或者是一个方法，并用（）关键字标识。 A. synchronized B. include C. import D. Thread 5. 线程控制方法中，yield()的作用是（） A. 返回当前线程的引用 B. 使比其低的优先级线程执行 C. 强行终止线程 D. 只让给同优先级线程运行 6. 线程同步中，对象的锁在（）情况下持有线程返回 A. 当synchronized()语句块执行完后 B. 当在synchronized()语句块执行中出现例外（exception）时 C. 当持有锁的线程调用该对象的wait()方法时 D. 以上都是 7. 在以下（）情况下，线程就进入可运行状态 A. 线程调用了sleep()方法时 B. 线程调用了join()方法时 C. 线程调用了yield()方法时 D. 以上都是 8. java用（）机制实现了进程之间的异步执行
基于java的学生信息管理系统设计与实现 基于java的学生信息管理系统设计与实现摘要：利用计算机进行学生信息管理，不仅能够保证准确、无误、快速输出，而且还可以利用计算机对有关信息进行查询，检索迅速、查找方便、可靠性高、存储量大、保密性好。本设计就是一个为实现信息化管理而开发的信息管理系统，能够进行信息存储、查询、修改等能功。该系统由六个模块构成，包括学生管理系统的主界面模块、学生信息管理模块、课程信息管理模块、成绩信息管理模块、信息查询模块和数据库操作模块。通过这些模块的有机结合，能方便的对学生信息进行综合管理，从而实现了信息化管理的目的。由于本人的能力有限，设计过程中难免有不足之处，设计中的存在问题本人将在日后进一步修改，以便让程序的设计更加完善。 关键词：oracle;异常处理；关系模型 目录
1 引言 1.1背景及意义 学生信息管理系统是一个教育单位不可缺少的部分。一个功能齐全、简单易用的信息管理系统不但能有效地减轻学校相关工作人员的工作负担，它的内容对于学校的决策者和管理者来说都至关重要。所以学生信息管理系统应该能够为用户提供充足的信息和快捷的查询手段。但一直以来人们使用传统人工的方式管理文件档案、统计和查询数据，这种管理方式存在着许多缺点，如：效率低、保密性差、人工的大量浪费；另外时间一长，将产生大量的文件和数据，这对于查找、更新和维护都带来了不少困难。随着科学技术的不断提高，计算机科学日渐成熟其强大的功能已为人们深刻认识，它已进入人类社会的各个领域并发挥着越来越重要的作用。 作为计算机应用的一部分，使用计算机对学校的各类信息进行管理，具有手工管理无法比拟的优点。例如：检索迅速、查询方便、效率高、可靠性好、存储量大、保密性好、寿命长、成本低等。利用计算机进行学生信息管理，不仅能够保证准确、无误、快速输出，而且还可以利用计算机对有关信息进行查询，检索迅速、查找方便、可靠性高、存储量大、保密性好。要科学地实现信息化管理，开发一个适合学校的，能够进行信息存储、查询、修改等功能的信息管理系统是十分重要的。这些优点能够极大地提高学校信息管理的效率，也是一个单位科学化、正规化管理，与世界接轨的重要条件。 本系统是将现代化的计算机技术和传统的教学、教务工作相结合，按照学院的工作流程设计完成的。通过一个简化的学生信息管理系统，使学生信息管理工作系统化、规范化、自动化，从而达到提高学生信息管理效率的目的。本课题就是针对便于学生信息管理的问题而设计的一个管理系统。 1.2 实验技术选择 本课题设计主要运用的技术有两个：java项目开发和oracle对数据库的操作。这里主要介绍本课题为什么选用这两个开发技术： ⑴首先了解一下Java语言特点
硬盘 heap stack Data code 内存 程序 操作系统代码 程序代码 New ，在堆里面为属性分配空间，初始化（String 默认值为null ） 声明的时候非配空间，初始值为null （局部变量，方法参数） 全局变量 存放程序所需要的代码 类变量，全局字符串，常量存放在数据段
Java内存分配与管理是Java的核心技术之一，之前我们曾介绍过Java的内存管理与内存泄露以及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常量）和对其他类型，字段和
JAVA 文件编译执行与虚拟机(JVM)介绍 Java 虚拟机(JVM)是可运行Java代码的假想计算机。只要根据JVM规格描述将解释器移植到特定的计算机上，就能保证经过编译的任何Java代码能够在该系统上运行。本文首先简要介绍从Java文件的编译到最终执行的过程，随后对JVM规格描述作一说明。 一.Java源文件的编译、下载、解释和执行 Java应用程序的开发周期包括编译、下载、解释和执行几个部分。Java编译程序将Java源程序翻译为JVM可执行代码?字节码。这一编译过程同C/C++的编译有些不同。当C编译器编译生成一个对象的代码时，该代码是为在某一特定硬件平台运行而产生的。因此，在编译过程中，编译程序通过查表将所有对符号的引用转换为特定的内存偏移量，以保证程序运行。Java编译器却不将对变量和方法的引用编译为数值引用，也不确定程序执行过程中的内存布局，而是将这些符号引用信息保留在字节码中，由解释器在运行过程中创立内存布局，然后再通过查表来确定一个方法所在的地址。这样就有效的保证了Java的可移植性和安全性。 运行JVM字节码的工作是由解释器来完成的。解释执行过程分三部进行：代码的装入、代码的校验和代码的执行。装入代码的工作由"类装载器"（class loader）完成。类装载器负责装入运行一个程序需要的所有代码，这也包括程序代码中的类所继承的类和被其调用的类。当类装载器装入一个类时，该类被放在自己的名字空间中。除了通过符号引用自己名字空间以外的类，类之间没有其他办法可以影响其他类。在本台计算机上的所有类都在同一地址空间内，而所有从外部引进的类，都有一个自己独立的名字空间。这使得本地类通过共享相同的名字空间获得较高的运行效率，同时又保证它们与从外部引进的类不会相互影响。当装入了运行程序需要的所有类后，解释器便可确定整个可执行程序的内存布局。解释器为符号引用同特定的地址空间建立对应关系及查询表。通过在这一阶段确定代码的内存布局，Java很好地解决了由超类改变而使子类崩溃的问题，同时也防止了代码对地址的非法访问。 随后，被装入的代码由字节码校验器进行检查。校验器可发现操作数栈溢出，非法数据类型转化等多种错误。通过校验后，代码便开始执行了。 Java字节码的执行有两种方式： 1.即时编译方式：解释器先将字节码编译成机器码，然后再执行该机器码。 2.解释执行方式：解释器通过每次解释并执行一小段代码来完成Java字节码程序的所有操作。 通常采用的是第二种方法。由于JVM规格描述具有足够的灵活性，这使得将字节码翻译为机器代码的工作 具有较高的效率。对于那些对运行速度要求较高的应用程序，解释器可将Java字节码即时编译为机器码，从而很好地保证了Java代码的可移植性和高性能。 二.JVM规格描述 JVM的设计目标是提供一个基于抽象规格描述的计算机模型，为解释程序开发人员提很好的灵活性，同时也确保Java代码可在符合该规范的任何系统上运行。JVM对其实现的某些方面给出了具体的定义，特别是对Java可执行代码，即字节码(Bytecode)的格式给出了明确的规格。这一规格包括操作码和操作数的语法和数值、标识符的数值表示方式、以及Java类文件中的J ava对象、常量缓冲池在JVM的存储映象。这些定义为JVM解释器开发人员提供了所需的信息和开发环境。Java的设计者希望给开发人员以随心所欲使用Java的自由。
源代码： 第一个类：divDTO publicclassdivDTO { privateintdivBase; privateintlength; privateintdivFlag; publicdivDTO(intdivBase,intlength,intdivFlag) { this.divBase=divBase; this.divFlag=divFlag; this.length=length; } publicdivDTO() { }
{ this.divBase=base; } publicintgetDivBase() { returnthis.divBase; } publicvoidsetLength(intlength) { this.length=length; } publicintgetLength() { returnthis.length; }
{ this.divFlag=flag; } publicintgetDivFalg() { returnthis.divFlag; } } 2.第二个类：PcbDTO publicclassPcbDTO { staticfinalintRunning=1; staticfinalintReady=2; staticfinalintWaiting=3; privateStringprocessName;
privateintrunTime; privateintprority; privateintprocessState; privateintbase; privateintlimit; privateintpcbFlag; publicPcbDTO(Stringname,inttime,intpro,intbase,intlimit) { this.processName=name; this.runTime=time; this.prority=pro; this.processState=0; this.limit=limit; this.base=base; } publicPcbDTO()
JAVA经典面试题：Java内存模型 因为Java内存模型不仅是java重点要学习的技术知识，还是面试的时候经典面试题，希望引起同学们的重视，今天千锋小编就来分享一下java内存模型的相关技术知识。 不同的渠道，内存模型是不一样的，但是jvm的内存模型标准是一致的。其实java的多线程并发问题都会反映在java的内存模型上，所谓线程安全无非是要操控多个线程对某个资源的有序拜访或修改。总结java的内存模型，要解决两个首要的问题：可见性和有序性。 可见性：多个线程之间是不能相互传递数据通信的，它们之间的交流只能经过同享变量来进行。Java内存模型(JMM)规定了jvm有主内存，主内存是多个线程同享的。当new一个目标的时分，也是被分配在主内存中，每个线程都有自己的作业内存，作业内存存储了主存的某些目标的副本，当然线程的作业内存大小是有限制的。当线程操作某个目标时，履行次序如下： (1) 从主存仿制变量到当前作业内存(read and load) (2) 履行代码，改动同享变量值(use and assign) (3) 用作业内存数据改写主存相关内容(store and write)
当一个同享变量在多个线程的作业内存中都有副本时，如果一个线程修改了这个同享变量，那么其他线程应该可以看到这个被修改后的值，这就是多线程的可见性问题。 有序性：线程在引证变量时不能直接从主内存中引证,如果线程作业内存中没有该变量,则会从主内存中复制一个副本到作业内存中，完成后线程会引证该副本。当同一线程再度引证该字段时,有可能从头从主存中获取变量副本(read-load-use),也有可能直接引证本来的副本(use),也就是说read,load,use次序可以由JVM完成体系决议。 线程不能直接为主存中字段赋值，它会将值指定给作业内存中的变量副本(assign),完成后这个变量副本会同步到主存储区(store- write)，至于何时同步往昔，依据JVM完成体系决议。有该字段，则会从主内存中将该字段赋值到作业内存中,这个进程为read-load,完成后线程会引证该变量副本。 知识就财富，这句话再IT行业显示的尤其现实残酷，懂就是懂，不懂就是不懂，所以各位同学，你的努力与否与你财富直接挂钩。一起加油吧！更多java 技术经典面试题欢迎关注千锋小编。