`
m635674608
  • 浏览: 4928656 次
  • 性别: Icon_minigender_1
  • 来自: 南京
社区版块
存档分类
最新评论

jvm 变量 内存分配

 
阅读更多
public class T {

	// 常量池中分配 String final
	private String a = "aa";

	// 常量池中分配
	final int ee = 22;
	// 堆中分配
	int ff = 20;
	// 超过一定的范围 在常量池中
	int ff2 = 200000;
	
	
	// 堆中分配
	Integer i = 4;
	// 超过一定的范围 在常量池中
	Integer i2 = 444444;
	// 堆中分配
	final Integer ii = 544;
	// 超过一定的范围 在常量池中
	final Integer ii2 = 55555;

	public void t() {
		// 常量池中分配 String final
		String b = "bb";
		// 常量池中分配
		final String c = "cc";
		// 栈中分配
		int f = 1;
		// 超过一定的范围 在常量池中
		int f1 = 111111;
		// 栈中分配
		final int f2 = 33;
		// 超过一定的范围 在常量池中
		final int f3 = 33333;
	}

}

    

const #2 = Asciz        T;
const #3 = class        #4;     //  java/lang/Object
const #4 = Asciz        java/lang/Object;
const #5 = Asciz        a;
const #6 = Asciz        Ljava/lang/String;;
const #7 = Asciz        ee;
const #8 = Asciz        I;
const #9 = Asciz        ConstantValue;
const #10 = int 22;
const #11 = Asciz       ff;
const #12 = Asciz       ff2;
const #13 = Asciz       i;
const #14 = Asciz       Ljava/lang/Integer;;
const #15 = Asciz       i2;
const #16 = Asciz       ii;
const #17 = Asciz       ii2;
const #18 = Asciz       <init>;
const #19 = Asciz       ()V;
const #20 = Asciz       Code;
const #21 = Method      #3.#22; //  java/lang/Object."<init>":()V
const #22 = NameAndType #18:#19;//  "<init>":()V
const #23 = String      #24;    //  aa
const #24 = Asciz       aa;
const #25 = Field       #1.#26; //  T.a:Ljava/lang/String;
const #26 = NameAndType #5:#6;//  a:Ljava/lang/String;
const #27 = Field       #1.#28; //  T.ee:I
const #28 = NameAndType #7:#8;//  ee:I
const #29 = Field       #1.#30; //  T.ff:I
const #30 = NameAndType #11:#8;//  ff:I
const #31 = int 200000;
const #32 = Field       #1.#33; //  T.ff2:I
const #33 = NameAndType #12:#8;//  ff2:I
const #34 = Method      #35.#37;        //  java/lang/Integer.valueOf:(I)L
ang/Integer;
const #35 = class       #36;    //  java/lang/Integer
const #36 = Asciz       java/lang/Integer;
const #37 = NameAndType #38:#39;//  valueOf:(I)Ljava/lang/Integer;
const #38 = Asciz       valueOf;
const #39 = Asciz       (I)Ljava/lang/Integer;;
const #40 = Field       #1.#41; //  T.i:Ljava/lang/Integer;
const #41 = NameAndType #13:#14;//  i:Ljava/lang/Integer;
const #42 = int 444444;
const #43 = Field       #1.#44; //  T.i2:Ljava/lang/Integer;
const #44 = NameAndType #15:#14;//  i2:Ljava/lang/Integer;
const #45 = Field       #1.#46; //  T.ii:Ljava/lang/Integer;
const #46 = NameAndType #16:#14;//  ii:Ljava/lang/Integer;
const #47 = int 55555;
const #48 = Field       #1.#49; //  T.ii2:Ljava/lang/Integer;
const #49 = NameAndType #17:#14;//  ii2:Ljava/lang/Integer;
const #50 = Asciz       LineNumberTable;
const #51 = Asciz       LocalVariableTable;
const #52 = Asciz       this;
const #53 = Asciz       LT;;
const #54 = Asciz       t;
const #55 = String      #56;    //  bb
const #56 = Asciz       bb;
const #57 = String      #58;    //  cc
const #58 = Asciz       cc;
const #59 = int 111111;
const #60 = int 33333;
const #61 = Asciz       b;
const #62 = Asciz       c;
const #63 = Asciz       f;
const #64 = Asciz       f1;
const #65 = Asciz       f2;
const #66 = Asciz       f3;
const #67 = Asciz       SourceFile;
const #68 = Asciz       T.java;

{
final int ee;
  Constant value: int 22
int ff;

int ff2;

java.lang.Integer i;

java.lang.Integer i2;

final java.lang.Integer ii;

final java.lang.Integer ii2;

public T();
  Code:
   Stack=2, Locals=1, Args_size=1
   0:   aload_0
   1:   invokespecial   #21; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   ldc     #23; //String aa
   7:   putfield        #25; //Field a:Ljava/lang/String;
   10:  aload_0
   11:  bipush  22
   13:  putfield        #27; //Field ee:I
   16:  aload_0
   17:  bipush  20
   19:  putfield        #29; //Field ff:I
   22:  aload_0
   23:  ldc     #31; //int 200000
   25:  putfield        #32; //Field ff2:I
   28:  aload_0
   29:  iconst_4
   30:  invokestatic    #34; //Method java/lang/Integer.valueOf:(I)Ljava/l
teger;
   33:  putfield        #40; //Field i:Ljava/lang/Integer;
   36:  aload_0
   37:  ldc     #42; //int 444444
   39:  invokestatic    #34; //Method java/lang/Integer.valueOf:(I)Ljava/l
teger;
   42:  putfield        #43; //Field i2:Ljava/lang/Integer;
   45:  aload_0
   46:  sipush  544
   49:  invokestatic    #34; //Method java/lang/Integer.valueOf:(I)Ljava/l
teger;
   52:  putfield        #45; //Field ii:Ljava/lang/Integer;
   55:  aload_0
   56:  ldc     #47; //int 55555
   58:  invokestatic    #34; //Method java/lang/Integer.valueOf:(I)Ljava/l
teger;
   61:  putfield        #48; //Field ii2:Ljava/lang/Integer;
   64:  return
  LineNumberTable:
   line 1: 0
   line 4: 4
   line 7: 10
   line 9: 16
   line 11: 22
   line 15: 28
   line 17: 36
   line 19: 45
   line 22: 55
   line 1: 64

  LocalVariableTable:
   Start  Length  Slot  Name   Signature
   0      65      0    this       LT;


public void t();
  Code:
   Stack=1, Locals=7, Args_size=1
   0:   ldc     #55; //String bb
   2:   astore_1
   3:   ldc     #57; //String cc
   5:   astore_2
   6:   iconst_1
   7:   istore_3
   8:   ldc     #59; //int 111111
   10:  istore  4
   12:  bipush  33
   14:  istore  5
   16:  ldc     #60; //int 33333
   18:  istore  6
   20:  return
  LineNumberTable:
   line 26: 0
   line 28: 3
   line 30: 6
   line 32: 8
   line 34: 12
   line 36: 16
   line 37: 20

  LocalVariableTable:
   Start  Length  Slot  Name   Signature
   0      21      0    this       LT;
   3      18      1    b       Ljava/lang/String;
   6      15      2    c       Ljava/lang/String;
   8      13      3    f       I
   12      9      4    f1       I
   16      5      5    f2       I
   20      1      6    f3       I


}

 

分享到:
评论

相关推荐

    java实现内存动态分配

    Java中分配堆内存是自动初始化的,即为一个对象分配内存的时候,会初始化这个对象中变量。虽然Java中所有对象的存储空间都是在堆中分配的,但是这个对象的引用却是在栈中分配,也就是说在建立一个对象时在堆和栈中都...

    深入理解JVM内存结构及运行原理全套视频加资料.txt

    包括JVM执行过程、虚拟机类加载机制、运行时数据区、GC、类加载器、内存分配与回收策略等,全套视频加资料高清无密码  第1讲 说在前面的话 免费 00:05:07  第2讲 整个部分要讲的内容说明 免费 00:06:58  第3讲...

    Java内存分配全面浅析

    所以在学习Java内存分配原理的时候一定要牢记这一切都是在JVM中进行的,JVM是内存分配原理的基础与前提。l.寄存器:JVM内部虚拟寄存器,存取速度非常快,程序不可控制。2.栈:保存局部变量的值,包括:1.用来保存基

    Java栈内存与堆内存

    Java把内存划分成两种:一种是栈内存,一种...当在一段代码块定义一个变量时,Java就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java会自动释放掉为该变量所分配的内存空间,该内存空间可以立即被另作他用。

    深入理解Java虚拟机视频教程(jvm性能调优+内存模型+虚拟机原理)视频教程

    第46节内存分配-长期存活的对象进入老年代00:03:40分钟 | 第47节内存分配-空间分配担保00:04:54分钟 | 第48节内存分配-逃逸分析与栈上分配00:10:32分钟 | 第49节虚拟机工具介绍00:10:27分钟 | 第50节虚拟机工具-...

    谈谈Java中的i++

    这是和JVM的内存分配有关,JVM在处理这段带代码时,会先把i++的结果赋值给一个临时变量temp,然后再将这个临时变量的值赋值给i。即如下: int i = 0; int temp; // i = i++; int a = temp = i++;// 临时变量...

    关于JVM的总结

    准备:正式为类变量分配内存,并设置变量初始值.这些变量都存储在方法区. 解析:将常量池中的符号引用替换为直接引用的过程,虚拟机不会重新再解析而是通过缓存去拿出解析的数据 初始化:在准备阶段已经赋过一个系统...

    深入理解_Java_虚拟机 JVM_高级特性与最佳实践

    / 41 2.5 本章小结 / 42 第3章 垃圾收集器与内存分配策略 / 43 3.1 概述 / 43 3.2 对象已死? / 44 3.2.1 引用计数算法 / 44 3.2.2 根搜索算法 / 46 3.2.3 再谈引用 / 47 3.2.4 生存还是死亡? / 48 3.2.5 ...

    Java内存分配分析/栈内存、堆内存

    首先学习JVM相关需要需要内存的组成。  基本内容  · 堆  java动态创建对象,即对于new的一个实例对象。但是需要注意的是该实例对象的成员变量都存储在各自的堆区域中,其中对象方法是在堆中共享,即不是每次...

    Java对象与内存管理

    1、实例变量和类变量的内存分配  类变量:使用static修饰的成员变量是类变量,属于该类本身  实例变量:没有使用static修饰的成员变量是实例变量,属于该类的实例  由于同一个JVM内每个累只对应一个Class...

    【jvm】01- java内存结构分析

    java内存结构分析java内存结构java栈结构分析:栈帧局部变量表操作数栈动态连接返回地址运行时常量池对象的创建过程类加载的执行流程图对象创建的过程:对象内存分配方式指针碰撞空闲列表栈上分配:内存逃逸:对象...

    Android静态变量的生命周期 简单介绍

    我们知道静态变量是在类被load的时候分配内存的,并且存在于方法区。当类被卸载的时候,静态变量被销毁。在PC机的客户端程序中,一个类被加载和卸载,可简单的等同于jvm进程的启动和结束。那么在Android中呢?用的...

    Java学习笔记

    的内存分布是在运行的时候才动态分配的) b) JVM:真正解释字节码文件内容并且和操作 系统交互的部分 Sun(Oracle)已经给每一 款操作系统都写好了现成的JVM JVM组成部分: 类加载器 ClassLoader 字节码校验器 解释执行...

    java核心面试

    java 内存模型 ( java memory model ):根据Java Language Specification中的说明, jvm系统中存在一个主内存(Main Memory或Java Heap Memory),Java中所有对象成员变量都储存在主存中,对于所有线程都是共享的。...

    java核心面试技术点

    java 内存模型 ( java memory model ):根据Java Language Specification中的说明, jvm系统中存在一个主内存(Main Memory或Java Heap Memory),Java中所有对象成员变量都储存在主存中,对于所有线程都是共享的。...

    java8rt.jar源码-JVM:学习JVM

    2.java虚拟机栈:线程私有,虚拟机栈描述的是java方法执行的内存模型:每个方法在执行的时候都会创建一个栈帧,存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个 方法从调用到执行完成的过程中,就对应...

    浅谈Android中关于静态变量(static)的使用问题

    静态变量在类被load的时候分配内存,并存在于方法区。当类被卸载时,静态变量被销毁。在PC机的客户端程序中,一个类被加载和卸载,可简单的等同于jvm进程的启动和结束。在Android中,用的DVM也是一样的,不过Android...

    高级java开发并发问题

    1.JVM为一个线程栈分配内存,该栈为每个线程方法调用保存一个栈帧 2.每一栈帧由一个局部变量数组、返回值、操作数堆栈和常量池组成 3.每个线程获得一个程序计数器,用于记录当前虚拟机正在执行的线程指令地址 4.系统...

    Java虚拟机.docx

    (2)栈内容分配越大越好吗:不是,因为栈内存越大,能够支持线程数目越少 (3)局部变量是线程安全的,如果方法内部的局部变量,没有逃离方法的作用范围 (4)栈内存溢出:栈帧过多,栈帧过大 3.本地方法栈:当Java去调用...

    Java常见面试问题整理.docx

    直接内存:不受JVM GC管理,直接内存并不是虚拟机运行时数据区的一部分,也不是Java 虚拟机规范中定义的内存区域。在JDK1.4 中新加入了NIO(New Input/Output)类,引入了一种基于通道(Channel)与缓冲区(Buffer)的I/...

Global site tag (gtag.js) - Google Analytics