本文將通過Three.js的介紹及示例帶我們走進3D的奇妙世界。

文章來源：宜信技術學院 & 宜信支付結算團隊技術分享第6期-支付結算部支付研發團隊前端研發高級工程師-劉琳《three.js – 走進3D的奇妙世界》

分享者：宜信支付結算部支付研發團隊前端研發高級工程師-劉琳

原文首發於支付結算團隊公號-“野指針”

隨着人們對用戶體驗越來越重視，Web開發已經不滿足於2D效果的實現，而把目標放到了更加炫酷的3D效果上。Three.js是用於實現web端3D效果的JS庫，它的出現讓3D應用開發更簡單，本文將通過Three.js的介紹及示例帶我們走進3D的奇妙世界。

一、Three.js相關概念

1.1 Three.JS

Three.JS是基於WebGL的Javascript開源框架，簡言之，就是能夠實現3D效果的JS庫。

1.2 WebGL

WebGL是一種Javascript的3D圖形接口，把JavaScript和OpenGL ES 2.0結合在一起。

1.3 OpenGL

OpenGL是開放式圖形標準，跨編程語言、跨平台，Javascript、Java 、C、C++ 、 python 等都能支持OpenG ，OpenGL的Javascript實現就是WebGL，另外很多CAD製圖軟件都採用這種標準。OpenGL ES 2.0是OpenGL的子集，針對手機、遊戲主機等嵌入式設備而設計。

1.4 Canvas

Canvas是HTML5的畫布元素，在使用Canvas時，需要用到Canvas的上下文，可以用2D上下文繪製二維的圖像，也可以使用3D上下文繪製三維的圖像，其中3D上下文就是指WebGL。

二、Three.js應用場景

利用Three.JS可以製作出很多酷炫的3D動畫，並且Three.js還可以通過鼠標、鍵盤、拖拽等事件形成交互，在頁面上增加一些3D動畫和3D交互可以產生更好的用戶體驗。

通過Three.JS可以實現全景視圖，這些全景視圖應用在房產、家裝行業能夠帶來更直觀的視覺體驗。在電商行業利用Three.JS可以實現產品的3D效果，這樣用戶就可以360度全方位地觀察商品了，給用戶帶來更好的購物體驗。另外，使用Three.JS還可以製作類似微信跳一跳那樣的小遊戲。隨着技術的發展、基礎網絡的建設，web3D技術還能得到更廣泛的應用。

三、主要組件

在Three.js中，有了場景（scene）、相機（camera）和渲染器（renderer） 這3個組建才能將物體渲染到網頁中去。

1）場景

場景是一個容器，可以看做攝影的房間，在房間中可以布置背景、擺放拍攝的物品、添加燈光設備等。

2）相機

相機是用來拍攝的工具，通過控制相機的位置和方向可以獲取不同角度的圖像。

3）渲染器

渲染器利用場景和相機進行渲染，渲染過程好比攝影師拍攝圖像，如果只渲染一次就是靜態的圖像，如果連續渲染就能得到動態的畫面。在JS中可以使用requestAnimationFrame實現高效的連續渲染。

3.1 常用相機

1）透視相機

透視相機模擬的效果與人眼看到的景象最接近，在3D場景中也使用得最普遍，這種相機最大的特點就是近大遠小，同樣大小的物體離相機近的在畫面上顯得大，離相機遠的物體在畫面上顯得小。透視相機的視錐體如上圖左側所示，從近端面到遠端面構成的區域內的物體才能显示在圖像上。

透視相機構造器

PerspectiveCamera( fov : Number, aspect : Number, near : Number, far : Number )

• fov — 攝像機視錐體垂直視野角度
• aspect — 攝像機視錐體長寬比
• near — 攝像機視錐體近端面
• far — 攝像機視錐體遠端面

2）正交相機

使用正交相機時無論物體距離相機遠或者近，在最終渲染的圖片中物體的大小都保持不變。正交相機的視錐體如上圖右側所示，和透視相機一樣，從近端面到遠端面構成的區域內的物體才能显示在圖像上。

正交相機構造器

OrthographicCamera( left : Number, right : Number, top : Number, bottom : Number, near : Number, far : Number )

• left — 攝像機視錐體左側面
• right — 攝像機視錐體右側面
• top — 攝像機視錐體上側面
• bottom — 攝像機視錐體下側面
• near — 攝像機視錐體近端面
• far — 攝像機視錐體遠端面

3.2 坐標系

在場景中，可以放物品、相機、燈光，這些東西放置到什麼位置就需要使用坐標系。Three.JS使用右手坐標系，這源於OpenGL默認情況下，也是右手坐標系。從初中、高中到大學的課堂上，教材中所涉及的幾何基本都是右手坐標系。

上圖右側就是右手坐標系，五指併攏手指放平，指尖指向x軸的正方向，然後把四個手指垂直彎曲大拇指分開，併攏的四指指向y軸的正方向，大拇指指向的就是Z軸的正方向。

