专栏首页Nodejs技术栈你需要了解的有关 Node.js 的所有信息

你需要了解的有关 Node.js 的所有信息

  • 原文地址:https://dev.to/jorge_rockr/everything-you-need-to-know-about-node-js-lnc
  • 原文作者:Jorge Ramón
  • 译者:五月君,公众号 “Nodejs技术栈” 作者

Node.js 是当前用来构建可扩展的、高效的 REST API's 的最流行的技术之一。它还可以用来构建混合移动应用、桌面应用甚至用于物联网领域。

我真的很喜欢它,我已经使用 Node.js 工作了 6 年。这篇文章试图成为了解 Node.js 工作原理的终极指南。

Node.js 之前的世界

多线程服务器

Web 应用程序是用一个 client/server(客户端/服务器)模式所编写的,其中 client 将向 server 请求资源并且 server 将会根据这个资源以响应。server 仅在 client 请求时做出响应,并在每次响应后关闭连接。

这种模式是有效的,因为对服务器的每一个请求都需要时间和资源(内存、CPU 等)。服务器必须完成上一个请求,才能接受下一个请求。

所以,服务器在一定的时间内只处理一个请求?这不完全是,当服务器收到一个新请求时,这个请求将会被一个线程处理。

简而言之,线程是 CPU 为执行一小段指令所花费的时间和资源。话虽如此,服务器一次要处理多个请求,每个线程一个(也可以称为 thread-per-request 模式)。

注:thread-per-request 意为每一个请求一个线程

要同时处理 N 个请求,服务器就需要 N 个线程。如果现在有 N+1 个请求,它就必须等待,直到 N 个线程中的任何一个可用。

在多线程服务器示例中,服务器同时最多允许 4 个请求(线程)当接下来收到 3 个请求时,这些请求必须等待直到这 4 个线程中的任何一个可用。

解决此限制的一种方法是向服务器添加更多资源(内存,CPU内核等),但这可能根本不是一个好主意...

当然,会有技术限制。

阻塞 I/O

服务器中的线程数不仅仅是这里唯一的问题。也许你想知道为什么一个线程不能同时处理 2 个或更多的请求?这是因为阻塞了 Input/Output 操作。

假设你正在开发一个在线商店应用,并且它需要一个页面,用户可以在其中查看您的所有产品。

用户访问 http://yourstore.com/products 服务器将从数据库中获取你的全部产品来呈现一个 HTML 文件,这很简单吧?

但是,后面会发生什么?...

  • 1. 当用户访问 /products 时,需要执行特定的方法或函数来满足请求,因此会有一小段代码来解析这个请求的 url 并定位到正确的方法或函数。线程正在工作。✔️
  • 2. 该方法或函数以及第一行将被执行。线程正在工作。✔️
  • 3. 因为你是一名优秀的开发者,你会保存所有的系统日志在一个文件中,要确保路由执行了正确的方法/函数,你的日志要增加一个字符串 “Method X executing!!”(某某方法正在执行),这是一个阻塞的 I/O 操作。线程正在等待。❌
  • 4. 日志已被保存并且下一行将被执行。线程正在工作。✔️
  • 5. 现在是时候去数据库并获取所有产品了,一个简单的查询,例如 SELECT * FROM products 操作,但是您猜怎么着?这是一个阻塞的 I/O 操作。线程正在等待。❌
  • 6. 你会得到一个所有的产品列表,但要确保将它们记录下来。线程正在等待。❌
  • 7. 使用这些产品,是时候渲染模版了,但是在渲染它之前,你应该先读取它。线程正在等待。❌
  • 8. 模版引擎完成它的工作,并将响应发送到客户端。线程再次开始工作。✔️
  • 9. 线程是自由的(空闲的),像鸟儿一样。?️

I/O 操作有多慢?这得需要看情况。

让我们检查以下表格:

操作

CPU 时钟周期数

CPU 寄存器

3 ticks

L1 Cache(一级缓存)

8 ticks

L2 Cache(二级缓存)

12 ticks

RAM(随机存取存储器)

150 ticks

Disk(磁盘)

30,000,000 ticks

Network(网络)

250,000,000 ticks

