Node Js Non-blocking or asynchronous Blocking or synchronous.pdf

N ODE. J S
Node Js: Non-blocking or asynchronous | Blocking or
synchronous
CronJ, 4 years ago 19 min read

🔊Listen to Post
Node.js is a server-side scripting language based on Google’s V8 Javascript engine. Node js is a single-threaded and highly scalable system. Instead of separate
processes and threads, it uses asynchronous, event-driven I/O operations. So It can achieve high output via single-threaded event loop and non-blocking I/O.
Node.js: Why and Where to Use It?
Table of Contents
1. Node.js: Why and Where to Use It?
2. How to Run Code in Node.js?
3. Why Node Js is single-threaded?
4. What is Non-blocking or asynchronous?
5. What is Blocking or synchronous?
6. What is IO?
7. Blocking vs Non Blocking NodeJS
8. Blocking or Non-blocking in Node.js: Which is Faster?
9. Dangers of Mixing Blocking and Non-Blocking Code
10. How can We Convert Blocking Code to Non-blocking Code?
11. Pros and Cons of Non Blocking IO Node.js
12. Is it possible to use asynchronous architecture?

Blog Home / Node.js / Node Js: Non-blocking or asynchronous | Blocking or synchronous
Asign menu 07 AUG
2023
HOME INSIGHTS ABOUT US WEB PORTFOLIO MOBILE PORTFOLIO CAREERS CONTACT US BLOG  0

Node.js has gained immense popularity in recent years due to its unique features and capabilities. It is a powerful JavaScript
runtime built on Chrome’s V8 JavaScript engine, which enables developers to build scalable and high-performance
applications. In this article, we will explore the reasons why you should consider using Node.js and where it can be most
beneficial.
Why to Use Node.js?
Efficient and Scalable:
Node.js is known for its efficiency and scalability, making it an excellent choice for developing applications that can handle a
large number of concurrent connections. It uses an event-driven, non-blocking I/O model, allowing it to handle multiple
requests without getting blocked, unlike traditional blocking I/O models used in other languages. This makes Node.js ideal
for applications that require real-time interactions, such as chat applications, collaborative tools, and gaming platforms.
Single Language, Full Stack:
One significant advantage of Node.js is that it enables developers to use JavaScript both on the server and the client side. This
means that you can have a seamless development experience, using the same language and libraries throughout the entire
stack. This consistency reduces the complexity of development and eases the transition between front-end and back-end
development tasks. It also enables the reuse of code and modules, resulting in faster development cycles and increased
productivity.
Large and Active Community:
Node.js has a vibrant and extensive community of developers, which means you can easily find support, libraries, and
resources to help you in your Node.js development journey. The community actively contributes to the Node Package
Manager (NPM), which hosts a vast collection of open-source packages that can be easily integrated into your projects. With a
rich ecosystem and continuous community-driven enhancements, Node.js ensures that you can find solutions to most of
your development challenges.
Where to Use Node.js?
High Performance:
Node.js’s event-driven, non-blocking architecture allows it to handle a large number of concurrent connections efficiently.
This, coupled with its ability to use JavaScript’s asynchronous programming paradigm, makes it highly performant, especially
when dealing with I/O-intensive tasks. Node.js excels in scenarios such as handling HTTP requests, file system operations,
and database queries. It can significantly improve the response time and throughput of your applications, making it a
preferred choice for high-performance web servers.
Microservices and APIs:
Node.js is an excellent choice for building microservices and RESTful APIs. Its lightweight and modular nature allow
developers to create small, independent services that can communicate with each other. This promotes a modular and
decoupled architecture, making it easier to scale and maintain your applications. Additionally, Node.js provides a range of
frameworks and libraries, such as Express.js, that simplify the development of APIs, enabling you to quickly build robust and
scalable back-end services.
Node.js offers a compelling set of features and benefits that make it a valuable tool for modern web development. Its
efficiency, scalability, and the ability to use JavaScript both on the server and client sides make it an attractive choice for
developers. With its large and active community, high performance, and support for microservices and APIs, Node.js proves
to be a versatile platform suitable for a wide range of applications.
How to Run Code in Node.js?
Running code in Node.js allows developers to execute JavaScript outside of the browser environment, enabling server-side
scripting and building command-line tools. In this comprehensive guide, we will walk you through the process of running
code in Node.js, from setting up the environment to executing your first program.

