前言

本文是個人在實際開發(fā)和學(xué)習(xí)中對nodejs的一些理解，現(xiàn)整理出來方便日后查閱，如果能給您啟發(fā)將不勝榮幸。

非阻塞I/O

I/O：即 Input / Output，一個系統(tǒng)的輸入和輸出。

一個系統(tǒng)可以理解為一個個體，比如說一個人，你說話就是輸出，你聽就是輸入。

阻塞 I/O 與非阻塞 I/O 的區(qū)別就在于系統(tǒng)接收輸入再到輸出期間，能不能接收其他輸入。

下面以兩個例子來說明什么是阻塞 I/O 和非阻塞 I/O:

打飯

首先我們要確定一個系統(tǒng)的范圍，在這個例子中食堂阿姨和餐廳的服務(wù)生看成是一個系統(tǒng)，輸入就是點菜，輸出就是端菜。

那么在點菜和端菜之間能不能接受其他人的點菜，就可以判斷是阻塞I/O還是非阻塞I/O。

對于食堂阿姨，他在點菜的時候，是不能幫其他同學(xué)點菜的，只有這個同學(xué)點完菜端菜走了之后，才能接受下一個同學(xué)的點菜，所以食堂阿姨是阻塞I/O。

對于餐廳服務(wù)員，他可以在點完菜以后，這個客人端菜之前是可以服務(wù)下一位客人的，所以服務(wù)員是非阻塞I/O。

做家務(wù)

在洗衣服的時候，是不需要等著洗衣機(jī)旁邊的，這個時候可以去掃地和整理書桌，當(dāng)整理完書桌后衣服也洗好了，這個時候去晾衣服，那么總共只需要25分鐘。

洗衣服其實就是一個非阻塞I/O，在把衣服扔進(jìn)洗衣機(jī)和洗完衣服期間，你是可以干其他事情的。

非阻塞I/O之所以能提升性能，是因為它可以把不必要的等待給節(jié)省掉。

理解非阻塞I/O的要點在于：

• 確定一個進(jìn)行I/O的系統(tǒng)邊界。這非常關(guān)鍵，如果把系統(tǒng)擴(kuò)大，上面餐廳的例子，如果把系統(tǒng)擴(kuò)大到整個餐廳，那么廚師肯定是一個阻塞 I/O。
• 在 I/O 過程中，能不能進(jìn)行其他 I/O。

nodejs的非阻塞 I/O

nodejs的非阻塞 I/O 是怎么體現(xiàn)的呢？前面說過理解非阻塞 I/O 的一個重要點是先確定一個系統(tǒng)邊界，nodejs的系統(tǒng)邊界就是主線程。

如果下面的架構(gòu)圖按照線程的維護(hù)劃分，左邊虛線部分是nodejs線程，右邊虛線部分是c++線程。

現(xiàn)在 nodejs 線程需要去查詢數(shù)據(jù)庫，這是一個典型的 I/O 操作，它不會等待 I/O 的結(jié)果，而且繼續(xù)處理其他的操作，它會把大量的計算能力分發(fā)到其他的c++線程去計算。

等到結(jié)果出來后返回給nodejs線程，在獲得結(jié)果之前nodejs 線程還能進(jìn)行其他的I/O操作，所以是非阻塞的。

nodejs 線程 相當(dāng)于左邊部分是服務(wù)員，c++ 線程是廚師。

所以，node的非阻塞I/O是通過調(diào)用c++的worker threads來完成的。

那當(dāng) c++ 線程獲取結(jié)果后怎么通知 nodejs 線程呢？答案是事件驅(qū)動。

事件驅(qū)動

阻塞：I/O時進(jìn)程休眠，等待I/O完成后進(jìn)行下一步； 

非阻塞：I/O時函數(shù)立即返回，進(jìn)程不等待I/O完成。

那怎么知道返回的結(jié)果，就需要用到事件驅(qū)動。

所謂事件驅(qū)動可以理解為跟前端點擊事件一樣，我首先寫一個點擊事件，但是我不知道什么時候觸發(fā)，只有觸發(fā)的時候就去讓主線程執(zhí)行事件驅(qū)動函數(shù)。

這種模式也是一種觀察者模式，就是我首先先監(jiān)聽這個事件，等觸發(fā)時我就去執(zhí)行。

那怎么實現(xiàn)事件驅(qū)動呢？答案是異步編程。

異步編程

上面說過nodejs有大量的非阻塞I/O，那么非阻塞I/O的結(jié)果是需要通過回調(diào)函數(shù)來獲取的，這種通過回調(diào)函數(shù)的方式，就是異步編程。比如下面的代碼是通過回調(diào)函數(shù)獲取結(jié)果的:

