MySQL 優化大全：設定 my.cnf 優化指南

http://coldly74.blog.fc2.com/blog-entry-6.html

開啟 MySQL query cache
如果 MySQL server 是非常繁忙，可以開啟 query cache 以加速回應時間，開啟方法可以在 my.cnf 裡面加入以下項目:
(Redhat 下面是 /etc/my.cnf；Debian 是在 etc/mysql/my.cnf)
query_cache_size = 268435456
query_cache_type = 1
query_cache_limit = 1048576

linux Page cache和buffer cache 正解

http://rritw.com/a/bianchengyuyan/C__/20121113/252994.html

Page cache和buffer cache一直以來是兩個比較容易混淆的概念，在網上也有很多人在爭辯和猜想這兩個cache到底有什麼區別，討論到最後也一直沒有一個統一和正確的結 論，在我工作的這一段時間，page cache和buffer cache的概念曾經困擾過我，但是仔細分析一下，這兩個概念實際上非常的清晰。如果能夠了解到這兩個cache的本質，那麼我們在分析io問題的時候可 能會更加得心應手。

　　Page cache實際上是針對文件系統的，是文件的緩存，在文件層面上的數據會緩存到page cache。文件的邏輯層需要映射到實際的物理磁盤，這種映射關系由文件系統來完成。當page cache的數據需要刷新時，page cache中的數據交给buffer cache，但是這種處理在2.6版本的內核之後就變的很簡單了，沒有真正意義上的cache操作。

　　Buffer cache是針對磁盤塊的緩存，也就是在沒有文件系統的情況下，直接對磁盤進行操作的數據會緩存到buffer cache中，例如，文件系統的元數據都會緩存到buffer cache中。

　　簡單說來，page cache用來緩存文件數據，buffer cache用來緩存磁盤數據。在有文件系統的情況下，對文件操作，那麼數據會緩存到page cache，如果直接采用dd等工具對磁盤進行讀寫，那麼數據會緩存到buffer cache。

　　補充一點，在文件系統層每個設備都會分配一個def_blk_ops的文件操作方法，這是設備的操作方法，在每個設備的inode下面會存在 一個radix tree，這個radix tree下面將會放置緩存數據的page頁。這個page的數量將會在top程序的buffer一欄中顯示。如果設備做了文件系統，那麼會生成一個 inode，這個inode會分配ext3_ops之類的操作方法，這些方法是文件系統的方法，在這個inode下面同样存在一個radix tree，這裏會緩存文件的page頁，緩存頁的數量在top程序的cache一欄進行統計。從上面的分析可以看出，2.6內核中的buffer cache和page cache在處理上是保持一致的，但是存在概念上的差別，page cache針對文件的cache，buffer是針對磁盤塊數據的cache，僅此而已。

LINUX MEMORY FAQ

http://wiki.gentoo.tw/index.php/FAQ_LINUXMEMORY

op 的輸出裡，VIRT、RES、SHR 的差別

VIRT 指的是一個程序 (process) 的虛擬大小 (virtual size)，這指的便是該程序總共的記憶體使用量，這包含有：1. 被指定給它的記憶體 (例如給 X server 使用的顯示卡的 RAM)、2. 它使用的檔案所用的記憶體 (例如共用的函式庫)、3. 與其它程序共享的記憶體。VIRT 代表的便是現在該程式總共可以存取多少的記憶體。
RES 是 resident size 的縮寫，簡單的說，它代表著該程序實際上使用到的記憶體 (跟 %MEM 一樣)。這通常會少於 VIRT 裡顯示的大小，因為大部分的程式會使用到 C 的函式庫。
SHR 指的是 VIRT 裡有多少的空間是可分享的 (記憶體或是函式庫)。依函式庫為例，它並非指該程序使用的整個函式庫，換句話說，如果一個程式只使用函式庫裡幾個函數，則該函式庫將會被計算至 VIRT 和 SHR 中，但在 RES 裡，它只會計算在使用到那些函數的函式庫檔案。

緩衝區 (buffer) 和 快取 (cache) 的差別 

Buffers are associated with a specific block device, and cover caching of filesystem metadata as well as tracking in-flight pages. The cache only contains parked file data. That is, the buffers remember what's in directories, what file permissions are, and keep track of what memory is being written from or read to for a particular block device. The cache only contains the contents of the files themselves.
Corrections and additions to this section welcome; I've done a bit of guesswork based on tracing how /proc/meminfo is produced to arrive at these conclusions.

 

Page Cache和Buffer Cache的区别

