专注虚拟机与编译器研究

在本地函数中会使用Java服务，这些服务都可以通过调用JNIEnv中封装的函数获取。我们在本地函数中可以访问所传入的引用类型参数，也可以通过JNI函数创建新的 Java 对象。这些 Java 对象显然也会受到GC的影响。所以我们需要通过JNI 的局部引用（Local Reference）和全局引用（Global Reference）来保证不让GC回收这些本地函数中可能引用到的 Java 对象。

无论是局部引用还是全局引用，其实都是通过句柄进行引用。其中，局部引用所对应的句柄有两种存储方式，一是在本地方法栈帧中，主要用于存放 C 函数所接收的来自 Java 层面的引用类型参数；另一种则是线程私有的句柄块，主要用于存放本地函数运行过程中创建的局部引用（实际是通过JNI函数来完成来这些操作）。无论是传入的引用类型参数，还是通过JNI函数（除NewGlobalRef及NewWeakGlobalRef之外）返回的引用类型对象，都属于局部引用。

关于句柄我们不应该陌生，在《深入剖析Java虚拟机：源码剖析与实例详解（基础卷）》一书中详细介绍过，Java栈在引用Java堆中的对象时会通过句柄的方式来引用，句柄指的是内存中 Java 对象的指针的指针。同时也介绍了HandleMark、HandleArea与Chunk这几个类的用法，它是为解决JVM内部的本地代码引用情况。当发生垃圾回收时，如果 Java 对象被移动了，那么句柄指向的指针值也将发生变动，但句柄本身保持不变。

HotSpot VM的JNI句柄是放在若干不同的区域里的，但不会放在GC堆中。传递参数用的句柄直接在栈上；局部句柄放在每个Java线程中的JNIHandleBlock里；全局句柄放在HotSpot VM全局的JNIHandleBlock里。

JNIHandles类的定义如下：

源代码位置：openjdk/hotspot/src/share/vm/runtime/jniHandles.hpp

class JNIHandles : AllStatic {
private:
// 保存全局引用的JNIHandleBlock链表的头元素
static JNIHandleBlock* _global_handles;
// 保存全局弱引用的JNIHandleBlock链表的头元素
static JNIHandleBlock* _weak_global_handles;
static oop _deleted_handle;
…
}
　
调用JNIHandles类的initialize()函数初始化如上的属性，如下：

void JNIHandles::initialize() {
_global_handles = JNIHandleBlock::allocate_block();
_weak_global_handles = JNIHandleBlock::allocate_block();
// 宏扩展为如下的形式：
// Thread* the_thread = 0;
// ExceptionMark __em(the_thread);
EXCEPTION_MARK;

Klass* k = SystemDictionary::Object_klass();
_deleted_handle = InstanceKlass::cast(k)->allocate_instance(CATCH);
}
HotSpot VM会在启动时调用init_globals()函数初始化全局模块，init_globals()函数会间接调用到JNIHandles::initialize()函数，在这个函数中对全局的变量分配对应的JNIHandleBlock块。所以说，全局对象的句柄存储在JNIHandleBlock中。

JNIHandle分为两种，全局和局部对象引用，大部分的对象引用属于局部对象引用，最终还是调用了JNIHandleBlock来管理，因为JNIHandle没有设计一个JNIHandleMark的机制，所以在创建局部对象引用时需要明确调用JNIHandles::mark_local()函数，在回收时也需要明确调用JNIHandles::destroy_local()函数。

在线程中定义的、与局部引用对象相关的变量如下：

// 保存活跃的JNIHandleBlock块，块中存储的句柄对象也是活跃的
JNIHandleBlock* _active_handles;

// 保存空闲JNIHandleBlock块，在必要时进行重用
JNIHandleBlock* _free_handle_block;

HandleMark* _last_handle_mark;
无论是全局还是局部对象引用，其句柄都存储在JNIHandleBlock块中。当需要分配一个新的块时，调用JNIHandleBlock::allocate_block()函数；当不需要块时，调用JNIHandleBlock::release_block()来释放JNIHandleBlock块。其中分配新块和释放块的操作的最典型应用就是在JavaCallWrapper类的构造函数和析构函数中，这个JavaCallWrapper我们在之前接触过，就是在介绍HotSpot VM调用Java主类的main()方法时，会调用到JavaCalls::call_helper()函数，这个函数中有如下调用：