译者备注:时钟周期也称(tick、clock cycle、clock period 等),指一个硬件在被使用过程中,被划分为多个时间周期,当我们需要比较不同硬件的性能时,就在不同硬件之上测试同一个软件,观察它们的时钟周期时间和周期数,如果时钟周期时间越长、周期数越多,就意味着这个硬件需要的性能较低。

磁盘和网络操作太慢了。您的系统进行了多少次查询或外部 API 调用?

在恢复过程中,I/O 操作使得线程等待且浪费资源。

C10K 问题

早在 2000 年代初期,服务器和客户端机器运行缓慢。这个问题是在一台服务器机器上同时运行 10,000 个客户端链接。

为什么我们传统的 “thread-per-request” 模式不能够解决这个问题?现在让我们做一些数学运算。

本地线程实现为每个线程分配大约 1 MB 的内存,所以 10K 线程就需要 10GB 的 RAM,请记住这仅仅是在 2000 年代初期!!

如今,服务器和客户端的计算能力比这更好,几乎任何编程语言和框架都解决了这个问题。实际,该问题已更新为在一台服务器上处理 10 million(1000 万) 个客户端链接(也称 C10M 问题)。

JavaScript 进行救援?

剧透提醒 ???!!

Node.js 解决了这个 C10K 问题... 但是为什么?

JavaScript 服务端早在 2000 年代并不是什么新鲜事,它基于 “thread-per-request” 模式在 Java 虚拟机之上有一些实现,例如,RingoJS、AppEngineJS。

但是,如果那不能解决 C10K 问题,为什么 Node.js 可以?好吧,因为它是单线程的。

Node.js 和 Event Loop

Node.js

Node.js 是一个构建在 Google Chrome's JavaScript 引擎(V8 引擎)之上的服务端平台,可将 JavaScript 代码编译为机器代码。

Node.js 基于事件驱动、非阻塞 I/O 模型,从而使其轻巧和高效。它不是一个框架,也不是一个库,它是一个运行时。

一个简单的例子:

// Importing native http module
const http = require('http');

// Creating a server instance where every call
// the message 'Hello World' is responded to the client
const server = http.createServer(function(request, response) {
  response.write('Hello World');
  response.end();
});

// Listening port 8080
server.listen(8080);

非阻塞 I/O

Node.js 是非阻塞 I/O,这意味着:

  • 主线程不会在 I/O 操作中阻塞。
  • 服务器将会继续参加请求。
  • 我们将使用异步代码。

让我们写一个例子,在每一次 /home 请求时,服务器将响应一个 HTML 页面,否则服务器响应一个 'Hello World' 文本。要响应 HTML 页面,首先要读取这个文件。

home.html

<html>
  <body>
    <h1>This is home page</h1>
  </body>
</html>

index.js

const http = require('http');
const fs = require('fs');

const server = http.createServer(function(request, response) {
  if (request.url === '/home') {
    fs.readFile(`${ __dirname }/home.html`, function (err, content) {
      if (!err) {
        response.setHeader('Content-Type', 'text/html');
        response.write(content);
      } else {
        response.statusCode = 500;
        response.write('An error has ocurred');
      }

      response.end();
    });
  } else {
    response.write('Hello World');
    response.end();
  }
});

server.listen(8080);

如果这个请求的 url 是 /home,我们使用 fs 本地模块读取这个 home.html 文件。

传递给 http.createServer 和 fs.readFile 的函数称为回调。这些功能将在将来的某个时间执行(第一个功能将在收到一个请求时执行,第二个功能将在文件读取并且缓冲之后执行)。

在读取文件时,Node.js 仍然可以处理请求,甚至再次读取文件,all at once in a single thread... but how?!

The Event Loop(事件循环)

事件循环是 Node.js 背后的魔力,简而言之,事件循环实际上是一个无限循环,并且是线程里唯一可用的。

Libuv 是一个实现此模式的 C 语言库,是 Node.js 核心模块的一部分。阅读关于 Libuv 的更多内容 here。

