標籤: 台北網頁設計公司

Java性能分析神器1–VisualVM Launcher

VisualVM

當你日復一日敲代碼的時候，當你把各種各樣的框架集成到一起的時候，看着大功告成成功運行的日誌，有沒有那麼一絲絲迷茫和惆悵：這TM起的是什麼玩意？每一行日誌背後代表的是什麼東西？？他為什麼就能跑起來了呢？？？？

這種時候不要慌，給大家推薦一款功能強大的插件：VisualVM Launcher。(eclipse就叫 )。這個插件需要和客戶端配合使用 。

VisualVM是集成了命令行JDK工具和輕量級分析功能的可視化工具。JVM提供了一些常用的jdk命令行工具：

• jstat(JVM Statistics Monitoring Tool):用於收集Hotspot虛擬機各方面的運行數據(查看虛擬機各雲心狀態信息)，显示本地或遠程虛擬機進程中的類裝載，內存，垃圾收集， JIT編譯等運行數據。
• jps(JVM Process Status Tool):显示指定系統內所有的HotSpot虛擬機進程(查看虛擬機進程信息)，可用於查詢正在運行的虛擬機進程， 同時可選擇性的显示虛擬機執行主類， 即執行main函數的類， 以及進程的本地虛擬機
  ID(Local Virtual Machine Identifier 簡稱LVMID)（對於本地虛擬機進程來說， 進程的本地虛擬機ID與操作系統的進程ID是一致的）
• jinfo(Configuration Info for Java):显示虛擬機配置信息(查看虛擬機配置參數信息)，可用於查看和調整虛擬機的配置參數.
• jmap(JVM Memory Map):生成虛擬機的內存轉儲快照， 生成heapdump文件(生成虛擬機內存轉儲快照)，可用於獲取heapdump文件， 且可以查詢finalize執行隊列， Java堆與永久代的一些信息。
• jhat(JVM Heap Dump Browser):用於分析heapdump文件， 它會建立一個HTTP/HTML服務器， 讓用戶在瀏覽器上查看分析結果(分析虛擬機轉儲快照信息)，jhat命令與jmap命令搭配使用， 用於分析jmap生成的堆轉儲快照， jhat內置了一個微型的HTTP/HTML服務器， 生成dump文件的分析結果后， 可以在瀏覽器中查看。
• jstack(JVM Stack Trace):显示虛擬機的線程快照(虛擬機堆棧跟蹤)，用於生成虛擬機當前時刻的線程快照。 線程快照指的是當前虛擬機內的每一條線程正在執行的方法堆棧的集合， 生成線程快照的作用是， 可用於定位線程出現長時間停頓的原因， 如線程間死鎖， 死循環， 請求外部資源導致的長時間等待等問題， 當線程出現停頓時 就可以用jstack各個線程調用的堆棧情況

這些工具功能強大，可以很方便的查看jvm內存分配，內存大小，裝載類總數，線程總數等。有了這些信息，就可以很快的進程診斷，性能調優辣。

安裝VisualVM和VisualVM Launcher

1. Idea安裝VisualVM Launcher插件

​ Preferences –> Plugins –> 搜索VisualVM Launcher，安裝重啟即可

2. 配置Idea VisualVM Launcher插件

​ Preferences –> other settings -> VisualVM Launcher –> 輸入VisualVM executable 和 JDK home即可

3. 配置完之後的idea頁面

4. 安裝VisualVM客戶端

​ –> 選擇對應的系統安裝包 –> 對應安裝，安裝完成后打開是這樣的頁面：

VisualVM和java命令行工具

1. jmap+jhat內存快照與分析：Heap Dump

1. HeapDump又叫做堆存儲文件，指一個Java進程在某個時間點的內存快照。Heap Dump在觸發內存快照的時候會保存此刻的java對象和類的信息。通常在寫heap Dump文件前會觸發一次FullGC，所以heap dump文件里保存的都是FullCG后留下的對象信息。

2. jmap進行內存快照方式：

   jmap -dump:format=b,file=<filename.hprof> <pid>

3. jhat進行內存快照分析：

   • jhat <heap dump file>
   • 使用了jhat命令，就啟動了一個http服務，端口是7000，即http://localhost:7000/，就可以在瀏覽器里分析

4. VisualVM進行內存快照方式：

   • 在“應用程序”窗口中右鍵單擊應用程序節點，然後選擇“堆 Dump”。
   • 在“應用程序”窗口中雙擊應用程序節點以打開應用程序標籤，然後在“監視”標籤中單擊“堆 Dump”。

