深入理解Node.js的Asynchooks

虽然Async hooks至此还是实验性API，但是他的确可以解决应用中的一些问题，比如日志和调用栈跟踪。本文从应用和原理方便介绍一下Node.js的Async hooks。

大悟网站建设公司创新互联,大悟网站设计制作，有大型网站制作公司丰富经验。已为大悟千余家提供企业网站建设服务。企业网站搭建\成都外贸网站建设要多少钱，请找那个售后服务好的大悟做网站的公司定做！

1 env中的AsyncHooks

在Node.js的env对象中有一个AsyncHooks对象，负责Node.js进程中async_hooks的管理。我们看一下定义。

1.1 类定义

 
 
 
 
    
  
  
  
  
  1. class AsyncHooks : public MemoryRetainer { 
    2. 
  
  
  
  
  2.  public: 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.   enum Fields { 
    5. 
  
  
  
  
  5.     // 五种钩子 
    6. 
  
  
  
  
  6.     kInit, 
    7. 
  
  
  
  
  7.     kBefore, 
    8. 
  
  
  
  
  8.     kAfter, 
    9. 
  
  
  
  
  9.     kDestroy, 
    10. 
  
  
  
  
  10.     kPromiseResolve, 
    11. 
  
  
  
  
  11.     // 钩子总数 
    12. 
  
  
  
  
  12.     kTotals, 
    13. 
  
  
  
  
  13.     // async_hooks开启的个数 
    14. 
  
  
  
  
  14.     kCheck, 
    15. 
  
  
  
  
  15.     // 记录栈的top指针 
    16. 
  
  
  
  
  16.     kStackLength, 
    17. 
  
  
  
  
  17.     // 数组大小 
    18. 
  
  
  
  
  18.     kFieldsCount, 
    19. 
  
  
  
  
  19.   }; 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21.   enum UidFields { 
    22. 
  
  
  
  
  22.     kExecutionAsyncId, 
    23. 
  
  
  
  
  23.     kTriggerAsyncId, 
    24. 
  
  
  
  
  24.     // 当前async id的值 
    25. 
  
  
  
  
  25.     kAsyncIdCounter, 
    26. 
  
  
  
  
  26.     kDefaultTriggerAsyncId, 
    27. 
  
  
  
  
  27.     kUidFieldsCount, 
    28. 
  
  
  
  
  28.   }; 
    29. 
  
  
  
  
  29.  
    30. 
  
  
  
  
  30.  private: 
    31. 
  
  
  
  
  31.   inline AsyncHooks(); 
    32. 
  
  
  
  
  32.   // 异步资源的类型 
    33. 
  
  
  
  
  33.   std::array, AsyncWrap::PROVIDERS_LENGTH> providers_; 
    34. 
  
  
  
  
  34.   // 栈 
    35. 
  
  
  
  
  35.   AliasedFloat64Array async_ids_stack_; 
    36. 
  
  
  
  
  36.   // 整形数组，每个元素值的意义和Fields对应 
    37. 
  
  
  
  
  37.   AliasedUint32Array fields_; 
    38. 
  
  
  
  
  38.   // 整形数组，每个元素值的意义和UidFields对应 
    39. 
  
  
  
  
  39.   AliasedFloat64Array async_id_fields_; 
    40. 
  
  
  
  
  40. }; 
    41.

结构图如下

接下来看一下env的AsyncHooks对象提供了哪些API，这些API是上层的基础。

1.2 读API

我们看一下env对象中获取AsyncHooks对象对应字段的API。

 
 
 
 
    
  
  
  
  
  1. // 获取对应的字段 
    2. 
  
  
  
  
  2. inline AliasedUint32Array& AsyncHooks::fields() { 
    3. 
  
  
  
  
  3.   return fields_; 
    4. 
  
  
  
  
  4. } 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. inline AliasedFloat64Array& AsyncHooks::async_id_fields() { 
    7. 
  
  
  
  
  7.   return async_id_fields_; 
    8. 
  
  
  
  
  8. } 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. inline AliasedFloat64Array& AsyncHooks::async_ids_stack() { 
    11. 
  
  
  
  
  11.   return async_ids_stack_; 
    12. 
  
  
  
  
  12. } 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14. // 获取资源类型 
    15. 
  
  
  
  
  15. inline v8::Local AsyncHooks::provider_string(int idx) { 
    16. 
  
  
  
  
  16.   return providers_[idx].Get(env()->isolate()); 
    17. 
  
  
  
  
  17. } 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. // 新建资源的时候，获取新的async id 
    20. 
  
  
  
  
  20. inline double Environment::new_async_id() { 
    21. 
  
  
  
  
  21.   async_hooks()->async_id_fields()[AsyncHooks::kAsyncIdCounter] += 1; 
    22. 
  
  
  
  
  22.   return async_hooks()->async_id_fields()[AsyncHooks::kAsyncIdCounter]; 
    23. 
  
  
  
  
  23. } 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25. // 获取当前async id 
    26. 
  
  
  
  
  26. inline double Environment::execution_async_id() { 
    27. 
  
  
  
  
  27.   return async_hooks()->async_id_fields()[AsyncHooks::kExecutionAsyncId]; 
    28. 
  
  
  
  
  28. } 
    29. 
  
  
  
  
  29.  
    30. 
  
  
  
  
  30. // 获取当前trigger async id 
    31. 
  
  
  
  
  31. inline double Environment::trigger_async_id() { 
    32. 
  
  
  
  
  32.   return async_hooks()->async_id_fields()[AsyncHooks::kTriggerAsyncId]; 
    33. 
  
  
  
  
  33. } 
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35. // 获取默认的trigger async id，如果没有设置，则获取当前的async id 
    36. 
  
  
  
  
  36. inline double Environment::get_default_trigger_async_id() { 
    37. 
  
  
  
  
  37.   double default_trigger_async_id = async_hooks()->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId]; 
    38. 
  
  
  
  
  38.   // If defaultTriggerAsyncId isn't set, use the executionAsyncId 
    39. 
  
  
  
  
  39.   if (default_trigger_async_id < 0) 
    40. 
  
  
  
  
  40.     default_trigger_async_id = execution_async_id(); 
    41. 
  
  
  
  
  41.   return default_trigger_async_id; 
    42. 
  
  
  
  
  42. } 
    43.

