先說結論，V8引擎在預設Platform中初始化的這個執行緒是用於處理類似於setTimeout的延時任務。
另外附一些圖，包括繼承樹、關鍵屬性歸屬、純邏輯工作流程，對程式碼木得興趣的看完圖可以X掉了。
上一篇講了V8初始化預設Platform物件時會做三件事，其中生成空白DefaultPlatform、獲取執行緒池大小已經講過了，剩下執行緒啟動相關的內容。
寫之前花了10幾分鐘學了下mac下C++的執行緒，對API有一個初步瞭解，給一個簡單的例子，大概流程如下。
// V8原始碼中設定的stack_size 在測試demo中不好使 const int stack_size = 1 * 1024 * 512; int tmp = 0; // 執行緒的任務 引數來源於建立時的第四個引數 void* add(void* number){ tmp = tmp + *(int*)number; printf("tmp: %i\n", tmp); return nullptr; }; int main(int argc, const char * argv[]) { // 建立執行緒物件 pthread_t pt; // 建立執行緒屬性 pthread_attr_t attr; memset(&attr, 0, sizeof(attr)); pthread_attr_init(&attr); // 設定屬性的size pthread_attr_setstacksize(&attr, stack_size); // 函式引數 int num = 5; int* ptr = # // 生成一個執行緒 // 引數列表參照各個變數 int ret = pthread_create(&pt, &attr, add, ptr); if(ret != 0) printf("cannot create thread"); return 0; }
通過幾個步驟，就可以建立一條執行緒來處理任務，啟動後的輸出就懶得截圖了，反正就是列印一個5。
有了上面的例子，可以慢慢來看V8初始化時多執行緒的啟動過程，首先是入門方法。
// 3 void DefaultPlatform::EnsureBackgroundTaskRunnerInitialized() { // 這裡初始化DefaultPlatform的屬性 需要加鎖 base::MutexGuard guard(&lock_); if (!worker_threads_task_runner_) { worker_threads_task_runner_ = // 3-2 std::make_shared<DefaultWorkerThreadsTaskRunner>( thread_pool_size_, time_function_for_testing_ ? time_function_for_testing_ // 3-1 : DefaultTimeFunction); } } // 3-1 double DefaultTimeFunction() { return base::TimeTicks::HighResolutionNow().ToInternalValue() / static_cast<double>(base::Time::kMicrosecondsPerSecond); }
if中的worker_threads_task_runner是DefaultPlatform的私有屬性，由於初始化時預設值為NULL，這裡做一個定義賦值。第一個引數是在第二步獲取的執行緒池大小，第二個引數是一個計數方法，預設引用之前Time模組裡的東西，返回硬體時間戳，具體實現可以看我之前寫的。
接下來看DefaultWorkerThreadsTaskRunner類的建構函式，接受2個引數。
// 3-2 // queue_ => DelayedTaskQueue::DelayedTaskQueue(TimeFunction time_function) : time_function_(time_function) {} DefaultWorkerThreadsTaskRunner::DefaultWorkerThreadsTaskRunner( uint32_t thread_pool_size, TimeFunction time_function) : queue_(time_function), time_function_(time_function), thread_pool_size_(thread_pool_size) { for (uint32_t i = 0; i < thread_pool_size; ++i) { // 3-3 thread_pool_.push_back(base::make_unique<WorkerThread>(this)); } }
用2個引數初始化了3個屬性，並且根據size往執行緒池中新增執行緒，thread_pool_這個屬性用vector在管理，push_back相當於JS的push，當成陣列來理解就行了。
新增的WorkerThread類是在DefaultWorkerThreadsTaskRunner裡面的一個私有內部類，繼承於Thread，單純的用來管理執行緒。C++的this比較簡單，沒有JS那麼多概念，就是一個指向當前物件的指標，來看一下執行緒類的建構函式。
// 3-3 DefaultWorkerThreadsTaskRunner::WorkerThread::WorkerThread(DefaultWorkerThreadsTaskRunner* runner) // 這裡呼叫父類建構函式 : Thread(Options("V8 DefaultWorkerThreadsTaskRunner WorkerThread")), // 這裡初始化當前類屬性 runner_(runner) { // 3-4 Start(); }
這裡同時呼叫了父類建構函式並初始化本身的屬性，runner就是上面那個物件本身。這個建構函式長得比較奇怪，其中Options類是Thread的內部類，有一個接受一個型別為字串的建構函式，而Thread的建構函式只接受Options型別，所以會這樣，程式碼如下。
class Thread { public: // Opaque data type for thread-local storage keys. using LocalStorageKey = int32_t; class Options { public: Options() : name_("v8:<unknown>"), stack_size_(0) {} explicit Options(const char* name, int stack_size = 0) : name_(name), stack_size_(stack_size) {} // ... }; // Create new thread. explicit Thread(const Options& options); // ... }
可以簡單理解這裡給執行緒取了一個名字，在給Options命名的同時，其實也給Thread命名了，如下。
Thread::Thread(const Options& options) : data_(new PlatformData), stack_size_(options.stack_size()), start_semaphore_(nullptr) { if (stack_size_ > 0 && static_cast<size_t>(stack_size_) < PTHREAD_STACK_MIN) { stack_size_ = PTHREAD_STACK_MIN; } set_name(options.name()); } class Thread { // The thread name length is limited to 16 based on Linux's implementation of // prctl(). static const int kMaxThreadNameLength = 16; char name_[kMaxThreadNameLength]; } void Thread::set_name(const char* name) { // 這裡的長度被限制在16以內 strncpy(name_, name, sizeof(name_)); name_[sizeof(name_) - 1] = '\0'; }
看註釋說，由於Linux的prctl方法限制了長度，所以這裡的name也最多隻能儲存16位，而且C++的字串的最後一位還要留給結束符，所以理論上傳入Options的超長字串
"V8 DefaultWorkerThreadsTaskRunner WorkerThread"只有前15位作為Thread的name儲存下來了，也就是"V8 Defaultworke"，非常戲劇性的把r給砍掉了。。。
初始化完成後，會呼叫Start方法啟動執行緒，這個方法並不需要子類實現，而是基類已經定義好了，保留關鍵程式碼如下。
// 3-4 void Thread::Start() { int result; // 執行緒物件 pthread_attr_t attr; memset(&attr, 0, sizeof(attr)); // 初始化執行緒物件 result = pthread_attr_init(&attr); size_t stack_size = stack_size_; if (stack_size == 0) { stack_size = 1 * 1024 * 1024; } if (stack_size > 0) { // 設定執行緒物件屬性 result = pthread_attr_setstacksize(&attr, stack_size); } { // 建立一個新執行緒 // 3-5 result = pthread_create(&data_->thread_, &attr, ThreadEntry, this); } // 摧毀執行緒物件 result = pthread_attr_destroy(&attr); }
參照一下文章開始的demo，可以看出去掉了合法性檢測和巨集之後，在初始化和啟動執行緒基本上V8的形式是一樣的。
簡單總結一下，V8初始化了一個DefaultPlatform類，計算了一下可用執行緒池大小，生成了幾條執行緒弄進執行緒池，而每條執行緒的任務就是那個ThreadEntry，這篇全部寫完算了。
這個方法賊麻煩。
// 3-5 static void* ThreadEntry(void* arg) { Thread* thread = reinterpret_cast<Thread*>(arg); // We take the lock here to make sure that pthread_create finished first since // we don't know which thread will run first (the original thread or the new // one). { MutexGuard lock_guard(&thread->data()->thread_creation_mutex_); } // 3-6 SetThreadName(thread->name()); // 3-7 thread->NotifyStartedAndRun(); return nullptr; }
由於執行緒任務的引數定義與返回值都是void*，這裡直接做一個強轉。隨後會加一個執行緒鎖，因為這幾個執行緒在初始化的時候並不需要同時執行這個任務。執行的第一個方法雖然從名字來看只是簡單的給執行緒設定名字，但是內容卻不簡單。
傳入SetThreadName方法的引數是之前那個被截斷的字串，看一下這個方法。
// 3-6 static void SetThreadName(const char* name) { // pthread_setname_np is only available in 10.6 or later, so test // for it at runtime. int (*dynamic_pthread_setname_np)(const char*); // 讀取動態連結庫 *reinterpret_cast<void**>(&dynamic_pthread_setname_np) = dlsym(RTLD_DEFAULT, "pthread_setname_np"); if (dynamic_pthread_setname_np == nullptr) return; // Mac OS X does not expose the length limit of the name, so hardcode it. static const int kMaxNameLength = 63; // 從讀取到的方法處理name dynamic_pthread_setname_np(name); }
裡面用了一個很玄的api的叫dlsym，官方解釋如下。
The function dlsym() takes a "handle" of a dynamic library returned by dlopen() and the null-terminated symbol name, returning the address where that symbol is loaded into memory.
大概就是根據控制程式碼讀取一個動態連結庫，名字就是那個字串，返回其在記憶體中的地址，所以這塊的除錯全是機器碼，根本看不懂，最後返回的一個函式。
知道這是個函式就行了，至於怎麼設定執行緒名字我也不太想知道。
第二步的方法名就是執行執行緒的任務，呼叫鏈比較長，會來回在幾個類之間穿梭，呼叫各自屬性的方法。
// 3-7 void NotifyStartedAndRun() { if (start_semaphore_) start_semaphore_->Signal(); // 3-8 Run(); } // 3-8 void DefaultWorkerThreadsTaskRunner::WorkerThread::Run() { runner_->single_worker_thread_id_.store(base::OS::GetCurrentThreadId(), std::memory_order_relaxed); // 3-9 while (std::unique_ptr<Task> task = runner_->GetNext()) { // 每一個task會實現自己的run函式 task->Run(); } } // 3-9 std::unique_ptr<Task> DefaultWorkerThreadsTaskRunner::GetNext() { // 3-10 return queue_.GetNext(); }
不理清楚，這個地方真的很麻煩，繞得很，可以看頂部的繼承圖。總之，最後呼叫的是DefaultWorkerThreadsTaskRunner類上一個型別為DelayedTaskQueue類的GetNext方法，返回型別是Task類，V8只是簡單定義了一個基類，實際執行時的所以task都需要繼承這個類並實現其Run方法以便執行緒執行。
最後的最後，GetNext的邏輯其實可以參考libuv的邏輯，機制都大同小異，方法的原始碼如下。
// 3-10 std::unique_ptr<Task> DelayedTaskQueue::GetNext() { base::MutexGuard guard(&lock_); for (;;) { /** * 這一片內容完全可以參考libuv事件輪詢的前兩步 * 1、從DelayQueue佇列中依次取出超過指定時間的task * 2、將所有超時的task放到task_queue_佇列中 * 3、從task_queue_中將task依次取出並返回 * 4、外部會呼叫task的Run方法並重復呼叫該函式 */ double now = MonotonicallyIncreasingTime(); std::unique_ptr<Task> task = PopTaskFromDelayedQueue(now); while (task) { task_queue_.push(std::move(task)); task = PopTaskFromDelayedQueue(now); } if (!task_queue_.empty()) { std::unique_ptr<Task> result = std::move(task_queue_.front()); task_queue_.pop(); return result; } if (terminated_) { queues_condition_var_.NotifyAll(); return nullptr; } /** * 1、當task_queue_佇列沒有task需要處理 但是delay_task_queue_有待處理task * 這裡會計算當前佇列中延遲task中最近的觸發時間 等待對應的時間再次觸發 * 2、當兩個佇列都沒有需要的事件 * 執行緒會直接休眠等待喚醒 */ if (task_queue_.empty() && !delayed_task_queue_.empty()) { double wait_in_seconds = delayed_task_queue_.begin()->first - now; base::TimeDelta wait_delta = base::TimeDelta::FromMicroseconds(base::TimeConstants::kMicrosecondsPerSecond * wait_in_seconds); bool notified = queues_condition_var_.WaitFor(&lock_, wait_delta); USE(notified); } else { queues_condition_var_.Wait(&lock_); } } }
哎……V8引擎不過如此。