• 高清:创意十足!杭州萌娃毕业照留下成长足迹 2019-04-08
  • 上交所:存托凭证上市首日不实行价格涨跌幅限制 2019-04-08
  • 谁拆迁都是一样一片狼藉,拆迁时欢天喜地,回迁时垂头丧气。拆迁者得到好处,被拆者哭天喊地。 2019-04-07
  • 网上支付出现异常如何解决? 2019-04-07
  • [微笑]咱建议进一步提高挂号费标准,最起码也得200元起步…… 2019-03-30
  • 一语惊坛(5月30日):磋商,不等于反复折腾。 2019-03-16
  • 体彩十一选五玩法:JAVA虚拟机的生命周期

    一个运行时的Java虚拟机实例的天职是:负责运行一个java程序。当启动一个Java程序时,一个虚拟机实例也就诞生了。当该程序关闭退出,这个虚拟机实例也就随之消亡。如果同一台计算机上同时运行三个Java程序,将得到三个Java虚拟机实例。每个Java程序都运行于它自己的Java虚拟机实例中。

    Java虚拟机实例通过调用某个初始类的main()方法来运行一个Java程序。而这个main()方法必须是共有的(public)、静态的(static)、返回值为void,并且接受一个字符串数组作为参数。任何拥有这样一个main()方法的类都可以作为Java程序运行的起点。

    public class Test {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            System.out.println("Hello World");
        }
    
    }

    在上面的例子中,Java程序初始类中的main()方法,将作为该程序初始线程的起点,任何其他的线程都是由这个初始线程启动的。

    在Java虚拟机内部有两种线程:守护线程和非守护线程。守护线程通常是由虚拟机自己使用的,比如执行垃圾收集任务的线程。但是,Java程序也可以把它创建的任何线程标记为守护线程。而Java程序中的初始线程——就是开始于main()的那个,是非守护线程。

    只要还有任何非守护线程在运行,那么这个Java程序也在继续运行。当该程序中所有的非守护线程都终止时,虚拟机实例将自动退出。假若安全管理器允许,程序本身也能够通过调用Runtime类或者System类的exit()方法来退出。

    JAVA虚拟机的体系结构

    下图是JAVA虚拟机的结构图,每个Java虚拟机都有一个类装载子系统,它根据给定的全限定名来装入类型(类或接口)。同样,每个Java虚拟机都有一个执行引擎,它负责执行那些包含在被装载类的方法中的指令。

     

    当JAVA虚拟机运行一个程序时,它需要内存来存储许多东西,例如:字节码、从已装载的class文件中得到的其他信息、程序创建的对象、传递给方法的参数,返回值、局部变量等等。Java虚拟机把这些东西都组织到几个“运行时数据区”中,以便于管理。

    某些运行时数据区是由程序中所有线程共享的,还有一些则只能由一个线程拥有。每个Java虚拟机实例都有一个方法区以及一个堆,它们是由该虚拟机实例中所有的线程共享的。当虚拟机装载一个class文件时,它会从这个class文件包含的二进制数据中解析类型信息。然后把这些类型信息放到方法区中。当程序运行时,虚拟机会把所有该程序在运行时创建的对象都放到堆中。

     

    当每一个新线程被创建时,它都将得到它自己的PC寄存器(程序计数器)以及一个Java栈,如果线程正在执行的是一个Java方法(非本地方法),那么PC寄存器的值将总是指向下一条将被执行的指令,而它的Java栈则总是存储该线程中Java方法调用的状态——包括它的局部变量,被调用时传进来的参数、返回值,以及运算的中间结果等等。而本地方法调用的状态,则是以某种依赖于具体实现的方法存储在本地方法栈中,也可能是在寄存器或者其他某些与特定实现相关的内存区中。

    Java栈是由许多栈?。╯tack frame)组成的,一个栈帧包含一个Java方法调用的状态。当线程调用一个Java方法时,虚拟机压入一个新的栈帧到该线程的Java栈中,当该方法返回时,这个栈帧被从Java栈中弹出并抛弃。

    Java虚拟机没有寄存器,其指令集使用Java栈来存储中间数据。这样设计的原因是为了保持Java虚拟机的指令集尽量紧凑、同时也便于Java虚拟机在那些只有很少通用寄存器的平台上实现。另外,Java虚拟机这种基于栈的体系结构,也有助于运行时某些虚拟机实现的动态编译器和即时编译器的代码优化。

    下图描绘了Java虚拟机为每一个线程创建的内存区,这些内存区域是私有的,任何线程都不能访问另一个线程的PC寄存器或者Java栈。

    上图展示了一个虚拟机实例的快照,它有三个线程正在执行。线程1和线程2都正在执行Java方法,而线程3则正在执行一个本地方法。

    Java栈都是向下生长的,而栈顶都显示在图的底部。当前正在执行的方法的栈帧则以浅色表示,对于一个正在运行Java方法的线程而言,它的PC寄存器总是指向下一条将被执行的指令。比如线程1和线程2都是以浅色显示的,由于线程3当前正在执行一个本地方法,因此,它的PC寄存器——以深色显示的那个,其值是不确定的。

    数据类型

    Java虚拟机是通过某些数据类型来执行计算的,数据类型可以分为两种:基本类型和引用类型,基本类型的变量持有原始值,而引用类型的变量持有引用值。

    Java语言中的所有基本类型同样也都是Java虚拟机中的基本类型。但是boolean有点特别,虽然Java虚拟机也把boolean看做基本类型,但是指令集对boolean只有很有限的支持,当编译器把Java源代码编译为字节码时,它会用int或者byte来表示boolean。在Java虚拟机中,false是由整数零来表示的,所有非零整数都表示true,涉及boolean值的操作则会使用int。另外,boolean数组是当做byte数组来访问的,但是在“堆”区,它也可以被表示为位域。

    Java虚拟机还有一个只在内部使用的基本类型:returnAddress,Java程序员不能使用这个类型,这个基本类型被用来实现Java程序中的finally子句。该类型是jsr, ret以及jsr_w指令需要使用到的,它的值是JVM指令的操作码的指针。returnAddress类型不是简单意义上的数值,不属于任何一种基本类型,并且它的值是不能被运行中的程序所修改的。

    Java虚拟机的引用类型被统称为“引用(reference)”,有三种引用类型:类类型、接口类型、以及数组类型,它们的值都是对动态创建对象的引用。类类型的值是对类实例的引用;数组类型的值是对数组对象的引用,在Java虚拟机中,数组是个真正的对象;而接口类型的值,则是对实现了该接口的某个类实例的引用?;褂幸恢痔厥獾囊弥凳莕ull,它表示该引用变量没有引用任何对象。

    JAVA中方法参数的引用传递

    java中参数的传递有两种,分别是按值传递和按引用传递。按值传递不必多说,下面就说一下按引用传递。

    当一个对象被当作参数传递到一个方法”,这就是所谓的按引用传递。

    public class User {
    
        private String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
    }
    public class Test {
    
        public void set(User user){
            user.setName("hello world");
        }
    
        public static void main(String[] args) {
    
            Test test = new Test();
            User user = new User();
            test.set(user);
            System.out.println(user.getName());
        }
    }

    上面代码的输出结果是“hello world”,这不必多说,那如果将set方法改为如下,结果会是多少呢?

        public void set(User user){
            user.setName("hello world");
            user = new User();
            user.setName("change");
        }

    答案依然是“hello world”,下面就让我们来分析一下如上代码。

    首先

    User user = new User();

    是在堆中创建了一个对象,并在栈中创建了一个引用,此引用指向该对象,如下图:

     

    test.set(user);

     

    是将引用user作为参数传递到set方法,注意:这里传递的并不是引用本身,而是一个引用的拷贝。也就是说这时有两个引用(引用和引用的拷贝)同时指向堆中的对象,如下图:

     

    user.setName("hello world");

    在set()方法中,“user引用的拷贝”操作堆中的User对象,给name属性设置字符串”hello world”。如下图:

     

    user = new User();

    在set()方法中,又创建了一个User对象,并将“user引用的拷贝”指向这个在堆中新创建的对象,如下图:

    user.setName("change");

     

    在set()方法中,“user引用的拷贝”操作的是堆中新创建的User对象。

     

    set()方法执行完毕,目光再回到mian()方法

    System.out.println(user.getName());

     

    因为之前,”user引用的拷贝”已经将堆中的User对象的name属性设置为了”hello world”,所以当main()方法中的user调用getName()时,打印的结果就是”hello world”。如下图:

    类装载子系统

    在JAVA虚拟机中,负责查找并装载类型的那部分被称为类装载子系统。

    JAVA虚拟机有两种类装载器:启动类装载器和用户自定义类装载器。前者是JAVA虚拟机实现的一部分,后者则是Java程序的一部分。由不同的类装载器装载的类将被放在虚拟机内部的不同命名空间中。

    类装载器子系统涉及Java虚拟机的其他几个组成部分,以及几个来自java.lang库的类。比如,用户自定义的类装载器是普通的Java对象,它的类必须派生自java.lang.ClassLoader类。ClassLoader中定义的方法为程序提供了访问类装载器机制的接口。此外,对于每一个被装载的类型,JAVA虚拟机都会为它创建一个java.lang.Class类的实例来代表该类型。和所有其他对象一样,用户自定义的类装载器以及Class类的实例都放在内存中的堆区,而装载的类型信息则都位于方法区。

    类装载器子系统除了要定位和导入二进制class文件外,还必须负责验证被导入类的正确性,为类变量分配并初始化内存,以及帮助解析符号引用。这些动作必须严格按以下顺序进行:

    (1)装载——查找并装载类型的二进制数据。

    (2)连接——指向验证、准备、以及解析(可?。?。

    ● 验证  确保被导入类型的正确性。

    ● 准备  为类变量分配内存,并将其初始化为默认值。

    ● 解析  把类型中的符号引用转换为直接引用。

    (3)初始化——把类变量初始化为正确初始值。

    每个JAVA虚拟机实现都必须有一个启动类装载器,它知道怎么装载受信任的类。

    每个类装载器都有自己的命名空间,其中维护着由它装载的类型。所以一个Java程序可以多次装载具有同一个全限定名的多个类型。这样一个类型的全限定名就不足以确定在一个Java虚拟机中的唯一性。因此,当多个类装载器都装载了同名的类型时,为了惟一地标识该类型,还要在类型名称前加上装载该类型(指出它所位于的命名空间)的类装载器标识。

    方法区

    在Java虚拟机中,关于被装载类型的信息存储在一个逻辑上被称为方法区的内存中。当虚拟机装载某个类型时,它使用类装载器定位相应的class文件,然后读入这个class文件——1个线性二进制数据流,然后它传输到虚拟机中,紧接着虚拟机提取其中的类型信息,并将这些信息存储到方法区。该类型中的类(静态)变量同样也是存储在方法区中。

    JAVA虚拟机在内部如何存储类型信息,这是由具体实现的设计者来决定的。

    当虚拟机运行Java程序时,它会查找使用存储在方法区中的类型信息。由于所有线程都共享方法区,因此它们对方法区数据的访问必须被设计为是线程安全的。比如,假设同时有两个线程都企图访问一个名为Lava的类,而这个类还没有被装入虚拟机,那么,这时只应该有一个线程去装载它,而另一个线程则只能等待。

    对于每个装载的类型,虚拟机都会在方法区中存储以下类型信息:

      ● 这个类型的全限定名

      ● 这个类型的直接超类的全限定名(除非这个类型是java.lang.Object,它没有超类)

      ● 这个类型是类类型还是接口类型

      ● 这个类型的访问修饰符(public、abstract或final的某个子集)

      ● 任何直接超接口的全限定名的有序列表

    除了上面列出的基本类型信息外,虚拟机还得为每个被装载的类型存储以下信息:

      ● 该类型的常量池

      ● 字段信息

      ● 方法信息

      ● 除了常量以外的所有类(静态)变量

      ● 一个到类ClassLoader的引用

      ● 一个到Class类的引用

      

    常量池

    虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用常量的一个有序集合,包括直接常量和对其他类型、字段和方法的符号引用。池中的数据项就像数组一样是通过索引访问的。因为常量池存储了相应类型所用到的所有类型、字段和方法的符号引用,所以它在Java程序的动态连接中起着核心的作用。

    字段信息

    对于类型中声明的每一个字段。方法区中必须保存下面的信息。除此之外,这些字段在类或者接口中的声明顺序也必须保存。

    ○ 字段名

    ○ 字段的类型

    ○ 字段的修饰符(public、private、protected、static、final、volatile、transient的某个子集)

    方法信息

    对于类型中声明的每一个方法,方法区中必须保存下面的信息。和字段一样,这些方法在类或者接口中的声明顺序也必须保存。

    ○ 方法名

    ○ 方法的返回类型(或void)

    ○ 方法参数的数量和类型(按声明顺序)

    ○ 方法的修饰符(public、private、protected、static、final、synchronized、native、abstract的某个子集)

     

    除了上面清单中列出的条目之外,如果某个方法不是抽象的和本地的,它还必须保存下列信息:

    ○ 方法的字节码(bytecodes)

    ○ 操作数栈和该方法的栈帧中的局部变量区的大小

    ○ 异常表

    类(静态)变量

    类变量是由所有类实例共享的,但是即使没有任何类实例,它也可以被访问。这些变量只与类有关——而非类的实例,因此它们总是作为类型信息的一部分而存储在方法区。除了在类中声明的编译时常量外,虚拟机在使用某个类之前,必须在方法区中为这些类变量分配空间。

    而编译时常量(就是那些用final声明以及用编译时已知的值初始化的类变量)则和一般的类变量处理方式不同,每个使用编译时常量的类型都会复制它的所有常量到自己的常量池中,或嵌入到它的字节码流中。作为常量池或字节码流的一部分,编译时常量保存在方法区中——就和一般的类变量一样。但是当一般的类变量作为声明它们的类型的一部分数据面保存的时候,编译时常量作为使用它们的类型的一部分而保存。

    指向ClassLoader类的引用

    每个类型被装载的时候,虚拟机必须跟踪它是由启动类装载器还是由用户自定义类装载器装载的。如果是用户自定义类装载器装载的,那么虚拟机必须在类型信息中存储对该装载器的引用。这是作为方法表中的类型数据的一部分保存的。

    虚拟机会在动态连接期间使用这个信息。当某个类型引用另一个类型的时候,虚拟机会请求装载发起引用类型的类装载器来装载被引用的类型。这个动态连接的过程,对于虚拟机分离命名空间的方式也是至关重要的。为了能够正确地执行动态连接以及维护多个命名空间,虚拟机需要在方法表中得知每个类都是由哪个类装载器装载的。

    指向Class类的引用

    对于每一个被装载的类型(不管是类还是接口),虚拟机都会相应地为它创建一个java.lang.Class类的实例,而且虚拟机还必须以某种方式把这个实例和存储在方法区中的类型数据关联起来。

    在Java程序中,你可以得到并使用指向Class对象的引用。Class类中的一个静态方法可以让用户得到任何已装载的类的Class实例的引用。

    public static Class<?> forName(String className)

    比如,如果调用forName(“java.lang.Object”),那么将得到一个代表java.lang.Object的Class对象的引用??梢允褂胒orName()来得到代表任何包中任何类型的Class对象的引用,只要这个类型可以被(或者已经被)装载到当前命名空间中。如果虚拟机无法把请求的类型装载到当前命名空间,那么会抛出ClassNotFoundException异常。

     

    另一个得到Class对象引用的方法是,可以调用任何对象引用的getClass()方法。这个方法被来自Object类本身的所有对象继承:

    public final native Class<?> getClass();

    比如,如果你有一个到java.lang.Integer类的对象的引用,那么你只需简单地调用Integer对象引用的getClass()方法,就可以得到表示java.lang.Integer类的Class对象。

    方法区使用实例

    为了展示虚拟机如何使用方法区中的信息,下面来举例说明:

    class Lava {
    
        private int speed = 5;
        void flow(){
    
        }
    }
    public class Volcano {
    
        public static void main(String[] args){
            Lava lava = new Lava();
            lava.flow();
        }
    }

    不同的虚拟机实现可能会用完全不同的方法来操作,下面描述的只是其中一种可能——但并不是仅有的一种。

    要运行Volcano程序,首先得以某种“依赖于实现的”方式告诉虚拟机“Volcano”这个名字。之后,虚拟机将找到并读入相应的class文件“Volcano.class”,然后它会从导入的class文件里的二进制数据中提取类型信息并放到方法区中。通过执行保存在方法区中的字节码,虚拟机开始执行main()方法,在执行时,它会一直持有指向当前类(Volcano类)的常量池(方法区中的一个数据结构)的指针。

    注意:虚拟机开始执行Volcano类中main()方法的字节码的时候,尽管Lava类还没被装载,但是和大多数(也许所有)虚拟机实现一样,它不会等到把程序中用到的所有类都装载后才开始运行。恰好相反,它只会需要时才装载相应的类。

    main()的第一条指令告知虚拟机为列在常量池第一项的类分配足够的内存。所以虚拟机使用指向Volcano常量池的指针找到第一项,发现它是一个对Lava类的符号引用,然后它就检查方法区,看Lava类是否已经被加载了。

    这个符号引用仅仅是一个给出了类Lava的全限定名“Lava”的字符串。为了能让虚拟机尽可能快地从一个名称找到类,虚拟机的设计者应当选择最佳的数据结构和算法。

    当虚拟机发现还没有装载过名为“Lava”的类时,它就开始查找并装载文件“Lava.class”,并把从读入的二进制数据中提取的类型信息放在方法区中。

    紧接着,虚拟机以一个直接指向方法区Lava类数据的指针来替换常量池第一项(就是那个字符串“Lava”),以后就可以用这个指针来快速地访问Lava类了。这个替换过程称为常量池解析,即把常量池中的符号引用替换为直接引用。

    终于,虚拟机准备为一个新的Lava对象分配内存。此时它又需要方法区中的信息?;辜堑酶崭辗诺絍olcano类常量池第一项的指针吗?现在虚拟机用它来访问Lava类型信息,找出其中记录的这样一条信息:一个Lava对象需要分配多少堆空间。

    JAVA虚拟机总能够通过存储与方法区的类型信息来确定一个对象需要多少内存,当JAVA虚拟机确定了一个Lava对象的大小后,它就在堆上分配这么大的空间,并把这个对象实例的变量speed初始化为默认初始值0。

    当把新生成的Lava对象的引用压到栈中,main()方法的第一条指令也完成了。接下来的指令通过这个引用调用Java代码(该代码把speed变量初始化为正确初始值5)。另一条指令将用这个引用调用Lava对象引用的flow()方法。

    Java程序在运行时创建的所有类实例或数组都放在同一个堆中。而一个JAVA虚拟机实例中只存在一个堆空间,因此所有线程都将共享这个堆。又由于一个Java程序独占一个JAVA虚拟机实例,因而每个Java程序都有它自己的堆空间——它们不会彼此干扰。但是同一个Java程序的多个线程却共享着同一个堆空间,在这种情况下,就得考虑多线程访问对象(堆数据)的同步问题了。

    JAVA虚拟机有一条在堆中分配新对象的指令,却没有释放内存的指令,正如你无法用Java代码区明确释放一个对象一样。虚拟机自己负责决定如何以及何时释放不再被运行的程序引用的对象所占据的内存。通常,虚拟机把这个任务交给垃圾收集器。

    数组的内部表示

    在Java中,数组是真正的对象。和其他对象一样,数组总是存储在堆中。同样,数组也拥有一个与它们的类相关联的Class实例,所有具有相同维度和类型的数组都是同一个类的实例,而不管数组的长度(多维数组每一维的长度)是多少。例如一个包含3个int整数的数组和一个包含300个整数的数组拥有同一个类。数组的长度只与实例数据有关。

    数组类的名称由两部分组成:每一维用一个方括号“[”表示,用字符或字符串表示元素类型。比如,元素类型为int整数的、一维数组的类名为“[I”,元素类型为byte的三维数组为“[[[B”,元素类型为Object的二维数组为“[[Ljava/lang/Object”。

    多维数组被表示为数组的数组。比如,int类型的二维数组,将表示为一个一维数组,其中的每一个元素是一个一维int数组的引用,如下图:

    在堆中的每个数组对象还必须保存的数据时数组的长度、数组数据,以及某些指向数组的类数据的引用。虚拟机必须能够通过一个数组对象的引用得到此数组的长度,通过索引访问其元素(期间要检查数组边界是否越界),调用所有数组的直接超类Object声明的方法等等。

    程序计数器

    对于一个运行中的Java程序而言,其中的每一个线程都有它自己的PC(程序计数器)寄存器,它是在该线程启动时创建的,PC寄存器的大小是一个字长,因此它既能够持有一个本地指针,也能够持有一个returnAddress。当线程执行某个Java方法时,PC寄存器的内容总是下一条将被执行指令的“地址”,这里的“地址”可以是一个本地指针,也可以是在方法字节码中相对于该方法起始指令的偏移量。如果该线程正在执行一个本地方法,那么此时PC寄存器的值是“undefined”。

    Java栈

    每当启动一个新线程时,Java虚拟机都会为它分配一个Java栈。Java栈以帧为单位保存线程的运行状态。虚拟机只会直接对Java栈执行两种操作:以帧为单位的压栈和出栈。

    某个线程正在执行的方法被称为该线程的当前方法,当前方法使用的栈帧称为当前帧,当前方法所属的类称为当前类,当前类的常量池称为当前常量池。在线程执行一个方法时,它会跟踪当前类和当前常量池。此外,当虚拟机遇到栈内操作指令时,它对当前帧内数据执行操作。

    每当线程调用一个Java方法时,虚拟机都会在该线程的Java栈中压入一个新帧。而这个新帧自然就成为了当前帧。在执行这个方法时,它使用这个帧来存储参数、局部变量、中间运算结果等数据。

    Java方法可以以两种方式完成。一种通过return返回的,称为正常返回;一种是通过抛出异常而异常终止的。不管以哪种方式返回,虚拟机都会将当前帧弹出Java栈然后释放掉,这样上一个方法的帧就成为当前帧了。

    Java帧上的所有数据都是此线程私有的。任何线程都不能访问另一个线程的栈数据,因此我们不需要考虑多线程情况下栈数据的访问同步问题。当一个线程调用一个方法时,方法的的局部变量保存在调用线程Java栈的帧中。只有一个线程能总是访问那些局部变量,即调用方法的线程。

    本地方法栈

    前面提到的所有运行时数据区都是Java虚拟机规范中明确定义的,除此之外,对于一个运行中的Java程序而言,它还可能会用到一些跟本地方法相关的数据区。当某个线程调用一个本地方法时,它就进入了一个全新的并且不再受虚拟机限制的世界。本地方法可以通过本地方法接口来访问虚拟机的运行时数据区,但不止如此,它还可以做任何它想做的事情。

    本地方法本质上时依赖于实现的,虚拟机实现的设计者们可以自由地决定使用怎样的机制来让Java程序调用本地方法。

    任何本地方法接口都会使用某种本地方法栈。当线程调用Java方法时,虚拟机会创建一个新的栈帧并压入Java栈。然而当它调用的是本地方法时,虚拟机会保持Java栈不变,不再在线程的Java栈中压入新的帧,虚拟机只是简单地动态连接并直接调用指定的本地方法。

    如果某个虚拟机实现的本地方法接口是使用C连接模型的话,那么它的本地方法栈就是C栈。当C程序调用一个C函数时,其栈操作都是确定的。传递给该函数的参数以某个确定的顺序压入栈,它的返回值也以确定的方式传回调用者。同样,这就是虚拟机实现中本地方法栈的行为。

    很可能本地方法接口需要回调Java虚拟机中的Java方法,在这种情况下,该线程会保存本地方法栈的状态并进入到另一个Java栈。

    下图描绘了这样一个情景,就是当一个线程调用一个本地方法时,本地方法又回调虚拟机中的另一个Java方法。这幅图展示了JAVA虚拟机内部线程运行的全景图。一个线程可能在整个生命周期中都执行Java方法,操作它的Java栈;或者它可能毫无障碍地在Java栈和本地方法栈之间跳转?! ?img class="aligncenter" src="data:image/png;base64,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" alt="" />

    该线程首先调用了两个Java方法,而第二个Java方法又调用了一个本地方法,这样导致虚拟机使用了一个本地方法栈。假设这是一个C语言栈,其间有两个C函数,第一个C函数被第二个Java方法当做本地方法调用,而这个C函数又调用了第二个C函数。之后第二个C函数又通过本地方法接口回调了一个Java方法(第三个Java方法),最终这个Java方法又调用了一个Java方法(它成为图中的当前方法)。



    相关文章

    发表评论

    Comment form

    (*) 表示必填项

    1 条评论

    1. 小明 说道:

      从《Inside the java virtual machine》翻译过来的

      Thumb up 0 Thumb down 0

    广东好彩36开奖结果
    返回顶部
  • 高清:创意十足!杭州萌娃毕业照留下成长足迹 2019-04-08
  • 上交所:存托凭证上市首日不实行价格涨跌幅限制 2019-04-08
  • 谁拆迁都是一样一片狼藉,拆迁时欢天喜地,回迁时垂头丧气。拆迁者得到好处,被拆者哭天喊地。 2019-04-07
  • 网上支付出现异常如何解决? 2019-04-07
  • [微笑]咱建议进一步提高挂号费标准,最起码也得200元起步…… 2019-03-30
  • 一语惊坛(5月30日):磋商,不等于反复折腾。 2019-03-16