《自己动手写java虚拟机》学习笔记（八）-----线程私有运行时数据区（java）

项目地址：https://github.com/gongxianshengjiadexiaohuihui

这个图就是线程私有的数据区结构

我们按照从外到内的方式来构建

线程Thread

package classfile.rtda;

/**
 * @Author:ggp
 * @Date:2019/2/13 14 27
 * @Description:线程
 */
public class Thread {
    /**
     * 如果当前方法是java方法，存放正在执行的java虚拟机指令的地址，否则当前方法是本地方法，存放的值没有明确定义
     */
    private int pc;
    /**
     * java虚拟机栈
     */
    private Stack stack;

    public Thread() {
        /**
         * 默认虚拟机栈可以存放1024个栈帧
         */
        stack = new Stack(1024);
    }

    public int getPc() {
        return pc;
    }

    public void setPc(int pc) {
        this.pc = pc;
    }

    /**
     * 进栈
     * @param frame
     */
    public void pushFrame(Frame frame){
        stack.push(frame);
    }

    /**
     * 出栈
     * @return
     */
    public Frame popFrame(){
        return stack.pop();
    }

    /**
     * 返回当前帧
     * @return
     */
    public Frame getCurrentFrame(){
        return stack.top();
    }
}

线程包含两个部分，一个pc计数器，用来存放正在执行指令的地址，一个jvm栈，用来执行指令，基本单位是栈帧，一帧相当于执行一次操作

jvm栈

package classfile.rtda;

import java.util.EmptyStackException;

/**
 * @Author:ggp
 * @Date:2019/2/13 14 28
 * @Description:虚拟机栈
 */
public class Stack {
    /**
     * 最大容量
     */
    private int maxSize;
    /**
     * 实际栈帧数量
     */
    private int size;
    /**
     * 栈顶的帧
     */
    private Frame top;

    public Stack(int maxSize) {
        this.maxSize = maxSize;
    }

    /**
     * 进栈
     * @param frame
     */
    public void push(Frame frame){
        if(size >= maxSize){
            /**
             * 如果栈已经满了，就抛出StackOverflowError错误
             */
            throw new StackOverflowError();
        }
        if(top != null){
            /**
             * 如果栈顶不为空，就可以让新的栈帧把它压下去一个位置，把它保留在next位置
             */
            frame.next = top;
        }
        top = frame;
        size++;
    }

    /**
     * 出栈
     * @return
     */
    public Frame pop(){
        if(top == null){
            /**
             * 如果栈为空，就抛出EmptyStackException异常
             */
            throw new EmptyStackException();
        }
        Frame tamp = top;
        top = top.next;
        tamp.next = null;
        size--;
        return tamp;
    }
    public Frame top(){
        if(top == null){
            /**
             * 如果栈为空，就抛出EmptyStackException异常
             */
            throw new EmptyStackException();
        }
        return top;
    }

}

就是一个栈是由栈帧组成的链表，包含进栈出栈等操作

栈帧Frame

package classfile.rtda;

/**
 * @Author:ggp
 * @Date:2019/2/13 14 34
 * @Description:
 */
public class Frame {
    /**
     * 指向相邻的下一个栈帧
     */
    public Frame next;
    /**
     * 局部变量表
     */
    private LocalVars localVars;
    /**
     * 操作数栈
     */
    private OperandStack operandStack;
    public Frame(int maxlocals, int maxStack){
        localVars = new LocalVars(maxlocals);
        operandStack = new OperandStack(maxStack);
    }

    public LocalVars getLocalVars() {
        return localVars;
    }

    public OperandStack getOperandStack() {
        return operandStack;
    }
}

是一个链表的基本单位，包含局部变量表（用来存放计算过程中的变量和临时生成的变量），操作数栈（用来存放待计算的变量）

slot

package classfile.rtda;

/**
 * @Author:ggp
 * @Date:2019/2/13 14 23
 * @Description:
 * 局部变量表是按照索引访问的，所以可以把它想象成一个数组，根据虚拟机规范，这个数组每个元素至少可以容纳一个int，或引用值，两个连续的元素可以容纳一个一个long或double值
 */
public class Slot {
    public int num;
    public Object ref;
    public Slot(){};
}

局部变量表和操作数栈的基本组成单位。可以存放一个基本类型或引用

引用

package classfile.rtda;

/**
 * @Author:ggp
 * @Date:2019/2/13 14 22
 * @Description:作为对象引用
 */
public class Object {

}

局部变量表和操作数栈

package classfile.rtda;

/**
 * @Author:ggp
 * @Date:2019/2/13 15 04
 * @Description:
 */
public class LocalVars {
    private Slot[] localvars;
    public LocalVars(int maxLocals){
        if(maxLocals > 0){
            localvars = new Slot[maxLocals];
        }else {
            throw new RuntimeException("maxLocal < 0");
        }
    }

    /**
     *局部变量表中存的数据是基本类型和引用，下面是他们的get set 方法
     */
    public void setInt(int index, int val){
        Slot slot = new Slot();
        slot.num = val;
        localvars[index] = slot;
    }
    public int getInt(int index){
        return localvars[index].num;
    }

    public void setFloat(int index, float val){
        Slot slot = new Slot();
        slot.num = Float.floatToIntBits(val);
        localvars[index] = slot;
    }
    public float getFloat(int index){
        return Float.intBitsToFloat(localvars[index].num);
    }