Installing Node.js:
To begin running code in Node.js, the first step is to install Node.js on your machine. Visit the official Node.js website
(nodejs.org) and download the appropriate installation package for your operating system. Follow the installation
instructions provided, and upon completion, you will have Node.js and its accompanying package manager, npm, installed on
your system.
Creating a JavaScript File:
Once Node.js is installed, you can start by creating a JavaScript file that contains the code you want to run. Using a text editor
or an integrated development environment (IDE), create a new file with a .js extension, such as “myScript.js”. This file will
serve as the entry point for your Node.js program.
Writing Your Node.js Code:
Open the JavaScript file you created and begin writing your Node.js code. You have the flexibility to use JavaScript syntax and
leverage the rich set of Node.js APIs and modules available. For example, you can utilize the ‘fs’ module to work with the file
system, the ‘http’ module to create a web server, or third-party libraries available on npm to enhance your code’s
functionality.
Command-Line Execution:
To run your Node.js code, open a command-line interface (CLI) or terminal window and navigate to the directory where your
JavaScript file is located. Use the ‘node’ command followed by the name of your file to execute the code. For example, in the
terminal, enter:
node myScript.js
Node.js will interpret and execute the code, providing the output or performing the specified actions defined within your
program.
Handling Command-Line Arguments:
Node.js allows you to pass command-line arguments to your program, enabling dynamic behavior and user input. Within
your JavaScript code, you can access these arguments using the ‘process.argv’ array. This allows you to customize the
execution of your code based on the provided arguments.
Interacting with the Console:
During code execution, you can interact with the console by using functions such as ‘console.log()’ to display messages,
values, or debug information. The console output will be visible in the command-line interface or terminal window where
your code is running, aiding in the development and troubleshooting process.
Running code in Node.js is a fundamental skill for JavaScript developers, as it unlocks the ability to build server-side
applications and command-line tools. By following the step-by-step guide provided above, you can successfully set up the
Node.js environment, create JavaScript files, and execute code using the command line. Experiment with different Node.js
APIs, modules, and command-line arguments to explore the full potential of Node.js and leverage its capabilities in your
projects.
Why Node Js is single-threaded?

Node.js is single-threaded for asynchronous processing. By doing asynchronous processing on a single-thread under typical web loads, more performance and
scalability can be achieved.
What is Non-blocking or asynchronous?
A non-blocking operation will not wait for I/O operation to complete.
When blocking operation caused the process to be put on the back burner at the operating system level, performing a non-blocking I/O operation the
process continues to run instead.
A non-blocking call initiates the operation, leaves it for the operating system to complete returning and immediately without any results.
Alternate means are then used to determine the completion of the I/O operation.
There are a few ways to communicate that non-blocking I/O operation has been completed.
Programs interacting closer with operating systems that use polling.
By using polling, the program repeatedly asks from the operating system that has any I/O operation to complete? and then process those operations
have. In Javascript, we can also do with callbacks.
A non-blocking call in JavaScript, that provides a callback function that is to be called when the operation is completed.

Node.js was internally used operating system level polling in combination with worker threads for operations that do not support polling.
Then node.js translates these mechanisms to callbacks.
A performant application uses non-blocking I/O operations.
This allows a single process to serve multiple requests at the same time.
Instead of no of processes being blocked and waiting for a single I/O operation to complete, this waiting time can be used to serve other requests.
All Node.js libraries and the Node.js core API offer non-blocking operations.
For your reference please have a look at the image.
Let us take a real-time example,
Eg:
When you went to a restaurant, the waiter comes to your table, takes your order and gives it to the kitchen.
Then he moved to serve another table.
While the chef is preparing your meal, so the same person can serve many different tables.
They don’t have to wait for the chef to cook one meal before they serve another table.

