深入V8引擎-初始化Platform之mac篇(1)

int main(int argc, char* argv[]) {
  // Initialize V8.
  // 这个方法在mac不作为
  v8::V8::InitializeICUDefaultLocation(argv[0]);
  // 读取指定名称的配置文件 也不用鸟
  v8::V8::InitializeExternalStartupData(argv[0]);
  // 生成一个默认的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_{0};
    uint32_t thread_pool_size_;
};

/**
 * A Task represents a unit of work.
 */
class Task {
 public:
  virtual ~Task() = default;
  // 所有的task需要继承这个类并实现Run方法
  virtual void Run() = 0;
};

class userTask : public Task {
  public:
    void Run() {
      // do something...
    };
};

void handleTash() {
  // 新建一个task
  auto task = new userTask();
  // 加入队列
  queue_.push_back(task);
  // 唤醒线程
  thread_.signal();
  // 线程处理task
  auto task = queue_pop_back();
  task -> Run();
  // 线程等待唤醒
  thread_.wait();
}