通过Handle理解V8的代码设计（基于V0.1.5）

本文转载自微信公众号「编程杂技」，作者theanarkh。转载本文请联系编程杂技公众号。

目前创新互联建站已为上千的企业提供了网站建设、域名、网页空间、网站托管、服务器租用、企业网站设计、舒城网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。

前言：Handle在V8里是一个非常重要的概念，本文从早期的源码分析Handle的原理，在分析的过程中我们还可以看到V8在代码设计上的一些细节。

假设我们有以下代码

 
 
 
 
    
  
  
  
  
  1. HandleScope scope; 
    2. 
  
  
  
  
  2. Local hello = String::New(参数); 
    3.

这个看起来很简单的过程，其实在V8的内部实现起来比较复杂。

HandleScope

我们从创建一个HandleScope对象开始分析。HandleScope是负责管理多个Handle的对象，主要是为了方便管理Handle的分配和释放。

 
 
 
 
    
  
  
  
  
  1. class HandleScope { 
    2. 
  
  
  
  
  2.  public: 
    3. 
  
  
  
  
  3.   HandleScope() : previous_(current_), is_closed_(false) { 
    4. 
  
  
  
  
  4.     current_.extensions = 0; 
    5. 
  
  
  
  
  5.   } 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7.   static void** CreateHandle(void* value); 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.  private: 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.   class Data { 
    12. 
  
  
  
  
  12.    public: 
    13. 
  
  
  
  
  13.     // 分配了一块内存后，又额外分配的块数 
    14. 
  
  
  
  
  14.     int extensions; 
    15. 
  
  
  
  
  15.     // 下一个可用的位置 
    16. 
  
  
  
  
  16.     void** next; 
    17. 
  
  
  
  
  17.     // 达到limit执行的地址后说明当前内存块用完了 
    18. 
  
  
  
  
  18.     void** limit; 
    19. 
  
  
  
  
  19.     inline void Initialize() { 
    20. 
  
  
  
  
  20.       extensions = -1; 
    21. 
  
  
  
  
  21.       next = limit = NULL; 
    22. 
  
  
  
  
  22.     } 
    23. 
  
  
  
  
  23.   }; 
    24. 
  
  
  
  
  24.   // 当前的HandleScope 
    25. 
  
  
  
  
  25.   static Data current_; 
    26. 
  
  
  
  
  26.   // 上一个HandleScope 
    27. 
  
  
  
  
  27.   const Data previous_; 
    28. 
  
  
  
  
  28. }; 
    29. 
  
  
  
  
  29.  
    30. 
  
  
  
  
  30. HandleScope::Data HandleScope::current_ = { -1, NULL, NULL }; 
    31.

通过HandleScope的构造函数我们知道每次定义一个HandleScope对象的时候，previous就会指向前一个HandleScope的数据(但是current_除了第一次创建HandleScope的时候更新了(见CreateHandle)，后续似乎没有更新?后续详细看一下)，从HandleScope的定义中我们知道他的布局如下。