1.3 写API

 
 
 
 
    
  
  
  
  
  1. inline void AsyncHooks::push_async_ids(double async_id, 
    2. 
  
  
  
  
  2.                                        double trigger_async_id) { 
    3. 
  
  
  
  
  3.   // 获取当前栈顶指针 
    4. 
  
  
  
  
  4.   uint32_t offset = fields_[kStackLength]; 
    5. 
  
  
  
  
  5.   // 不够则扩容 
    6. 
  
  
  
  
  6.   if (offset * 2 >= async_ids_stack_.Length()) 
    7. 
  
  
  
  
  7.     grow_async_ids_stack(); 
    8. 
  
  
  
  
  8.   // 把旧的上下文压栈   
    9. 
  
  
  
  
  9.   async_ids_stack_[2 * offset] = async_id_fields_[kExecutionAsyncId]; 
    10. 
  
  
  
  
  10.   async_ids_stack_[2 * offset + 1] = async_id_fields_[kTriggerAsyncId]; 
    11. 
  
  
  
  
  11.   // 栈指针加一 
    12. 
  
  
  
  
  12.   fields_[kStackLength] += 1; 
    13. 
  
  
  
  
  13.   // 记录当前上下文 
    14. 
  
  
  
  
  14.   async_id_fields_[kExecutionAsyncId] = async_id; 
    15. 
  
  
  
  
  15.   async_id_fields_[kTriggerAsyncId] = trigger_async_id; 
    16. 
  
  
  
  
  16. } 
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18. // 和上面的逻辑相反 
    19. 
  
  
  
  
  19. inline bool AsyncHooks::pop_async_id(double async_id) { 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21.   if (fields_[kStackLength] == 0) return false; 
    22. 
  
  
  
  
  22.   uint32_t offset = fields_[kStackLength] - 1; 
    23. 
  
  
  
  
  23.   async_id_fields_[kExecutionAsyncId] = async_ids_stack_[2 * offset]; 
    24. 
  
  
  
  
  24.   async_id_fields_[kTriggerAsyncId] = async_ids_stack_[2 * offset + 1]; 
    25. 
  
  
  
  
  25.   fields_[kStackLength] = offset; 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27.   return fields_[kStackLength] > 0; 
    28. 
  
  
  
  
  28. } 
    29.

2 底层资源封装类 - AsyncWrap

接着看一下异步资源的基类AsyncWrap。所有依赖于C、C++层实现的资源(比如TCP、UDP)都会继承AsyncWrap。看看该类的定义。

 
 
 
 
    
  
  
  
  
  1. class AsyncWrap : public BaseObject { 
    2. 
  
  
  
  
  2.  private: 
    3. 
  
  
  
  
  3.   ProviderType provider_type_ = PROVIDER_NONE; 
    4. 
  
  
  
  
  4.   double async_id_ = kInvalidAsyncId; 
    5. 
  
  
  
  
  5.   double trigger_async_id_; 
    6. 
  
  
  
  
  6. }; 
    7.

我们看到每个AsyncWrap对象都有async_id_、trigger_async_id_和provider_type_属性，这正是在init回调里拿到的数据。我们看看AsyncWrap的构造函数。接下来看一下新建一个资源(AsyncWrap)时的逻辑。