http://www.penglixun.com/tech/system/the_diffrents_of_page_cache_and_buffer_cache.html

在监控中开始对着两个Cache有点搞不清楚，后来查了下，弄清楚了它们的区别，都是Cache但完全不是缓存一种东西，很好区分。
磁盘的操作有逻辑级（文件系统）和物理级（磁盘块），这两种Cache就是分别缓存逻辑和物理级数据的。
假设我们通过文件系统操作文件，那么文件将被缓存到Page Cache，如果需要刷新文件的时候，Page Cache将交给Buffer Cache去完成，因为Buffer Cache就是缓存磁盘块的。
也就是说，直接去操作文件，那就是Page Cache区缓存，用dd等命令直接操作磁盘块，就是Buffer Cache缓存的东西。

free命令的cache和buffer分别是page cache和cache buffer吗?
简单理解的话是这样的，buffer是指cache buffer； cache是指page cache。

Linux 的記憶體快取（Cache Memory）功能 - Linux 系統把記憶體用光了？

http://www.gtwang.org/2013/07/linux-cache-memory-linux.html

這裡 Linux 記憶體中的記憶體快取（Cache Memory）是什麼，並討論相關的一些指令用法。

在 Linux 中系統會將暫時沒有用到的記憶體借來當作磁碟的快取（cache），而在用 top 指令看系統的 free 的記憶體時，感覺記憶體好像所剩無幾，有些人就會以為 Linux 系統把記憶體吃光光了，然後就推測這樣系統會用到 swap 記憶體，效能也會跟著下降，但其實不是這樣的，而且真正的情況剛好相反。

實際上 Linux 系統拿沒有用到的記憶體當作硬碟的快取，可以會讓整個系統的效能提昇很多，而且沒有任何副作用（除了讓一些不了解的人很緊張之外），它只是「暫時」把沒有 用到的記憶體借來用一下而已，當有程式需要記憶體時，系統就會馬上把記憶體拿回來給需要記憶體的程式使用，完全沒有霸佔記憶體的問題。

有些人也會擔心這樣的機制會不會讓系統使用到 swap 記憶體？事實上這也不用擔心，快取只會用到暫時沒有使用 RAM，並不會使用到 swap 來作為快取（使用 swap 也沒什麼意義，因為 swap 就是在磁碟上，不會比較快）。

至於有時候整個系統中沒有在執行什麼程式，而用 top 與 free 指令查看記憶體使用狀況時，會顯示很大一部分的記憶體是 used 的狀態，不懂的人就會感覺很奇怪，這其實是對於他的意義有些誤解，我們用下面這個表來解釋：

記憶體狀態	你的認知	Linux 系統的認知
正在被應用程式使用	Used	Used
可以被應用程式使用，但被暫時借去做別的用途	Free	Used
沒有被使用	Free	Free

會出問題就在於記憶體暫時借去做別的用途時（像硬碟快取），Linux 系統會顯示 used，但是大部分人應該會認為這部份的記憶體應該顯示為 free，就是因為這個落差，導致很多人誤以為系統的記憶體被吃光，換句話說，那些被標示為 used 的記憶體其實包含被拿去作為快取的部份，而這些部份其實在程式需要時是可以馬上拿回來的，所以可以被一般應用程式使用的記憶體會比你想像的要多一些。

既然看一般的 top 輸出的 free 記憶體不太準，那到底要如何知道我們實際上真正可以用的記憶體有多少呢？其實可以使用 free 指令來看，只是在看他的輸出的時候，要知道看哪一個欄位：
free -m
輸出為：

             total       used       free     shared    buffers     cached
Mem:          3953       3154        799          0        135        990
-/+ buffers/cache:       2029       1924
Swap:         3813          0       3813

若要看實際上應用程式可用的記憶體就看 -/+ buffers/cache 這一行的 free 這一欄有多少就是了，我們這裡使用 -m 參數，所以這裡的單位都是 MB，以這個例子來說就是還有 1924 MB 可以使用，而如果你只是單純看上面的 Mem 那一行，你可能會以為系統只剩下 799 MB 的記憶體了。

除了使用 free 指令之外，也可以使用比較直覺的 htop 工具，它類似 top 指令，但是有更人性化的輸出，下面這個是他的使用畫面：

其中 Mem 的部份就會顯示目前的記憶體使用狀況，而它會以不同顏色表示不同的記憶體的使用狀況，像快取的話就會使用黃色表示，這樣可以讓管理者更容易看出整體記憶體的狀況。