在Three.JS中提供了坐標軸工具（THREE.AxesHelper），在場景中添加坐標軸后，畫面會出現3條垂直相交的直線，紅色表示x軸，綠色表示y軸，藍色表示z軸（如下圖所示）。

3.3 示例代碼

/* 場景 */
var scene = new THREE.Scene();
scene.add(new THREE.AxesHelper(10)); // 添加坐標軸輔助線

/* 幾何體 */
// 這是自定義的創建幾何體方法，如果創建幾何體後續會介紹
var kleinGeom = createKleinGeom(); 
scene.add(kleinGeom); // 場景中添加幾何體

/* 相機 */
var camera = new THREE.PerspectiveCamera(45, width/height, 1, 100);
camera.position.set(5,10,25); // 設置相機的位置
camera.lookAt(new THREE.Vector3(0, 0, 0)); // 相機看向原點

/* 渲染器 */
var renderer = new THREE.WebGLRenderer({antialias:true});
renderer.setSize(width, height);
// 將canvas元素添加到body
document.body.appendChild(renderer.domElement);
// 進行渲染
renderer.render(scene, camera);

 

四、幾何體

計算機內的3D世界是由點組成，兩個點能夠組成一條直線，三個不在一條直線上的點就能夠組成一個三角形面，無數三角形面就能夠組成各種形狀的幾何體。

以創建一個簡單的立方體為例，創建簡單的立方體需要添加8個頂點和12個三角形的面，創建頂點時需要指定頂點在坐標系中的位置，添加面的時候需要指定構成面的三個頂點的序號，第一個添加的頂點序號為0，第二個添加的頂點序號為1…

創建立方體的代碼如下：

var geometry = new THREE.Geometry();

// 添加8個頂點
geometry.vertices.push(new THREE.Vector3(1, 1, 1));
geometry.vertices.push(new THREE.Vector3(1, 1, -1));
geometry.vertices.push(new THREE.Vector3(1, -1, 1));
geometry.vertices.push(new THREE.Vector3(1, -1, -1));
geometry.vertices.push(new THREE.Vector3(-1, 1, -1));
geometry.vertices.push(new THREE.Vector3(-1, 1, 1));
geometry.vertices.push(new THREE.Vector3(-1, -1, -1));
geometry.vertices.push(new THREE.Vector3(-1, -1, 1));

// 添加12個三角形的面
geometry.faces.push(new THREE.Face3(0, 2, 1));
geometry.faces.push(new THREE.Face3(2, 3, 1));
geometry.faces.push(new THREE.Face3(4, 6, 5));
geometry.faces.push(new THREE.Face3(6, 7, 5));
geometry.faces.push(new THREE.Face3(4, 5, 1));
geometry.faces.push(new THREE.Face3(5, 0, 1));
geometry.faces.push(new THREE.Face3(7, 6, 2));
geometry.faces.push(new THREE.Face3(6, 3, 2));
geometry.faces.push(new THREE.Face3(5, 7, 0));
geometry.faces.push(new THREE.Face3(7, 2, 0));
geometry.faces.push(new THREE.Face3(1, 3, 4));
geometry.faces.push(new THREE.Face3(3, 6, 4));

 

4.1 正面和反面

創建幾何體的三角形面時，指定了構成面的三個頂點，如： new THREE.Face3(0, 2, 1)，如果把頂點的順序改成0,1,2會有區別嗎？

通過下圖可以看到，按照0,2,1添加頂點是順時針方向的，而按0,1,2添加頂點則是逆時針方向的，通過添加頂點的方向就可以判斷當前看到的面是正面還是反面，如果頂點是逆時針方向添加，當前看到的面是正面，如果頂點是順時針方向添加，則當前面為反面。

下圖所看到的面就是反面。如果不好記，可以使用右手沿頂點添加的方向握住，大拇指所在的面就是正面，很像我們上學時學的電磁感應定律。

五、材質

創建幾何體時通過指定幾何體的頂點和三角形的面確定了幾何體的形狀，另外還需要給幾何體添加皮膚才能實現物體的效果，材質就像物體的皮膚，決定了物體的質感。常見的材質有如下幾種：

• 基礎材質：以簡單着色方式來繪製幾何體的材質，不受光照影響。
• 深度材質：按深度繪製幾何體的材質。深度基於相機遠近端面，離近端面越近就越白，離遠端面越近就越黑。
• 法向量材質：把法向量映射到RGB顏色的材質。
• Lambert材質：是一種需要光源的材質，非光澤表面的材質，沒有鏡面高光，適用於石膏等表面粗糙的物體。
• Phong材質：也是一種需要光源的材質，具有鏡面高光的光澤表面的材質，適用於金屬、漆面等反光的物體。
• 材質捕獲：使用存儲了光照和反射等信息的貼圖，然後利用法線方向進行採樣。優點是可以用很低的消耗來實現很多特殊風格的效果；缺點是僅對於固定相機視角的情況較好。