事件循环需要经历 6 个阶段,所有阶段的执行被称为 tick。

  • timers:这个阶段执行定时器 setTimeout() 和 setInterval() 的回调函数。
  • pending callbacks:几乎所有的回调在这里执行,除了 close 回调、定时器 timers 阶段的回调和 setImmediate()。
  • idle, prepare: 仅在内部应用。
  • poll:检索新的 I/O 事件;适当时 Node 将在此处阻塞。
  • check:setImmediate() 回调函数将在这里执行。
  • close callbacks: 一些准备关闭的回调函数,如:socket.on('close', ...)。

好的,所以只有一个线程并且该线程是一个 EventLoop,但是 I/O 操作由谁来执行呢?

注意 ???!!!

当 Event Loop 需要执行 I/O 操作时,它将从一个池(通过 Libuv 库)中使用系统线程,当这个作业完成时,回调将排队等待在 “pending callbacks” 阶段被执行。

那不是很完美吗?

CPU 密集型任务问题

Node.js 似乎很完美,你可以用它来构建任何你想要的东西。

让我们构建一个 API 来计算质数。

质数又称素数。一个大于 1 的自然数,除了 1 和它自身外,不能被其他自然数整除的数叫做质数;

给一个数 N,这个 API 必须计算并在一个数组中返回 N 个自然数。

primes.js

function isPrime(n) {
  for(let i = 2, s = Math.sqrt(n); i <= s; i++)
    if(n % i === 0) return false;
  return n > 1;
}

function nthPrime(n) {
  let counter = n;
  let iterator = 2;
  let result = [];

  while(counter > 0) {
    isPrime(iterator) && result.push(iterator) && counter--;
    iterator++;
  }

  return result;
}

module.exports = { isPrime, nthPrime };

index.js

const http = require('http');
const url = require('url');
const primes = require('./primes');

const server = http.createServer(function (request, response) {
  const { pathname, query } = url.parse(request.url, true);

  if (pathname === '/primes') {
    const result = primes.nthPrime(query.n || 0);
    response.setHeader('Content-Type', 'application/json');
    response.write(JSON.stringify(result));
    response.end();
  } else {
    response.statusCode = 404;
    response.write('Not Found');
    response.end();
  }
});

server.listen(8080);

primes.js 是质数功能实现,isPrime 检查给予的参数 N 是否为质数,如果是一个质数 nthPrime 将返回 n 个质数

index.js 创建一个服务并在每次请求 /primes 时使用这个库。通过 query 传递参数。

获取 20 前的质数,我们发起一个请求 http://localhost:8080/primes?n=2

假设有 3 个客户端访问这个惊人的非阻塞 API:

  • 第一个每秒请求前 5 个质数。
  • 第二个每秒请求前 1,000 个质数
  • 第三个请求一次性输入前 10,000,000,000 个质数,但是...

当我们的第三个客户端发送请求时,客户端将会被阻塞,因为质数库会占用大量的 CPU。主线程忙于执行密集型的代码将无法做其它任何事情。

但是 Libuv 呢?如果你记得这个库使用系统线程帮助 Node.js 做一些 I/O 操作以避免主线程阻塞,那你是对的,这个可以帮助我们解决这个问题,但是使用 Libuv 库我们必须要使用 C++ 语言编写。

值得庆祝的是 Node.js v10.5 引入了工作线程。

工作线程

如文档所述:

工作线程对于执行 CPU 密集型的 JavaScript 操作非常有用。它们在 I/O 密集型的工作中用途不大。Node.js 的内置的异步 I/O 操作比工作线程效率更高。

修改代码

现在修复我们的初始化代码:

primes-workerthreads.js

const { workerData, parentPort } = require('worker_threads');

function isPrime(n) {
  for(let i = 2, s = Math.sqrt(n); i <= s; i++)
    if(n % i === 0) return false;
  return n > 1;
}

function nthPrime(n) {
  let counter = n;
  let iterator = 2;
  let result = [];

  while(counter > 0) {
    isPrime(iterator) && result.push(iterator) && counter--;
    iterator++;
  }

  return result;
}

parentPort.postMessage(nthPrime(workerData.n));

index-workerthreads.js

const http = require('http');
const url = require('url');
const { Worker } = require('worker_threads');

