int main(int argc, char* argv[]) {

  // Initialize V8.

  // 这个方法在mac不作为

  v8::V8::InitializeICUDefaultLocation(argv[]);

  // 读取指定名称的配置文件 也不用鸟

  v8::V8::InitializeExternalStartupData(argv[]);

  // 生成一个默认的platform对象

  std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();

  // 初始化刚才的platform

  v8::V8::InitializePlatform(platform.get());

  // V8的初始化

  v8::V8::Initialize();

  // ...

}

/**

 * V8 Platform abstraction layer.

 *

 * The embedder has to provide an implementation of this interface before

 * initializing the rest of V8.

 */

class Platform {};

class DefaultPlatform : public Platform {

  public:

    // 接受一个枚举值、一个TracingController类的构造函数

    explicit DefaultPlatform(

      IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled,

      std::unique_ptr<v8::TracingController> tracing_controller = {});

    ~DefaultPlatform() override;

    // 设置线程池大小

    void SetThreadPoolSize(int thread_pool_size);

    // 初始化线程池、管理线程任务相关的方法

    void EnsureBackgroundTaskRunnerInitialized();

  private:

    // 最大线程池数量 默认为8

    static const int kMaxThreadPoolSize;

    int thread_pool_size_;

    IdleTaskSupport idle_task_support_;

    // 线程任务启动器

    std::shared_ptr<DefaultWorkerThreadsTaskRunner> worker_threads_task_runner_;

    // 工具类

    std::unique_ptr<TracingController> tracing_controller_;

    std::unique_ptr<PageAllocator> page_allocator_;

    // 计数方法 用的是之前介绍的Time模块

    TimeFunction time_function_for_testing_;

};

/**

 * V8 Tracing controller.

 *

 * Can be implemented by an embedder to record trace events from V8.

 */

class TracingController {};

/**

 * A V8 memory page allocator.

 *

 * Can be implemented by an embedder to manage large host OS allocations.

 */

class PageAllocator {};

// Thread

//

// Thread objects are used for creating and running threads. When the start()

// method is called the new thread starts running the run() method in the new

// thread. The Thread object should not be deallocated before the thread has

// terminated.

class V8_BASE_EXPORT Thread {

  public:

    // Start new thread by calling the Run() method on the new thread.

    void Start();

    // ...

};

/**

 * A TaskRunner allows scheduling of tasks. The TaskRunner may still be used to

 * post tasks after the isolate gets destructed, but these tasks may not get

 * executed anymore. All tasks posted to a given TaskRunner will be invoked in

 * sequence. Tasks can be posted from any thread.

 */

class TaskRunner {};

class DefaultWorkerThreadsTaskRunner : public TaskRunner {

  public:

    using TimeFunction = double (*)();

    DefaultWorkerThreadsTaskRunner(uint32_t thread_pool_size, TimeFunction time_function);

  private:

    class WorkerThread : public Thread {

    public:

      explicit WorkerThread(DefaultWorkerThreadsTaskRunner* runner);

      ~WorkerThread() override;

      // This thread attempts to get tasks in a loop from |runner_| and run them.

      void Run() override;

    private:

      DefaultWorkerThreadsTaskRunner* runner_;

    };

    // 获取下一个task

    std::unique_ptr<Task> GetNext();

    bool terminated_ = false;

    // task队列

    DelayedTaskQueue queue_;

    // 线程池

    std::vector<std::unique_ptr<WorkerThread>> thread_pool_;

    // 计数方法

    TimeFunction time_function_;

    std::atomic_int single_worker_thread_id_{};

    uint32_t thread_pool_size_;

};

/**

 * A Task represents a unit of work.

 */

class Task {

 public:

  virtual ~Task() = default;

  // 所有的task需要继承这个类并实现Run方法

  virtual void Run() = ;

};

class userTask : public Task {

  public:

    void Run() {

      // do something...

    };

};

void handleTask() {

  // 新建一个task

  auto task = new userTask();

  // 加入队列

  queue_.push_back(task);

  // 唤醒线程

  thread_.signal();

  // 线程处理task

  while(true) {

    if(queue_.empty()) break;

    auto task = queue_pop_back();

    task->Run();

  }

  // 线程等待唤醒

  thread_.wait();

}