下圖是使用不同貼圖實現的效果：

六、光源

前面提到的光敏材質（Lambert材質和Phong材質）需要使用光源來渲染出3D效果，在使用時需要將創建的光源添加到場景中，否則無法產生光照效果。下面介紹一下常用的光源及特點。

6.1 點光源

點光源類似蠟燭放出的光，不同的是蠟燭有底座，點光源沒有底座，可以把點光源想象成懸浮在空中的火苗，點光源放出的光線來自同一點，且方向輻射向四面八方，點光源在傳播過程中有衰弱，如下圖所示，點光源在接近地面的位置，物體底部離點光源近，物體頂部離光源遠，照到物體頂部的光就弱些，所以頂部會比底部暗些。

6.2 平行光

平行光模擬的是太陽光，光源發出的所有光線都是相互平行的，平行光沒有衰減，被平行光照亮的整個區域接受到的光強是一樣的。

6.3 聚光燈

類似舞台上的聚光燈效果，光源的光線從一個錐體中射出，在被照射的物體上產生聚光的效果。聚光燈在傳播過程也是有衰弱的。

6.4 環境光

環境光是經過多次反射而來的光，環境光源放出的光線被認為來自任何方向，物體無論法向量如何，都將表現為同樣的明暗程度。

環境光通常不會單獨使用，通過使用多種光源能夠實現更真實的光效，下圖是將環境光與點光源混合后實現的效果，物體的背光面不像點光源那樣是黑色的，而是呈現出深褐色，更自然。

七、紋理

在生活中純色的物體還是比較少的，更多的是有凹凸不平的紋路或圖案的物體，要用Three.JS實現這些物體的效果，就需要使用到紋理貼圖。3D世界的紋理是由圖片組成的，將紋理添加在材質上以一定的規則映射到幾何體上，幾何體就有了帶紋理的皮膚。

7.1 普通紋理貼圖

在這個示例中使用上圖左側的地球紋理，在球形幾何體上進行貼圖就能製作出一個地球。

代碼如下：

/* 創建地球 */
function createGeom() {
    // 球體
    var geom = new THREE.SphereGeometry(1, 64, 64);
    // 紋理
    var loader = new THREE.TextureLoader();
    var texture = loader.load('./earth.jpg');
    // 材質
    var material = new THREE.MeshLambertMaterial({
        map: texture
    });
    var earth = new THREE.Mesh(geom, material);
    return earth;
}

 

7.2 反面貼圖實現全景視圖

這個例子是通過在球形幾何體的反面進行紋理貼圖實現的全景視圖，實現原理是這樣的：創建一個球體構成一個球形的空間，把相機放在球體的中心，相機就像在一個球形的房間中，在球體的裏面（也就是反面）貼上圖片，通過改變相機拍攝的方向，就能看到全景視圖了。

材質默認是在幾何體的正面進行貼圖的，如果想要在反面貼圖，需要在創建材質的時候設置side參數的值為THREE.BackSide，代碼如下：

/* 創建反面貼圖的球形 */
// 球體
var geom = new THREE.SphereGeometry(500, 64, 64);
// 紋理
var loader = new THREE.TextureLoader();
var texture = loader.load('./panorama.jpg');
// 材質
var material = new THREE.MeshBasicMaterial({
    map: texture,
    side: THREE.BackSide
});
var panorama = new THREE.Mesh(geom, material);

 

7.3 凹凸紋理貼圖

凹凸紋理利用黑色和白色值映射到與光照相關的感知深度，不會影響對象的幾何形狀，隻影響光照，用於光敏材質（Lambert材質和Phong材質）。

如果只用上圖左上角的磚牆圖片進行貼圖的話，就像一張牆紙貼在上面，視覺效果很差，為了增強立體感，可以使用上圖左下角的凹凸紋理，給物體增加凹凸不平的效果。

凹凸紋理貼圖使用方式的代碼如下：

// 紋理加載器
var loader = new THREE.TextureLoader();
// 紋理
var texture = loader.load( './stone.jpg');
// 凹凸紋理
var bumpTexture = loader.load( './stone-bump.jpg');
// 材質
var material =  new THREE.MeshPhongMaterial( {
    map: texture,
    bumpMap: bumpTexture
} );

 

7.4 法線紋理貼圖

法線紋理也是通過影響光照實現凹凸不平視覺效果的，並不會影響物體的幾何形狀，用於光敏材質（Lambert材質和Phong材質）。上圖左下角的法線紋理圖片的RGB值會影響每個像素片段的曲面法線，從而改變物體的光照效果。

使用方式的代碼如下：

// 紋理
var texture = loader.load( './metal.jpg');
// 法線紋理
var normalTexture = loader.load( './metal-normal.jpg');
var material =  new THREE.MeshPhongMaterial( {
    map: texture,
    normalMap: normalTexture
} );

 