5. VisualVM快照頁面，也可以右鍵保存此時的快照：

6. 想要打開保存好的java快照:

   • 單擊“堆 Dump”工具欄中的“類”，以查看活動類和對應實例的列表。
   • 雙擊某個類名打開“實例”視圖，以查看實例列表。
   • 從列表中選擇某個實例，以查看對該實例的引用。

2. jinfo：显示虛擬機配置信息(查看虛擬機配置參數信息)

1. 虛擬機配置信息：JVM的啟動參數

2. jinfo進行查看虛擬機配置信息查詢(jinfo -help查看更多)

   jinfo <pid>

3. Visual VM查看虛擬機配置信息，直接在應用程序打開，就可以看到JVM參數 和 系統屬性：

4. 一些常見的虛擬機配置參數：

   • -Xms：初始堆大小。如：-Xms256m
   • -Xmx：最大堆大小。如：-Xmx512m
   • -Xmn：新生代大小。通常為 Xmx 的 1/3 或 1/4。
   • -Xss：為每個線程分配的內存大小，JDK1.5+ 每個線程堆棧大小為 1M，一般來說如果棧不是很深的話， 1M 是絕對夠用了的。
   • -XX:NewRatio：新生代與老年代的比例，如 –XX:NewRatio=2，則新生代占整個堆空間的1/3，老年代佔2/3
   • -XX:SurvivorRatio：新生代中 Eden 與 Survivor 的比值。默認值為 8。即 Eden 佔新生代空間的 8/10，另外兩個 Survivor 各占 1/10
   • -XX:PermSize：永久代(方法區)的初始大小
     • PermSize永久代的概念在jdk1.8中已經不存在了，取而代之的是metaspace元空間，當認為執行永久代的初始大小以及最大值是jvm會給出如此下提示：
       • Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=30m; support was removed in 8.0
       • Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=30m; support was removed in 8.0
   • -XX:MaxPermSize：永久代(方法區)的最大值
   • -XX:+PrintGCDetails：打印 GC 信息
   • -XX:+HeapDumpOnOutOfMemoryError：讓虛擬機在發生內存溢出時 Dump 出當前的內存堆轉儲快照，以便分析用

3. jps查看虛擬機進程信息

1. 用來查詢正在運行的虛擬機進程

2. jps命令，：

   • jps

3. VisualVM查看正在運行的虛擬機進程：

4. jstack显示虛擬機的線程快照

1. 生成虛擬機當前時刻的線程快照，用來查找運行時死鎖，死循環的原因

2. jstack命令，

   • jstack <pid>

3. VisualVM生成虛擬機線程快照方式：

   • 在“應用程序”窗口中右鍵單擊應用程序節點，然後選擇“線程 Dump”。
   • 在“應用程序”窗口中雙擊應用程序節點以打開應用程序標籤，然後在“線程”標籤中單擊“線程 Dump”。

4. VisualVM線程快照頁面，也可以右鍵保存快照：

5. jstat收集Hotspot虛擬機各方面的運行數據

1. 運行數據：對Java應用程序的資源和性能進行實時監控，主要包括GC情況和Heap Size資源使用情況。

2. jstat進行資源與性能監控，：

   • jstat -gc <pid>

3. VisualVM進行程序資源的實時監控：

VisualVM也提供了一些其他功能

此外，VisualVM也提供很多插件，有各樣的功能，我就不多介紹了

這篇文章，介紹了VisualVM的作用和用法，下面會寫一篇姊妹篇 帶上代碼，去分析當系統出現死鎖或者循環等異常時，內存、線程和CPU在做什麼。

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

【其他文章推薦】

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

※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

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

目錄

示例代碼託管在：

博客園地址：

華為雲社區地址：

附件PPT來自開發文檔。術語里的cc指的是Chromium Compositor

一直以來都想了解瀏覽器合成層的運作機制，但是相關的中文資料大多比較關注框架和開發技術，這方面的資料實在是太少了，後來在chromium官方網站的文檔里找到了項目組成員malaykeshav在 2019年4月的一份關於瀏覽器合成流水線的演講PPT，個人感覺裏面講的非常清楚了，由於沒有找到視頻，有些部分只能自行理解，本文僅對關鍵信息做一些筆記，對此感興趣的讀者可以在文章開頭的github倉庫或附件中拿到這個PPT自行學習。