網路上有很多清除快取記憶體的教學，這些動作其實對於整個系統效能是沒有幫助的，甚至你把硬碟快取強制清除之後，因為沒有快取的輔助，導致有些資料還要重 新從硬碟讀取，反而讓整體效能更差也不一定，而且重點是不管你有沒有去手動釋放快取記憶體，只要你的程式需要記憶體時，都可以馬上使用這些記憶體空間，所 以跟本不需要多花這些力氣。

以下是手動清除快取記憶體的方式，這裡只是純粹的討論技術，這個部份通常一般人是沒有什麼機會需要用到的，除非你有一些很特殊的需求，而且在做這些動作之前，你應該要很清楚自己在做什麼與需要什麼。

要釋放 Linux 的記憶體快取，可以透過更改 /proc/sys/vm/drop_caches 這個檔案的內容來達到，當這個檔案內容被設為 1 時，是表示要求 Linux 釋放沒在使用的一般性快取（pagecache），而設為 2 時，則代表要求釋放 dentry 與 inode 所使用到的快取，若設為 3 則是釋放所有的快取（也就是包含 1 與 2 的狀況）。

在設定時，也可以加上 sync 指令，讓一些沒有寫入硬碟的資料先寫入之後，才將快取釋放，另外這個指令會需要 root 權限，所以整個完整的指令就會像這樣：
sudo sh -c "sync; echo 3 > /proc/sys/vm/drop_caches"
另外，如果不想使用 echo，也可以用 sysctl 指令的方式：
sudo sysctl vm.drop_caches=3
最後再強調一次，這個釋放快取的動作在大部分的狀況是沒有什麼好處的，所以如果你要使用，請先搞清楚這是在做什麼。

Linux作業系統中記憶體buffer和cache的區別

http://hon0612.blogspot.tw/2007/10/linuxbuffercache.html

Linux作業系統中記憶體buffer和cache的區別

Free　　free 命令相對於top 提供了更簡潔的查看系統記憶體使用情況：

　　$ free
　 　total used free shared buffers cachedMem: 255268 238332 16936 0 85540 126384-/+ buffers/cache: 26408 228860Swap: 265000 0 265000
　　Mem：表示物理記憶體統計
　　-/+ buffers/cached：表示物理記憶體的緩存統計
　　Swap：表示硬盤上交換分區的使用情況，這裡我們不去關心。
　　系統的總物理記憶體：255268Kb（256M），但系統當前真正可用的記憶體b並不是第一行free 標記的 16936Kb，它僅代表未被分配的記憶體。
　　我們使用total1、used1、free1、used2、free2 等名稱來代表上面統計數據的各值，1、2 分別代表第一行和第二行的數據。
　　total1：表示物理記憶體總量。
　　used1：表示總計分配給緩存（包含buffers 與cache ）使用的數量，但其中可能部分緩存並未實際使用。
　　free1：未被分配的記憶體。
　　shared1：共用記憶體，一般系統不會用到，這裡也不討論。
　　buffers1：系統分配但未被使用的buffers 數量。
　　cached1：系統分配但未被使用的cache 數量。buffer 與cache 的區別見後面。
　　used2：實際使用的buffers 與cache 總量，也是實際使用的記憶體總量。
　　free2：未被使用的buffers 與cache 和未被分配的記憶體之和，這就是系統當前實際可用記憶體。
　　可以整理出如下等式：
　　total1 = used1 + free1total1 = used2 + free2used1 = buffers1 + cached1 + used2free2 = buffers1 + cached1 + free1
　　buffer 與cache 的區別
　 　A buffer is something that has yet to be "written" to disk. A cache is something that has been "read" from the disk and stored for later use.
　　更詳細的解釋參考：Difference Between Buffer and Cache
　 　對於共用記憶體（Shared memory），主要用於在UNIX 環境下不同進程之間共用數據，是進程間通信的一種方法，一般的應用程式不會申請使用共用記憶體，筆者也沒有去驗證共用記憶體對上面等式的影響。如果你有興 趣，請參考：What is Shared Memory?
　　cache 和 buffer的區別：
　 　Cache：高速緩存，是位於CPU與主記憶體間的一種容量較小但速度很高的記憶體。由於CPU的速度遠高於主記憶體，CPU直接從記憶體中存取數據要 等待一定時間週期，Cache中保存著CPU剛用過或迴圈使用的一部分數據，當CPU再次使用該部分數據時可從Cache中直接調用,這樣就減少了CPU 的等待時間,提高了系統的效率。Cache又分為一級Cache(L1 Cache)和二級Cache(L2 Cache)，L1 Cache集成在CPU內部，L2 Cache早期一般是焊在主板上,現在也都集成在CPU內部，常見的容量有256KB或512KB L2 Cache。
　　Buffer：緩衝區，一個用於存儲速度不同步的設備或優先級不同的設備之間傳輸數據的區域。通過緩衝區，可以使進程之間的相互等待變少，從而使從速度慢的設備讀入數據時，速度快的設備的操作進程不發生間斷。
　　Free中的buffer和cache：（它們都是佔用記憶體）：
　　buffer : 作為buffer cache的記憶體，是塊設備的讀寫緩衝區
　　cache: 作為page cache的記憶體, 文件系統的cache
　　如果 cache 的值很大，說明cache住的文件數很多。如果頻繁訪問到的文件都能被cache住，那麼磁片的讀IO bi會非常小。