7.5 環境貼圖

環境貼圖是將當前環境作為紋理進行貼圖，能夠模擬鏡面的反光效果。在進行環境貼圖時需要使用立方相機在當前場景中進行拍攝，從而獲得當前環境的紋理。立方相機在拍攝環境紋理時，為避免反光效果的小球出現在環境紋理的畫面上，需要將小球設為不可見。

環境貼圖的主要代碼如下：

/* 立方相機 */
var cubeCamera = new THREE.CubeCamera( 1, 10000, 128 );
/* 材質 */
var material = new THREE.MeshBasicMaterial( {
    envMap: cubeCamera.renderTarget.texture
});
/* 鏡面反光的球體 */
var geom = new THREE.SphereBufferGeometry( 10, 32, 16 );
var ball = new THREE.Mesh( geom, material );
// 將立方相機添加到球體
ball.add( cubeCamera );
scene.add( ball );

// 立方相機生成環境紋理前將反光小球隱藏
ball.visible = false;
// 更新立方相機，生成環境紋理
cubeCamera.update( renderer, scene );
balls.visible = true;

// 渲染
renderer.render(scene, camera);

 

八、加載外部3D模型

Three.JS已經內置了很多常用的幾何體，如：球體、立方體、圓柱體等等，但是在實際使用中往往需要用到一些特殊形狀的幾何體，這時可以使用3D建模軟件製作出3D模型，導出obj、json、gltf等格式的文件，然後再加載到Three.JS渲染出效果。

上圖的椅子是在3D製圖軟件繪製出來的，chair.mtl是導出的材質文件，chair.obj是導出的幾何體文件，使用材質加載器加載材質文件，加載完成后得到材質對象，給幾何體加載器設置材質，加載后得到幾何體對象，然後再創建場景、光源、攝像機、渲染器等進行渲染，這樣就等得到如圖的效果。主要的代碼如下：

// .mtl材質文件加載器
var mtlLoader = new THREE.MTLLoader();
// .obj幾何體文件加載器
var objLoader = new THREE.OBJLoader();

mtlLoader.load('./chair.mtl', function (materials) {
    objLoader.setMaterials(materials)
        .load('./chair.obj', function (obj) {
            scene.add(obj);
            …
        });
});

 

九、說明

以上內容對Three.JS的基本使用進行了介紹，文中涉及到的示例源碼已上傳到github，感興趣的同學可以下載查看，下載地址：https://github.com/liulinsp/three-demo。使用時如果有不清楚的地方可以查看Three.JS的官方文檔：https://threejs.org/docs/index.html。

作者：劉琳

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【精選推薦文章】

自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

評比前十大台北網頁設計、台北網站設計公司知名案例作品心得分享

台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

歡迎關注文章這一系列，一起學習

《提升能力，漲薪可待篇》

《面試知識，工作可待篇》

《實戰演練，拒絕996篇》

如果此文對你有幫助、喜歡的話，那就點個讚唄，點個關注唄！

1.持久化

1.1 持久化簡介

持久化（Persistence），持久化是將程序數據在持久狀態和瞬時狀態間轉換的機制，即把數據（如內存中的對象）保存到可永久保存的存儲設備中（如磁盤）。

1.2 redis持久化

redis為內存數據庫，為了防止服務器宕機以及服務器進程退出后，服務器數據丟失，Redis提供了持久化功能，即將Redis中內存數據持久化到磁盤中。Redis 提供了不同級別的持久化方式：

• RDB持久化方式：可以在指定的時間間隔能對數據進行快照存儲.

• AOF持久化方式：記錄每次對服務器寫的操作,當服務器重啟的時候會重新執行這些命令來恢復原始的數據,AOF命令以redis協議追加保存每次寫的操作到文件末尾.Redis還能對AOF文件進行後台重寫,使得AOF文件的體積不至於過大.

如果服務器開啟了AOF持久化功能。服務器會優先使用AOF文件還原數據。只有關閉了AOF持久化功能，服務器才會使用RDB文件還原數據

2. RDB持久化

2.1 RDB文件格式

RDB文件是一個經過壓縮的二進制文件（默認的文件名：dump.rdb），由多個部分組成，RDB格式：

2.2 RDB文件持久化創建與載入

在 Redis持久化時， RDB 程序將當前內存中的數據庫狀態保存到磁盤文件中， 在 Redis 重啟動時， RDB 程序可以通過載入 RDB 文件來還原數據庫的狀態。

2.3 工作方式

當 Redis 需要保存 dump.rdb 文件時， 服務器執行以下操作:

• Redis 調用forks。同時擁有父進程和子進程。

• 子進程將數據集寫入到一個臨時 RDB 文件中。

• 當子進程完成對新 RDB 文件的寫入時，Redis 用新 RDB 文件替換原來的 RDB 文件，並刪除舊的 RDB 文件。