    public void setLong(int index, long val){
        /**
         * 低32位
         */
        Slot low = new Slot();
        low.num = (int)val;
        localvars[index] = low;
        /**
         * 高32位
         */
        Slot high = new Slot();
        high.num = (int)(val >> 32);
        localvars[index + 1] = high;
    }
    public long getLong(int index){
        /**
         * 如果是负数，jvm会根据符号位扩展，填充32个1
         */
        long low = (long)localvars[index].num & 0xffffffff;
        long high = (long)localvars[index + 1].num << 32;
        return high|low;
    }

    public void setDouble(int index, double val){
        long num = Double.doubleToLongBits(val);
        setLong(index,num);
    }
    public double getDouble(int index){
        return Double.longBitsToDouble(getLong(index));
    }

    public void setRef(int index, Object ref){
        Slot slot = new Slot();
        slot.ref = ref;
        localvars[index] = slot;
    }
    public Object getRef(int index){
        return localvars[index].ref;
    }

}

package classfile.rtda;

/**
 * @Author:ggp
 * @Date:2019/2/13 15 04
 * @Description:
 */
public class OperandStack {
    /**
     * 栈顶元素在数组的位置（index）,是基本类型，不初始化默认值是0
     */
    private int size;
    private Slot[] operandStack;

    /**
     *
     * @param maxStack 操作栈的深度
     */
    public OperandStack(int maxStack){
        if(maxStack > 0){
            operandStack = new Slot[maxStack];
        }else{
         throw new RuntimeException("maxStack < 0");
        }

    }

    public void pushInt(int val){
        Slot slot = new Slot();
        slot.num = val;
        operandStack[size++] = slot;
    }
    public int popInt(){
        return operandStack[--size].num;
    }

    public void pushFloat(float val){
        Slot slot = new Slot();
        slot.num = Float.floatToIntBits(val);
        operandStack[size++] =slot;
    }
    public float popFloat(){
        return Float.intBitsToFloat(operandStack[--size].num);
    }

    public void pushLong(long val){
        Slot low = new Slot();
        low.num = (int)val;
        operandStack[size++] = low;

        Slot high = new Slot();
        high.num = (int)(val >> 32);
        operandStack[size++] = high;
    }
    public long popLong(){
        long high = (long)operandStack[--size].num << 32;
        long low = (long)operandStack[--size].num & 0xffffffff;
        return high|low;

    }

    public void pushDouble(double val){
        long num = Double.doubleToLongBits(val);
        pushLong(num);
    }
    public double popDouble(){
        return Double.longBitsToDouble(popLong());
    }
    public void pushRef(Object ref){
        Slot slot = new Slot();
        slot.ref = ref;
        operandStack[size++] = slot;
    }
    public Object popRef(){
        return operandStack[--size].ref;
    }
}

都是有slot数组构成，说明它们存放的只能是基本类型或引用，需要注意的还是，jvm的符号位扩展问题

测试方法，修改Main类

import classfile.ClassFile;
import classfile.rtda.Frame;
import classfile.rtda.LocalVars;
import classfile.rtda.OperandStack;
import classpath.ClassPath;
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.util.Arrays;

/**
 * @ClassName Main
 * @Description TODO
 * @Author Mr.G
 * @Date 2018/10/9 10:43
 * @Version 1.0
 */
public class Main {
    public static void main(String[] args){
        Cmd cmd=new Cmd(args);
        if(!cmd.isRightFmt||cmd.helpFlag){
            cmd.printUsage();
        }else if(cmd.versionFlag){
            System.out.println("version 0.0.1");
        }else{
            startJVM(cmd);
        }
    }
    public static void startJVM(Cmd cmd){
        Frame frame = new Frame(100, 100);
        testLocalVars(frame.getLocalVars());
        testOperandStack(frame.getOperandStack());

    }
    public static void testLocalVars(LocalVars localVars){
        localVars.setInt(0,100);
        localVars.setInt(1, -100);
        localVars.setLong(2, 299792580);
        localVars.setLong(4,-299792580);
        localVars.setFloat(6, (float) 3.12);
        localVars.setFloat(7, (float)-3.12);
        localVars.setDouble(8, 3.14159265358979);
        localVars.setDouble(10, -3.14159265358979);
        localVars.setRef(12, null);
        System.out.println(localVars.getInt(0));
        System.out.println(localVars.getInt(1));
        System.out.println(localVars.getLong(2));
        System.out.println(localVars.getLong(4));
        System.out.println(localVars.getFloat(6));
        System.out.println(localVars.getFloat(7));
        System.out.println(localVars.getDouble(8));
        System.out.println(localVars.getDouble(10));
        System.out.println(localVars.getRef(12));

    }
    public static void testOperandStack(OperandStack operandStack){
        operandStack.pushInt(100);
        operandStack.pushInt(-100);
        operandStack.pushLong(299792580);
        operandStack.pushLong(-299792580);
        operandStack.pushFloat((float) 3.12);
        operandStack.pushFloat((float)-3.12);
        operandStack.pushDouble(3.14159265358979);
        operandStack.pushDouble(-3.14159265358979);
        operandStack.pushRef(null);
        System.out.println(operandStack.popRef());
        System.out.println(operandStack.popDouble());
        System.out.println(operandStack.popDouble());
        System.out.println(operandStack.popFloat());
        System.out.println(operandStack.popFloat());
        System.out.println(operandStack.popLong());
        System.out.println(operandStack.popLong());
        System.out.println(operandStack.popInt());
        System.out.println(operandStack.popInt());

    }


}

测试结果