How to defer loading of javascript

http://www.feedthebot.com/pagespeed/defer-loading-javascript.html

Deferring of javascript is one of those issues on the web that can make you want to pull your hair out trying to find a solution.
Many people say "just use defer" or "just use async" or others say "just put your javascript at bottom of page".

None of the above are solutions to the problem of actually allowing a webpage to fully load and then (and only then) loading external JS. Nor will any of the above always get you past that "Defer loading of javascript" warning you are getting from the Google page speed tool. This solution will and is the recommended solution from the Google help pages.

How to defer loading of javascript

The below code is what Google recommends. This code should be placed in your HTML just before the </body> tag (near the bottom of your HTML file). I highlighted the name of the external JS file.

<script type="text/javascript">
function downloadJSAtOnload() {
var element = document.createElement("script");
element.src = "defer.js";
document.body.appendChild(element);
}
if (window.addEventListener)
window.addEventListener("load", downloadJSAtOnload, false);
else if (window.attachEvent)
window.attachEvent("onload", downloadJSAtOnload);
else window.onload = downloadJSAtOnload;
</script>

What does this do?

This code says wait for the entire document to load, then load the external file "defer.js".

Specific instructions

1. Copy above code.
2. Paste code in your HTML just before the </body> tag (near the bottom of your HTML file).
3. Change the "defer.js" to the name of your external JS file.
4. Ensure the path to your file is correct. Example: if you just put "defer.js", then the file "defer.js" must be in the same folder as your HTML file.

What you can use this code for (and what you can not)

This code will not load the external file you specify until after the document has loaded. Because of this you should not put any javascript in there that is needed for the page to load properly. You should separate your javascript into two groups. One group is the javascript the page needs to load and the the second group is the javascript that is doing stuff after the page loads (like looking for click events or something). The javascript that can wait until after the page loads should be all put into the one external file you are calling above.
For example, on this page I use the above file to defer - Google analytics, Viglink (how I make money), and the Google plus badge that is displayed in my footer (my social media). There are no reasons for me to load these files for the initial page load because none of them are necessary to load the above the fold content. You probably have the same type of stuff on your pages. Are you making your users wait to load these before showing them your content?

Why don't the other methods work?

The methods of inlining, placing scripts at the bottom, using "defer" or using "async" all do not accomplish the goal of letting the page load first then loading JS and they certainly do not work universally and cross browser.

Why does it matter?

It matters because Google is judging page speed as a ranking factor and because users want fast loading pages. Google measures your page speed from the the time it is called to when the page is initially loaded. This means you want to get to the page load event as quickly as possible. That initial page load time is what Google is using to judge your webpage (and let's not forget your users waiting for it to load). Google actively promotes and recommends prioritizing above the fold content so getting any resources at all (js, css, images, etc.) out of the critical rendering path is well worth the effort. If it makes your users happy, and it makes Google happy, you should probably do it.

Example usage

I have created a page here that you can see using the code.

Example files for your testing

Okay, just to illustrate I have made some example pages for you to play with. Each page does the same thing. It is a plain HTML page that uses one script that waits two seconds then says "hello world". You can test these and see that only one method will register a load time that does not include the 2 second wait.

• Page with script inline - here
• Page with external script using "defer" - here
• Page using the recommended code above - here

Key point

The overwhelming priority should be placed on delivering the content to the user as soon as possible. We have not been doing that with how we have treated our javascript. A user should not have to wait to see their content because of some script that is likely doing something to below the fold content. No matter how cool your footer is, there really is no reason for a user who may never even scroll down to your footer to load the javascript that makes your footer cool.

by Patrick Sexton