const server = http.createServer(function (request, response) {
  const { pathname, query } = url.parse(request.url, true);

  if (pathname === '/primes') {
    const worker = new Worker('./primes-workerthreads.js', { workerData: { n: query.n || 0 } });

    worker.on('error', function () {
      response.statusCode = 500;
      response.write('Oops there was an error...');
      response.end();
    });

    let result;
    worker.on('message', function (message) {
      result = message;
    });

    worker.on('exit', function () {
      response.setHeader('Content-Type', 'application/json');
      response.write(JSON.stringify(result));
      response.end();
    });
  } else {
    response.statusCode = 404;
    response.write('Not Found');
    response.end();
  }
});

server.listen(8080);

index-workerthreads.js 在每个请求中将创建一个 Worker 实例,在一个工作线程中加载并执行 primes-workerthreads.js 文件。当这个质数列表计算完成,这个 message 消息将会被触发,接收信息并赋值给 result。由于这个 job 已完成,将会再次触发 exit 事件,允许主线程发送数据给到客户端。

primes-workerthreads.js 变化小一点。它导入 workerData(从主线程传递参数),parentPort 这是我们向主线程发送消息的方式。

现在让我们再次做 3 个客户端例子,看看会发生什么:

主线程不再阻塞 ?????!!!!!

它的工作方式与预期的一样,但是生成工作线程并不是最佳实践,创建新线程并不便宜。一定先创建一个线程池。

结论

Node.js 是一项功能强大的技术,值得学习。

我的建议总是很好奇,如果您知道事情的进展,您将做出更好的决定。

伙计们,到此为止。希望您对 Node.js 有所了解。

感谢您的阅读,下一篇文章中相见。❤️

本文分享自微信公众号 - Nodejs技术栈(NodejsDeveloper),作者:五月君 译

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2020-01-30

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 你觉得 Node.js 是单线程这个结论对吗?

    ——爱默生

    五月君
  • 去哪儿网前后端分离实践(含 Node.js 应用实践)

    第一种是项目分离,承载页面分离。他的特点是简单,快速,前端只关注浏览器方面,除浏览器端之外都是后端负责。当然缺点是沟通成本高,前期,前端需要使用 ng 或者代理...

    五月君
  • Java 能抵挡住 JavaScript 的进攻吗?

    德高望重的IO大臣颤悠悠地走上前来:“启禀陛下,昨日收到战报,有个叫做Node.js的番邦又一次向我国进攻,我边防将士死伤惨重。”

    五月君
  • JMeter(连载2)

    接下来就可以用JMeter修改录制和脚本了,在修改之前,介绍一下一些最基本的组件功能。由于JMeter功能非常强大并且支持很多控件,所以介绍所有的组件是不可能的...

    小老鼠
  • iOS多线程

    进程是指系统中正在运行的一个应用程序。每个进程之间是独立的,每个进程均运行在其专用且受保护的内存空间内。

    hrscy
  • 面试独门技巧,手刃&quot;面试官&quot;

    这个代码主要放在主线程,就会严重影响程序的性能,造成堵塞,影响用户体验.这个时候我们的多线程就发挥它的作用了

    CC老师
  • 一个简单实用的线程基类

    这篇文章介绍线程基类CThreadBase,其将线程资源封装成对象,提供生命周期控制接口,派生类覆盖相应的虚函数进行业务功能实现。

    gaigai
  • ThinkJS + MySql搭建个人博客站点

    ThinkJS 是一款使用 ES6/7 特性全新开发的 Node.js MVC 框架,它综合了众多框架的设计理念和思想,让使用 Node.js 开发项目更加简单...

    不安分的猿人
  • Java核心(三)并发中的线程同步与锁

    乐观锁、悲观锁、公平锁、自旋锁、偏向锁、轻量级锁、重量级锁、锁膨胀...难理解?不存的!来,话不多说,带你飙车。

    Java中文社群_老王
  • Java concurrency in practice笔记 02 03

    线程安全性的核心是正确性,正确性的含义是如果类的行为与其规范完全一致。因此当多个线程访问某个类时,类的行为始终是安全的,这个类就是线程安全的,...

    Dylan Liu

扫码关注云+社区

领取腾讯云代金券

玩转腾讯云 有奖征文活动