接着我们看HandleScope的CreateHandle方法。

 
 
 
 
    
  
  
  
  
  1. void** v8::HandleScope::CreateHandle(void* value) { 
    2. 
  
  
  
  
  2.   // 获取下一个可用的地址 
    3. 
  
  
  
  
  3.   void** result = current_.next; 
    4. 
  
  
  
  
  4.   // 到达limit的地址了或者为空（初始化的时候）则获取新的内存 
    5. 
  
  
  
  
  5.   if (result == current_.limit) { 
    6. 
  
  
  
  
  6.     // Block是二维数组，每个元素指向一个可以存储数据的数组。非空说明可能有可用的内存空间 
    7. 
  
  
  
  
  7.     if (!thread_local.Blocks()->is_empty()) { 
    8. 
  
  
  
  
  8.       // 拿到list中最后一个元素，得到一个数组首地址，然后再获取他的limit地址，即末地址 
    9. 
  
  
  
  
  9.       void** limit = &thread_local.Blocks()->last()[i::kHandleBlockSize]; 
    10. 
  
  
  
  
  10.       if (current_.limit != limit) { 
    11. 
  
  
  
  
  11.         current_.limit = limit; 
    12. 
  
  
  
  
  12.         // v8里少了这一句，看起来是需要修改result的值的 
    13. 
  
  
  
  
  13.         // result = limit - i::kHandleBlockSize;  
    14. 
  
  
  
  
  14.       } 
    15. 
  
  
  
  
  15.     } 
    16. 
  
  
  
  
  16.   } 
    17. 
  
  
  
  
  17.   // 下一个可用的地址 
    18. 
  
  
  
  
  18.   current_.next = result + 1; 
    19. 
  
  
  
  
  19.   *result = value; 
    20. 
  
  
  
  
  20.   return result; 
    21. 
  
  
  
  
  21. } 
    22.

我们看到CreateHandle会首先获取一片内存，然后把入参value的值保存到该内存中。

String::New

了解了HandleScope后，我们继续分析String::New。

 
 
 
 
    
  
  
  
  
  1. Local v8::String::New(const char* data, int length) { 
    2. 
  
  
  
  
  2.   i::Handle result = 
    3. 
  
  
  
  
  3.       i::Factory::NewStringFromUtf8(i::Vector(data, length)); 
    4. 
  
  
  
  
  4.   return Utils::ToLocal(result); 
    5. 
  
  
  
  
  5. } 
    6.

我们接着看NewStringFromUtf8。

 
 
 
 
    
  
  
  
  
  1. Handle Factory::NewStringFromUtf8(Vector string,PretenureFlag pretenure) { 
    2. 
  
  
  
  
  2.   CALL_HEAP_FUNCTION(Heap::AllocateStringFromUtf8(string,  
    3. 
  
  
  
  
  3.                     pretenure),  
    4. 
  
  
  
  
  4.                     String); 
    5. 
  
  
  
  
  5. } 
    6.

我们先看一下AllocateStringFromUtf8的实现，然后再看CALL_HEAP_FUNCTION。

 
 
 
 
    
  
  
  
  
  1. Object* Heap::AllocateStringFromUtf8(Vector string,PretenureFlag pretenure) { 
    2. 
  
  
  
  
  2.   return AllocateStringFromAscii(string, pretenure); 
    3. 
  
  
  
  
  3. } 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. Object* Heap::AllocateStringFromAscii(Vector string,PretenureFlag pretenure) { 
    6. 
  
  
  
  
  6.   // 从堆中分配一块内存 
    7. 
  
  
  
  
  7.   Object* result = AllocateRawAsciiString(string.length(), pretenure); 
    8. 
  
  
  
  
  8.   // 设置堆对象的内容 
    9. 
  
  
  
  
  9.   AsciiString* string_result = AsciiString::cast(result); 
    10. 
  
  
  
  
  10.   for (int i = 0; i < string.length(); i++) { 
    11. 
  
  
  
  
  11.     string_result->AsciiStringSet(i, string[i]); 
    12. 
  
  
  
  
  12.   } 
    13. 
  
  
  
  
  13.   return result; 
    14. 
  
  
  
  
  14. } 
    15.

我们看到AllocateStringFromUtf8最后返回了一个堆内存地址。接着我们看下CALL_HEAP_FUNCTION这个宏。

 
 
 
 
    
  
  
  
  
  1. #define CALL_HEAP_FUNCTION(FUNCTION_CALL, TYPE)         
    2. 
  
  
  
  
  2.   do {                  
    3. 
  
  
  
  
  3.     Object* __object__ = FUNCTION_CALL;                                       
    4. 
  
  
  
  
  4.     return Handle(TYPE::cast(__object__));    
    5. 
  
  
  
  
  5.   } while (false) 
    6.