{
// 使用JavaCallWrapper保存相关信息
JavaCallWrapper link(method, receiver, result, CHECK);
{
HandleMark hm(thread);
StubRoutines::call_stub()(
(address)&link,
result_val_address,
result_type,
method(),
entry_point,
args->parameters(),
args->size_of_parameters(),
CHECK
);

  result = link.result(); 

  if (oop_result_flag) {
    thread->set_vm_result((oop) result->get_jobject());
  }
}

} // Exit JavaCallWrapper (can block - potential return oop must be preserved)
这个link会从C/C++函数调用到Java方法时，存储到栈上，如下图所示。

其中的call wrapper就是保存的link值。

其实任何从C/C++调用到Java方法时都会在C/C++的栈帧中保存call wrapper，其中保存的信息非常重要，因为寄生在C/C++栈中的C/C++函数和Java方法对应的栈帧混合在一起，我们有时候要遍历C/C++栈帧，有时候需要遍历Java栈帧，当C/C++函数或Java函数执行完成后，还要能正确恢复调用者的栈帧信息并执行，这里我们不对这些内容做过多介绍，我们只关心C/C++函数使用的局部变量句柄即可。

如上图所示，在第1个C/C++栈帧（非当前执行的函数对应的C/C++栈帧）中可通过call wrapper找到JavaCallWrapper，然后通过JavaCallWrapper::_handles找到之前使用的JNIHandleBlock单链表，这样就能遍历到之前的C/C++栈帧中引用的堆中对象了。在第2个C/C++栈帧（当前正在执行的函数）中，通过Thread::_active_handles就能找到当前使用的JNIHandleBlock单链表，这样就能遍历引用的堆中对象了。对于Java栈引用的堆中对象来说，在《深入剖析Java虚拟机：源码剖析与实例详解（基础卷）》一书中介绍过，可通过HandleMark、HandleArea与Chunk等进行管理。

如果发生GC，那么需要遍历线程中的所有C/C++栈找到所有使用的JNIHandleBlock块，这样才能不产生漏标现象。

在JavaCallWrapper类中有如下属性定义：

JNIHandleBlock* _handles; // 实际保存JNI引用的内存块的指针
在JavaCallWrapper构造函数中有如下实现：

JavaCallWrapper::JavaCallWrapper(
methodHandle callee_method,
Handle receiver,
JavaValue* result,
TRAPS
) {
JavaThread* thread = (JavaThread *)THREAD;
// …

// 分配一个新的JNIHandleBlock
JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);

// …

_thread = (JavaThread *)thread;
// 保存当前线程的active_handles
_handles = _thread->active_handles();

// 将新分配的JNIHandleBlock作为线程的active_handles
_thread->set_active_handles(new_handles);
}
无论是全局变量还是局部变量，都需要分配调用JNIHandleBlock::allocate_block()函数分配JNIHandleBlock。JNIHandleBlock类的定义如下：

class JNIHandleBlock : public CHeapObj {
private:
enum SomeConstants {
// 每个JNIHandleBlock中只能分配出32个句柄，所以只能存储32个oop
block_size_in_oops = 32
};

// 句柄中保存的是oop，本地函数只能通过句柄来操作oop
oop _handles[block_size_in_oops];
// 下一个没有使用的_handles中的slot，可以在这个slot上存储oop，
// 然后返回此slot的地址给本地函数进行操作
int _top;
// 通过_next字段将所有的JNIHandleBlock连接成单链表
JNIHandleBlock* _next;

// 指向JNIHandleBlock链表中的最后一个块，这个块中的_handles正在负责为当前线程分配句柄区域
JNIHandleBlock* _last;
JNIHandleBlock* _pop_frame_link;

// 将空闲的句柄区域通过列表连接起来
oop* _free_list;

// 将空闲的JNIHandleBlock通过如下字段连接成单链表，注意这是
// 一个静态变量，所以这个列表保存的JNIHandleBlock块可被任何线程重用
static JNIHandleBlock* _block_free_list;
// …
}
其中各个属性的说明如下图所示。

注意，在线程中分配局部变量的句柄时，会从_last指向的JNIHandleBlock块的_handles数组中分配，如果top已经指向了_handles数组的下一个位置，则表示此数组已经无法分配出额外的句柄空间，需要调用JNIHandleBlock::allocate_block()函数分配一个新的JNIHandleBlock并连接到单链表中。

