Node erklärt die Prozessanalyse der Ausführung von js

Der Inhalt dieses Artikels besteht darin, Ihnen die Analyse des Prozesses der Knotenerklärung und -ausführung von js mitzuteilen. Interessierte Freunde können einen Blick darauf werfen, und Freunde in Not können sich auch darauf beziehen

Erklärung : Knoten ist Single-Threaded, ereignisgesteuert (ähnlich wie udev-Ereignisse im Kernel, Sie können sich auf den Listening-Callback-Mechanismus beziehen)

Nehmen Sie hauptsächlich node-v8.10.0 als Objekt src/node_main.cc und src/node.cc Dokument.

1. Entrance
   node-v8.10.0/src/node_main.cc --> 90 int main(int argc, char *argv[])
   Call node::Start( argc, argv);
   node-v8.10.0/src/node.cc --> 4863 int Start(int argc, char** argv)
   a: 4864 atexit([] () { uv_tty_reset_mode( ); });
   # Führen Sie die anonyme Funktion nach der Ausführung von *.js aus, die tatsächlich uv_tty_reset_mode() ausführt.
   b: 4865 PlatformInit();
   # Führen Sie die Inline-Funktion PlatformInit() aus, signalisieren Sie Volume Verarbeitung der Funktionsregistrierung
   c: 4866 node::performance::performance_node_start = PERFORMANCE_NOW();
   Kapselung der uv_hrtime-Funktion: src/node_perf_common.h:13:#define PERFORMANCE_NOW() uv_hrtime()
   Exportdefinition: deps/uv/include/uv.h:1457:UV_EXTERN uint64_t uv_hrtime(void);
   Implementierung: deps/uv/src/unix/core.c:111:uint64_t uv_hrtime(void)
   uv_hrtime ruft uv__hrtime Definition: deps/uv/src/unix/internal.h:252:uint64_t uv__hrtime(uv_clocktype_t type);
   Implementierung: deps/uv/src/unix/linux-core.c:442:uint64_t uv__hrtime( UV_ClockType_t Typ) {
   Kurz gesagt: Notieren Sie den Startzeitpunkt der Knotenausführung*.js-Skript. Zeichnen Sie ähnlich den Startzeitpunkt des V8 auf:
   4903 node :: performance :: Performance_v8_Start = Performance_now (); d: 4868 CHECK_GT(argc, 0);
   src/util.h:129:#define CHECK_GT(a, b) CHECK((a) > (b))
   e : 4871 argv = uv_setup_args (argc, argv);
   Definition: DEPS/UV/Include/UV.H: 1051: UV_EXTERN CHAR ** UV_Setup_ARGS (InT ARGC, CHAR ** ARGV); 877 Init(&argc, const_cast< const char**>(argv), &exec_argc, &exec_argv);
   4542 void Init(int* argc,
   4543 const char** argv,
   4544 int* exec_argc,
   4545 const char *** exec_argv) {
   4617 ProcessArgv(argc, argv, exec_argc, exec_argv);
   4502 ParseArgs(arg c, argv, exec_argc, exec_argv, &v8_argc, &v8_argv, is_env);
   4015 static void. Parse Argumente (int* argc,
   Parse-Parameter
   g: OpenSSL-bezogene Konfiguration
   h: 4895 v8_platform.Initialize(v8_thread_pool_size, uv_default_loop());
   i: 4902 V8::Initialize ();
   v8-Initialisierung
   j: 4905 const int exit_code =
   4906 Start(uv_default_loop(), argc, argv, exec_argc, exec_argv);
   k: Exit
   4908 v8_platform.StopTracingAgent ();
   4910 v8_initialized = false;
   4911 V8::Dispose();
   4919 v8_platform.Dispose();
   4921 delete[] exec_argv;
   4922 exec_argv = nullptr;
   4924 return exit_code ;
   2. Analyse von Teil j in 1
   a: 4814 inline int Start(uv_loop_t* event_loop,
   4815 int argc, const char* const* argv,
             4816 &   ner(OnMessage);
             4829   isolieren- >SetAbortOnUncaughtExceptionCallback(ShouldAbortOnUncaughtException);
             4830   Isolate->SetAutorunMicrotasks(false);
             4831   Isolate->SetFatalErrorHandler(OnFatalError);
              new Isolate对象，并设置相关参数.
         c: 4843   int exit_code;
             4844   {
             4845     Locker locker(isolate);
             4846     Isolate::Scope isolate_scope(isolate);
            4847     HandleScope handle_scope(isolate);
             4848     IsolateData isolate_data(isolate , event_loop, allocator.zero_fill_field());
             4849     exit_code = Start(isolate, &isolate_data, argc, argv, exec_argc, exec_argv);
             4850   }
               准备开始执行的参数，isolate对象.
         d:  4745 inline int Start(Isolate* isolate, IsolateData* isolate_data,
             4746                 int argc, const char* const* argv,
             4747                  int exec_argc, const char* const* exec_argv) {
         e:环境准备
               4748   HandleScope handle_scope(isolate);
               4749   Local context = Context::New(isolate);
               4750   Context::Scope context_scope(context);
               4751   Environment env(isolate_data, context);
               4754   env.Start(argc, argv, exec_ argc, exec_argv , v8_is_profiling) v
         f:  在d中的函数里面进行eventloop，没有event的时候，就会退出node
   
   3.  分析核心部分
           4777   {
           4778     SealHandleScope seal(isolate);
           4779     bool more;
           4780 PERFORMANCE_MARK(&env, LOOP_START);
           4781     do {
           4782       uv_run(env.event_loop(), UV_RUN_DEFAULT);
           4783
           4784       v8_platform.DrainVMTasks();
           4785
           4786 more = uv_loop_alive(env.event_loop());
           4787       if (more)
           4788         continue;
           4789
           4790      Exit(&env);
           4791
           4792       // Emit ` beforeExit`, wenn die Schleife entweder nach der Ausgabe aktiv wurde
   4793 // Ereignis oder nach dem Ausführen einiger Rückrufe.
   4794 more = uv_loop_alive(env.event_loop()); // Ermitteln Sie erneut, ob es Ereignisse gibt, die nicht verarbeitet wurden. Einige asynchrone Vorgänge verfügen möglicherweise über Rückruffunktionen.
   4795 } while (more == true);
   4796 PERFORMANCE_MARK(&env, LOOP_EXIT); // Wenn keine Ereignisverarbeitung erfolgt, beenden.
   4797 🎜> a: Die Kernfunktion uv_run zur Verarbeitung von Ereignissen
   Deklaration: deps/uv/include/uv.h:281:UV_EXTERN int uv_run(uv_loop_t*, uv_run_mode mode);
   Implementierung: de PS /uv/src/unix/core.c:348:int uv_run(uv_loop_t* loop, uv_run_mode mode) {
   b: Bestimmen Sie, ob sich die Schleife im aktiven Zustand befindet: ob ein Handle vorhanden ist, Anforderungssignal und der Griff ist nicht geschlossen.
   343 int uv_loop_alive(const uv_loop_t* loop) {
   344 return uv__loop_alive(loop);
   345 }
   336 static int uv__loop_alive( const uv_loop_t* loop) {
   337 return uv__has_active_handles(loop ) ||
   338 uv__has_active_reqs(loop) ||
   339 loop->closing_handles != NULL;
   340 }
   c: uv__has_active_handles(loop):
   deps/uv/src/ uv-common.h: 145: #define uv__has_active_handles (Loop)
   129 #define UV__Has_Active_Reqs (Loop)) == 0)
   
   
   
   
   

Das obige ist der detaillierte Inhalt vonNode erklärt die Prozessanalyse der Ausführung von js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!