CALL_HEAP_FUNCTION的作用是把函数FUNCTION_CALL执行的结果转成Handle对象。我们知道FUNCTION_CALL函数返回的结果是一个堆内存指针。接下来我们看看是如何转成Handle的。这个Handle不是我们在代码里使用的Handle。而是V8内部使用的Handle(代码在handles.h)，我们看看实现。

 
 
 
 
    
  
  
  
  
  1. template 
    2. 
  
  
  
  
  2. class Handle { 
    3. 
  
  
  
  
  3.  public: 
    4. 
  
  
  
  
  4.   explicit Handle(T* obj); 
    5. 
  
  
  
  
  5.  private: 
    6. 
  
  
  
  
  6.   T** location_; 
    7. 
  
  
  
  
  7. }; 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. template 
    10. 
  
  
  
  
  10. Handle::Handle(T* obj) { 
    11. 
  
  
  
  
  11.   location_ = reinterpret_cast(HandleScope::CreateHandle(obj)); 
    12. 
  
  
  
  
  12. } 
    13.

我们看到Handle内部使用的是T**二级指针，而我们刚才拿到堆内存地址是一级指针，自然不能直接赋值，而是通过CreateHandle又处理了一下。HandleScope::CreateHandle我们刚才已经分析过了。执行CreateHandle后布局如下。

所以NewStringFromUtf8最后返回了一个Handle对象(里面维护了一个二级指针location_)，接着V8调用Utils::ToLocal把他转成外部使用的Handle。接着赋值给Handle hello。这里的Handle是外部使用的Handle。

 
 
 
 
    
  
  
  
  
  1. Local Utils::ToLocal(v8::internal::Handle obj) {  
    2. 
  
  
  
  
  2.     return Local(reinterpret_cast(obj.location()));  
    3. 
  
  
  
  
  3. } 
    4.

首先通过obj.location()拿到一个二级指针。然后转成一个String *指针。接着构造一个Local对象。ToLocal是V8代码的分水岭，我们看看Local的定义。

 
 
 
 
    
  
  
  
  
  1. template  class Local : public Handle { 
    2. 
  
  
  
  
  2.  public: 
    3. 
  
  
  
  
  3.   template  inline Local(S* that) : Handle(that) { } 
    4. 
  
  
  
  
  4. }; 
    5.

直接调用Handle类的函数

 
 
 
 
    
  
  
  
  
  1. template  class Handle { 
    2. 
  
  
  
  
  2.   explicit Handle(T* val) : val_(val) { } 
    3. 
  
  
  
  
  3.   private: 
    4. 
  
  
  
  
  4.     T* val_; 
    5. 
  
  
  
  
  5. } 
    6.

这时候的结构图如下

 
 
 
 
    
  
  
  
  
  1. template  class Handle { 
    2. 
  
  
  
  
  2.   explicit Handle(T* val) : val_(val) { } 
    3. 
  
  
  
  
  3.   private: 
    4. 
  
  
  
  
  4.     T* val_; 
    5. 
  
  
  
  
  5. } 
    6.

所以最后通过ToLocal返回一个外部Handle对象给用户。当执行

 
 
 
 
    
  
  
  
  
  1. Local  xxx = Local对象 
    2.

时就会调用Local的拷贝函数。

 
 
 
 
    
  
  
  
  
  1. template   
    2. 
  
  
  
  
  2.       inline Local(Local that) 
    3. 
  
  
  
  
  3.       // *that即取得他底层对象的地址 
    4. 
  
  
  
  
  4.       : Handle(reinterpret_cast(*that)) {} 
    5.

我们首先看一下that。Handle类重载了运算符。

 
 
 
 
    
  
  
  
  
  1. template  
    2. 
  
  
  
  
  2. T* Handle::operator*() { 
    3. 
  
  
  
  
  3.   return val_; 
    4. 
  
  
  
  
  4. } 
    5.