摘要

1.合成流水線

合成流水線，就是指瀏覽器處理合成層的工作流程，其基本步驟如下：

大致的流程就是說Paint環節會生成一個列表，列表裡登記了頁面元素的繪製指令，接着這個列表需要經過Raster光柵化處理，並在合成幀中處理紋理，最後的Draw環節才是將這些紋理圖展示在瀏覽器內容區。

2. 預定義UI層

chromium中預定義了一些指定類型的UI層，大致分為：

• Not Drawn – 為了處理透明度或濾鏡效果、transform變形或者clip剪裁的非繪製層
• Solid color layer – 固有顏色層
• Painted texture layer – Texture紋理會在這個層執行paint渲染和後續的rasterized光柵化任務
• Transferable resource layer – 共享資源層，可能是GPU裏面的Texture紋理也可能未來會發給GPU的位圖
• Surface layer – 臨時佔位層，因為自頂向下遍歷layer樹時子樹都還沒處理，需要先佔位最後再填充
• Nine patch layer – 用於實現陰影的層

3. paint是什麼意思

每個層layer是由若干個views組成的，所謂paint，就是每個views將自己對應圖形的繪製指令添加到層的可展示元素列表Display Item List里，這個列表會被添加到一個延遲執行的光柵化任務中，並最終生成當前層的texture紋理（可以理解為當前層的繪製結果），考慮到傳輸性能以及未來增量更新的需求，光柵化的結果會以tiles瓦片形式保存。在chrome中也可以看到頁面瓦片化拆分的結果:

4. 分層的優勢和劣勢

分層的優勢和劣勢也在此進行了說明，和之前我們主動思考的答案基本一致（暗爽一下）。

5. 視圖屬性及其處理方式

views中支持的屬性包含Clip剪裁，transform變換,effect效果（如半透明或濾鏡等）,mask遮罩，通常按照後序遍歷的方式自底向上進行遍歷處理。

clip剪裁的處理方式是在父節點和子節點之間插入一個剪裁層，用來將其子樹的渲染結果剪裁到限定的範圍內，然後再向上與父級進行合併；

transform變換直接作用於父節點，處理到這個節點時其子樹都已經處理完畢，直接將整體應用變形即可；

effect效果一般直接作用於當前處理的節點，有時也會產生交叉依賴的場景；

PPT第40頁中在介紹effect效果處理時描述了兩種不同的透明度處理需求，從而引出了一個Render Surface的概念，它相當於一個臨時的層，它的子樹需要先繪製在這個層上，然後再向上與父節點進行合併，屏幕就是是根級的Render Surface。

6. Quads

Layer遍歷處理輸出的結果被稱為Quads（從意思上理解好像就是指輸出了很多個矩形方塊），每個quad都持有它被繪製到目標緩衝區所需要的資源，根據它持有的資源不同可以分為：

• Solid Color-固定顏色型
• Texture– 紋理型
• Tile– 瓦片型
• Surface– 臨時繪圖表面型
• Video – 視頻幀型
• Render Pass – Render Surface類型的佔位區，Render Surface子樹處理完后填充到關聯的Render Pass

7. Compositor Frame

合成層真正的工作要開始了，主角概念Compositor Frame(合成幀)登場，它負責將quads合併繪製在一起，膠片里59-62頁非常清楚地展示了合成的過程，最終輸出的結果就是根節點的紋理。

chromium是多進程架構，Browser Process瀏覽器進程會對菜單欄等等容器部分的畫面生成合成幀來輸出，每個網頁的Render Process渲染進程會對頁面內容生成合成幀來輸出，最終的結果都被共享給GPU ProcessGPU進程進行聚合併生成最終完整的合成表面，接着在Display Compositor環節將最後的位圖展示在屏幕上。

8. 關於光柵化以及渲染方式

膠片里並沒有描述具體的光柵化的處理過程，但是layer輸出的quads看起來應該是光柵化以後的結果，推測應該是處理Display Item List中的繪圖指令時也和WebGL類似，經過頂點着色器和片元着色器的遍歷式處理機制，並在過程中自動完成像素插值。

9.【重要】軟件渲染和硬件渲染的區別

聲明：本節內容是個人理解，僅用作技術交流，不保證對！

