深入理解Jvm--Java静态分配和动态分配完全解析

jvm中分配Dispatch的概念

分派是针对方法而言的，指的是方法确定的过程，通常发生在方法调用的过程中。分派根据方法选择的发生时机可以分为静态分派和动态分派，其中对于动态分派，根据宗量种数又可以分为单分派和多分派。实际上指的是方法的接收者和属性的所有者的类型确定（determine by atual type or determine by static type）。根据类型确定发生在运行期还是编译期以及依据实际类型还是静态类型，可以将Dispatch分为动态分配Dynamic Dispatch和静态分配Static Dispatch两类。

虚方法和非虚方法

在理解动态绑定和静态绑定之前必须先理解虚方法和非虚方法。

①非虚方法

只要能被invokestatic和invokespecial指令调用的方法，都可以在解析阶段中确定唯一的调用版本，符合这个条件的有静态方法、私有方法、实例构造器、 final方法，它们在类加载的时候就会把符号引用解析为该方法的直接引用。这些方法可以称为非虚方法。

②虚方法

非私有的实例方法等。

静态分配Static Dispatch

静态分派的典型应用是方法重载overlord。静态分派指的是在编译期间进行的方法选择，通常以方法名称，方法接收者和方法参数的静态类型来作为方法选择的依据。这些可以静态分派的方法一般都具有“签名唯一性”的特点（签名只考虑参数的静态类型而不管参数的实际类型），即不会出现相同签名的方法，因此可以在编译期就实现方法确定。Java中的非虚方法（主要包括静态方法，私有方法，final方法等，这些方法一般不可重写，故而不会有相同签名的情况出现）通常仅需要静态分派就可以实现方法的最终确定，更特别一点的例子是静态方法的隐藏，也是利用了静态分派，后面会专门讲解。虚方法的重载在编译时也用到了静态分派（尽管虚方法的调用在运行时还会涉及动态分派）。静态分配实例：

public class StaticDispatch{

static abstract class Human{

}

static class Man extends Human{

}

static class Woman extends Human{

}

    public void sayHello(Human guy){

        System.out.println("hello,guy！");

    }

    public void sayHello(Man guy){

        System.out.println("hello,gentleman！");

    }

    public void sayHello(Woman guy){

        System.out.println("hello,lady！");

    }

    public static void main(String[]args){

        Human man=new Man();

        Human woman=new Woman();

        StaticDispatch sr=new StaticDispatch();

        sr.sayHello(man);

        sr.sayHello(woman);

}

}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

运行结果：

hello,guy！

hello,guy！



1
2

动态分配Dynamic Dispatch

动态分派的典型应用是方法重写override动态分派是指方法的确定在run-time才能最终完成。使用动态分派来实现方法确定的方法一般在编译期间都是一些“不明确”的方法（比如一些重写方法，拥有相同的方法签名并且方法接收者的静态类型可能也相同），因此只能在运行时期根据方法接收者和方法参数的实际类型最终实现方法确定。Java中的虚方法（主要指实例方法）通常需要在运行期采用动态分派来实现方法确定（利用invokevirtual指令获取方法接收者的实际类型）。动态分配实例：

public class DynamicDispatch{

    static abstract class Human{

        protected abstract void sayHello（）；

    }

    static class Man extends Human{

        @Override

        protected void sayHello（）{

        System.out.println（"man say hello"）；

        }

    }

    static class Woman extends Human{

        @Override

        protected void sayHello（）{

        System.out.println（"woman say hello"）；

        }

    }

    public static void main（String[]args）{

        Human man=new Man（）；

        Human woman=new Woman（）；

        man.sayHello（）；

        woman.sayHello（）；

        man=new Woman（）；

        man.sayHello（）；

    }

}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

运行结果：

man say hello

woman say hello

woman say hello



1
2
3

相关笔试面试题

class Person{

  int age = 30;

  int getAge(){

    return age;

  }

}

class Man extends Person{

  int age = 40;

  int height = 160;

  int getAge(){

    return age;

  }

}

public class Demo{

  public static void main(String[] args){

    Person a = new Man();

    //  a.age内部主要通过如下字节码实现：

    //  getfield      #5                  // Field test/Person.age:I

    System.out.println(a.age);

    //  a.getAge()内部主要通过如下字节码实现：

    //  invokevirtual #7                  // Method test/Person.getAge:()I

    System.out.println(a.getAge());

  }

}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

运行结果：

上面题目不仅涉及到Dispatch而且涉及到了Binding,

Static Binding

类型在编译期就已经可以确定，并且该类型确定在运行期保持不变，即最终通过静态类型确定该变量类型。Java中，在Java中，静态绑定通常用于属性所有者的类型绑定，非虚方法（类方法，私有方法，构造器方法，final方法）接收者的类型绑定，以及方法参数的类型绑定。

上例中，age属性是对象属性，age属性的所有者（对象a）在此次访问中是静态绑定，因此这里对象a的类型在编译期被确定为a的静态类型Person，并且该类型确定后在运行期执行getfield指令时也不会发生改变，最后”a.age”调用的是a的静态类型Person的age属性值。这里也涉及到了属性隐藏的问题：父类和子类有同名域时，域的访问是通过域的所有者的静态类型决定的。比如上面例子中如果想访问子类Man中的age，则必须将对象a强制转型为Man，或者在当时创建之初就声明为Man类型而非Person类型。

通过静态绑定来实现访问对象属性所有者类型绑定的好处在于：编译期就可以确定最终类型，避免了动态查找，高效快速，但是是以牺牲一部分灵活性为代价的。

Dynamic Binding

类型在运行时才能最终确定，通过最终实际类型（运行时类型）来确定变量类型。Java中，动态绑定通常用于虚方法（如非私有的实例方法等）接收者的类型绑定。

某些动态类型语言将动态绑定作为默认的内部实现。Java作为一种静态类型语言，采取了一些其他的方法来实现动态绑定（比如invokevirtual指令动态识别对象的实际类型）。

上面例子中，getAge()属于虚方法， getAge()方法的接收者（对象a）在此次访问中是动态绑定，因此这里对象a的类型尽管在编译期被标记为Person，最后在运行期会被invokevirtual指令重新确定为a的实际类型Man，并在Man中查找能够匹配符号引用中方法名和描述符的方法，因此”a.getAge()”调用的是a的实际类型Man的getAge方法。

Java的“静态多分派，动态单分派”

所谓的”静态多分派“概念：由于java的静态分派需要同时考虑方法接收者和方法参数的静态类型，某种层度上而言是考虑了两种宗量，尽管没有涉及任何实际类型，依然可以从行为上勉强理解为”多分派“。

参考文献

①深入理解Java虚拟机

②http://hippo-jessy.com/2017/02/13/【深入理解Java虚拟机-1】Resolution-vs-Binding-vs-Dispatch/

原文地址：https://blog.csdn.net/u013309870/article/details/72991236