所以reinterpret_cast(that)拿到了Handle底层指针的值并转成String 类型。接着执行

 
 
 
 
    
  
  
  
  
  1. explicit Handle(T* val) : val_(val) { } 
    2.

整个过程下来，其实就是把被复制对象的底层指针复制过来。=

通过Handle访问一个函数

当我们使用Handle hello这个对象的方法时是怎样的，比如hello->Length()。Handle重载了->运算符。

 
 
 
 
    
  
  
  
  
  1. template  
    2. 
  
  
  
  
  2. T* Handle::operator->() { 
    3. 
  
  
  
  
  3.   return val_; 
    4. 
  
  
  
  
  4. } 
    5.

我们看到执行hello->Length()的时候首先会拿到一个String *。然后调用Length方法。其实就是调用String对象(在v8.h中定义)的Length方法。我们看看Length方法的实现。

 
 
 
 
    
  
  
  
  
  1. int String::Length() { 
    2. 
  
  
  
  
  2.   return Utils::OpenHandle(this)->length(); 
    3. 
  
  
  
  
  3. } 
    4.

首先通过传入this调用OpenHandle拿到内部Handle。从前面的架构图中我们知道this(即val_和location_指向的值)本质上是一个String **，即二级指针。

 
 
 
 
    
  
  
  
  
  1. v8: :internal: :Handle < v8: :internal: :String >  
    2. 
  
  
  
  
  2. Utils: :OpenHandle(v8: :String * that) { 
    3. 
  
  
  
  
  3.     return v8: :internal: :Handle < v8: :internal: :String > (reinterpret_cast < v8: :internal: :String * *>(that)); 
    4. 
  
  
  
  
  4. } 
    5.

OpenHandle就是首先把外部的表示转成一个二级指针。然后再构造一个内部Handle。在内部Handle里保存了这个二级指针。接着访问这个Handle对象的length方法。而Handle重载了->运算符。

 
 
 
 
    
  
  
  
  
  1. INLINE(T* operator ->() const)  { return operator*(); } 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. template inline T* Handle::operator*() const { 
    4. 
  
  
  
  
  4.   return *location_; 
    5. 
  
  
  
  
  5. } 
    6.

我们看到->的操作最终会被解引用一次变成String *，然后访问函数length，也就是访问String对象的length函数。

后记：从上面的分析中我们不仅看到了Handle的实现原理，也看到了V8代码的一些设计细节，V8在内部实现了一类对象，然后把内部对象转成外部使用的类型后返回给用户，当用户使用该返回的对象时，V8又会转成内部的对象再操作这个对象。核心的数据结构是两个Handle族的类。因为他们是维护了真实对象的句柄。其他的一些类，比如String，同样分为外部和内部类，内部类是实现了String的细节，而外部类只是一个壳子，他负责给用户暴露API，而不负责实现细节，但用户操作这些类时，V8会会转成内部类再进行操作。外部类的定义在v8.h中，这是我们使用V8时需要了解的最好文档。内部类的实现根据版本不同而不同，比如早期版本都是在object.h里实现的，而实现内外部对象转换的方法在api.c中定义。

网页名称：通过Handle理解V8的代码设计（基于V0.1.5）
标题链接：http://www.36103.cn/qtweb/news43/7643.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

域名注册知识

各行业网站

绵阳电信机房　　 　四川绵阳主机托管　　 　成都小程序开发公司　　 　成都名片印刷　　 　东方电机技改服务有限公司　　 　腾讯云免备案空间　　 　界面设计　　 　成都微商城开发　　 　成都画册快印　　 　网络推广公司　　 　绵阳梓潼做网站　　 　成都网站设计　　 　成都网络推广　　 　网站seo　　 　成都封阳台　　 　雅安主机托管　　 　固迪佳新材料　　 　力比特机械　　 　成都外贸网站优化　　 　企业手机网站建设