軟件渲染和硬件渲染的區別對筆者而言一直非常抽象，只是知道基本概念。後來在（國內可能無法訪問）中《Compositor Thread Architecture》這篇合成器線程架構的文章中找到了一些相關描述，也解開了筆者心中一直以來的疑惑，相關部分摘抄如下：

Texture Upload

One challenge with all these textures is that we rasterize them on the main thread of the renderer process, but need to actually get them into the GPU memory. This requires handing information about these textures (and their contents) to the impl thread, then to the GPU process, and once there, into the GL/D3D driver. Done naively, this causes us to copy a single texture over and over again, something we definitely don’t want to do.

We have two tricks that we use right now to make this a bit faster. To understand them, an aside on “painting” versus “rasterization.”

• Painting is the word we use for telling webkit to dump a part of its RenderObject tree to a GraphicsContext. We can pass the painting routine a GraphicsContext implementation that executes the commands as it receives them, or we can pass it a recording context that simply writes down the commands as it receives them.
• Rasterization is the word we use for actually executing graphics context commands. We typically execute the rasterization commands with the CPU (software rendering) but could also execute them directly with the GPU using Ganesh.
• Upload: this is us actually taking the contents of a rasterized bitmap in main memory and sending it to the GPU as a texture.With these definitions in mind, we deal with texture upload with the following tricks:
• Per-tile painting: we pass WebKit paint a recording context that simply records the GraphicsContext operations into an SkPicture data structure. We can then rasterize several texture tiles from that one picture.
• SHM upload: instead of rasterizing into a void* from the renderer heap, we allocate a shared memory buffer and upload into that instead. The GPU process then issues its glTex* operations using that shared memory, avoiding one texture copy.The holy grail of texture upload is “zero copy” upload. With such a scheme, we manage to get a raw pointer inside the renderer process’ sandbox to GPU memory, which we software-rasterize directly into. We can’t yet do this anywhere, but it is something we fantasize about.

大概翻譯一下，方便英語水平一般的小夥伴理解，GPU處理圖片的方式是按照Texture進行貼圖的，對此不熟悉的小夥伴可以查看筆者以前發的有關Three.js相關的博文。

紋理上傳:
處理紋理的挑戰之一就是它是在渲染進程（可以理解為單個Tab網頁的進程）的主線程里進行的，但是最終需要將其放入GPU內存。這就需要將紋理數據遞交給合成器線程，然後再交給GPU進程（Chromium架構里有專門的GPU進程用來專門處理和GPU之間的協作任務），最後再傳遞給底層的Direct3D或OpenGL（也就是圖形學的底層技術），如果只是按照常規流程來處理，就會需要一次又一次來複制生成的紋理數據，這顯然不是我們想要的。
我們現在使用了兩個小方法來使這個流程變得快一點。它們分別作用於painting（繪製）和rasterization（光柵化）兩個階段。

• 1號知識點！！！Painting我們用來告訴webkit為RenderObject Tree的來生成對應的GraphicsContext。通過給painting routine（繪製流程）傳遞一個GraphicsContext的具體實現來執行這些已經編排好的繪製命令，也可以傳遞一個record context（記錄上下文）只是簡單地把繪圖命令都記錄下來。
• 2號知識點！！！Rasterization（光柵化）是指Graphics context關聯的繪圖命令實際被執行的過程。通常我們使用CPU（也就是軟件渲染的方式）來執行光柵化任務，也可以直接使用GPU來渲染（也就是硬件渲染的方式）。
• 上傳：指在主線程存儲區獲取到光柵化以後的位圖內容然後將它作為紋理上傳給GPU的過程，考慮到上述已經提及的定義，上傳過程是如下來處理的：
  • 瓦片繪製：我們在webkit中使用recording context來簡單地記錄Graphics Context的操作指令，將它存儲為SkPicture類型（直接使用軟件光柵化時生成的是SkBitmap類型），隨後可以從一張picture裏面光柵化處理得到多個紋理瓦片。
  • 共享內存：在軟件渲染的方式中，光柵化的結果會被存儲在renderer進程的堆內存里，現在不這樣搞了，我們重新分配了一塊共享緩衝區，然後通過它來傳遞相關對象，GPU進程隨後在獲取紋理時直接從共享內存中獲取就行了，這樣就避免了數據的拷貝。
    總的來說，紋理上傳的過程幾乎是零拷貝的。利用這樣的結構，我們在renderer進程（也就是網頁的渲染進程）的沙箱環境內也可以獲取到指向GPU 內存的指針，而在軟件光柵化的過程中，是直接將位圖結果放在這裏的。