glob(__dirname+'/**/*', (err, res) => {
    result = res
    console.log('get result')
})

回調(diào)函數(shù)格式規(guī)范

nodejs的回調(diào)函數(shù)第一個參數(shù)是error，后面的參數(shù)才是結(jié)果。為什么要這么做呢？

try {
  interview(function () {
       console.log('smile')
  })
} catch(err) {
    console.log('cry', err)
}

function interview(callback) {
    setTimeout(() => {
        if(Math.random() < 0.1) {
            callback('success')
        } else {
            throw new Error('fail')
        }
    }, 500)
}

執(zhí)行之后，沒有被捕獲，錯誤被扔到了全局，導(dǎo)致整個nodejs程序崩潰了。

沒有被try catch捕獲是因為setTimeout重新開啟了事件循環(huán)，每開啟一個事件循環(huán)就重新生一個調(diào)用棧context，try catch是屬于上一個事件循環(huán)的調(diào)用棧的，setTimeout的回調(diào)函數(shù)執(zhí)行的時候，調(diào)用棧都不一樣了，在這個新的調(diào)用棧中是沒有try catch，所以這個錯誤被扔到全局，無法捕獲。具體可以參考這一篇文章JavaScript異步隊列進(jìn)行try catch時的問題解決。

那么怎么辦呢？把錯誤也作為一個參數(shù):

function interview(callback) {
    setTimeout(() => {
        if(Math.random() < 0.5) {
            callback('success')
        } else {
            callback(new Error('fail'))
        }
    }, 500)
}

interview(function (res) {
    if (res instanceof Error) {
        console.log('cry')
        return
    } 
    console.log('smile')
})

但是這樣就比較麻煩，在回調(diào)中還要判斷，所以就產(chǎn)生一種約定成熟的規(guī)定，第一個參數(shù)是err，如果不存在表示執(zhí)行成功。

function interview(callback) {
    setTimeout(() => {
        if(Math.random() < 0.5) {
            callback(null, 'success')
        } else {
            callback(new Error('fail'))
        }
    }, 500)
}

interview(function (res) {
    if (res) {
        return
    } 
    console.log('smile')
})

異步流程控制

nodejs的回調(diào)寫法，不僅會帶來回調(diào)地域，還會帶來異步流程控制的問題。

異步流程控制主要是指當(dāng)并發(fā)的時候，怎么來處理并發(fā)的邏輯。還是上面的例子，如果你同事面試兩家公司，只有當(dāng)成功面試兩家的時候，才可以不面試第三家，那么怎么寫這個邏輯呢？需要全局頂一個一個變量count:

var count = 0
interview((err) => {
    if (err) {
        return
    }
    count++
    if (count >= 2) {
        // 處理邏輯
    }
})
interview((err) => {
    if (err) {
        return
    }
    count++
    if (count >= 2) {
        // 處理邏輯
    }
})

像上面這種寫法就非常麻煩，且難看。所以，后來就出現(xiàn)了promise，async/await的寫法。

promise

當(dāng)前事件循環(huán)得不到的結(jié)果，但未來的事件循環(huán)會給你結(jié)果。很像一個渣男說的話。

promise不僅是一個渣男，還是一個狀態(tài)機(jī):

• pending
• fulfilled/resolved
• rejectd

const pro = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve('2')
    }, 200)
})
console.log(pro) // 打?。篜romise { <pending> }

then & .catch

• resolved 狀態(tài)的 promise 會調(diào)用后面的第一個 then
• rejected 狀態(tài)的 promise 會調(diào)用后面的第一個 catch
• 任何一個 reject 狀態(tài)且后面沒有 .catch 的 promise，都會造成瀏覽器或者 node 環(huán)境的全局錯誤。uncaught 表示未捕獲的錯誤。

執(zhí)行then或者catch會返回一個新的promise，該promise最終狀態(tài)根據(jù)then和catch的回調(diào)函數(shù)的執(zhí)行結(jié)果決定:

• 如果回調(diào)函數(shù)始終是throw new Error，該promise是rejected狀態(tài)
• 如果回調(diào)函數(shù)始終是return，該promise是resolved狀態(tài)
• 但如果回調(diào)函數(shù)始終是return一個promise，該promise會和回調(diào)函數(shù)return的promise狀態(tài)保持一致。

function interview() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (Math.random() > 0.5) {
                resolve('success')
            } else {
                reject(new Error('fail'))
            }
        })
    })
}
var promise = interview()
var promise1 = promise.then(() => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('accept')
        }, 400)
    })
})

