nodejs进程几个基本概念

1. 同步异步
   同步就是执行了某个请求，此请求返回消息才执行下一个请求，异步就是执行了某个请求，不管此请求返回没有，直接执行下一个操作
2. 异步IO
   当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者的输入输出操作
3. 阻塞非阻塞
   阻塞就是进程执行一件事的时候，在这件事完成之前，该线程不能做其他事，只能等着，非阻塞就是该事情等待时候线程可以完成其他事请
4. 事件循环，事件驱动

      ┌───────────────────────┐
   ┌─>│     timers(计时器)     │
   |  |   执行setTimeout以及   |
   |  |   setInterval的回调。  |
   │  └──────────┬────────────┘
   │  ┌──────────┴────────────┐
   │  │     I/O callbacks     |
   │  | 处理网络、流、tcp的错误 |
   |  | callback              |
   │  └──────────┬────────────┘
   │  ┌──────────┴────────────┐
   │  │     idle, prepare     │
   |  |     node内部使用       |
   │  └──────────┬────────────┘      
   │  ┌──────────┴────────────┐       ┌───────────────┐ 
   │  │       poll（轮询）     │       │   incoming:   │
   |  | 执行poll中的i/o队列    | <─────┤  connections, │
   |  | 检查定时器是否到时      |       │   data, etc.  |     
   │  └──────────┬────────────┘       └───────────────┘    
   │  ┌──────────┴────────────┐      
   │  │      check（检查）     │
   |  | 存放setImmediate回调   |
   │  └──────────┬────────────┘
   │  ┌──────────┴────────────┐
   └──┤    close callbacks    |
      │ 关闭的回调例如:        |
      | sockect.on('close')   |
      └───────────────────────┘

   

   1. timers 阶段: 这个阶段执行setTimeout(callback) 和 setInterval(callback)预定的callback;
   2. I/O callbacks 阶段: 执行除了close事件的callbacks、被timers(定时器，setTimeout、setInterval等)设定的callbacks、setImmediate()设定的callbacks之外的callbacks；
   3. idle, prepare 阶段: 仅node内部使用;
   4. poll 阶段: 获取新的I/O事件, 适当的条件下node将阻塞在这里;
   5. check 阶段: 执行setImmediate() 设定的callbacks;
   6. close callbacks 阶段: 比如socket.on(‘close’, callback)的callback会在这个阶段执行。
5. 单线程
   单线程程序只有一个线程，代码顺序执行，容易出现代码阻塞（页面假死）
6. 多线程
   程序有多个线程，线程间独立运行，能有效地避免代码阻塞，并且提高程序的运行性能。
7. 进程
   计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。
8. 子进程
   一个任务完成需要多个子任务的配合
9. 启动子进程
   子进程指的是由另一进程（对应称之为父进程）所创建的进程，父进程创建子进程之后对其没什么关系了，在停止之后会收回资源，比如网页进程，打开word文档子进程，一个网页打开两个页面称为两个线程
10. 进程通信
    常见的通信方式
    1. 管道pipe：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
    2. 命名管道FIFO：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
    3. 消息队列MessageQueue：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
    4. 共享存储SharedMemory：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，信号量，配合使用，来实现进程间的同步和通信。
    5. 信号量Semaphore：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
    6. 套接字Socket：套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。
    7. 信号 ( sinal ) ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。
11. 同步异步和阻塞非阻塞的区别
    同步异步指的的被调用的事件，阻色非阻塞指的是调用者的是否可以做其他事情

12.             console.log('start');
     
                var intervalA = setInterval(() => {
                    console.log('intervalA');
                }, 0);
     
                setTimeout(() => {
                    console.log('timeout');
     
                    clearInterval(intervalA);
                }, 0);
     
                var intervalB = setInterval(() => {
                    console.log('intervalB');
                }, 0);
     
                var intervalC = setInterval(() => {
                    console.log('intervalC');
                }, 0);
     
                new Promise((resolve, reject) => {
                    console.log('promise');
     
                    for (var i = 0; i < 10000; ++i) {
                        i === 9999 && resolve();
                    }
     
                    console.log('promise after for-loop');
                }).then(() => {
                    console.log('promise1');
                }).then(() => {
                    console.log('promise2');
     
                    clearInterval(intervalB);
                });
     
                new Promise((resolve, reject) => {
                    setTimeout(() => {
                        console.log('promise in timeout');
                        resolve();
                    });
     
                    console.log('promise after timeout');
                }).then(() => {
                    console.log('promise4');
                }).then(() => {
                    console.log('promise5');
     
                    clearInterval(intervalC);
                });
     
                Promise.resolve().then(() => {
                    console.log('promise3');
                });
     
                console.log('end');