• Painting: this is the process of asking Layers for their content. This is where we ask webkit to tell us what is on a layer. We might then rasterize that content into a bitmap using software, or we might do something fancier. Painting is a main thread operation.
• Drawing: this is the process of taking the layer tree and smashing it together with OpenGL onto the screen. Drawing is an impl-thread operation.
• painting:表示的過程是向Layers對象查詢層內容，也就是讓webkit告訴我們每一層上面到底有什麼。接下來我們就可以使用軟件光柵化的方式將這些內容處理為位圖，也可以做一些更牛的事情，painting是一個主線程行為。
• drawing：是指將Layer中的內容用OpenGL繪製在屏幕上的過程，它是另一個線程中的操作。

概念比較多沒有基礎的讀者可能理解起來有難度，我嘗試用自己的話複述一下：

【軟件渲染】的模式下，在paint時會直接利用Graphics Context繪圖上下文將結果繪製出來，在一個SkBitmap實例中保存為位圖信息；【硬件渲染】的模式下，在paint時傳入一個SkPicture實例，將需要執行的繪圖命令保存在裏面先不執行，然後通過共享內存將它傳給GPU進程，藉助GPU來最終去執行繪圖命令，生成多個瓦片化的位圖紋理結果（OpenGL中頂點着色器向片元着色器傳遞數據時可以自動進行數據插值，完成光柵化的任務）。 純軟件渲染里嚴格說是沒有合成層概念的，因為最終輸出的只有一張位圖，按照順序從下往上畫，和畫到一個新層上再把新層貼到已有結果上其實是一樣的。

不管使用哪種途徑，paint動作都是得到位圖數據，而最終的draw這個動作是藉助OpenGL和位圖數據最終把圖形显示在显示器上。

所以【硬件渲染】就是渲染進程把要做的事情和需要的數據都寫好，然後打包遞給GPU讓它去幹活。

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

【其他文章推薦】

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

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

最近，我們對新版博客後台（Angular 8.2.7 + .NET Core 3.0）進行了灰度發布，如果您訪問博客後台時跳轉到 ，說明使用的就是新版博客後台。

今天我們在一次基於 gitlab-ci 的自動化發布過程中，由於操作問題在發布前沒有對 appsettings.Production.json 的修改進行保存，造成容器在啟動時使用了舊版的配置文件，再加上容器的健康檢查不能檢查出這種不正常情況（這個地方的改進還沒完成），最不該的是在發布后沒有對關鍵功能進行測試驗證以及值班人員沒有及時處理用戶反饋，從而造成 18:22~19:27 期間使用新版博客后的用戶無法正常發布博文，非常抱歉由此給您帶來了麻煩，請您諒解。

我們會吸取教訓，並採取以下改進措施：

• 更高優先級改進健康檢查。一是容器的健康檢查，二是阿里云云監控的健康檢查。當關鍵功能不可用時，讓健康檢查失敗（之前的健康檢查沒有對業務功能進行檢查）。這樣發布時如果出現問題，容器健康檢查失敗，docker swarm 就不會部署新容器。當正在運行的容器出現問題影響關鍵功能的使用時及時報警。
• 盡可能實現在生產環境發布後用“機器人”對關鍵功能進行測試驗證。
• 每次自動化發布時在值班群發消息通知值班人員留意用戶反饋。

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

【其他文章推薦】

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

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

對於MySQL而言，其實分為客戶端與服務端。

• 服務端，就是MySQL應用，當我們使用net start mysql命令啟動的服務，其實就是啟動了MySQL的服務端。

• 客戶端，負責發送請求到服務端並從服務端獲取數據，客戶端可以有多種形式，可以是我們通過mysql -uroot -p1234打開的黑窗口，也可以是我們使用的Nativecat、SQLyog等數據庫連接工具，甚至我們的程序，也可以稱作MySQL的客戶端。

而當我們在mysql窗口或者數據庫連接工具中輸入一句sql后，我們就可以獲取到想要的數據，這中間MySQL到底是怎麼工作的呢？

在我們執行SQL后，例如一句簡單的select * from user where name = ‘yanger’，客戶端發送請求到服務端，請求到達Server層，會經過連接器、查詢緩存、分析器、優化器、執行器等，最終通過存儲引擎從文件系統獲取數據或者插入數據到文件系統。