This is called non-blocking or asynchronous architecture and this is how node applications work.
Example for non-blocking:
Let’s take a file name called sample.txt. It contains only “Hello World..”.
Write a snippet in another file:
If you run node server you will get the following output.
What is Blocking or synchronous?
”
const fs = require(‘fs’); // Require the fs library
console.log(“Execution started..”);
// File I/O Operation
fs.readFile(‘file.txt’, function(err, data){
if(err) {
return console.error(err);
}
console.log(data.toString());
});
console.log(“Execution Ended..”);

Once again let’s go back to our restaurant example.
Eg:
Imagine you went to another restaurant. A waiter is allocated to you. You gave an order to him.
Now the waiter went to the kitchen and give orders to the chef, and now he is sitting ideal while preparing your order.
That means now the waiter here acting like a thread.
He will go to the next order after delivering your order.
While preparing your order your thread (waiter) is waiting for the response.
This is called blocking or synchronous architecture and that’s how applications built with frameworks like a speed net or rails work out of the box.
So a thread is allocated to handle that request when we receive a request on the server as a part of handling that request.
It is likely that we’re going to query a database and as you know sometimes it may take a little while until the result is ready.
When the database is executing the query that the thread is waiting ideally, it can’t be used to serve for another client.
So we need another new thread to serve another client.
Imagine what would happen if we have a large number of parallel clients at some point we are going to run out of threads to serve these clients.
For your reference please have a look at the image.

Example for blocking:
var contents = fs.readFile(‘file.txt’,’utf8′, function(err,contents){
console.log(contents);
});

This will give you the output:
What is IO?
Input/Output (I/O) operations play a crucial role in any software application, including Node.js. In this article, we will explore
the concept of I/O and delve into the differences between blocking and non-blocking operations. Specifically, we will focus on
how Node.js leverages non-blocking I/O to enhance performance and scalability.
Understanding I/O in Software:
I/O refers to the communication between a program and external devices, such as disks, networks, or user input. In the
context of Node.js, I/O operations involve reading from or writing to files, making network requests, or interacting with
databases. Efficient I/O handling is essential for optimizing the overall performance of an application.
Blocking I/O:
In traditional programming models, I/O operations are typically blocking, meaning that the program halts its execution until
the I/O operation completes. This blocking behavior can lead to inefficiencies and reduced performance, especially when
handling multiple concurrent connections. In such scenarios, the application waits until each I/O operation finishes before
moving on to the next one, potentially causing delays and bottlenecks.
Non-blocking I/O:
Node.js distinguishes itself by employing a non-blocking I/O model. Non-blocking I/O allows the program to continue
executing other tasks while waiting for I/O operations to complete. Instead of waiting, Node.js delegates I/O operations to
the underlying system and registers callbacks to be executed upon completion. This asynchronous approach enables the
application to handle multiple operations concurrently, resulting in improved efficiency and responsiveness.
Non-blocking I/O in Node.js:
Node.js takes full advantage of non-blocking I/O to maximize its performance and efficiency. It uses an event-driven
architecture and employs asynchronous programming techniques. Asynchronous APIs allow developers to write non-
blocking code by utilizing callbacks, promises, or async/await syntax. Node.js also provides a vast ecosystem of modules and
libraries built on top of non-blocking principles, further enhancing its capabilities.
I/O operations are essential components of software applications, including Node.js. Understanding the difference between
blocking and non-blocking I/O is crucial for building performant and scalable applications. Node.js, with its non-blocking I/O
model, offers significant advantages by enabling efficient resource utilization, enhanced performance, and scalability. By
leveraging non-blocking I/O, developers can unlock the full potential of Node.js and build high-performance applications that
can handle thousands of concurrent connections.
Blocking vs Non Blocking NodeJS
In Node.js, understanding the difference between blocking and non-blocking operations is crucial for building efficient and
responsive applications. In this article, we will explore the concepts of blocking and non-blocking in Node.js, their
implications, and how they affect the performance of your code.
”
var contents = fs.readFile(‘file1.txt’,’utf8′, function(err,contents){
console.log(contents);
});