promise1的狀態(tài)是由return里面的promise的狀態(tài)決定的，也就是return里面的promise執(zhí)行完后的狀態(tài)就是promise1的狀態(tài)。這樣有什么好處呢？這樣可以解決回調(diào)地獄的問題。

var promise = interview()
    .then(() => {
        return interview()
    })
    .then(() => {
        return interview()
    })
    .then(() => {
        return interview()
    })
    .catch(e => {
        console.log(e)
    })

then如果返回的promise的狀態(tài)是rejected，那么會調(diào)用后面第一個catch，后面的then就不會在調(diào)用了。記?。簉ejected調(diào)用后面的第一個catch，resolved調(diào)用后面的第一個then。

promise解決異步流程控制

如果promise僅僅是為了解決地獄回調(diào)，太小看promise了，promise最主要的作用是解決異步流程控制問題。下面如果要同時面試兩家公司:

function interview() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (Math.random() > 0.5) {
                resolve('success')
            } else {
                reject(new Error('fail'))
            }
        })
    })
}
promise
    .all([interview(), interview()])
    .then(() => {
        console.log('smile')
    })
    // 如果有一家公司rejected，就catch
    .catch(() => {
        console.log('cry')
    })

async/await

sync/await到底是什么:

console.log(async function() {
    return 4
})
console.log(function() {
    return new Promise((resolve, reject) => {
        resolve(4)
    })
})

打印的結(jié)果一樣，也就是async/await是promse的語法糖而已。

我們知道try catch捕獲錯誤是依賴調(diào)用棧的，只能捕獲到調(diào)用棧以上的錯誤。但是如果使用await后能捕捉到調(diào)用棧所有函數(shù)的錯誤。即便這個錯誤是在另一個事件循環(huán)的調(diào)用棧拋出的，比如setTimeout。

改造面試代碼，可以看到代碼精簡了很多。

try {
    await interview(1)
    await interview(2)
    await interview(2)
} catch(e => {
    console.log(e)
})

如果是并行任務(wù)呢？

await Promise.all([interview(1), interview(2)])

事件循環(huán)

因為nodejs的非阻塞 I/0， 所以需要利用事件驅(qū)動的方式獲取 I/O 的結(jié)果，實現(xiàn)事件驅(qū)動拿到結(jié)果必須使用異步編程，比如回調(diào)函數(shù)。那么如何來有序的執(zhí)行這些回調(diào)函數(shù)來獲取結(jié)果呢？那就需要使用事件循環(huán)。

事件循環(huán)是實現(xiàn) nodejs 非阻塞 I/O 功能的關(guān)鍵基礎(chǔ)，非阻塞I/O和事件循環(huán)都是屬于 libuv 這個c++庫提供的能力。

代碼演示:

const eventloop = {
    queue: [],
    loop() {
        while(this.queue.length) {
            const callback = this.queue.shift()
            callback()
        }
        setTimeout(this.loop.bind(this), 50)
    },
    add(callback) {
        this.queue.push(callback)
    }
}
eventloop.loop()
setTimeout(() => {
    eventloop.add(() => {
        console.log('1')
    })
}, 500)

setTimeout(() => {
	eventloop.add(() => {
		console.log('2')
	})
}, 800)

setTimeout(this.loop.bind(this), 50)保證了50ms就會去看隊列中是否有回調(diào)，如果有就去執(zhí)行。這樣就形成了一個事件循環(huán)。

當(dāng)然實際的事件要復(fù)雜的多，隊列也不止一個，比如有一個文件操作對列，一個時間對列。

const eventloop = {
    queue: [],
    fsQueue: [],
    timerQueue: [],
    loop() {
        while(this.queue.length) {
            const callback = this.queue.shift()
            callback()
        }
        this.fsQueue.forEach(callback => {
            if (done) {
                callback()
            }
        })
        setTimeout(this.loop.bind(this), 50)
    },
    add(callback) {
        this.queue.push(callback)
    }
}

總結(jié)

首先我們弄清楚了什么是非阻塞I/O，即遇到I/O立刻跳過執(zhí)行后面的任務(wù)，不會等待I/O的結(jié)果。當(dāng)I/O處理好了之后就會調(diào)用我們注冊的事件處理函數(shù)，這就叫事件驅(qū)動。實現(xiàn)事件驅(qū)動就必須要用異步編程，異步編程是nodejs中最重要的環(huán)節(jié)，它從回調(diào)函數(shù)到promise，最后到async/await(使用同步的方法寫異步邏輯)。

到此這篇關(guān)于整理幾個關(guān)鍵節(jié)點深入理解nodejs的文章就介紹到這了,更多相關(guān)深入理解nodejs內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論