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

朱雀 2021-01-24 19:06 573阅读 0赞

项目地址：[https://github.com/gongxianshengjiadexiaohuihui][https_github.com_gongxianshengjiadexiaohuihui]

在运行java程序时，Java虚拟机需要使用内存来存放各种各样的数据，Java虚拟机规范把这些内存的区域叫做运行时数据区。运行时数据区可以分为两类：一类是多个线程共享的，另一类是线程私有的。多线程共享的运行时数据区需要在java虚拟机启动时创建，在java虚拟机退出时销毁。线程私有的运行时数据区则在创建线程时才创建，线程退出时销毁。

多线程共享的内存区域主要存放两类数据：类数据和类实例对象。对象数据放在堆中,类数据放在方法区中。堆由垃圾回收器定期清理，所以程序员不需要关心对象空间的释放。类数据包括字段信息和方法信息，方法的字节码，运行时常量池。从逻辑上讲，方法区也是堆的一部分。

线程私有的运行时数据区用于辅助执行java字节码，每个线程都有自己的pc寄存器，和java虚拟机栈。java虚拟机栈又有栈帧构成，帧中保存方法执行的状态。包括局部变量表和操作数栈。在某一时刻，某一线程肯定是在执行某个方法。这个方法叫做当前方法，执行该方法的帧，叫做线程的当前帧。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTQzNjM0_size_16_color_FFFFFF_t_70][]

java虚拟机支持的数据类型

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTQzNjM0_size_16_color_FFFFFF_t_70 1][]

我们来根据这个图实现线程私有的运行时数据区

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTQzNjM0_size_16_color_FFFFFF_t_70 2][]

首先是Thread

package rtda
    
    type Thread struct {
    	pc   int
    	stack *Stack
    }
    //构造函数
    func  NewThread() *Thread{
    	return &Thread{
    		stack: newStack(1024),
    	}
    }
    //setter&getter
    func (self *Thread)PC() int{
    	return self.pc
    }
    func (self *Thread)SetPC(pc int){
    	self.pc = pc
    }
    //操作栈帧
    func (self *Thread)PushFrame(frame *Frame){
    	self.stack.push(frame)
    }
    func (self *Thread)PopFrame() *Frame{
    	return self.stack.pop()
    }
    func (self *Thread)CurrentFrame() *Frame{
    	return self.stack.top()
    }

从上层往下层，接下来构造jvm\_stack

package rtda
    
    type Stack struct {
    //最大容量
    maxSize uint
    //当前数量
    size    uint
    //这是一个链表结构，_top相当于头指针
    _top    *Frame
    }
    //构造函数
    func newStack(maxSize uint) *Stack {
    return &Stack{
    maxSize: maxSize,
    
      }
     }
    //出栈进栈操作
    func (self *Stack) push(frame *Frame) {
    if self.size >= self.maxSize {
    panic("java.lang.StackOverflowError")
     }
    
    if self._top != nil {
    frame.lower = self._top
    }
    
    self._top = frame
    self.size++
    }
    
    func (self *Stack) pop() *Frame {
    if self._top == nil {
    
    panic("jvm stack is empty!")
    
     }
    
    top := self._top
    self._top = top.lower
    top.lower = nil
    self.size--
    
    return top
    }
    
    func (self *Stack) top() *Frame {
    if self._top == nil {
    panic("jvm stack is empty!")
    }
    
    return self._top
    }

接下来一层是我们的栈帧

package rtda
    
    type Frame struct {
    	lower *Frame
    	localVars LocalVars
    	operandStack *OperandStack
    }
    func NewFrame(maxLocals, maxStack uint)*Frame{
    	return &Frame{
    		localVars : newLocalVars(maxLocals),
    		operandStack : newOperandStack(maxStack),
    	}
    }
    //getter
    func (self *Frame)LocalVars()LocalVars{
    	return self.localVars
    }
    func (self *Frame)OperandStack()*OperandStack{
    	return self.operandStack
    }

在构造局部变量表和操作数栈之前，我们要准备两样东西

一个是object，因为我们操作的数据不仅有基本类型，还有引用，因为具体object我们会在后面实现，在次先创建一个内容为空的object

package rtda
    
    type Object struct {
    
    }

局部变量表是按索引访问的，类似于按照数组下标访问的，这个数组的每个元素至少可以容纳一个int值或引用值。我们想到可以用一个结构体去表示一个int值和一个引用，需要什么值，取什么值即可。

package rtda
    
    type Slot struct {
    	num int32
    	ref *Object
    }

局部变量表

因为局部变量表存放的是int32，所以存放float，double，long的时候，需要我们进行转换