Blocking Operations in Node.js:
Blocking operations refer to tasks that halt the execution of the program until the operation is completed. When a blocking
operation is encountered, Node.js waits for it to finish before moving on to the next task. This can cause delays and
inefficiencies, especially in scenarios where there are multiple concurrent operations.
Non-blocking Operations in Node.js:
Non-blocking operations, on the other hand, allow the program to continue executing other tasks while waiting for an
operation to complete. Instead of waiting, Node.js delegates the operation to the underlying system and registers a callback
function to be executed upon completion. This asynchronous approach enables Node.js to handle multiple operations
concurrently, improving efficiency and responsiveness.
Comparison: Blocking vs. Non-blocking Operations in Node.js
Blocking Operations Non-blocking Operations
Execution Model Synchronous Asynchronous
Program Flow Waits for each operation to finish Continues with other tasks
Responsiveness Can be slow for multiple tasks Improved responsiveness
Performance Lower concurrency, potential delays Higher concurrency, better performance
Resource Usage Higher resource utilization Efficient resource utilization
In Node.js, understanding the difference between blocking and non-blocking operations is vital for writing high-performance
applications. By leveraging non-blocking operations, Node.js can handle concurrent tasks efficiently, resulting in improved
responsiveness, scalability, and resource utilization. Asynchronous programming and the event-driven architecture of
Node.js enable developers to harness the power of non-blocking operations, making it a preferred choice for building
scalable and responsive applications.
Blocking or Non-blocking in Node.js: Which is Faster?
Non-blocking Advantages: Non-blocking operations, including asynchronous operations in Node.js, offer several benefits that
contribute to speed and performance:
Enhanced Responsiveness
Non-blocking operations prevent the program from becoming unresponsive during I/O tasks. By allowing concurrent
execution, Node.js can quickly respond to incoming requests and handle multiple operations simultaneously.
Scalability
Non-blocking operations enable Node.js to efficiently handle a large number of concurrent connections, making it suitable
for applications with high traffic and real-time communication requirements.
Efficient Resource Utilization
Non-blocking operations optimize resource usage by utilizing the CPU and system resources effectively. The program doesn’t
idle while waiting for I/O operations to complete, allowing it to perform additional tasks, resulting in better overall
performance.
In the world of Node.js, the choice between blocking and non-blocking operations significantly impacts the speed and
performance of your applications. While blocking operations may be suitable for specific use cases, non-blocking operations,
including asynchronous programming, offer advantages in terms of responsiveness, scalability, and resource utilization. By
understanding the differences and utilizing non-blocking techniques effectively, developers can optimize the speed and
overall performance of their Node.js applications.

