NodeJS Architecture - I/O

Sdílet
Vložit
  • čas přidán 7. 06. 2024
  • Node is a non-blocking Javascript runtime. You can concurrently run an HTTP Server, read files from disk, send UDP datagrams, accept TCP connections from clients and still have room to execute Javascript code operations without blocking. Most of these operations are known as I/O, you send an input to a device, file or a socket and it replies back with an output. Node achieves non-blocking I/O with mostly a single thread executed asynchronously using a library called lib_uv.
    The exception being DNS queries, which use a thread pool. This means when you use fetch or axios to make an HTTP request to a domain, the DNS resolution for that domain will most probably go through the thread pool, while the actual request itself will be sent asynchronously on the main thread.
    In this episode of the backend engineering show I go through an article I wrote discussing NodeJS Asynchronous I/O.
    / when-nodejs-i-o-blocks
    Learn the fundamentals of network engineering, get my udemy course
    network.husseinnasser.com
    0:00 Intro
    3:00 Part 1 Socket/IO
    9:48 Part 2 File I/O
    12:42 Part 3 DNS
    16:22 Part 4 NodeJS Single Threaded
    19:10 Part 5 NodeJS Thread Pool
    21:23 Part 6 DNS lookup bottleneck in Node
    Fundamentals of Networking for Effective Backends udemy course (link redirects to udemy with coupon)
    network.husseinnasser.com
    Fundamentals of Database Engineering udemy course (link redirects to udemy with coupon)
    database.husseinnasser.com
    Introduction to NGINX (link redirects to udemy with coupon)
    nginx.husseinnasser.com
    Python on the Backend (link redirects to udemy with coupon)
    python.husseinnasser.com
    Become a Member on CZcams
    / @hnasr
    Buy me a coffee if you liked this
    www.buymeacoffee.com/hnasr
    Arabic Software Engineering Channel
    / @husseinnasser
    🔥 Members Only Content
    • Members-only videos
    🏭 Backend Engineering Videos in Order
    backend.husseinnasser.com
    💾 Database Engineering Videos
    • Database Engineering
    🎙️Listen to the Backend Engineering Podcast
    husseinnasser.com/podcast
    Gears and tools used on the Channel (affiliates)
    🖼️ Slides and Thumbnail Design
    Canva
    partner.canva.com/c/2766475/6...
    Stay Awesome,
    Hussein
  • Věda a technologie

Komentáře • 28

  • @dog4ik
    @dog4ik Před rokem +34

    I was always wondering how single threaded js backends can accept so many concurrent connections. Great article!

    • @333ruka
      @333ruka Před rokem +2

      remember event loop ?

  • @sandeepparmar3113
    @sandeepparmar3113 Před rokem

    Really Intringing , Changed my perspective of NodeJS. And as alwyas great content.

  • @juhairahamed5342
    @juhairahamed5342 Před 3 měsíci

    Thanks. I taken your udemy course. Excellent discussion on database.. Now onward u you are a role model related to software area

  • @timibolu
    @timibolu Před rokem

    Thank you very much. This is very valuable information.

  • @biplobmanna
    @biplobmanna Před rokem +2

    Very informative, but now I have more questions about how the underlying syscalls work. Time to dive into the rabbit hole.

  • @nadaquever5161
    @nadaquever5161 Před rokem

    tyvm mr. nasser. kickass content

  • @abbasramees4238
    @abbasramees4238 Před rokem +1

    I read that async operations like network request and async file reading are executed once the stack is empty, so, until then, where are these async operations stored? did Node use any queue data structure for that

  • @mahedihassanshawon4821

    Thanks! for these contents

  • @IgorRoztr
    @IgorRoztr Před rokem

    Love these deeep dives ;)

  • @wrlee
    @wrlee Před rokem +1

    The definition of "blocking" is not simply semantics, it's a matter of stratifying the kinds of blocking you are talking about. Simply stated, blocking is when the application's execution is waiting for something to happen. Waiting for the kernel to transfer a buffer to app/user space is quite different than waiting for data to appear on a socket, but both are "blocking," at different _layers_-the former is more local while the later is dependent on external activity. We might even describe the wait for a CPU instruction to complete to be blocking-a hyper-local form of blocking. So we can analyze blocking by looking at the system architecture and what the application is waiting on: user, internet network (and other non-deterministic external systems), infrastructure architecture (e.g., external storage vs internal storage), operating system, bus architecture, CPU. The solution for mitigating blocking effects on applications depends on the solutions to circumventing delays between and within those layers.

  • @juhairahamed5342
    @juhairahamed5342 Před 3 měsíci

    good explanation

  • @toritsejuFO
    @toritsejuFO Před 3 měsíci

    Good stuff.

  • @shivraj1459
    @shivraj1459 Před rokem +1

    super helpful following you since I discovered you .Can you please make a video about auth server and resource server relating to your recent linkedIn post?

  • @isurucumaranathunga
    @isurucumaranathunga Před rokem

    Really Really Really appreciate your effort and thank you so much for this valuable content Hussein. I love you content so much. Hussein what about the Vert.x library in JAVA. It is also using this asynchronous processing using a concept called verticles and event bus. I highly appreciate if you could do a content on that also. Looking forward for another great content like this. Thanks

  • @coderkashif
    @coderkashif Před 3 měsíci

    Great

  • @elakstein
    @elakstein Před rokem

    If you are doing cpu intensive task then it will block other tasks as everything is running on a single thread.
    Let's say you do a math heavy calculation and it takes 3 seconds to complete. Then your application will be blocked for those 3 seconds and it won't be able to do anything else.
    In cases like this, multi threaded application will do better, as these type of computation you can do in a separate thread.

  • @CamaradaArdi
    @CamaradaArdi Před rokem

    Where do the quotes come from? I've done a google search and I got no results aside from your post

    • @muhammedkadirtan3469
      @muhammedkadirtan3469 Před rokem

      they are meant to emphasize that paragraph contains additional information

  • @tenthlegionstudios1343
    @tenthlegionstudios1343 Před rokem +8

    Great video. A more in depth video on this I found useful was by Kprotty about Zig's IO. He goes super deep into all of this, and does an iceberg on concurrent models and IO. Very cool. ScyllaDB is at the bottom of this iceberg. It also goes in depth into rust tokio and GOs IO model. And it expands a lot on IOuring. Also Bun (competitor to node) basically just uses KProttys implementation of IO to greatly outperform node. Bun uses zig under the hood and is basically rewriting the parts of node that interact with the OS kernel. Link Here: czcams.com/video/Ul8OO4vQMTw/video.html

  • @aliadel1723
    @aliadel1723 Před 8 měsíci

    Node can be multithreaded with the worker thread. or am I wrong?

    • @yusufmirkar6508
      @yusufmirkar6508 Před 4 měsíci

      for very simple compute, it is single-threaded. for async io / dns etc mentioned in this video, nodejs is multi threaded