這種工作方式使得 Redis 可以從寫時複製（copy-on-write）機制中獲益。

2.4 創建方式

SAVE

同步操作，在執行該命令時，服務器會被阻塞，拒絕客戶端發送的命令請求

    redis> save

BGSAVE

異步操作，在執行該命令時，子進程執行保存工作，服務器還可以繼續讓主線程處理客戶端發送的命令請求

 redis>bgsave

自動創建

由於BGSAVE命令可不阻塞服務器進程下執行，可以讓用戶自定義save屬性，讓服務器每個一段時間自動執行一次BGSAVE命令（即通過配置文件對 Redis 進行設置， 讓它在“ N 秒內數據集至少有 M 個改動”這一條件被滿足時， 自動進行數據集保存操作）。

比如：
/*服務器在900秒之內，對數據庫進行了至少1次修改*/
Save 900   1
/*服務器在300秒之內，對數據庫進行了至少10次修改*/
Save 300   10
/*服務器在60秒之內，對數據庫進行了至少10000次修改*/
Save 60     10000

只要滿足其中一個條件就會執行BGSAVE命令

 

 

2.5 RDB 默認配置

################################ SNAPSHOTTING  ################################
#
# Save the DB on disk:
#在給定的秒數和給定的對數據庫的寫操作數下，自動持久化操作。
#   save <seconds> <changes>
# 
save 900 1
save 300 10
save 60 10000
​
#bgsave發生錯誤時是否停止寫入，一般為yes
stop-writes-on-bgsave-error yes
​
#持久化時是否使用LZF壓縮字符串對象?
rdbcompression yes
​
#是否對rdb文件進行校驗和檢驗，通常為yes
rdbchecksum yes
​
# RDB持久化文件名
dbfilename dump.rdb
​
#持久化文件存儲目錄
dir ./

 

3. AOF持久化

3.1 AOF持久化簡介

AOF持久化是通過保存Redis服務器所執行的寫命令來記錄數據庫狀態

 

 

AOF持久化功能實現：

1. append命令追加：當AOF持久化功能處於打開狀態時，服務器執行完一個寫命令會協議格式被執行的命令追加服務器狀態的aof_buf緩衝區的末尾。

   reids>SET KET VAULE //協議格式 \r\n$3\r\nSET\r\n$3\r\nKEY\r\n$5\r\nVAULE\r\n

2. 文件寫入和同步sync：Redis的服務器進程是一個事件循環，這個文件事件負責接收客戶端的命令請求以及向客戶端發送命令回復。當執行了append命令追加后，服務器會調用flushAppendOnlyFile函數是否需要將AOF緩衝區的內容寫入和保存到AOF文件

    redis> SET msg "Ccww"
   redis> SADD persistence "rdb" "aof"
   redis> RPUSH size 128 256 512

 

3.2 AOF持久化策略

AOF持久化策略(即緩衝區內容寫入和同步sync到AOF中)，可以通過配置appendfsync屬性來選擇AOF持久化策略：

• always：將aof_buf緩衝區中的所有內容寫入並同步到AOF文件，每次有新命令追加到 AOF 文件時就執行一次 fsync。

• everysec（默認）：如果上次同步AOF的時間距離現在超過一秒，先將aof_buf緩衝區中的所有內容寫入到AOF文件，再次對AOF文件進行同步，且同步操作由一個專門線程負責執行。

• no：將aof_buf緩衝區中的所有內容寫入到AOF文件，但並不對AOF文件進行同步，何時同步由操作系統(OS)決定。

AOF持久化策略的效率與安全性：

• Always:效率最慢的，但安全性是最安全的，即使出現故障宕機，持久化也只會丟失一個事件 循環的命令數據

• everysec：兼顧速度和安全性，出現宕機也只是丟失一秒鐘的命令數據

• No:寫入最快，但綜合起來單次同步是時間是最長的，且出現宕機時會丟失上傳同步AOF文件之後的所有命令數據。

 

3.3 AOF重寫

由於AOF持久化會把執行的寫命令追加到AOF文件中，所以隨着時間寫入命令會不斷增加， AOF文件的體積也會變得越來越大。AOF文件體積大對Reids服務器，甚至宿主服務器造成影響。

為了解決AOF文件體積膨脹的問題，Redis提供了AOF文件重寫（rewrite）功能：

• 生成一個不保存任何浪費空間的冗餘命令新的AOF文件，且新舊AOF文件保存數據庫狀態一樣的

• 新的AOF文件是通過讀取數據庫中的鍵值對來實現的，程序無須對現有的AOF文件進行讀入，分析，或者寫入操作。

• 為防止緩衝區溢出，重寫處理list，hash，set以及Zset時，超過設置常量數量時會多條相同命令記錄一個集合。

