Node.js子线程调试和诊断指南

调试、诊断子线程最直接的方式就是像调试、诊断主线程一样，但是无论是动态开启还是静态开启，子线程都不可避免地需要内置一些相关的非业务代码，本文介绍另外一种对子线程代码无侵入的调试方式，另外也介绍一下通过子线程调试主线程的方式。

1.初始化子线程的Inspector

在Node.js启动子线程的时候，会初始化Inspector。

env_->InitializeInspector(std::move(inspector_parent_handle_)); 

在分析InitializeInspector之前，我们先看一下inspector_parent_handle_。

std::unique_ptr inspector_parent_handle_; 

inspector_parent_handle_是一个ParentInspectorHandle对象，这个对象是子线程和主线程通信的桥梁。我们看一下他的初始化逻辑(在主线程里执行)。

inspector_parent_handle_ = env->inspector_agent()->GetParentHandle(thread_id_, url); 

调用agent的GetParentHandle获取一个ParentInspectorHandle对象。

std::unique_ptr Agent::GetParentHandle(int thread_id, const std::string& url) { 
 return client_->getWorkerManager()->NewParentHandle(thread_id, url); 
} 

内部其实是通过client_->getWorkerManager()对象的NewParentHandle方法获取ParentInspectorHandle对象，接下来我们看一下WorkerManager的NewParentHandle。

std::unique_ptr WorkerManager::NewParentHandle(int thread_id, const std::string& url) { 
  bool wait = !delegates_waiting_on_start_.empty(); 
  return std::make_unique(thread_id, url, thread_, wait); 
} 
 
ParentInspectorHandle::ParentInspectorHandle( 
    int id, const std::string& url, 
    std::shared_ptr parent_thread,  
    bool wait_for_connect 
) 
    : id_(id),  
      url_(url),  
      parent_thread_(parent_thread), 
      wait_(wait_for_connect) {} 

最终的架构图如下入所示。

分析完ParentInspectorHandle后继续看一下env_->InitializeInspector(std::move(inspector_parent_handle_))的逻辑(在子线程里执行)。

int Environment::InitializeInspector( 
    std::unique_ptr parent_handle) { 
 
  std::string inspector_path; 
  inspector_path = parent_handle->url(); 
  inspector_agent_->SetParentHandle(std::move(parent_handle)); 
  inspector_agent_->Start(inspector_path, 
                          options_->debug_options(), 
                          inspector_host_port(), 
                          is_main_thread()); 
} 

首先把ParentInspectorHandle对象保存到agent中，然后调用agent的Start方法。

bool Agent::Start(...) { 
    // 新建client对象 
   client_ = std::make_shared(parent_env_, is_main); 
   // 调用agent中保存的ParentInspectorHandle对象的WorkerStarted 
   parent_handle_->WorkerStarted(client_->getThreadHandle(), ...); 
} 

Agent::Start创建了一个client对象，然后调用ParentInspectorHandle对象的WorkerStarted方法(刚才SetParentHandle的时候保存的)，我们看一下这时候的架构图。

接着看parent_handle_->WorkerStarted。

void ParentInspectorHandle::WorkerStarted( 
    std::shared_ptr worker_thread, bool waiting) { 
  std::unique_ptr request( 
      new WorkerStartedRequest(id_, url_, worker_thread, waiting)); 
  parent_thread_->Post(std::move(request)); 
} 

WorkerStarted创建了一个WorkerStartedRequest请求，然后通过parent_thread_->Post提交，parent_thread_是MainThreadInterface对象。

void MainThreadInterface::Post(std::unique_ptr request) { 
  Mutex::ScopedLock scoped_lock(requests_lock_); 
  // 之前是空则需要唤醒消费者 
  bool needs_notify = requests_.empty(); 
  // 消息入队 
  requests_.push_back(std::move(request)); 
  if (needs_notify) { 
       // 获取当前对象的一个弱引用 
       std::weak_ptr* interface_ptr = new std::weak_ptr(shared_from_this()); 
      // 请求V8执行RequestInterrupt入参对应的回调 
      isolate_->RequestInterrupt([](v8::Isolate* isolate, void* opaque) { 
        // 把执行时传入的参数转成MainThreadInterface 
        std::unique_ptr> interface_ptr { 
          static_cast*>(opaque)  
        }; 
        // 判断对象是否还有效，是则调用DispatchMessages 
        if (auto iface = interface_ptr->lock()) iface->DispatchMessages(); 
 
      }, static_cast(interface_ptr)); 
  } 
  // 唤醒消费者 
  incoming_message_cond_.Broadcast(scoped_lock); 
} 

我们看看这时候的架构图。

接着看回调里执行MainThreadInterface对象DispatchMessages方法的逻辑。

void MainThreadInterface::DispatchMessages() { 
  // 遍历请求队列 
  requests_.swap(dispatching_message_queue_); 
  while (!dispatching_message_queue_.empty()) { 
    MessageQueue::value_type task; 
    std::swap(dispatching_message_queue_.front(), task); 
    dispatching_message_queue_.pop_front(); 
    // 执行任务函数 
    task->Call(this); 
  } 
} 

task是WorkerStartedRequest对象，看一下Call方法的代码。

void Call(MainThreadInterface* thread) override { 
  auto manager = thread->inspector_agent()->GetWorkerManager(); 
  manager->WorkerStarted(id_, info_, waiting_); 
} 

接着调用agent的WorkerManager的WorkerStarted。

void WorkerManager::WorkerStarted(int session_id, 
                                  const WorkerInfo& info, 
                                  bool waiting) { 
  children_.emplace(session_id, info); 
  for (const auto& delegate : delegates_) { 
    Report(delegate.second, info, waiting); 
  } 
} 

WorkerStarted记录了一个id和上下文，因为delegates_初始化的时候是空的，所以不会执行。至此，子线程Inspector初始化的逻辑就分析完了，结构图如下。

我们发现，和主线程不一样，主线程会启动一个WebSocket服务器接收客户端的连接请求，而子线程只是初始化了一些数据结构。下面我们看一下基于这些数据结构，主线程是如何动态开启调试子线程的。

2.主线程开启调试子线程的能力

我们可以以以下方式开启对子线程的调试。

const { Worker, workerData } = require('worker_threads'); 
const { Session } = require('inspector'); 
// 新建一个新的通信通道 
const session = new Session(); 
session.connect(); 
// 创建子线程 
const worker = new Worker('./httpServer.js', {workerData: {port: 80}});  
// 子线程启动成功后开启调试子线程的能力 
worker.on('online', () => { 
    session.post("NodeWorker.enable", 
                 {waitForDebuggerOnStart: false},   
                 (err) => {   
                    err && console.log("NodeWorker.enable", err); 
                 }); 
    }); 
// 防止主线程退出 
setInterval(() => {}, 100000); 

我们先来分析一下connect函数的逻辑。

connect() { 
    this[connectionSymbol] = new Connection((message) => this[onMessageSymbol](message)); 
} 

新建了一个Connection对象并传入一个回调函数，该回调函数在收到消息时被回调。Connection是C++层导出的对象，由模版类JSBindingsConnection实现。

template  
class JSBindingsConnection {} 

我们看看导出的路逻辑。

JSBindingsConnection<Connection>::Bind(env, target); 

接着看Bind。

static void Bind(Environment* env, Local