連接器

在客戶端程序發起連接的時候，需要攜帶主機信息、用戶名、密碼，服務器程序會對客戶端程序提供的這些信息進行認證，如果認證失敗，服務器程序會拒絕連接。

連接命令大家都比較熟悉。

mysql -h$ip -P$port -u$user -p

輸完命令之後，需要繼續輸入密碼，密碼也可以直接跟在 -p 後面，但這樣可能會導致你的密碼泄露，如果你連的是生產服務器，強烈建議你不要這麼做。

MySQL採用TCP作為服務器和客戶端之間的網絡通信協議，完成 TCP 握手后，連接器主要做密碼校驗和權限獲取。

• 如果用戶名或密碼不對，你就會收到一個”Access denied for user”的錯誤

• 如果用戶名密碼認證通過，連接器會到權限表裡面查出你擁有的權限。之後，這個連接裏面的權限判斷邏輯，都將依賴於此時讀到的權限

MySQL的默認連接是8小時，由參數 wait_timeout 控制的，如果超過這個時間不使用，會自動斷開，並在之後的操作中，拋出Lost connection to MySQL server during query的錯誤。

查詢緩存

針對於查詢語句，MySQL 拿到一個查詢請求后，會先到查詢緩存看看，之前是不是執行過這條語句，之前執行過的語句及其結果可能會以 key-value 對的形式，被直接緩存在內存中。如果命中緩存，將直接返回結果。如果不在查詢緩存中，就會繼續後面的執行階段。執行完成后，執行結果會被存入查詢緩存中。

針對於更新語句，包含插入刪除語句，MySQL 收到更新請求時，會把查詢緩存中該表相關的緩存數據全部清空。

我們可以看到，只要有更新，緩存就會失效，而對於正常的業務，更新其實是比較頻繁的，也就是說，其實MySQL的查詢緩存命中率並不會很高，所以建議一般不到開啟。

可以通過設置 query_cache_type 為 DEMAND 來關閉查詢緩存功能。而事實上，在 MySQL 8.0 版本，更是直接移除了查詢緩存這一個功能。

分析器

MySQL 首先需要對SQL語句進行分析，分析過程本質上算是一個編譯過程，涉及詞法解析、語法分析、語義分析等階段，通過分析MySQL知道自己要做什麼。

如果語句不對，就會收到“You have an error in your SQL syntax”的錯誤提醒，一般語法錯誤會提示第一個出現錯誤的位置，所以你要關注的是緊接“use near”的內容。

優化器

面對分析器拿到的結果，MySQL會做一些優化處理，例如在表裡面有多個索引的時候，決定使用哪個索引，或者在一個語句有多表關聯（join）的時候，決定各個表的連接順序。

優化的結果就是生成一個執行計劃，這個執行計劃表明了應該使用哪些索引進行查詢，表之間的連接順序是啥樣的。我們可以使用EXPLAIN語句來查看某個語句的執行計劃。

這裏\G在命令窗口無法一行時，可以豎著展示結果，方便查看。

執行器

經過了分析器和優化器，就正式進行執行階段了，不過執行之前，需要做權限驗證，如果權限不足，就會拋出權限的錯誤。其實在查詢緩存的時候，一樣也會進行權限校驗。

如果通過驗證，執行器就打開表繼續執行。打開表的時候，執行器就會根據表的引擎定義，去使用這個引擎提供的接口。

存儲引擎

MySQL支持非常多種存儲引擎，常用的是InnoDB和MyISAM，MySQL的默認存儲引擎是InnoDB。

假如我們選擇是InnoDB引擎，對於查詢，那InnoDB 會取這個表的第一行來進行判斷是不是符合要求，符合則存在結果集中，否則繼續進行下一行，直到該表的最後一行。

然後存儲引擎將結果返回給執行器， 執行器拿着結果返回給客戶端，這樣一句SQL就執行完成了。

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

【其他文章推薦】

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

※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

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

面試的時候，常常會問數組和鏈表的區別，很多人都回答說，“鏈表適合插入、刪除，時間複雜度O(1)；數組適合查找，查找時間複雜度為O(1)”。實際上，這種表述是不準確的。數組是適合查找操作，但是查找的時間複雜度並不為O(1)。即便是排好序的數組，你用二分查找，時間複雜度也是O(logn)。所以，正確的表述應該是，數組支持隨機訪問，根據下標隨機訪問的時間複雜度為O(1)。