• Redis 2.4 可以通過配置自動觸發 AOF 重寫，觸發參數 auto-aof-rewrite-percentage(觸發AOF文件執行重寫的增長率) 以及 auto-aof-rewrite-min-size(觸發AOF文件執行重寫的最小尺寸)

AOF重寫的作用：

• 減少磁盤佔用量

• 加速數據恢復

 

Redis服務器使用單個線程來處理命令請求，服務器大量調用aof_rewrite函數，在AOF重寫期間，則無法處理client發來的命令請求，所以AOF重寫程序放在子進程執行，好處：

1. 子進程進行AOF重寫期間，服務器進程可以繼續處理命令請求

2. 子進程帶有服務器進程的數據副本，保證了數據的安全性。

AOF重寫使用子進程會造成數據庫與重寫后的AOF保存的數據不一致，為了解決這種數據不一致，redis使用了AOF重寫緩衝區 實現：

BGREWRITEAOF命令實現原理（只有信號處理函數執行時才對服務器進程造成阻塞）：

• 執行命令，同時將命令追加到AOF緩衝區和AOF重寫緩衝區

• 當AOF子進程重寫完成后，發送一個信號給父進程，父進程將執行AOF重寫緩衝區中的所有內容寫入到新AOF文件中，新AOF文件保存的數據庫狀態將和服務器當前的數據庫狀態一致。

• 對新的AOF文件進行改名，原子性地覆蓋現有AOF文件，完成新舊兩個AOF文件替換處理完成。

 

 

3.4 AOF持久化默認參數

############################## APPEND ONLY MODE ###############################
​
#開啟AOF持久化方式
appendonly no
​
#AOF持久化文件名
appendfilename "appendonly.aof"
#每秒把緩衝區的數據fsync到磁盤
appendfsync everysec
# appendfsync no
#是否在執行重寫時不同步數據到AOF文件
no-appendfsync-on-rewrite no
​
# 觸發AOF文件執行重寫的增長率
auto-aof-rewrite-percentage 100
#觸發AOF文件執行重寫的最小size
auto-aof-rewrite-min-size 64mb
​
#redis在恢復時，會忽略最後一條可能存在問題的指令
aof-load-truncated yes
​
#是否打開混合開關
aof-use-rdb-preamble yes

4 持久化方式總結與抉擇

4.1 RDB優缺點

RDB的優點

• RDB是一個非常緊湊的文件,它保存了某個時間點得數據集,非常適用於數據集的備份,比如你可以在每個小時報保存一下過去24小時內的數據,同時每天保存過去30天的數據,這樣即使出了問題你也可以根據需求恢復到不同版本的數據集.

• 基於RDB文件緊湊性,便於複製數據到一個遠端數據中心，非常適用於災難恢復.

• RDB在保存RDB文件時父進程唯一需要做的就是fork出一個子進程,接下來的工作全部由子進程來做，父進程不需要再做其他IO操作，所以RDB持久化方式可以最大化redis的性能.

• 與AOF相比,在恢復大的數據集的時候，RDB方式會更快一些.

RDB的缺點

• 如果你希望在redis意外停止工作（例如電源中斷）的情況下丟失的數據最少的話，那麼RDB不適合你.雖然你可以配置不同的save時間點(例如每隔5分鐘並且對數據集有100個寫的操作),是Redis要完整的保存整個數據集是一個比較繁重的工作,你通常會每隔5分鐘或者更久做一次完整的保存,萬一在Redis意外宕機,你可能會丟失幾分鐘的數據.

• RDB 需要經常fork子進程來保存數據集到硬盤上,當數據集比較大的時候,fork的過程是非常耗時的,可能會導致Redis在一些毫秒級內不能響應客戶端的請求.如果數據集巨大並且CPU性能不是很好的情況下,這種情況會持續1秒,AOF也需要fork,但是你可以調節重寫日誌文件的頻率來提高數據集的耐久度.

4.2 AOF的優缺點

AOF的優點：

• 使用AOF 會讓你的Redis更加耐久:使用不同的fsync策略：無fsync,每秒fsync,每次寫的時候fsync.使用默認的每秒fsync策略,Redis的性能依然很好(fsync是由後台線程進行處理的,主線程會儘力處理客戶端請求),一旦出現故障，你最多丟失1秒的數據.

• AOF文件是一個只進行追加的日誌文件,所以不需要寫入seek,即使由於某些原因(磁盤空間已滿，寫的過程中宕機等等)未執行完整的寫入命令,你也可使用redis-check-aof工具修復問題.

• Redis可以在AOF文件體積變得過大時，自動對 AOF 進行重寫： 重寫后的新 AOF 文件包含了恢復當前數據集所需的最小命令集合。 整個重寫操作是絕對安全的，因為 Redis 在創建新 AOF 文件的過程中，會繼續將命令追加到現有的 AOF 文件裏面，即使重寫過程中發生停機，現有的 AOF 文件也不會丟失。 而一旦新 AOF 文件創建完畢，Redis 就會從舊 AOF 文件切換到新 AOF 文件，並開始對新 AOF 文件進行追加操作。