2.1 资源初始化

 
 
 
 
    
  
  
  
  
  1. AsyncWrap::AsyncWrap(Environment* env, 
    2. 
  
  
  
  
  2.                      Local object, 
  
  
  
  
  3.                      ProviderType provider, 
    4. 
  
  
  
  
  4.                      double execution_async_id, 
    5. 
  
  
  
  
  5.                      bool silent) 
    6. 
  
  
  
  
  6.     : AsyncWrap(env, object) { 
    7. 
  
  
  
  
  7.   // 资源类型 
    8. 
  
  
  
  
  8.   provider_type_ = provider; 
    9. 
  
  
  
  
  9.   AsyncReset(execution_async_id, silent); 
    10. 
  
  
  
  
  10. } 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12. void AsyncWrap::AsyncReset(Local resource, double execution_async_id, 
  
  
  
  
  13.                            bool silent) { 
    14. 
  
  
  
  
  14.   // 获取一个新的async id，execution_async_id默认是kInvalidAsyncId 
    15. 
  
  
  
  
  15.   async_id_ = execution_async_id == kInvalidAsyncId ? env()->new_async_id() 
    16. 
  
  
  
  
  16.                                                      : execution_async_id; 
    17. 
  
  
  
  
  17.   // 获取trigger async id                                                    
    18. 
  
  
  
  
  18.   trigger_async_id_ = env()->get_default_trigger_async_id(); 
    19. 
  
  
  
  
  19.   // 执行init钩子 
    20. 
  
  
  
  
  20.   EmitAsyncInit(env(), resource, 
    21. 
  
  
  
  
  21.                 env()->async_hooks()->provider_string(provider_type()), 
    22. 
  
  
  
  
  22.                 async_id_, trigger_async_id_); 
    23. 
  
  
  
  
  23. } 
    24. 
 
 
 
 
    接着看EmitAsyncInit
     
 
 
 
      
  
  
  
  
    1. void AsyncWrap::EmitAsyncInit(Environment* env, 
      2. 
  
  
  
  
    2.                               Local object, 
  
  
  
  
    3.                               Local type, 
      4. 
  
  
  
  
    4.                               double async_id, 
      5. 
  
  
  
  
    5.                               double trigger_async_id) { 
      6. 
  
  
  
  
    6.   AsyncHooks* async_hooks = env->async_hooks(); 
      7. 
  
  
  
  
    7.   HandleScope scope(env->isolate()); 
      8. 
  
  
  
  
    8.   Local init_fn = env->async_hooks_init_function(); 
      9. 
  
  
  
  
    9.  
      10. 
  
  
  
  
    10.   Local argv[] = { 
      11. 
  
  
  
  
    11.     Number::New(env->isolate(), async_id), 
      12. 
  
  
  
  
    12.     type, 
      13. 
  
  
  
  
    13.     Number::New(env->isolate(), trigger_async_id), 
      14. 
  
  
  
  
    14.     object, 
      15. 
  
  
  
  
    15.   }; 
      16. 
  
  
  
  
    16.  
      17. 
  
  
  
  
    17.   TryCatchScope try_catch(env, TryCatchScope::CatchMode::kFatal); 
      18. 
  
  
  
  
    18.   // 执行init回调 
      19. 
  
  
  
  
    19.   USE(init_fn->Call(env->context(), object, arraysize(argv), argv)); 
      20. 
  
  
  
  
    20. } 
      21. 
 
 
 
 
      那么env->async_hooks_init_function()的值是什么呢?这是在Node.js初始化时设置的。
       
 
 
 
        
  
  
  
  
      1. const { nativeHooks } = require('internal/async_hooks'); 
        2. 
  
  
  
  
      2. internalBinding('async_wrap').setupHooks(nativeHooks); 
        3. 
 
 
 
 
      SetupHooks的实现如下
       
 
 
 
        
  
  
  
  
      1. static void SetupHooks(const FunctionCallbackInfo& args) { 
        2. 
  
  
  
  
      2.  
        3. 
  
  
  
  
      3.   Environment* env = Environment::GetCurrent(args); 
        4. 
  
  
  
  
      4.   Local fn_obj = args[0].As();#define SET_HOOK_FN(name)                                                      \ 
  
  
  
  
      5.   do {                                                                         \ 
        6. 
  
  
  
  
      6.     Local v =                                                           \ 
        7. 
  
  
  
  
      7.         fn_obj->Get(env->context(),                                            \ 
        8. 
  
  
  
  
      8.                     FIXED_ONE_BYTE_STRING(env->isolate(), #name))              \ 
        9. 
  
  
  
  
      9.             .ToLocalChecked();                                                 \ 
        10. 
  
  
  
  
      10.     CHECK(v->IsFunction());                                                    \ 
        11. 
  
  
  
  
      11.     env->set_async_hooks_##name##_function(v.As());                  \ 
        12. 
  
  
  
  
      12.   } while (0) 
        13. 
  
  
  
  
      13.   // 保存到env中 
        14. 
  
  
  
  
      14.   SET_HOOK_FN(init); 
        15. 
  
  
  
  
      15.   SET_HOOK_FN(before); 
        16. 
  
  
  
  
      16.   SET_HOOK_FN(after); 
        17. 
  
  
  
  
      17.   SET_HOOK_FN(destroy); 
        18. 
  
  
  
  
      18.   SET_HOOK_FN(promise_resolve);#undef SET_HOOK_FN 
        19. 
  
  
  
  
      19. } 
        20. 
 
 
 
 
        nativeHooks的实现如下
         
 
 
 
          
  
  
  
  
        1. nativeHooks: { 
          2. 
  
  
  
  
        2.   init: emitInitNative, 
          3. 
  
  
  
  
        3.   before: emitBeforeNative, 
          4. 
  
  
  
  
        4.   after: emitAfterNative, 
          5. 
  
  
  
  
        5.   destroy: emitDestroyNative, 
          6. 
  
  
  
  
        6.   promise_resolve: emitPromiseResolveNative 
          7. 
  
  
  
  
        7. } 
          8. 
 
 
 
 
        这些Hooks会执行对应的回调，比如emitInitNative
         
 
 
 
          
  
  
  
  
        1. function emitInitNative(asyncId, type, triggerAsyncId, resource) { 
          2. 
  
  
  
  
        2.   for (var i = 0; i < active_hooks.array.length; i++) { 
          3. 
  
  
  
  
        3.       if (typeof active_hooks.array[i][init_symbol] === 'function') { 
          4. 
  
  
  
  
        4.         active_hooks.array[i][init_symbol]( 
          5. 
  
  
  
  
        5.           asyncId, type, triggerAsyncId, 
          6. 
  
  
  
  
        6.           resource 
          7. 
  
  
  
  
        7.         ); 
          8. 
  
  
  
  
        8.       } 
          9. 
  
  
  
  
        9.   } 
          10. 
  
  
  
  
        10. } 
          11. 
 
 
 
 
        active_hooks.array的值就是我们在业务代码里设置的钩子，每次调研createHooks的时候就对应数组的一个元素。
        2.2 执行资源回调
        

        当业务代码异步请求底层API，并且底层满足条件时，就会执行上层的回调，比如监听一个socket时，有连接到来。Node.js就会调用MakeCallback函数执行回调。
         
 
 
 
          
  
  
  
  
        1. MaybeLocal AsyncWrap::MakeCallback(const Local cb, 
          2. 
  
  
  
  
        2.                                           int argc, 
          3. 
  
  
  
  
        3.                                           Local* argv) { 
          4. 
  
  
  
  
        4.   // 当前AsyncWrap对象对应的执行上下文                              
          5. 
  
  
  
  
        5.   ProviderType provider = provider_type(); 
          6. 
  
  
  
  
        6.   async_context context { get_async_id(), get_trigger_async_id() }; 
          7. 
  
  
  
  
        7.   MaybeLocal ret = InternalMakeCallback(env(), object(), cb, argc, argv, context); 
          8. 
  
  
  
  
        8.  
          9. 
  
  
  
  
        9.   return ret; 
          10. 
  
  
  
  
        10. } 
          11. 
 
 
 
 
        MaybeLocal InternalMakeCallback(Environment* env, 
         
 
 
 
          
  
  
  
  
        1. MaybeLocal InternalMakeCallback(Environment* env, 
          2. 
  
  
  
  
        2.                                        Local recv, 
  
  
  
  
        3.                                        const Local callback, 
          4. 
  
  
  
  
        4.                                        int argc, 
          5. 
  
  
  
  
        5.                                        Local argv[], 
          6. 
  
  
  
  
        6.                                        async_context asyncContext) { 
          7. 
  
  
  
  
        7.   // 新建一个scope                                      
          8. 
  
  
  
  
        8.   InternalCallbackScope scope(env, recv, asyncContext); 
          9. 
  
  
  
  
        9.   // 执行回调 
          10. 
  
  
  
  
        10.   callback->Call(env->context(), recv, argc, argv); 
          11. 
  
  
  
  
        11.   // 关闭scope 
          12. 
  
  
  
  
        12.   scope.Close(); 
          13. 
  
  
  
  
        13. } 
          14. 
 
 
 
 
          我们看看新建和关闭scope都做了什么事情。
           
 
 
 
            
  
  
  
  
          1. InternalCallbackScope::InternalCallbackScope(Environment* env, 
            2. 
  
  
  
  
          2.                                              Local object, 
  
  
  
  
          3.                                              const async_context& asyncContext, 
            4. 
  
  
  
  
          4.                                              int flags) 
            5. 
  
  
  
  
          5.   : env_(env), 
            6. 
  
  
  
  
          6.     async_context_(asyncContext), 
            7. 
  
  
  
  
          7.     object_(object), 
            8. 
  
  
  
  
          8.     skip_hooks_(flags & kSkipAsyncHooks), 
            9. 
  
  
  
  
          9.     skip_task_queues_(flags & kSkipTaskQueues) { 
            10. 
  
  
  
  
          10.   // v14版本中，是先触发before再push上下文，顺序是不对的，v16已经改过来。 
            11. 
  
  
  
  
          11.   // 当前执行上下文入栈 
            12. 
  
  
  
  
          12.   env->async_hooks()->push_async_ids(async_context_.async_id, 
            13. 
  
  
  
  
          13.                                async_context_.trigger_async_id); 
            14. 
  
  
  
  
          14.   // 触发before钩子 
            15. 
  
  
  
  
          15.   if (asyncContext.async_id != 0 && !skip_hooks_) { 
            16. 
  
  
  
  
          16.     AsyncWrap::EmitBefore(env, asyncContext.async_id); 
            17. 
  
  
  
  
          17.   } 
            18. 
  
  
  
  
          18.  
            19. 
  
  
  
  
          19.   pushed_ids_ = true; 
            20. 
  
  
  
  
          20. } 
            21. 
 
 
 
 
            在scope里会把当前AsyncWrap对象的执行上下文作为当前执行上下文，并且触发before钩子，然后执行业务回调，所以我们在回调里获取当前执行上下文时就拿到了AsyncWrap对应的值( 调用executionAsyncId)，接着看Close
             
 
 
 
              
  
  
  
  
            1. void InternalCallbackScope::Close() { 
              2. 
  
  
  
  
            2.   // 执行 
              3. 
  
  
  
  
            3.   if (pushed_ids_) 
              4. 
  
  
  
  
            4.     env_->async_hooks()->pop_async_id(async_context_.async_id); 
              5. 
  
  
  
  
            5.  
              6. 
  
  
  
  
            6.   if (async_context_.async_id != 0 && !skip_hooks_) { 
              7. 
  
  
  
  
            7.     AsyncWrap::EmitAfter(env_, async_context_.async_id); 
              8. 
  
  
  
  
            8.   } 
              9. 
  
  
  
  
            9. } 
              10. 
 
 
 
 
            Close在执行回调后被调用，主要是恢复当前执行上下文并且触发after钩子。
            3 上层资源的封装 - Timeout、TickObjecd等
            

            并不是所有的异步资源都是底层实现的，比如定时器，tick也被定义为异步资源，因为他们都是和回调相关。这种异步资源是在JS层实现的，这里只分析Timeout。
            3.1 创建资源
            

            我们看一下执行setTimeout时的核心逻辑。
             
 
 
 
              
  
  
  
  
            1. function setTimeout(callback, after, arg1, arg2, arg3) { 
              2. 
  
  
  
  
            2.   const timeout = new Timeout(callback, after, args, false, true); 
              3. 
  
  
  
  
            3.   return timeout; 
              4. 
  
  
  
  
            4. } 
              5. 
  
  
  
  
            5.  
              6. 
  
  
  
  
            6. function Timeout(callback, after, args, isRepeat, isRefed) { 
              7. 
  
  
  
  
            7.   initAsyncResource(this, 'Timeout'); 
              8. 
  
  
  
  
            8. } 
              9. 
  
  
  
  
            9.  
              10. 
  
  
  
  
            10. function initAsyncResource(resource, type) { 
              11. 
  
  
  
  
            11.   // 获取新的async id 
              12. 
  
  
  
  
            12.   const asyncId = resource[async_id_symbol] = newAsyncId(); 
              13. 
  
  
  
  
            13.   const triggerAsyncId = resource[trigger_async_id_symbol] = getDefaultTriggerAsyncId(); 
              14. 
  
  
  
  
            14.   // 是否设置了init钩子，是则触发回调 
              15. 
  
  
  
  
            15.   if (initHooksExist()) 
              16. 
  
  
  
  
            16.     emitInit(asyncId, type, triggerAsyncId, resource); 
              17. 
  
  
  
  
            17. } 
              18. 
 
 
 
 
            执行setTimeout时，Node.js会创建一个Timeout对象，设置async_hooks相关的上下文并记录到Timeout对象中。然后触发init钩子。
             
 
 
 
              
  
  
  
  
            1. function emitInitScript(asyncId, type, triggerAsyncId, resource) { 
              2. 
  
  
  
  
            2.   emitInitNative(asyncId, type, triggerAsyncId, resource); 
              3. 
  
  
  
  
            3. } 
              4. 
 
 
 
 
            以上代码会执行每个async_hooks对象的init回调(通常我们只有一个async_hooks对象)。
            3.2执行回调
            

            当定时器到期时，会执行回调，我们看看相关的逻辑。
             
 
 
 
              
  
  
  
  
            1. // 触发before钩子 
              2. 
  
  
  
  
            2. emitBefore(asyncId, timer[trigger_async_id_symbol]); 
              3. 
  
  
  
  
            3. // 执行回调 
              4. 
  
  
  
  
            4. timer._onTimeout(); 
              5. 
  
  
  
  
            5. // 触发after回调emitAfter(asyncId); 
              6. 
 
 
 
 
            我们看到执行超时回调的前后会触发对应的钩子。
             
 
 
 
              
  
  
  
  
            1. function emitBeforeScript(asyncId, triggerAsyncId) { 
              2. 
  
  
  
  
            2.   // 和底层的push_async_ids逻辑一样 
              3. 
  
  
  
  
            3.   pushAsyncIds(asyncId, triggerAsyncId); 
              4. 
  
  
  
  
            4.   // 如果有回调则执行 
              5. 
  
  
  
  
            5.   if (async_hook_fields[kBefore] > 0) 
              6. 
  
  
  
  
            6.     emitBeforeNative(asyncId); 
              7. 
  
  
  
  
            7. } 
              8. 
  
  
  
  
            8.  
              9. 
  
  
  
  
            9. function emitAfterScript(asyncId) { 
              10. 
  
  
  
  
            10.   // 设置了after回调则emit 
              11. 
  
  
  
  
            11.   if (async_hook_fields[kAfter] > 0) 
              12. 
  
  
  
  
            12.     emitAfterNative(asyncId); 
              13. 
  
  
  
  
            13.   // 和底层的pop_async_ids逻辑一样 
              14. 
  
  
  
  
            14.   popAsyncIds(asyncId); 
              15. 
  
  
  
  
            15. } 
              16. 
 
 
 
 
            JS层的实现和底层是保持一致的。如果我们在setTimeout回调里新建一个资源，比如再次执行setTimeout，这时候trigger async id就是第一个setTimeout对应的async id，所以就连起来了，后面我们会看到具体的例子。
            4 DefaultTriggerAsyncIdScope
            

            Node.js为了避免过多通过参数传递的方式传递async id，就设计了DefaultTriggerAsyncIdScope。DefaultTriggerAsyncIdScope的作用类似在多个函数外维护一个变量，多个函数都可以通过DefaultTriggerAsyncIdScope获得trigger async id，而不需要通过层层传递的方式，他的实现非常简单。
             
 
 
 
              
  
  
  
  
            1. class DefaultTriggerAsyncIdScope { 
              2. 
  
  
  
  
            2.    private: 
              3. 
  
  
  
  
            3.     AsyncHooks* async_hooks_; 
              4. 
  
  
  
  
            4.     double old_default_trigger_async_id_; 
              5. 
  
  
  
  
            5. }; 
              6. 
  
  
  
  
            6.  
              7. 
  
  
  
  
            7. inline AsyncHooks::DefaultTriggerAsyncIdScope ::DefaultTriggerAsyncIdScope( 
              8. 
  
  
  
  
            8.     Environment* env, double default_trigger_async_id) 
              9. 
  
  
  
  
            9.     : async_hooks_(env->async_hooks()) { 
              10. 
  
  
  
  
            10.  
              11. 
  
  
  
  
            11.   // 记录旧的id，设置新的id 
              12. 
  
  
  
  
            12.   old_default_trigger_async_id_ = 
              13. 
  
  
  
  
            13.     async_hooks_->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId]; 
              14. 
  
  
  
  
            14.   async_hooks_->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId] = 
              15. 
  
  
  
  
            15.     default_trigger_async_id; 
              16. 
  
  
  
  
            16. } 
              17. 
  
  
  
  
            17.  
              18. 
  
  
  
  
            18. // 恢复 
              19. 
  
  
  
  
            19. inline AsyncHooks::DefaultTriggerAsyncIdScope ::~DefaultTriggerAsyncIdScope() { 
              20. 
  
  
  
  
            20.   async_hooks_->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId] = 
              21. 
  
  
  
  
            21.     old_default_trigger_async_id_; 
              22. 
  
  
  
  
            22. } 
              23. 
 
 
 
 
            DefaultTriggerAsyncIdScope主要是记录旧的id，然后把新的id设置到env中，当其他函数调用get_default_trigger_async_id时就可以获取设置的async id。同样JS层也实现了类似的API。
             
 
 
 
              
  
  
  
  
            1. function defaultTriggerAsyncIdScope(triggerAsyncId, block, ...args) { 
              2. 
  
  
  
  
            2.   const oldDefaultTriggerAsyncId = async_id_fields[kDefaultTriggerAsyncId]; 
              3. 
  
  
  
  
            3.   async_id_fields[kDefaultTriggerAsyncId] = triggerAsyncId; 
              4. 
  
  
  
  
            4.  
              5. 
  
  
  
  
            5.   try { 
              6. 
  
  
  
  
            6.     return block(...args); 
              7. 
  
  
  
  
            7.   } finally { 
              8. 
  
  
  
  
            8.     async_id_fields[kDefaultTriggerAsyncId] = oldDefaultTriggerAsyncId; 
              9. 
  
  
  
  
            9.   } 
              10. 
  
  
  
  
            10. } 
              11. 
 
 
 
 
            在执行block函数时，可以获取到设置的值，而不需要传递，执行完block后恢复。我们看看如何使用。下面摘自net模块的代码。
             
 
 
 
              
  
  
  
  
            1. // 获取handle里的async id 
              2. 
  
  
  
  
            2. this[async_id_symbol] = getNewAsyncId(this._handle); 
              3. 
  
  
  
  
            3. defaultTriggerAsyncIdScope(this[async_id_symbol], 
              4. 
  
  
  
  
            4.                              process.nextTick, 
              5. 
  
  
  
  
            5.                              emitListeningNT, 
              6. 
  
  
  
  
            6.                              this); 
              7. 
 
 
 
 
            我们看一下这里具体的情况。在defaultTriggerAsyncIdScope中会以emitListeningNT为入参执行process.nextTick。我们看看nextTick的实现。
             
 
 
 
              
  
  
  
  
            1. function nextTick(callback) { 
              2. 
  
  
  
  
            2.   // 获取新的async id 
              3. 
  
  
  
  
            3.   const asyncId = newAsyncId(); 
              4. 
  
  
  
  
            4.   // 获取默认的trigger async id，即刚才设置的 
              5. 
  
  
  
  
            5.   const triggerAsyncId = getDefaultTriggerAsyncId(); 
              6. 
  
  
  
  
            6.   const tickObject = { 
              7. 
  
  
  
  
            7.     [async_id_symbol]: asyncId, 
              8. 
  
  
  
  
            8.     [trigger_async_id_symbol]: triggerAsyncId, 
              9. 
  
  
  
  
            9.     callback, 
              10. 
  
  
  
  
            10.     args 
              11. 
  
  
  
  
            11.   }; 
              12. 
  
  
  
  
            12.   if (initHooksExist()) 
              13. 
  
  
  
  
            13.     // 创建了新的资源，触发init钩子 
              14. 
  
  
  
  
            14.     emitInit(asyncId, 'TickObject', triggerAsyncId, tickObject); 
              15. 
  
  
  
  
            15.   queue.push(tickObject); 
              16. 
  
  
  
  
            16. } 
              17. 
 
 
 
 
            我们看到在nextTick中通过getDefaultTriggerAsyncId拿到了trigger async id。
             
 
 
 
              
  
  
  
  
            1. function getDefaultTriggerAsyncId() { 
              2. 
  
  
  
  
            2.   const defaultTriggerAsyncId = async_id_fields[kDefaultTriggerAsyncId]; 
              3. 
  
  
  
  
            3.   if (defaultTriggerAsyncId < 0) 
              4. 
  
  
  
  
            4.     return async_id_fields[kExecutionAsyncId]; 
              5. 
  
  
  
  
            5.   return defaultTriggerAsyncId; 
              6. 
  
  
  
  
            6. } 
              7. 
 
 
 
 
            getDefaultTriggerAsyncId返回的就是刚才通过defaultTriggerAsyncIdScope设置的async id。所以在触发TickObject的init钩子时用户就可以拿到对应的id。不过更重要的时，在异步执行nextTick的任务时，还可以拿到原始的trigger async id。因为该id记录在tickObject中。我们看看执行tick任务时的逻辑。
             
 
 
 
              
  
  
  
  
            1. function processTicksAndRejections() { 
              2. 
  
  
  
  
            2.   let tock; 
              3. 
  
  
  
  
            3.   do { 
              4. 
  
  
  
  
            4.     while (tock = queue.shift()) { 
              5. 
  
  
  
  
            5.       // 拿到对应的async 上下文 
              6. 
  
  
  
  
            6.       const asyncId = tock[async_id_symbol]; 
              7. 
  
  
  
  
            7.       emitBefore(asyncId, tock[trigger_async_id_symbol]); 
              8. 
  
  
  
  
            8.       try { 
              9. 
  
  
  
  
            9.         const callback = tock.callback; 
              10. 
  
  
  
  
            10.         callback(); 
              11. 
  
  
  
  
            11.       } finally { 
              12. 
  
  
  
  
            12.         if (destroyHooksExist()) 
              13. 
  
  
  
  
            13.           emitDestroy(asyncId); 
              14. 
  
  
  
  
            14.       } 
              15. 
  
  
  
  
            15.       emitAfter(asyncId); 
              16. 
  
  
  
  
            16.     } 
              17. 
  
  
  
  
            17.   } while (!queue.isEmpty() || processPromiseRejections()); 
              18. 
  
  
  
  
            18. } 
              19. 
 
 
 
 
            

            5 资源销毁
            

            资源销毁的时候也会触发对应的钩子，不过不同的是这个钩子是异步触发的。无论是JS还是好C++层触发销毁钩子的时候，逻辑都是一致的。
             
 
 
 
              
  
  
  
  
            1. void AsyncWrap::EmitDestroy(Environment* env, double async_id) { 
              2. 
  
  
  
  
            2.   // 之前为空则设置回调 
              3. 
  
  
  
  
            3.   if (env->destroy_async_id_list()->empty()) { 
              4. 
  
  
  
  
            4.     env->SetUnrefImmediate(&DestroyAsyncIdsCallback); 
              5. 
  
  
  
  
            5.   } 
              6. 
  
  
  
  
            6.   // async id入队 
              7. 
  
  
  
  
            7.   env->destroy_async_id_list()->push_back(async_id); 
              8. 
  
  
  
  
            8. } 
              9. 
  
  
  
  
            9.  
              10. 
  
  
  
  
            10. template void Environment::SetUnrefImmediate(Fn&& cb) { 
              11. 
  
  
  
  
            11.   CreateImmediate(std::move(cb), false); 
              12. 
  
  
  
  
            12. } 
              13. 
  
  
  
  
            13.  
              14. 
  
  
  
  
            14. template void Environment::CreateImmediate(Fn&& cb, bool ref) { 
              15. 
  
  
  
  
            15.   auto callback = std::make_unique>( 
              16. 
  
  
  
  
            16.       std::move(cb), ref); 
              17. 
  
  
  
  
            17.   // 加入任务队列     
              18. 
  
  
  
  
            18.   native_immediates_.Push(std::move(callback)); 
              19. 
  
  
  
  
            19. } 
              20. 
 
 
 
 
            在事件循环的check阶段就会执行里面的任务，从而执行回调DestroyAsyncIdsCallback。
             
 
 
 
              
  
  
  
  
            1. void AsyncWrap::DestroyAsyncIdsCallback(Environment* env) { 
              2. 
  
  
  
  
            2.   Local fn = env->async_hooks_destroy_function(); 
              3. 
  
  
  
  
            3.   do { 
              4. 
  
  
  
  
            4.     std::vector destroy_async_id_list; 
              5. 
  
  
  
  
            5.     destroy_async_id_list.swap(*env->destroy_async_id_list()); 
              6. 
  
  
  
  
            6.     // 遍历销毁的async id 
              7. 
  
  
  
  
            7.     for (auto async_id : destroy_async_id_list) { 
              8. 
  
  
  
  
            8.       HandleScope scope(env->isolate()); 
              9. 
  
  
  
  
            9.       Local async_id_value = Number::New(env->isolate(), async_id); 
              10. 
  
  
  
  
            10.       // 执行JS层回调 
              11. 
  
  
  
  
            11.       MaybeLocal ret = fn->Call(env->context(), Undefined(env->isolate()), 1, &async_id_value); 
              12. 
  
  
  
  
            12.     } 
              13. 
  
  
  
  
            13.   } while (!env->destroy_async_id_list()->empty()); 
              14. 
  
  
  
  
            14. } 
              15. 
 
 
 
 
            

            6 Async hooks的使用
            

            我们通常以以下方式使用Async hooks
             
 
 
 
              
  
  
  
  
            1. const async_hooks = require('async_hooks'); 
              2. 
  
  
  
  
            2. async_hooks.createHook({ 
              3. 
  
  
  
  
            3.   init(asyncId, type, triggerAsyncId) {}, 
              4. 
  
  
  
  
            4.   before(asyncId) {}, 
              5. 
  
  
  
  
            5.   after(asyncId) {}, 
              6. 
  
  
  
  
            6.   destroy(asyncId) {}, 
              7. 
  
  
  
  
            7.   promiseResolve(asyncId), 
              8. 
  
  
  
  
            8. }).enable(); 
              9. 
 
 
 
 
            async_hooks是对资源生命周期的抽象，资源就是操作对象和回调的抽象。async_hooks定义了五个生命周期钩子，当资源的状态到达某个周期节点时，async_hooks就会触发对应的钩子。下面我们看一下具体的实现。我们首先看一下createHook。
             
 
 
 
              
  
  
  
  
            1. function createHook(fns) { 
              2. 
  
  
  
  
            2.   return new AsyncHook(fns); 
              3. 
  
  
  
  
            3. } 
              4. 
 
 
 
 
            createHook是对AsyncHook的封装
             
 
 
 
              
  
  
  
  
            1. class AsyncHook { 
              2. 
  
  
  
  
            2.   constructor({ init, before, after, destroy, promiseResolve }) { 
              3. 
  
  
  
  
            3.     // 记录回调 
              4. 
  
  
  
  
            4.     this[init_symbol] = init; 
              5. 
  
  
  
  
            5.     this[before_symbol] = before; 
              6. 
  
  
  
  
            6.     this[after_symbol] = after; 
              7. 
  
  
  
  
            7.     this[destroy_symbol] = destroy; 
              8. 
  
  
  
  
            8.     this[promise_resolve_symbol] = promiseResolve; 
              9. 
  
  
  
  
            9.   } 
              10. 
  
  
  
  
            10. } 
              11. 
 
 
 
 
            AsyncHook的初始化很简单，创建一个AsyncHook对象记录回调函数。创建了AsyncHook之后，我们需要调用AsyncHook的enable函数手动开启。
             
 
 
 
              
  
  
  
  
            1. class AsyncHook { 
              2. 
  
  
  
  
            2.   enable() { 
              3. 
  
  
  
  
            3.     // 获取一个AsyncHook对象数组和一个整形数组 
              4. 
  
  
  
  
            4.     const [hooks_array, hook_fields] = getHookArrays(); 
              5. 
  
  
  
  
            5.     // 执行过enable了则不需要再执行 
              6. 
  
  
  
  
            6.     if (hooks_array.includes(this)) 
              7. 
  
  
  
  
            7.       return this; 
              8. 
  
  
  
  
            8.     // 做些统计 
              9. 
  
  
  
  
            9.     const prev_kTotals = hook_fields[kTotals]; 
              10. 
  
  
  
  
            10.     hook_fields[kTotals] = hook_fields[kInit] += +!!this[init_symbol]; 
              11. 
  
  
  
  
            11.     hook_fields[kTotals] += hook_fields[kBefore] += +!!this[before_symbol]; 
              12. 
  
  
  
  
            12.     hook_fields[kTotals] += hook_fields[kAfter] += +!!this[after_symbol]; 
              13. 
  
  
  
  
            13.     hook_fields[kTotals] += hook_fields[kDestroy] += +!!this[destroy_symbol]; 
              14. 
  
  
  
  
            14.     hook_fields[kTotals] += 
              15. 
  
  
  
  
            15.         hook_fields[kPromiseResolve] += +!!this[promise_resolve_symbol]; 
              16. 
  
  
  
  
            16.     // 当前对象插入数组中 
              17. 
  
  
  
  
            17.     hooks_array.push(this); 
              18. 
  
  
  
  
            18.     // 如果之前的数量是0，本次操作后大于0则开启底层的逻辑 
              19. 
  
  
  
  
            19.     if (prev_kTotals === 0 && hook_fields[kTotals] > 0) { 
              20. 
  
  
  
  
            20.       enableHooks(); 
              21. 
  
  
  
  
            21.     } 
              22. 
  
  
  
  
            22.  
              23. 
  
  
  
  
            23.     return this; 
              24. 
  
  
  
  
            24.   } 
              25. 
  
  
  
  
            25. } 
              26. 
 
 
 
 
            1 hooks_array：是一个AsyncHook对象数组，主要用于记录用户创建了哪些AsyncHook对象，然后哪些AsyncHook对象里都设置了哪些钩子，在回调的时候就会遍历这个对象数组，执行里面的回调。
            2 hook_fields：对应底层的async_hook_fields。
            3 enableHooks：
             
 
 
 
              
  
  
  
  
            1. function enableHooks() { 
              2. 
  
  
  
  
            2.   // 记录async_hooks的开启个数 
              3. 
  
  
  
  
            3.   async_hook_fields[kCheck] += 1; 
              4. 
  
  
  
  
            4. } 
              5. 
 
 
 
 
            至此，async_hooks的初始化就完成了，我们发现逻辑非常简单。下面我们看一下他是如何串起来的。下面我们以TCP模块为例。
             
 
 
 
              
  
  
  
  
            1. const { createHook, executionAsyncId } = require('async_hooks'); 
              2. 
  
  
  
  
            2. const fs = require('fs'); 
              3. 
  
  
  
  
            3. const net = require('net'); 
              4. 
  
  
  
  
            4. createHook({ 
              5. 
  
  
  
  
            5.   init(asyncId, type, triggerAsyncId) { 
              6. 
  
  
  
  
            6.     fs.writeSync( 
              7. 
  
  
  
  
            7.       1, 
              8. 
  
  
  
  
            8.       `${type}(${asyncId}): trigger: ${triggerAsyncId} execution: ${executionAsyncId()}\n`); 
              9. 
  
  
  
  
            9.   }}).enable(); 
              10. 
  
  
  
  
            10.  
              11. 
  
  
  
  
            11. net.createServer((conn) => {}).listen(8080); 
              12. 
 
 
 
 
            以上代码输出
             
 
 
 
              
  
  
  
  
            1. init: type: TCPSERVERWRAP asyncId: 2 trigger id: 1 executionAsyncId(): 1 triggerAsyncId(): 0 
              2. 
  
  
  
  
            2. init: type: TickObject asyncId: 3 trigger id: 2 executionAsyncId(): 1 triggerAsyncId(): 0 
              3. 
  
  
  
  
            3. before: asyncId: 3 executionAsyncId(): 3 triggerAsyncId(): 2 
              4. 
  
  
  
  
            4. after: asyncId: 3 executionAsyncId(): 3 triggerAsyncId(): 2 
              5. 
 
 
 
 
            下面我们来分析具体过程。我们知道创建资源的时候会执行init回调，具体逻辑在listen函数中，在listen函数中，通过层层调用会执行new TCP新建一个对象，表示服务器。TCP是C++层导出的类，刚才我们说过，TCP会继承AsyncWrap，新建AsyncWrap对象的时候会触发init钩子，结构图如下。
            对应输出
             
 
 
 
              
  
  
  
  
            1. init: type: TCPSERVERWRAP asyncId: 2 trigger id: 1 executionAsyncId(): 1 triggerAsyncId(): 0 
              2. 
 
 
 
 
            那TickObject是怎么来的呢?我们接着看listen里的另一段逻辑。
             
 
 
 
              
  
  
  
  
            1. this[async_id_symbol] = getNewAsyncId(this._handle); 
              2. 
  
  
  
  
            2. defaultTriggerAsyncIdScope(this[async_id_symbol], 
              3. 
  
  
  
  
            3.                            process.nextTick, 
              4. 
  
  
  
  
            4.                            emitListeningNT, 
              5. 
  
  
  
  
            5.                            this); 
              6. 
 
 
 
 
            上面的代码我们刚才已经分析过，在执行process.nextTick的时候会创建一个TickObject对象封装执行上下文和回调。
             
 
 
 
              
  
  
  
  
            1. const asyncId = newAsyncId(); 
              2. 
  
  
  
  
            2. const triggerAsyncId = getDefaultTriggerAsyncId(); 
              3. 
  
  
  
  
            3. const tickObject = { 
              4. 
  
  
  
  
            4.   [async_id_symbol]: asyncId, 
              5. 
  
  
  
  
            5.   [trigger_async_id_symbol]: triggerAsyncId, 
              6. 
  
  
  
  
            6.   callback, 
              7. 
  
  
  
  
            7.   args 
              8. 
  
  
  
  
            8. }; 
              9. 
  
  
  
  
            9. emitInit(asyncId, 'TickObject', triggerAsyncId, tickObject); 
              10. 
 
 
 
 
            emitInit(asyncId, 'TickObject', triggerAsyncId, tickObject);
            这次再次触发了init钩子，结构如下(nextTick通过getDefaultTriggerAsyncId获取的id是defaultTriggerAsyncIdScope设置的id)。
            对应输出
             
 
 
 
              
  
  
  
  
            1. init: type: TickObject asyncId: 3 trigger id: 2 executionAsyncId(): 1 triggerAsyncId(): 0 
              2. 
 
 
 
 
            接着执行tick任务。
             
 
 
 
              
  
  
  
  
            1. const asyncId = tock[async_id_symbol]; 
              2. 
  
  
  
  
            2. emitBefore(asyncId, tock[trigger_async_id_symbol]); 
              3. 
  
  
  
  
            3. try { 
              4. 
  
  
  
  
            4.   tock.callback(); 
              5. 
  
  
  
  
            5. } finally { 
              6. 
  
  
  
  
            6.   if (destroyHooksExist()) 
              7. 
  
  
  
  
            7.     emitDestroy(asyncId); 
              8. 
  
  
  
  
            8. } 
              9. 
  
  
  
  
            9. emitAfter(asyncId); 
              10. 
 
 
 
 
            emitBefore时，结构图如下。
            对应输出
             
 
 
 
              
  
  
  
  
            1. before: asyncId: 3 executionAsyncId(): 3 triggerAsyncId(): 2 
              2. 
  
  
  
  
            2. after: asyncId: 3 executionAsyncId(): 3 triggerAsyncId(): 2 
              3. 
 
 
 
 
            执行完我们的JS代码后，所有入栈的上下文都会被清空，结构图如下。
            如果这时候有一个连接            
            
                文章名称：深入理解Node.js的Asynchooks
                
            
                当前URL：http://www.shufengxianlan.com/qtweb/news0/285400.html
            
            
            
            
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
            
            
            
                广告
                
            
            
            
            
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联
            
            
        
        
            
            
            猜你还喜欢下面的内容
            
            
        
            
    
    
            
        
            
            
            网站改版知识
            
            
        
            
        
            
            
            同城分类信息
            
            
        
            
    
            


            
    
            
        成都网站建设　　 　成都响应式网站建设公司　　 　网站建设推广　　 　网站制作　　 　成都网络公司　　 　成都网站建设公司　　 　网站营销推广　　 　专业网站设计　　 　自贡网站建设　　 　成都网站建设公司　　 　广汉锦华　　 　响应式网站设计　　 　无边发光字厂家　　 　西部信息服务器托管　　 　边坡柔性防护网　　 　成都网站排名　　 　高县网站建设　　 　江安网站建设　　 　娃娃鱼鱼苗　　 　橡塑板