每一種編程語言中，基本都會有數組這種數據類型。不過，它不僅僅是一種編程語言中的數據類型，還是一種最基礎的數據結構。儘管數組看起來非常基礎、簡單，但是我估計很多人都並沒有理解這個基礎數據結構的精髓。在大部分編程語言中，數組都是從0開始編號的，但你是否下意識地想過，為什麼數組要從0開始編號，而不是從1開始呢？ 從1開始不是更符合人類的思維習慣嗎？帶着這個問題來學習接下來的內容,帶着問題去學習往往效果會更好！！！

什麼是數組？我估計你心中已經有了答案。不過，我還是想用專業的話來給你做下解釋。數組（Array）是一種線性表數據結構。它用一組連續的內存空間，來存儲一組具有相同類型的數據。這個定義里有幾個關鍵詞，理解了這幾個關鍵詞，我想你就能徹底掌握數組的概念了。下面就從我的角度分別給你“點撥”一下。

第一是線性表（Linear List）。顧名思義，線性表就是數據排成像一條線一樣的結構。每個線性表上的數據最多只有前和后兩個方向。其實除了數組，鏈表、隊列、棧等也是線性表結構。而與它相對立的概念是非線性表，比如二叉樹、堆、圖等。之所以叫非線性，是因為，在非線性表中，數據之間並不是簡單的前後關係。

第二個是連續的內存空間和相同類型的數據。正是因為這兩個限制，它才有了一個堪稱“殺手鐧”的特性：“隨機訪問”。但有利就有弊，這兩個限制也讓數組的很多操作變得非常低效，比如要想在數組中刪除、插入一個數據，數組為了保持內存數據的連續性，會導致插入、刪除這兩個操作比較低效,相反的數組查詢則高效

數組java代碼：

package array;

/**
 * 1) 數組的插入、刪除、按照下標隨機訪問操作；
 * 2）數組中的數據是int類型的；
 *
 * Author: Zheng
 * modify: xing, Gsealy
 */
public class Array {
    //定義整型數據data保存數據
    public int data[];
    //定義數組長度
    private int n;
    //定義中實際個數
    private int count;

    //構造方法，定義數組大小
    public Array(int capacity){
        this.data = new int[capacity];
        this.n = capacity;
        this.count=0;//一開始一個數都沒有存所以為0
    }

    //根據索引，找到數據中的元素並返回
    public int find(int index){
        if (index<0 || index>=count) return -1;
        return data[index];
    }