• AOF 文件有序地保存了對數據庫執行的所有寫入操作， 這些寫入操作以 Redis 協議的格式保存， 因此 AOF 文件的內容非常容易被人讀懂， 對文件進行分析（parse）也很輕鬆。 導出（export） AOF 文件也非常簡單（例如， 如果你不小心執行了 FLUSHALL 命令， 但只要 AOF 文件未被重寫， 那麼只要停止服務器， 移除 AOF 文件末尾的 FLUSHALL 命令， 並重啟 Redis ， 就可以將數據集恢復到 FLUSHALL 執行之前的狀態）。

AOF 缺點：

• 對於相同的數據集來說，AOF 文件的體積通常要大於 RDB 文件的體積。

• 根據所使用的 fsync 策略，AOF 的速度可能會慢於 RDB 。 在一般情況下， 每秒 fsync 的性能依然非常高， 而關閉 fsync 可以讓 AOF 的速度和 RDB 一樣快， 即使在高負荷之下也是如此。 不過在處理巨大的寫入載入時，RDB 可以提供更有保證的最大延遲時間（latency）。

4.3 如何選擇使用哪種持久化方式？

一般來說， 如果想達到足以媲美 PostgreSQL 的數據安全性， 你應該同時使用兩種持久化功能。

如果你非常關心你的數據， 但仍然可以承受數分鐘以內的數據丟失， 那麼你可以只使用 RDB 持久化。

有很多用戶都只使用 AOF 持久化， 但我們並不推薦這種方式： 因為定時生成 RDB 快照（snapshot）非常便於進行數據庫備份， 並且 RDB 恢複數據集的速度也要比 AOF 恢復的速度要快， 除此之外， 使用 RDB 還可以避免之前提到的 AOF 程序的 bug 。

也歡迎關注公眾號【Ccww筆記】，原創技術文章第一時間推出

如果此文對你有幫助、喜歡的話，那就點個讚唄，點個關注唄！

 

 

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【精選推薦文章】

智慧手機時代的來臨，RWD網頁設計已成為網頁設計推薦首選

想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

帶您來看台北網站建置，台北網頁設計，各種案例分享

廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

引入

在實際應用中，我們經常需要從一組對象中查找最大值或最小值。當然我們可以每次都先排序，然後再進行查找，但是這種做法效率很低。哪么有沒有一種特殊的數據結構，可以高效率的實現我們的需求呢，答案就是堆(heap)

堆分為最小堆和最大堆，它們的性質相似，我們以最小堆為例子。

最小堆

舉例

如上圖所示，就為一個最小堆。

特性

• 是一棵完全二叉樹

如果一顆二叉樹的任何結點，或者是樹恭弘=叶 恭弘，或者左右子樹均非空，則這棵二叉樹稱做滿二叉樹（full binary tree）

如果一顆二叉樹最多只有最下面的兩層結點度數可以小於2，並且最下面一層的結點都集中在該層最左邊的連續位置上，則此二叉樹稱做完全二叉樹（complete binary tree）

• 局部有序

最小堆對應的完全二叉樹中所有結點的值均不大於其左右子結點的值，且一個結點與其兄弟之間沒有必然的聯繫

二叉搜索樹中，左子 < 父 < 右子

存儲結構

由於堆是一棵完全二叉樹，所以我們可以用順序結構來存儲它，只需要計算簡單的代數表達式，就能夠非常方便的查找某個結點的父結點和子節點，既避免了使用指針來保持結構，又能高效的執行相應操作。

結點i的左子結點為2xi+1,右子結點為2xi+2
結點i的父節點為(i-1)/2

數據結構

// 本例為最小堆
// 最大堆只需要修改less函數即可
type Heap []int

func (h Heap) swap(i, j int) {
    h[i], h[j] = h[j], h[i]
}

func (h Heap) less(i, j int) bool {
    return h[i] < h[j]
}

如上所示，我們使用slice來存儲我們的數據，為了後續方便我們在此定義了 swap 和 less 函數，分別用來交換兩個結點和比較大小。

插入-Push

如上圖所示，首先，新添加的元素加入末尾。為了保持最小堆的性質，需要沿着其祖先的路徑，自下而上依次比較和交換該結點與父結點的位置，直到重新滿足堆的性質為止。

這樣會出現兩種情況，要麼新結點升到最小堆的頂端，要麼到某一位置時發現父結點比新插入的結點關鍵值小。

上面的流程代碼如下：

func (h Heap) up(i int) {
    for {
        f := (i - 1) / 2 // 父親結點
        if i == f || h.less(f, i) {
            break
        }
        h.swap(f, i)
        i = f
    }
}

實現了最核心的 up 操作后，我們的插入操作 push 便很簡單，代碼如下：