Dangers of Mixing Blocking and Non-Blocking Code
Performance Bottlenecks
Mixing blocking and non-blocking code can lead to performance bottlenecks. When a blocking operation is encountered
within non-blocking code, it can stall the entire application, reducing the benefits of non-blocking architecture.
Unpredictable Behavior
Mixing blocking and non-blocking code can result in unpredictable behavior. The order of execution may become uncertain,
leading to unexpected outcomes and potential bugs that are difficult to debug.
Resource Utilization
Mixing blocking and non-blocking code may lead to inefficient resource utilization. Blocking operations can consume system
resources while waiting, hindering the execution of other non-blocking tasks and degrading overall performance.
Best Practices to Avoid Mixing Code:
Consistency: Strive for consistency throughout your codebase. Choose either blocking or non-blocking approach depending on your application’s requirements
and stick to that paradigm.
Design Considerations: Plan your application’s architecture and I/O handling strategy upfront, ensuring a coherent and consistent approach across your
codebase.
Use Non-blocking Libraries: Leverage non-blocking libraries and modules when working with third-party dependencies to maintain consistency and avoid
potential conflicts.
Mixing blocking and non-blocking code in Node.js can introduce risks and complexities that impact the performance and
reliability of your applications. It is crucial to understand the differences between blocking and non-blocking code and adopt
a consistent approach throughout your codebase. By adhering to best practices and maintaining consistency, you can ensure
the efficient execution of your Node.js applications and mitigate the risks associated with mixing blocking and non-blocking
code.
How can We Convert Blocking Code to Non-blocking Code?
In Node.js, converting blocking code to non-blocking code is a crucial step for optimizing performance and responsiveness.
By leveraging non-blocking techniques, you can enhance the scalability of your applications and ensure efficient resource
utilization. In this article, we will explore best practices for converting blocking code to non-blocking code in Node.js.
Identify Blocking Code:
Analyze your codebase to identify sections that involve blocking operations, such as file I/O, network requests, or database interactions.
Look for synchronous function calls that halt the execution until the operation is completed.
Utilize Asynchronous APIs:
Leverage the asynchronous APIs provided by Node.js for non-blocking operations. These include callbacks, promises, and async/await syntax.
Rewrite blocking code to use asynchronous functions and callbacks. Replace synchronous operations with their asynchronous counterparts.
Use Libraries and Modules:
Explore and utilize existing libraries and modules built on non-blocking principles. These libraries provide optimized solutions for common tasks and help
streamline the conversion process.
Examples of popular libraries include “axios” for non-blocking HTTP requests and “fs-extra” for non-blocking file operations.
Implement Event-driven Architecture:
Embrace the event-driven architecture of Node.js. Utilize events and event listeners to handle non-blocking operations effectively.
Register event listeners for I/O operations and execute the corresponding logic when the operation completes.
Parallelize Tasks:
Identify opportunities to parallelize tasks and execute them concurrently. Split complex tasks into smaller, independent units that can be processed concurrently,
utilizing the full potential of non-blocking capabilities.
Optimize Resource Utilization:
Ensure efficient utilization of resources by avoiding unnecessary blocking operations. Whenever possible, delegate I/O tasks to the underlying system and
continue with other operations while waiting for completion.