在JavaCallWrapper::JavaCallWrapper()构造函数中调用的JNIHandleBlock类的allocate_block()函数的实现如下：

JNIHandleBlock* JNIHandleBlock::allocate_block(Thread* thread) {
JNIHandleBlock* block;

// 如果当前线程的Thread::_free_handle_block中有空闲
// 的JNIHandleBlock，则从空闲的列表中获取即可
if (thread != NULL && thread->free_handle_block() != NULL) {
block = thread->free_handle_block();
thread->set_free_handle_block(block->_next);
}
else {
MutexLockerEx ml(JNIHandleBlockFreeList_lock,Mutex::_no_safepoint_check_flag);
if (_block_free_list == NULL) {
// 如果空闲列表中没有空闲的JNIHandleBlock，则分配一个新的JNIHandleBlock
// JNIHandleBlock的内存是通过调用os::malloc()函数进行分配的
block = new JNIHandleBlock();
_blocks_allocated++;

   if (ZapJNIHandleArea)
      block->zap();
} else {
   // 从JNIHandleBlock::_block_free_list中获取空闲块
   block = _block_free_list;
   _block_free_list = _block_free_list->_next;
}

}

block->_top = 0;
block->_next = NULL;
block->_pop_frame_link = NULL;

return block;
}
如上函数会在线程启动时调用，如在VMThread::run()、WatcherThread::run()和JavaThread::run()函数中调用，因为这几个函数都可能会执行native方法。当从线程的_free_handle_block和JNIHandleBlock::__block_free_list列表中都无法分配出空闲的JNIHandleBlock块时，就需要通过new关键字创建新的JNIHandleBlock了，JNIHandleBlock继承自CHeapObj，所以会通过调用os::malloc()函数从本地内存中分配块的内存。

JavaCallWrapper::~JavaCallWrapper()析构函数的实现如下：

JavaCallWrapper::~JavaCallWrapper() {
// 校验执行析构的是同一个Java线程
assert(_thread == JavaThread::current(), “must still be the same thread”);

// 获取当前线程的active_handles
JNIHandleBlock *_old_handles = _thread->active_handles();
// 恢复方法调用前的active_handles
_thread->set_active_handles(_handles);

// …

// 释放方法调用中新分配的JNIHandleBlock
JNIHandleBlock::release_block(_old_handles, _thread);
}
析构函数在Java方法返回到C/C++函数时调用，调用JNIHandleBlock::release_block()函数就相当于在释放本地函数栈帧中的句柄。所以我们也能看到，一旦从本地函数中返回到Java 方法中，那么局部引用将失效。也就是说，垃圾回收器在标记垃圾时不再考虑这些局部引用。这就意味着，我们不能缓存局部引用，以供另一个线程或下一次 native 方法调用时使用。对于这种应用场景，我们需要借助 JNI 函数NewGlobalRef，将该局部引用转换为全局引用，以确保其指向的 Java 对象不会被垃圾回收。相应的，我们还可以通过 JNI 函数DeleteGlobalRef来消除全局引用，以便回收被全局引用指向的 Java 对象。

调用的release_block()函数的实现如下：

void JNIHandleBlock::release_block(JNIHandleBlock* block, Thread* thread) {
JNIHandleBlock* pop_frame_link = block->pop_frame_link();

if (thread != NULL ) {
if (ZapJNIHandleArea)
block->zap();
JNIHandleBlock* freelist = thread->free_handle_block();
block->_pop_frame_link = NULL;
thread->set_free_handle_block(block);

// 将新的空闲块添加到列表头部，其它的空闲块添加到列表尾部
if ( freelist != NULL ) {
  while ( block->_next != NULL ) 
      block = block->_next;
  block->_next = freelist;
}
block = NULL;

}

if (block != NULL) {
MutexLockerEx ml(JNIHandleBlockFreeList_lock,Mutex::_no_safepoint_check_flag);
while (block != NULL) {
if (ZapJNIHandleArea)
block->zap();
// 如果函数传入的参数thread为NULL，那么会将block连接到静态变量
// _block_free_list列表中
JNIHandleBlock* next = block->_next;
block->_next = _block_free_list;
_block_free_list = block;
block = next;
}
}
// …
}　
亚马逊测评 www.yisuping.cn