// 注意go中所有參數轉遞都是值傳遞
// 所以要讓h的變化在函數外也起作用，此處得傳指針
func (h *Heap) Push(x int) {
    *h = append(*h, x)
    h.up(len(*h) - 1)
}

刪除-Remove

如上圖所示，首先把最末端的結點填入要刪除節點的位置，然後刪除末端元素，同理，這樣做也可能導致破壞最小堆的堆序特性。

為了保持堆的特性，末端元素需要與被刪除位置的父結點做比較，如果小於父結點，就要up（詳細代碼看插入）如果大於父結點，就要再和被刪除位置的子結點做比較，即down，直到該結點下降到小於最小子結點為止。

上面down的流程代碼如下：

func (h Heap) down(i int) {
    for {
        l := 2*i + 1 // 左孩子
        if l >= len(h) {
            break // i已經是恭弘=叶 恭弘子結點了
        }
        j := l
        if r := l + 1; r < len(h) && h.less(r, l) {
            j = r // 右孩子
        }
        if h.less(i, j) {
            break // 如果父結點比孩子結點小，則不交換
        }
        h.swap(i, j) // 交換父結點和子結點
        i = j        //繼續向下比較
    }
}

實現了核心的 down 操作后，我們的 Remove 便很簡單，代碼如下：

// 刪除堆中位置為i的元素
// 返回被刪元素的值
func (h *Heap) Remove(i int) (int, bool) {
    if i < 0 || i > len(*h)-1 {
        return 0, false
    }
    n := len(*h) - 1
    h.swap(i, n) // 用最後的元素值替換被刪除元素
    // 刪除最後的元素
    x := (*h)[n]
    *h = (*h)[0:n]
    // 如果當前元素大於父結點，向下篩選
    if (*h)[i] > (*h)[(i-1)/2] {
        h.down(i)
    } else { // 當前元素小於父結點，向上篩選
        h.up(i)
    }
    return x, true
}

彈出-Pop

當i=0時，Remove 就是 Pop

// 彈出堆頂的元素，並返回其值
func (h *Heap) Pop() int {
    n := len(*h) - 1
    h.swap(0, n)
    x := (*h)[n]
    *h = (*h)[0:n]
    h.down(0)
    return x
}

初始化-Init

在我們講完了堆的核心操作 up 和 down 后，我們來講如何根據一個數組構造一個最小堆。

其實我們可以寫個循環，然後將各個元素依次 push 進去，但是這次我們利用數學規律，直接由一個數組構造最小堆。

首先，將所有關鍵碼放到一維數組中，此時形成的完全二叉樹並不具備最小堆的特徵，但是僅包含恭弘=叶 恭弘子結點的子樹已經是堆。

即在有n個結點的完全二叉樹中，當 i>n/2-1 時，以i結點為根的子樹已經是堆。

func (h Heap) Init() {
    n := len(h)
    // i > n/2-1 的結點為恭弘=叶 恭弘子結點本身已經是堆了
    for i := n/2 - 1; i >= 0; i-- {
        h.down(i)
    }
}

測試

func main() {
    var h = heap.Heap{20, 7, 3, 10, 15, 25, 30, 17, 19}
    h.Init()
    fmt.Println(h) // [3 7 20 10 15 25 30 17 19]

    h.Push(6)
    fmt.Println(h) // [3 6 20 10 7 25 30 17 19 15]

    x, ok := h.Remove(5)
    fmt.Println(x, ok, h) // 25 true [3 6 15 10 7 20 30 17 19]

    y, ok := h.Remove(1)
    fmt.Println(y, ok, h) // 6 true [3 7 15 10 19 20 30 17]

    z := h.Pop()
    fmt.Println(z, h) // 3 [7 10 15 17 19 20 30]
}

完整代碼

堆排序

在講完堆的基礎知識后，我們再來看堆排序就變得非常簡單。利用最小堆的特性，我們每次都從堆頂彈出一個元素（這個元素就是當前堆中的最小值），即可實現升序排序。代碼如下：

// 堆排序
var res []int
for len(h) != 0 { 
    res = append(res, h.Pop())
}
fmt.Println(res)

優先隊列

優先隊列是0個或者多個元素的集合，每個元素都有一個關鍵碼，執行的操作有查找，插入和刪除等。

優先隊列的主要特點是支持從一個集合中快速地查找並移出具有最大值或最小值的元素。

堆是一種很好的優先隊列的實現方法。

參考資料

• 《數據結構與算法》張銘 王騰蛟 趙海燕 編著
• GO SDK 1.13.1 /src/container/heap

最後

本文是自己的學習筆記，在刷了幾道LeetCode中關於堆的題目后，感覺應該系統的學習和總結一下這一重要的數據結構了。

強烈建議看Go的源碼中關於heap的實現，仔細感受面向接口編程的思想，和他們的代碼風格以及質量。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【精選推薦文章】

自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

評比前十大台北網頁設計、台北網站設計公司知名案例作品心得分享

台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"