package rtda
    
    import "math"
    
    type LocalVars []Slot
    
    func newLocalVars(maxlocals uint) LocalVars{
    	if maxlocals > 0{
    		return make([]Slot,maxlocals)
    	}
    	return nil
    }
    func (self LocalVars) SetInt(index uint, val int32){
    	self[index].num = val
    }
    func (self LocalVars) GetInt(index uint) int32{
    	return self[index].num
    }
    func (self LocalVars) SetFloat(index uint, val float32){
    	bits := math.Float32bits(val)
    	self[index].num = int32(bits)
    }
    func (self LocalVars)GetFloat(index uint) float32{
    	bits := uint32(self[index].num)
    	return math.Float32frombits(bits)
    }
    func (self LocalVars)SetLong(index uint, val int64){
    	self[index].num = int32(val)
    	self[index+1].num = int32(val >> 32)
    }
    func (self LocalVars)GetLong(index uint) int64{
    	low := uint32(self[index].num)
    	high := uint32(self[index+1].num)
    	return int64(high)<<32 |int64(low)
    }
    func (self LocalVars)SetDouble(index uint, val float64){
    	bits := math.Float64bits(val)
    	self.SetLong(index,int64(bits))
    }
    func (self LocalVars)GetDouble(index uint)float64{
    	bits := (uint64)(self.GetLong(index))
    	return math.Float64frombits(bits)
    }
    func (self LocalVars)SetRef(index uint, ref *Object){
    	self[index].ref = ref
    }
    func (self LocalVars)GetRef(index uint)*Object{
    	return self[index].ref
    }

操作数栈

package rtda
    
    import "math"
    //操作数栈 属于栈帧 一个方法执行就对应一个
    
    //操作数栈大小是编译器编译时就确定的 在class文件的方法信息的code属性里面有写这项
    type OperandStack struct {
    	size uint
    	slots []Slot
    }
    
    func newOperandStack(maxStack uint)*OperandStack{
    	if maxStack > 0{
    		return &OperandStack{
    			slots : make([]Slot,maxStack),
    		}
    	}
    	return nil
    }
    
    func (self *OperandStack)PushInt(val int32){
    	self.slots[self.size].num = val
    	self.size ++
    }
    func (self *OperandStack)PopInt() int32{
    	self.size --
    	return  self.slots[self.size].num
    }
    
    func (self *OperandStack)PushFloat(val float32){
    	bits := math.Float32bits(val)
    	self.slots[self.size].num = int32(bits)
    	self.size ++
    }
    func (self *OperandStack)PopFloat()float32  {
    	self.size --
    	bits := uint32(self.slots[self.size].num)
    	return math.Float32frombits(bits)
    }
    
    func (self *OperandStack)PushLong(val int64){
    	self.slots[self.size].num = int32(val)
    	self.slots[self.size+1].num = int32(val >> 32)
    	self.size += 2
    }
    func (self *OperandStack)PopLong()int64{
    	self.size -= 2
    	low := uint32(self.slots[self.size].num)
    	high := uint32(self.slots[self.size+1].num)
    	return int64(high) << 32 | int64(low)
    }
    
    func (self *OperandStack)PushDouble(val float64){
    	bits := math.Float64bits(val)
    	self.PushLong(int64(bits))
    
    }
    func (self *OperandStack)PopDouble()float64{
    	bits := uint64(self.PopLong())
    	return math.Float64frombits(bits)
    }
    
    func (self *OperandStack)PushRef(ref *Object){
    	self.slots[self.size].ref = ref
    	self.size ++
    }
    func(self *OperandStack)PopRef() *Object{
    	self.size --
    	return self.slots[self.size].ref
    }

最后改造我们的main函数

package main
    
    import "fmt"
    import "jvmgo/rtda"
    
    
    func main(){
    	//调用解析命令行的行数，接受解析结果
        cmd:=parseCmd()
        if cmd.versionFlag{
        	fmt.Println("version 0.0.1")
        }else if cmd.helpFlag||cmd.class==""{
        	printUsage()
        }else{
        	startJVM(cmd)
        }
    }
    
    func startJVM(cmd *Cmd){
        frame := rtda.NewFrame(100,100)
        testLocalVars(frame.LocalVars());
        testOperandStack(frame.OperandStack());
    }
    func testLocalVars(vars rtda.LocalVars) {
    	vars.SetInt(0, 100)
    	vars.SetInt(1, -100)
    	vars.SetLong(2, 2997924580)
    	vars.SetLong(4, -2997924580)
    	vars.SetFloat(6, 3.1415926)
    	vars.SetDouble(7, 2.71828182845)
    	vars.SetRef(9, nil)
    	println(vars.GetInt(0))
    	println(vars.GetInt(1))
    	println(vars.GetLong(2))
    	println(vars.GetLong(4))
    	println(vars.GetFloat(6))
    	println(vars.GetDouble(7))
    	println(vars.GetRef(9))
    }
    
    func testOperandStack(ops *rtda.OperandStack) {
    	ops.PushInt(100)
    	ops.PushInt(-100)
    	ops.PushLong(2997924580)
    	ops.PushLong(-2997924580)
    	ops.PushFloat(3.1415926)
    	ops.PushDouble(2.71828182845)
    	ops.PushRef(nil)
    	println(ops.PopRef())
    	println(ops.PopDouble())
    	println(ops.PopFloat())
    	println(ops.PopLong())
    	println(ops.PopLong())
    	println(ops.PopInt())
    	println(ops.PopInt())
    }

运行结果

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTQzNjM0_size_16_color_FFFFFF_t_70 3][]

[https_github.com_gongxianshengjiadexiaohuihui]: https://github.com/gongxianshengjiadexiaohuihui
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTQzNjM0_size_16_color_FFFFFF_t_70]: /images/1611515170845.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTQzNjM0_size_16_color_FFFFFF_t_70 1]: /images/1611515148972.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTQzNjM0_size_16_color_FFFFFF_t_70 2]: /images/1611515127189.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTQzNjM0_size_16_color_FFFFFF_t_70 3]: /images/1611515107317.png