    //插入元素:頭部插入，尾部插入
    public boolean insert(int index, int value){
        //數組中無元素 

        //if (index == count && count == 0) {
        //    data[index] = value;
        //    ++count;
        //    return true;
        //}

        // 數組空間已滿
        if (count == n) {
            System.out.println("沒有可插入的位置");
            return false;
        }
        // 如果count還沒滿，那麼就可以插入數據到數組中
        // 位置不合法
        if (index < 0||index > count ) {
            System.out.println("位置不合法");
            return false;
        }
        // 位置合法
        for( int i = count; i > index; --i){
            data[i] = data[i - 1];
        }
        data[index] = value;
        ++count;
        return true;
    }
    //根據索引，刪除數組中元素
    public boolean delete(int index){
        if (index<0 || index >=count) return false;
        //從刪除位置開始，將後面的元素向前移動一位
        for (int i=index+1; i<count; ++i){
            data[i-1] = data[i];
        }
        //刪除數組末尾元素  這段代碼不需要也可以
        /*int[] arr = new int[count-1];
        for (int i=0; i<count-1;i++){
            arr[i] = data[i];
        }
        this.data = arr;*/

        --count;
        return true;
    }
    public void printAll() {
        for (int i = 0; i < count; ++i) {
            System.out.print(data[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Array array = new Array(5);
        array.printAll();
        array.insert(0, 3);
        array.insert(0, 4);
        array.insert(1, 5);
        array.insert(3, 9);
        array.insert(3, 10);
        //array.insert(3, 11);
        array.printAll();
    }
}

GenericArray數組代碼

public class GenericArray<T> {
    private T[] data;
    private int size;

    // 根據傳入容量，構造Array
    public GenericArray(int capacity) {
        data = (T[]) new Object[capacity];
        size = 0;
    }

    // 無參構造方法，默認數組容量為10
    public GenericArray() {
        this(10);
    }

    // 獲取數組容量
    public int getCapacity() {
        return data.length;
    }

    // 獲取當前元素個數
    public int count() {
        return size;
    }

    // 判斷數組是否為空
    public boolean isEmpty() {
        return size == 0;
    }

    // 修改 index 位置的元素
    public void set(int index, T e) {
        checkIndex(index);
        data[index] = e;
    }

    // 獲取對應 index 位置的元素
    public T get(int index) {
        checkIndex(index);
        return data[index];
    }

    // 查看數組是否包含元素e
    public boolean contains(T e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return true;
            }
        }
        return false;
    }

    // 獲取對應元素的下標, 未找到，返回 -1
    public int find(T e) {
        for ( int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }


    // 在 index 位置，插入元素e, 時間複雜度 O(m+n)
    public void add(int index, T e) {
        checkIndex(index);
        // 如果當前元素個數等於數組容量，則將數組擴容為原來的2倍
        if (size == data.length) {
            resize(2 * data.length);
        }

        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = e;
        size++;
    }

    // 向數組頭插入元素
    public void addFirst(T e) {
        add(0, e);
    }

    // 向數組尾插入元素
    public void addLast(T e) {
        add(size, e);
    }

    // 刪除 index 位置的元素，並返回
    public T remove(int index) {
        checkIndexForRemove(index);

        T ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size --;
        data[size] = null;

        // 縮容
        if (size == data.length / 4 && data.length / 2 != 0) {
            resize(data.length / 2);
        }

        return ret;
    }

    // 刪除第一個元素
    public T removeFirst() {
        return remove(0);
    }

    // 刪除末尾元素
    public T removeLast() {
        return remove(size - 1);
    }

    // 從數組中刪除指定元素
    public void removeElement(T e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
        }
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append(String.format("Array size = %d, capacity = %d \n", size, data.length));
        builder.append('[');
        for (int i = 0; i < size; i++) {
            builder.append(data[i]);
            if (i != size - 1) {
                builder.append(", ");
            }
        }
        builder.append(']');
        return builder.toString();
    }


    // 擴容方法，時間複雜度 O(n)
    private void resize(int capacity) {
        T[] newData = (T[]) new Object[capacity];

        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    private void checkIndex(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed! Require index >=0 and index <= size.");
        }
    }

    private void checkIndexForRemove(int index) {
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("remove failed! Require index >=0 and index < size.");
        }
    }
}

到這裏，就回溯最初的問題：

從數組存儲的內存模型上來看，“下標”最確切的定義應該是“偏移（offset）”。前面也講到，如果用a來表示數組的首地址，a[0]就是偏移為0的位置，也就是首地址，a[k]就表示偏移k個type_size的位置，所以計算a[k]的內存地址只需要用這個公式：

a[k]_address = base_address + k * type_size

但是，如果數組從1開始計數，那我們計算數組元素a[k]的內存地址就會變為：

a[k]_address = base_address + (k-1)*type_size

對比兩個公式，我們不難發現，從1開始編號，每次隨機訪問數組元素都多了一次減法運算，對於CPU來說，就是多了一次減法指令。那你可以思考一下，類比一下，二維數組的內存尋址公式是怎樣的呢？有興趣的可以在評論區評論出來哦QAQ

數組作為非常基礎的數據結構，通過下標隨機訪問數組元素又是其非常基礎的編程操作，效率的優化就要盡可能做到極致。所以為了減少一次減法操作，數組選擇了從0開始編號，而不是從1開始。
不過我認為，上面解釋得再多其實都算不上壓倒性的證明，說數組起始編號非0開始不可。所以我覺得最主要的原因可能是歷史原因。

關於數組，它可以說是最基礎、最簡單的數據結構了。數組用一塊連續的內存空間，來存儲相同類型的一組數據，最大的特點就是支持隨機訪問，但插入、刪除操作也因此變得比較低效，平均情況時間複雜度為O(n)。在平時的業務開發中，我們可以直接使用編程語言提供的容器類，但是，如果是特別底層的開發，直接使用數組可能會更合適。

如果本文對你有一點點幫助，那麼請點個讚唄，謝謝~

最後，若有不足或者不正之處，歡迎指正批評，感激不盡！如果有疑問歡迎留言，絕對第一時間回復！

歡迎各位關注我的公眾號，一起探討技術，嚮往技術，追求技術，說好了來了就是盆友喔…

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

【其他文章推薦】

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

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!