Converting blocking code to non-blocking code in Node.js is a fundamental step for enhancing performance and
responsiveness. By leveraging asynchronous APIs, utilizing libraries, implementing event-driven architecture, parallelizing
tasks, and optimizing resource utilization, you can successfully transition from blocking to non-blocking code. This
conversion unlocks the scalability and efficiency benefits of non-blocking I/O, enabling your Node.js applications to handle
concurrent operations and deliver optimal performance.
Pros and Cons of Non Blocking IO Node.js
In Node.js, non-blocking I/O is a fundamental concept that distinguishes it from traditional blocking-based architectures.
Understanding the pros and cons of non-blocking I/O in Node.js is essential for building efficient and scalable applications. In
this article, we will explore the advantages and trade-offs of non-blocking I/O in Node.js.
Pros of Non-blocking I/O in Node.js:
Enhanced Performance:
Non-blocking I/O allows Node.js to handle multiple concurrent operations without becoming unresponsive. This concurrency improves performance, especially
in scenarios with high I/O load or a large number of concurrent connections.
Non-blocking operations prevent the program from waiting idly during I/O tasks, optimizing resource utilization and overall system performance.
Scalability:
Node.js’s non-blocking I/O model enables it to handle a massive number of concurrent connections efficiently. With its single-threaded event loop, it can scale
horizontally and vertically, making it suitable for applications with high traffic and real-time communication requirements.
Non-blocking I/O ensures that the system remains responsive under heavy loads, providing a seamless user experience.
Responsiveness:
Non-blocking I/O makes Node.js highly responsive. It allows the program to continue executing other tasks while waiting for I/O operations to complete. This
responsiveness is crucial for applications requiring real-time updates, such as chat servers, collaborative tools, or streaming services.
Cons of Non-blocking I/O in Node.js:
Complexity:
Implementing non-blocking I/O requires careful handling of asynchronous operations and callbacks. This asynchronous programming style can be challenging,
especially for developers transitioning from traditional blocking-based architectures.
Non-blocking code can be more complex to write, read, and debug compared to blocking code. Proper error handling and control flow management are crucial
to avoid callback hell or “pyramid of doom” scenarios.
Limited CPU-Intensive Operations:
Node.js’s single-threaded nature limits its ability to efficiently handle CPU-intensive tasks. Blocking CPU-bound operations within the event loop can significantly
impact the responsiveness of the entire application.
To overcome this limitation, Node.js encourages delegating CPU-bound tasks to worker threads or separate processes, while keeping the main event loop free for
non-blocking I/O operations.
Non-blocking I/O in Node.js offers several advantages in terms of performance, scalability, and responsiveness. It enables
efficient handling of concurrent operations and optimal resource utilization. However, implementing non-blocking I/O
requires careful management of asynchronous code and can introduce complexities. Developers need to be mindful of the
limitations regarding CPU-intensive tasks and employ appropriate strategies to delegate such operations. Overall, Node.js’s
non-blocking I/O model is well-suited for building high-performance applications, particularly those involving I/O-heavy
workloads or real-time communication requirements.
Is it possible to use asynchronous architecture?

So with this kind of architecture, we are not utilizing our resources efficiently.
This is the problem with synchronous or blocking.
In previous examples as I explained that’s how applications built with frameworks like asp.net worked by default. Of course in asp.net, it is possible to use
asynchronous architecture.
To handle all requests we have a single thread, the linear request arrives that a single thread is used to handle that request.
If you need to query a database our single thread doesn’t have to wait for the database to return the data while the database is executing our query.
That thread will serve another client when the database prepares the result, it puts a message in what we call an event queue.
In the background, the Node is continuously monitoring this queue.
When it finds an event in this queue it will take it out and will do the remaining process.
This kind of architecture makes the node ideal for building applications that include a lot of network access or disks.
We can serve more clients without the need to throw in more hardware and that’s why no applications are highly scalable in contrast.
The node should not be used for CPU intensive applications like image manipulation service or a video encoding.
In such applications, we have a lot of calculations that should be done by CPU and few operations that touch the file system or the network.
Also Read: Writing Files In Nodejs? Here Is What You Need To Know.
Since no applications are single threaded while performing the calculations to serve one client, other clients have to wait.
And that’s the reason, the node should not be used or CPU intensive applications.
It should only be used for building data-intensive and real-time applications.
Follow Us on Facebook | Twitter | LinkedIn.
Thank You.

WordPress Theme built by Shufflehound.
CronJ
CronJ is a product development company which solves problems in Video analytics, IoT, Industrial automation, Manufacturing 4.0, Smart
Factory, Smart City, Blockchain, Artificial Intelligence, Mobility Solutions and supply chain consulting.
VIA
SOURCE
TAGS #NODEJS ASYNCHRONOUS SYNCHRONOUS #NODEJS NONBLOCKING BLOCKING
Related posts
N ODE. J S
Node JS WebSocket: Examples | Chat Features | Client-
Server communication

N ODE. J S
NodeJS Logging: What should you know about logging? 

Node Js Non-blocking or asynchronous Blocking or synchronous.pdf

Recommended

Recommended

More Related Content

Similar to Node Js Non-blocking or asynchronous Blocking or synchronous.pdf

Similar to Node Js Non-blocking or asynchronous Blocking or synchronous.pdf (20)

Recently uploaded

Recently uploaded (20)

Node Js Non-blocking or asynchronous Blocking or synchronous.pdf