轉自：

http://blog.csdn.net/qq_15437629/article/details/52388685

在這裏只做備份

計算機網絡

TCP/IP

模型

TCP/IP協議集的分層實施:

爲什麼要給網絡劃分層次？

（1）各層之間相對獨立，每層都可以用最合適的技術實現；
（2）各層只需知道通過層間接口提供的服務，各層因技術進步而做的改動不會影響到其它層，從而保持體系結構的穩定性；
（3）將整個系統劃分爲若干子系統，易於實現和維護；
（4）促進標準化工作

TCP、UDP

比較

TCP 是面向連接的，是可靠的，需要進行確認和排序，支持流量和錯誤控制，
而 UDP是無連接的，不進行確認和排序，不提供錯誤和流量控制功能。
UDP沒有TCP的握手、確認、窗口、重傳、擁塞控制等機制，優勢是它在傳遞數據時非常快，傳輸開銷小

TCP報頭中的字段包括源端口、目標端口、序列號、確認號、報頭長度、保留字段(保留供以後使用)、編碼位窗口大小、校驗和、緊急指針、選項和數據字段。

源端口：發送主機的應用程序的端口號(端口將在本節後面解釋)。
目標端口：目標主機的應用程序的端口號。
序列號：一個編號， TCP 用來將數據按正確的順序重新排列(稱爲排序) 重傳丟失或受損的數據。
確認號： TCP 期待接下來收到的數據段。
報頭長度：TCP 報頭的長度，以 32 位字爲單位。它指出了數據的開始位置，TCP 報頭的長度爲32 位的整數倍，即使包含選項時亦如此。
保留：總是設置爲零。
編碼位/標誌：用於建立和終止會話的控制功能。
窗口大小：發送方願意接受的窗口大小，單位爲字節
校驗和 CRC (Cyclic Redundancy Check，循環冗餘校驗)：由於 TCP 不信任低層，因此檢查所有數據。 CRC 檢查報頭和數據字段。
緊急：僅當設置了編碼位中的緊急指針字段時，該字段纔有效。如果設置了緊急指針，該字段表示非緊急數據的開頭位置相對於當前序列號的偏移量，單位爲字節。
選項：長度爲 32 位的整數倍。也就是說，沒有選項時，長度爲。然而，如果包含選項時導致該字段的長度不是 32位的整數倍，必須填充零，以確保該字段的長度爲 32 位的整數倍。
數據：傳遞給傳輸層的 TCP 協議的信息，包括上層報頭。

UDP 報頭只包含字段源端口、目標端口、長度、校驗和和數據。相對於TCP報頭，其字段更少了，但代價是不提供 TCP 的高級功能。

源端口號 : 發送主機的應用程序的端口號。
目標端口號 : 目標主機上被請求的應用程序的端口號
長度 : UDP 報頭和 UDP 數據的總長度
校驗和 : UDP 報頭和 UDP 數據的校驗和。
數據 : 上層數據。

TCP、UDP 必須使用端口號與上層通信，其值不小於1024。在數據段中， TCP，UDP 將它們用作源端口和目標端口。
小於 1024 的端口號爲知名端口號。
下表列出了 TCP/IP 協議簇常用的應用程序、它們的知名端口號以及它們使用的傳輸層協議: （DHCP->UDP）

可靠性

TCP通過下列方式來提供可靠性：

（1）需要進行確認和排序：對於收到的請求，給出確認響應；對失序數據進行重新排序，然後才交給應用層。對於重複數據，進行丟棄。

（2） TCP將保持它首部和數據的檢驗和。如果收到段的檢驗和有差錯，TCP將丟棄報文段，不給出響應，超時會重發數據。

（3）超時重發：當TCP發出一個段後，它啓動一個定時器，等待目的端確認收到這個報文段。如果不能及時收到一個確認，將重發這個報文段。

（4）TCP將數據截斷爲合理的長度進行發送。而UDP程序產生的數據報長度保持不變。

（5）TCP還能提供流量控制。TCP連接的每一方都有固定大小的緩衝空間，防止發送速率過快導致接收端的緩衝區溢出。TCP使用的流量控制協議是可變大小的滑動窗口協議。

滑動窗口技術：

滑動窗口（Sliding window）是一種流量控制技術。如果發送端不考慮網絡情況直接發送數據包，可能會超過接收端的接收能力而產生丟包的情況。
滑動窗口的大小意味着接收方還有多大的緩衝區可以用於接收數據。發送方可以通過滑動窗口的大小來確定應該發送多少字節的數據，防止發送速率過快導致接收端的緩衝區溢出。

滑動窗口處理過程：

（1）TCP連接階段，雙方協商窗口尺寸，同時接收方預留數據緩衝區用於接收數據。
（2）發送方根據協商結果發送符合窗口尺寸的數據字節流，並等待對方確認信息。
（3）然後根據確認信息，對窗口尺寸進行調整，增加或減少發送未得到確認的字節流中的字節數。（例如：出現擁塞時，將發送窗口減小爲原來的一半，同時將超時重傳的時間間隔擴大一倍）

TCP的擁塞控制由4個核心算法組成：

（1）“慢啓動”（Slow Start）：發送方維持一個叫做擁塞窗口cwnd（congestion window）的狀態變量。發送方讓自己的發送窗口等於擁塞窗口。慢啓動算法的思路就是，不要一開始就發送大量的數據，先探測一下網絡的擁塞程度，由小到大逐漸增加擁塞窗口的大小。一次傳輸輪次之後擁塞窗口就加倍。這就是乘法增長。
（2）“擁塞避免”（Congestion voidance）：擁塞避免算法讓擁塞窗口緩慢增長，即每經過一個往返時間RTT就把發送方的擁塞窗口cwnd加1，而不是加倍。這樣擁塞窗口按線性規律緩慢增長。
（3）“快速重傳 ”（Fast Retransmit）：快重傳要求接收方在收到一個失序的報文段後就立即發出重複確認（爲的是使發送方及早知道有報文段沒有到達對方）而不要等到自己發送數據時捎帶確認。快重傳算法規定，發送方只要一連收到三個重複確認就應當立即重傳對方尚未收到的報文段，而不必繼續等待設置的重傳計時器時間到期。
（4）“快速恢復”（Fast Recovery）：①當發送方連續收到三個重複確認時，就執行“乘法減小”算法，把慢開始門限ssthresh門限減半。但是接下去並不執行慢開始算法。
②因爲考慮到如果網絡出現擁塞的話就不會收到好幾個重複的確認，所以發送方現在認爲網絡可能沒有出現擁塞。所以此時不執行慢開始算法，而是將cwnd設置爲ssthresh的大小，然後執行擁塞避免算法。如下圖：

三次握手

首先服務器創建socket，綁定自身端口號進行監聽。
（1）第一次握手：客戶端向服務器發送SYN包，假設序列號爲x，進入SYN_SEND狀態。
（2）第二次握手：服務器收到SYN包，進行確認，發送ACK報文，序列號爲x+1，同時自己也發送一個SYN包（假設序列號爲y），此時服務器進入SYN_RECV狀態。
（3）第三次握手：客戶端收到服務器B的SYN＋ACK包，向服務器B發送確認包ACK（確認號爲y+1），客戶端和服務器進入ESTABLISHED狀態，完成三次握手。

四次揮手

（1）客戶端A發送一個FIN，用來關閉客戶A到服務器B的數據傳送。
（2）服務器B收到這個FIN，它發回一個ACK，確認序號爲收到的序號加1。
（3）然後服務器B也會發送一個FIN給客戶端A。
（4）客戶端A發回ACK報文確認，確認序號爲收到序號加1。

TIME_WAIT狀態

主動關閉連接的一方會進入TIME_WAIT狀態。這樣設計主要有兩個原因：
（1）可靠地實現TCP連接的終止。四次揮手過程中，如果客戶端最終發送的ACK丟失，服務器會重發FIN，通過保持TIME_WAIT狀態可以允許它重發ACK，保證TCP連接正常地終止。
（2）讓舊連接的重複分組在網絡中消失。因爲如果複用舊連接的端口馬上開啓一個新的連接，原來舊連接中的數據包可能會被這個新連接收到。處於TIME_WAIT狀態的連接就可以避免這種情況。它會持續2個最大分解生命期（MSL），也就是一個IP數據包能在網絡中生存的最長時間，保證新連接建立的時候，舊連接的數據包已經在網絡中消失了。

1 TCP/IP、Http、Socket的區別

TCP協議對應於傳輸層，主要解決數據如何在網絡中傳輸，
而HTTP協議對應於應用層，主要解決如何包裝數據。
socket則是對TCP/IP協議的封裝和應用。是應用層與TCP/IP協議族通信的中間軟件抽象層，它是一組接口。

ARP協議

ARP (Address Resolution Protocol)：地址解析協議: 負責將某個IP地址解析成對應的MAC地址。

原理：

主機會將包含目標IP地址的ARP請求廣播到網絡上的所有主機，目標主機收到ARP報文進行響應，這樣該主機就得到目標主機的物理地址；收到返回消息後將該IP地址和物理地址存入本機ARP緩存中並保留一定時間，下次請求時直接查詢ARP緩存以節約資源。

問題：

Arp是建立在網絡中各個主機互相信任的基礎上的，主機收到應答報文時不會檢測該報文的真實性就會將其記入本機ARP緩存；因此攻擊者就可以通過僞造IP地址和MAC地址實現ARP欺騙，使主機發送的信息無法到達預期的主機或到達錯誤的主機，造成網絡阻塞或中斷或中斷。

解決：

殺毒軟件，安裝ARP防火牆，
將IP和MAC地址進行綁定
對於不經常變動的網絡環境，可以通過靜態ARP的方式，讓ARP映射不被新的ARP數據刷新

icmp協議

ICMP是（Internet Control Message Protocol）因特網控制報文協議。可向主機提供有關網絡故障的消息，比如網絡通不通、主機是否可達、路由是否可用等。比如我們經常使用的Ping命令就是基於icmp協議的。

ping的原理

Ping主要有兩種情況，一種是同一網段，一種是跨網段的。

如果在同一網段，主機A ping主機B，主機A會先檢查自己緩存中是否有主機B的MAC地址，如果沒有B的MAC地址，就會向外發送一個ARP廣播包。交換機有學習MAC地址的能力，它會檢索自己有沒有保存主機B的MAC地址，如果有，就直接返回給A主機，如果沒有，就會向所有端口發送ARP廣播，直到主機B收到了報文進行響應。這時候主機A 學到了主機B的MAC地址，就把這個MAC封裝到ICMP報文中向主機B發送；當主機B收到了這個報文後，就按同樣的格式，返回一個值給主機A，完成了同一網段內的Ping過程。

如果主機A發現主機B不在同一個網段，同樣通過發送ARP廣播，先學到網關的MAC地址，發送ICMP報文，路由器查找路由表，找到去主機B的端口，將原來主機A的MAC地址改爲自己的MAC地址向主機B轉發。這樣一來主機B也學到路由器端口MAC，通過路由器就可以完成了跨網段的Ping過程。

Post和Get

區別：
1、Get是從服務器端獲取數據，Post則是向服務器端發送數據。
2、在客戶端，Get方式通過URL提交數據，在URL地址欄可以看到請求消息，該消息被編碼過；Post數據則是放在Html header內提交。
3、Get方式提交的參數及參數值會在地址欄顯示，不安全，而Post不會，比較安全。
4、對於Get方式，服務器端用Request.QueryString獲取變量的值；對用Post方式，服務器端用Request.Form獲取提交的數據值。
5、Get方式提交的數據最多1024字節，而Post則沒有限制。

Cookie和Session

比較	Cookie	Session
儲存位置	客戶端	服務器端
目的	跟蹤會話，也可以保存用戶偏好設置或者保存用戶名密碼等	跟蹤會話
安全性	不安全	安全

session技術是要使用到cookie的，之所以出現session技術，主要是爲了安全。

HTTP和HTTPS

基礎知識：Http的請求格式如下。

<code class="hljs xml has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-tag" style="color: rgb(0, 102, 102); box-sizing: border-box;"><<span class="hljs-title" style="box-sizing: border-box; color: rgb(0, 0, 136);">request</span> <span class="hljs-attribute" style="box-sizing: border-box; color: rgb(102, 0, 102);">line</span>></span>主要包含三個信息：
1、請求的類型（GET或POST），
2、要訪問的資源（如\res\img\a.jif），
3、Http版本（http/1.1）

<span class="hljs-tag" style="color: rgb(0, 102, 102); box-sizing: border-box;"><<span class="hljs-title" style="box-sizing: border-box; color: rgb(0, 0, 136);">header</span>></span>                用來說明服務器要使用的附加信息
<span class="hljs-tag" style="color: rgb(0, 102, 102); box-sizing: border-box;"><<span class="hljs-title" style="box-sizing: border-box; color: rgb(0, 0, 136);">blank</span> <span class="hljs-attribute" style="box-sizing: border-box; color: rgb(102, 0, 102);">line</span>></span>            這是Http的規定，必須空一行
[<span class="hljs-tag" style="color: rgb(0, 102, 102); box-sizing: border-box;"><<span class="hljs-title" style="box-sizing: border-box; color: rgb(0, 0, 136);">request-body</span>></span>]        請求的內容數據
</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li><li style="box-sizing: border-box; padding: 0px 5px;">9</li></ul>

HTTPS和HTTP的區別

　一、https協議需要到ca申請證書，一般免費證書很少，需要交費。
　二、http和https使用的是完全不同的連接方式，用的端口也不一樣，前者是80，後者是443。
　三、http是超文本傳輸協議，信息是明文傳輸，是無狀態的；https 則是具有安全性的ssl加密傳輸協議。是由SSL+HTTP協議構建的可進行加密傳輸、身份認證的網絡協議，比http協議安全。

HTTP1.0和HTTP1.1

HTTP 1.0規定瀏覽器與服務器只保持短暫的連接，瀏覽器的每次請求都需要與服務器建立一個TCP連接，服務器完成請求處理後立即斷開TCP連接，服務器不跟蹤每個客戶也不記錄過去的請求。

HTTP1.1概括如下：
1. 長鏈接
2. 文件斷點續傳
3. 請求頭Host字段,一個服務器多個網站
4. 提供了身份認證,狀態管理,Cache緩存等機制

HTTP 1.1支持持久連接，在一個TCP連接上可以傳送多個HTTP請求和響應，減少了建立和關閉連接的消耗和延遲。

HTTP 1.1還允許客戶端不用等待上一次請求結果返回，就可以發出下一次請求，但服務器端必須按照接收到客戶端請求的先後順序依次回送響應結果，以保證客戶端能夠區分出每次請求的響應內容，這樣也顯著地減少了整個下載過程所需要的時間。

HTTP 1.0不支持Host請求頭字段，HTTP 1.1中增加Host請求頭字段後，WEB瀏覽器可以使用主機頭名來明確表示要訪問服務器上的哪個WEB站點，這才實現了在一臺WEB服務器上可以在同一個IP地址和端口號上使用不同的主機名來創建多個虛擬WEB站點。

從輸入url到顯示網頁

後臺發生了什麼？

輸入url地址
瀏覽器通過域名系統(DNS)查找域名的 IP 地址，包括：瀏覽器緩存->系統緩存->路由器緩存->ISP DNS -> 遞歸搜索你的ISP的DNS服務器從跟域名服務器開始進行遞歸搜索，
瀏覽器向 web 服務器發送一個 HTTP 請求
服務器的重定向響應
瀏覽器跟蹤重定向地址
服務器處理請求
服務器返回一個 HTTP 響應
瀏覽器顯示 HTML
瀏覽器發送請求獲取嵌入在 HTML 中的資源（如圖片、音頻、視頻、CSS、JS等等）
瀏覽器發送異步請求

操作系統

進程與線程的區別

（調度、併發性、擁有資源、開銷）
進程：是程序的一次執行，負責一個程序運行時的內存分配空間，是資源分配的最小單位；
線程：是進程的一個執行單元，是cpu調度的最小單位。一個進程可以有多個線程。
不僅進程之間可以併發執行，同一個進程的多個線程之間也可併發執行。線程的劃分尺度小於進程，使得多線程程序的併發性高。
每個進程都有獨立的內存地址空間；而同一進程中的所有線程共享同一塊內存和系統資源，有利於提高了程序的運行效率。
概括地說：
進程速度慢，內存佔用、開銷大，但可靠性高，編譯調試簡單；
線程速度快，內存佔用、開銷小，但可靠性較差，編譯調試複雜。
故需要頻繁創建銷燬’或需要大量計算的優先用線程。

注：多線程和多進程的區別
必須從cpu調度，上下文切換，數據共享，多核cup利用率，資源佔用，等等各方面回答，然後有一個問題必須會被問到：哪些東西是一個線程私有的？答案中必須包含寄存器。

進程間通信方式：

進程間通信主要包括管道, 系統 IPC(包括消息隊列,信號量,共享內存), 信號，SOCKET.
(1) 管道包括三種:
①普通管道 pipe, 通常有限制,一是半雙工,只能單向傳輸;二是只能在父子進程間使用.
②流管道 s_pipe: 去除了第一種限制,可以雙向傳輸.
③命名管道:name_pipe, 去除了第二種限制,可以在許多並不相關的進程之間進行通訊.
(2) 消息隊列( message queue ) ：消息隊列是消息的鏈表，存放在內核中並由消息隊列標識符標識。消息隊列克服了信號傳遞信息少、管道只能承載無格式字節流以及緩衝區大小受限等缺點。
(3) 信號量( semophore ) ：信號量是一個計數器，可以用來控制多個進程對共享資源的訪問。它常作爲一種鎖機制，防止某進程正在訪問共享資源時，其他進程也訪問該資源。因此，主要作爲進程間以及同一進程內不同線程
之間的同步手段。
(4) 共享內存( shared memory ) ：共享內存就是映射一段能被其他進程所訪問的內存，這段共享內存由一個進程創建，但多個進程都可以訪問。共享內存是最快的 IPC 方式，它是針對其他進程間通信方式運行效率低而專門設計
的。它往往與其他通信機制，如信號量，配合使用，來實現進程間的同步和通信。
(5) 信號 ( signal ) ：信號是一種比較複雜的通信方式，用於通知接收進程某個事件已經發生。
(6) 套接字( socket )：套解字也是一種進程間通信機制，與其他通信機制不同的是它可用於不同機器間的進程通信。

線程間的通信方式:

● 使用全局變量：由於多個線程可能更改全局變量，因此全局變量最好聲明爲violate
● 使用消息實現通信：在Windows程序設計中，每一個線程都可以擁有自己的消息隊列（UI線程默認自帶消息隊列和消息循環，工作線程需要手動實現消息循環），因此可以採用消息進行線程間通信sendMessage,postMessage。
● 使用事件CEvent類實現線程間通信：Event對象有兩種狀態：有信號和無信號，線程可以監視處於有信號狀態的事件，以便在適當的時候執行對事件的操作。

注：Linux進程通信與線程通信的區別：

▶ linux中的進程，是由fork()系統調用創建的；進程間都有獨立的地址空間，它們之間不能之間通信，必須通過進程間通信機制（IPC）來完成。常見得有PIPE、命名管道、消息隊列、信號量、共享內存、信號、socket等。
▶ linux中的線程，是由clone()系統調用創建的，同一進程中的所有線程共享同一塊內存和系統資源的，故線程間可以直接訪問，但要注意併發情況，實現線程同步

同一進程中的所有線程共享同一塊內存和系統資源的，故線程間可以直接訪問，線程間通信的主要目的用於線程同步。

線程間的同步方式:

線程間的同步方法大體可分爲兩類：用戶模式和內核模式。
內核模式就是指利用系統內核對象的單一性來進行同步，使用時需要切換內核態與用戶態；
用戶模式就是不需要切換到內核態，只在用戶態完成操作。
用戶模式下的方法有：原子操作（例如一個單一的全局變量），臨界區。
內核模式下的方法有：事件，信號量，互斥量。

(1)、臨界區（ CCriticalSection）
當多個線程訪問一個獨佔性共享資源時，可以使用臨界區對象。擁有臨界區的線程可以訪問被保護起來的資源或代碼
段，其他線程若想訪問，則被掛起，直到擁有臨界區的線程放棄臨界區爲止。
具體應用方式：
1)、定義臨界區對象 CcriticalSection g_CriticalSection;
2)、在訪問共享資源（代碼或變量）之前，先獲得臨界區對象， g_CriticalSection.Lock（）；
3)、訪問共享資源後，則放棄臨界區對象， g_CriticalSection.Unlock（）；

(2)、事件（ CEvent）
事件機制，則允許一個線程在處理完一個任務後，主動喚醒另外一個線程執行任務。
比如在某些網絡應用程序中，一個線程如 A 負責偵聽通信端口，另外一個線程 B 負責更新用戶數據，利用事件機制，則線程 A 可以通知線程 B 何時更新用戶數據。每個 Cevent 對象可以有兩種狀態：有信號狀態和無信號狀態。 Cevent 類對象有兩種類型：人工事件和自動事件。
●自動事件對象，在被至少一個線程釋放後自動返回到無信號狀態；
●人工事件對象，獲得信號後，釋放可利用線程，但直到調用成員函數 ReSet()纔將其設置爲無信號狀態。在創建 Cevent
對象時，默認創建的是自動事件。

(3)、互斥量（ CMutex）
互斥對象和臨界區對象非常相似，只是其允許在進程間使用，而臨界區只限制與同一進程的各個線程之間使用，但是更節省資源，更有效率。

(4)、信號量（ CSemphore）
使用一個計數器來限制可以使用某共享資源的線程數目。
CSemaphore 類對象保存了對當前訪問某一個指定資源的線程的計數值，該計數值是當前還可以使用該資源的線程數目。如果這個計數達到了零，則所有對這個 CSemaphore 類對象所控制的資源的訪問嘗試都被放入到一個隊列中等待，直到超時或計數值不爲零爲止。

用戶線程和內核線程

●用戶線程（ULT）指不需要內核支持而在用戶程序中實現的線程，不依賴於操作系統核心，應用進程利用線程庫提供創建、同步、調度和管理線程的函數來控制用戶線程。不需要用戶態/核心態切換，速度快，操作系統內核不知道多線程的存在，因此一個線程阻塞將使得整個進程（包括它的所有線程）阻塞。由於這裏的處理器時間片分配是以進程爲基本單位，所以每個線程執行的時間相對減少。
●內核線程（KST，也叫守護線程）：由操作系統內核創建和撤銷。內核維護進程及線程的上下文信息以及線程切換。一個內核線程由於I/O操作而阻塞，不會影響其它線程的運行。Windows NT和2000/XP支持內核線程。

內核線程能很好的利用多核cpu，更有利於併發使用多處理器的資源，一個線程阻塞其他線程仍然可以正常運行；當線程進行切換的時候，需要由用戶態轉化爲內核態，上下文切換開銷大。
用戶線程上下文切換開銷小，但是如果一個線程阻塞整個進程就阻塞了，不能很好的利用多核cpu。

注：通過處理器實現進程交錯執行的機制稱爲上下文切換。

如何創建守護進程

fork()創建子進程，父進程退出;
setsid()在子進程中創建新會話
Chdir(“/”)改變當前目錄爲根目錄;
umask()重設文件權限掩碼;
關閉文件描述符;

內核態和用戶態的區別

•當一個進程執行系統調用而陷入內核代碼中執行時，我們就稱進程處於內核態。此時處理器處於特權級最高的0級。當進程處於內核態時，執行的內核代碼會使用當前進程的內核棧。每個進程都有自己的內核棧。
•當進程在執行用戶自己的代碼時，則稱其處於用戶態。即此時處理器在特權級最低的3級。當正在執行用戶程序而突然被中斷程序中斷時，此時用戶程序也可以象徵性地稱爲處於進程的內核態。因爲中斷處理程序將使用當前進程的內核棧。

爲什麼需要

內核態？

當進程處於內核態時，特權級最高，才能使用某些重要指令。在CPU的所有指令中，有一些指令是非常危險的，如果錯用，將導致整個系統崩潰。比如：清內存、設置時鐘等。普通的應用程序只能使用那些不會造成災難的指令。

什麼時候進入內核態？

當一個進程執行系統調用而陷入內核代碼中執行時，我們就稱進程處於內核態；當正在執行用戶程序而突然被中斷程序中斷時，此時用戶程序也可以象徵性地稱爲處於進程的內核態。因爲中斷處理程序將使用當前進程的內核棧。

並行與併發

• 並行是指多個CPU可以同時單獨處理多個進程，是真正的同時進行。
• 併發是指多個進程的指令交錯執行，宏觀上看起來，多個任務就像是同時在進行。
系統一次性預存很多批處理任務進入內存，然後通過一定的調度算法來讓這些批處理任務劃分CPU的時間，這樣看起來，多個任務就像是同時在進行。這個模式，就叫做併發。

常見的調度算法

先來先服務(FCFS, First Come First Serve)：就是按照各個作業進入系統的自然次序來調度作業。這種調度算法的優點是實現簡單，公平。其缺點是不利於短作業，因爲短作業等待處理的時間可能比實際運行時間長得多；
短作業優先(SJF, Shortest Job First)：: 就是優先調度並處理短作業，所謂短是指作業的運行時間短。而在作業未投入運行時，並不能知道它實際的運行時間的長短，因此需要用戶在提交作業時同時提交作業運行時間的估計值。
最高優先級調度(Priority Scheduling)：每一個作業規定一個表示該作業優先級別的整數，當需要將新的作業由輸入井調入內存處理時，優先選擇優先數最高的作業。
4.最高響應比優先算法(HRN)：既利於短作業又有利於長作業，選擇響應比最高的作業運行。響應比=1+作業等待時間/作業處理時間。
時間片輪轉(RR, Round Robin)
多級反饋隊列調度(multilevel feedback queue scheduling)

實時調度算法:

最早截至時間優先 EDF
最低鬆弛度優先 LLF

協程

• 調度算法對於程序來說都是“被動”式的。比如調度算法會把CPU的時間分配給還在IO等待中的程序，雖然可以立即檢查並交出CPU，但是這裏還是有一個切換的過程。
• 協程可以說是“主動式”的，由程序來告訴計算機，我要進行等待IO行爲了，可以把CPU的控制權交給別人，這個實現的基礎是用戶態的。所以，協程就是在用戶態線程中，兩個程序協商好了，通過某種方式協作運營，共享CPU控制權的方法。一般來說，這個協商的方法通用的關鍵字就是yield。

協程與進程線程比較有什麼優勢？

協程避免了無意義的調度，由此可以提高性能，但也因此，程序員必須自己承擔調度的責任，同時，協程也失去了標準線程使用多CPU的能力

孤兒進程

一個父進程退出，而它的一個或多個子進程還在運行，那麼那些子進程將成爲孤兒進程。孤兒進程將被init進程(進程號爲1)所收養，並由init進程對它們完成狀態收集工作。

殭屍進程

如果子進程已經退出，但是父進程又沒有調用wait/waitpid獲取子進程的狀態信息，釋放它佔用的資源，該子進程將成爲殭屍進程。

殭屍進程怎麼解除？怎麼避免？

需要找到其父進程：ps -ef | grep defunct_process_pid並kill掉。
如何避免：在fork子進程之後我們都要wait它們；同時，當子進程退出的時候，內核都會給父進程一個SIGCHLD信號，我們可以建立一個捕獲SIGCHLD信號的處理函數，在函數體中調用wait（或waitpid），就可以清理退出的子進程以達到防止殭屍進程的目的。

物理內存與虛擬內存

物理內存就是系統硬件提供的內存大小，是真正的內存；
虛擬內存是爲了滿足物理內存的不足而提出的策略，它是利用磁盤空間虛擬出的一塊邏輯內存，用作虛擬內存的磁盤空間被稱爲交換空間（SwapSpace）。

linux內存管理機制

linux的內存管理採取的是分頁存取機制，爲了保證物理內存能得到充分的利用，內核會在適當的時候將物理內存中不經常使用的數據頁自動交換到虛擬內存的交換空間中，而將經常使用的信息保留到物理內存。

Linux內存管理相比於windows的一個優秀特性，就是它的緩存機制，它會從內存中劃分出一部分空間作爲cache、buffers。這樣當操作系統需要讀取某些文件時，會首先在buffers和cached內存區查找，如果沒有找到需要的數據才從磁盤讀取。因爲內存的訪問速度必磁盤快很多，而且數據一旦被訪問就很有可能在短期內被再次訪問。所以提高了Linux系統的數據訪問性能。

注：buffers主要用來存放目錄、文件屬性及權限等等；而cached直接用來緩存我們常用到的文件和數據。

要深入瞭解linux內存運行機制，需要知道下面提到的幾個方面：

•Linux系統會根據系統配置不時地進行頁面交換操作，以保持一定量的空閒物理內存，有些配置下即使並沒有什麼事情需要內存，Linux也會交換出暫時不用的內存頁面。這可以避免等待交換所需的時間。
•Linux 進行頁面交換是有條件的，不是所有頁面在不用時都交換到虛擬內存，linux內核根據“最近最經常使用”算法，僅僅將一些不經常使用的頁面文件交換到虛擬內存
•交換空間的頁面在使用時會首先被交換到物理內存，如果此時沒有足夠的物理內存來容納這些頁面，它們又會被馬上交換出去，如此以來，虛擬內存中可能沒有足夠空間來存儲這些交換頁面，最終會導致linux出現假死機、服務異常等問題，linux雖然可以在一段時間內自行恢復，但是恢復後的系統已經基本不可用了。所以，需要合理規劃和設計Linux內存的使用

注：
內存監控常用指令：top、free；
linux可用內存=free+cached+buffers=total-used

內存泄漏

指某塊內存塊使用完後沒有及時釋放，不能被再次使用，我們就說這塊內存泄漏了。

如何避免內存泄漏？

1.減少不必要的全局變量或者生命週期較長的對象，像HashMap等的使用很容易出現內存泄露。
2.注意程序邏輯，避免“死循環”之類的
3.避免創建過多的對象和臨時變量。
4，成對使用new與delete,malloc和free；用類指針對象代替原始指針，利用析構函數自動釋放內存資源
5，對於循環引用導致的內存泄漏可以使用弱引用的智能指針來解決
6，監聽器在釋放對象時及時刪除，數據庫連接及時關閉。

注：智能指針是一種資源管理類，通過對原始指針進行封裝，在資源管理對象進行析構時對指針指向的內存進行釋放，通常使用引用計數方式進行管理。

如何定位內存泄漏？

1，如何發現內存泄漏？

實際上不同的系統都帶有內存監視工具，我們可以從監視工具收集一段時間內的堆棧內存信息，觀測增長趨勢，來確定是否有內存泄漏。在 Linux 平臺可以用 ps 命令，來監視內存的使用，比如 ps -aux ， (觀測指定進程的VSZ值)。

我們可以使用top指令觀察進程的動態內存總額。
程序退出時，可以使用ps、kill兩個命令檢測內存使用情況和進行回收。

定位方法(包括靜態分析，動態實時檢測)

2, 靜態分析

包括手動檢測和靜態工具分析，這是代價最小的調試方法。

2.1 手動檢測:通過少量的實踐和適當的文本搜索，您能夠快速驗證平衡的 malloc() 和 free() 或者 new 和 delete 的源主體。人工檢測
2.2 靜態代碼分析工具
比如 splint, PC-LINT, BEAM 等。
BEAM 可以檢測四類問題: 沒有初始化的變量；廢棄的空指針；內存泄漏；冗餘計算。而且支持的平臺比較多

3,動態運行檢測

實時檢測工具主要有 valgrind, Rational purify 等。
　　1、valgrind。valgrind檢測的內存泄漏是非常準的，可以精確定位到代碼行甚至是變量。valgrind基於valginrd core框架，這是個非常有強大的框架，他的作用不僅僅在於檢測內存泄漏的，強烈建議測試新手通讀下全部的文檔。valgind自己也會有誤報和漏報，所有具體場景需要具體分析。報告中一旦出現definitely lost的標記，就表示一定會有內存泄漏，泄漏的字節數也會報告出來，可以根據泄漏的內存大小和請求次數計算出到底是那個變量沒有釋放。
　　2、利用pmap+gdb，pmap可以列出特定進程的所有內存分配的地址和大小，通過gdb就可以直接看這些地址屬於什麼變量，通過統計這些內存地址的大小，就可以很容易的發現問題。利用自動化的gdb調試工具也可以很方便的定位。
　　3、其他的還包括memprof、商業工具Purify IBM出品，官方宣傳說的不錯，但是這種不開放的技術，在業界得不到認可，國內大公司一般那都不用，只有人傻錢多的公司在用。
　　4、利用一些trace工具，比如ptrace，strace之類的工具，這些trace工具會追蹤特定的api，只需要統計malloc和free的調用次數就可以簡單的發現是否有泄漏，但是無法定位代碼行。另外還有一個更高深的工具，SystemTap，這個在國內應用還不多，但是非常厲害，可以方便hook程序的關鍵邏輯並插入探針。從而可以方便的檢測內存泄漏。Systemtap目前還不通用，而且安裝複雜，暫時不推薦使用，可以關注下，過幾年可能會大規模應用。
　　

linux系統中找出並解決程序錯誤方法：

● 添加’print’ 打印語句
● 查詢 (/proc, /sys 等)
● 跟蹤命令(strace/ltrace)
● Valgrind 工具
● GDB單步調試

死鎖

死鎖：是指多個進程因競爭共享資源而造成的一種僵局，若無外力作用，這些進程都在等待對方執行完畢才能繼續往下執行，都陷入了無限的等待中。

原因:

系統資源不足後分配不當
程序推進順序不當

4個必要條件:

互斥條件：進程要求對所分配的資源進行排它性控制，即在一段時間內某資源僅爲一進程所佔用。
請求和保持條件：當進程因請求資源而阻塞時，對已獲得的資源保持不放。
不剝奪條件：進程已獲得的資源在未使用完之前，不能剝奪，只能在使用完時由自己釋放。
環路等待條件：在發生死鎖時，必然存在一個進程–資源的環形鏈。

解決死鎖的基本方法：

(1)預防死鎖：打破產生死鎖的4個必要條件之一
資源一次性分配：（破壞請求和保持條件）
可剝奪資源：即當某進程新的資源未滿足時，釋放已佔有的資源（破壞不可剝奪條件）
資源有序分配法：系統給每類資源賦予一個編號，每一個進程按編號遞增的順序請求資源，釋放則相反（破壞環路等待條件）

(2)避免死鎖(銀行家算法):
系統在進行資源分配之前預先計算資源分配的安全性。若此次分配不會導致系統進入不安全狀態，則將資源分配給進程；否則，進程等待。

(3)檢測死鎖：
系統檢測出死鎖發生的位置和原因，並通過外力把它從死鎖狀態中解脫出來，常採用的方法有：
1）從其他進程剝奪資源：從其它進程剝奪足夠數量的資源給死鎖進程，以解除死鎖狀態；
2）撤消死鎖進程：可以直接撤消死鎖進程或撤消代價最小的進程，直至有足夠的資源可用，死鎖狀態.消除爲止；所謂代價是指優先級、運行代價、進程的重要性和價值等。

(4). 解除死鎖: 1. 剝奪資源 2. 撤銷進程

自旋鎖和互斥鎖

1，自旋鎖：線程一直是running(加鎖——>解鎖)，它是死循環檢測的，加鎖全程消耗cpu，隨着持鎖時間的增加，開銷線性增長。主要用在臨界區持鎖時間非常短且CPU資源不緊張的情況下。

2，互斥鎖：線程會從sleep（加鎖）——>running（解鎖），過程中有上下文的切換，cpu的搶佔，信號的發送等開銷。但是臨界區持鎖時間的大小並不會對互斥鎖的開銷造成影響。所以雖然互斥鎖的起始開銷可能高於自旋鎖，卻更適合用於臨界區持鎖時間比較長的操作，比如：
1 臨界區IO操作
2 臨界區代碼複雜或者循環量大
3 臨界區競爭非常激烈
4 單核處理器

分頁和分段

分頁: 用戶程序的地址空間被劃分成若干固定大小的區域，稱爲“頁”，相應地，內存空間分成若干個物理塊，頁和塊的大小相等。可將用戶程序的任一頁放在內存的任一塊中，實現了離散分配。會產生內零頭。

分段: 將用戶程序地址空間分成若干個大小不等的段，每段可以定義一組相對完整的邏輯信息。存儲分配時，以段爲單位，段與段在內存中可以不相鄰接，也實現了離散分配。會產生外零頭。

分頁與分段的主要區別

頁是信息的物理單位,分頁是爲了實現非連續分配,以便解決內存碎片問題,是由於系統管理的需要.段是信息的邏輯單位,它含有一組意義相對完整的信息,分段的目的是爲了更好地實現共享,滿足用戶的需要.
頁的大小固定,由系統確定,將邏輯地址劃分爲頁號和頁內地址是由機器硬件實現的.而段的長度卻不固定,決定於用戶所編寫的程序,通常由編譯程序在對源程序進行編譯時根據信息的性質來劃分.
分頁的作業地址空間是一維的.分段的地址空間是二維的.
在編程的時候，如果是分頁存儲，你只需要給定一個虛擬地址，然後操作系統會自己去把虛擬地址劃分成虛頁號和頁內偏移，所以是一維的。而如果是段式存儲的話，你需要給定的虛擬地址必須包括虛段號和段內偏移量，因爲分段式從程序員的角度來分的，操作系統並不知道，所以段式存儲是二維的。

• 什麼是缺頁中斷?
（缺頁中斷就是要訪問的頁不在主存，需要操作系統將其調入主存後再進行訪問。）

頁面置換算法

先進先出FIFO
最近最久未使用算法LRU:最近一段時間裏最久沒有使用過的頁面予以置換.
clock算法
最佳置換算法OPT:不可能實現

中斷和輪詢的特點

1,中斷是指在計算機執行期間，系統內發生急需處理事件，使得CPU暫時中斷當前正在執行的程序而轉去執行相應的事件處理程序。待處理完畢後又返回原來被中斷處繼續執行或調度新的進程執行的過程。
2,輪詢是指定時地對各種設備輪流詢問一遍有無處理要求。有要求的則加以處理。在處理I/O設備的要求之後，處理機返回繼續工作。儘管輪詢需要時間，但輪詢要比I/O設備的速度要快得多，所以一般不會發生不能及時處理的問題。

當然，再快的處理機，能處理的輸入輸出設備的數量也是有一定限度的。而且，程序輪詢畢竟佔據了CPU相當一部分處理時間，因此，程序輪詢是一種效率較低的方式，在現代計算機系統中已很少應用。
輪詢——效率低，等待時間很長，CPU利用率不高。
中斷——容易遺漏一些問題，CPU利用率高。

中斷程序的分類

1，硬中斷就是由硬件引起的中斷。如鍵盤、定時器，以及一些硬件故障等。
硬中斷又可分爲可屏蔽中斷(如鍵盤產生的)；非屏蔽中斷(如由微處理器產生的)；
2，軟中斷是由中斷指令(INT)引起的中斷。

select,poll和epoll

　select，poll，epoll都是IO多路複用的機制。I/O多路複用就通過一種機制，可以監視多個描述符，一旦某個描述符就緒（一般是讀就緒或者寫就緒），能夠通知程序進行相應的讀寫操作。

（但select，poll，epoll本質上都是同步I/O，因爲他們都需要在讀寫事件就緒後自己負責進行讀寫，也就是說這個讀寫過程是阻塞的，而異步I/O則無需自己負責進行讀寫，異步I/O的實現會負責把數據從內核拷貝到用戶空間）

基本上select有3個缺點（poll改善了第一個缺點，epoll改了三個缺點.）:
1. 連接數受限
2. 查找配對速度慢
3. 數據由內核拷貝到用戶態

• select缺點:
1，最大併發數限制：默認是1024個fd；
2，效率低：採用輪詢處理，每次都會線性掃描整個fd_set，集合越大速度越慢；
3，內核/用戶空間內存拷貝問題；

• epoll的提升：
1，本身沒有最大併發連接的限制，僅受系統中進程能打開的最大文件數目限制；
2，效率提升：epoll是維護一個隊列，直接看隊列是不是空就可以了，epoll只會對”活躍”的socket進行操作，只有活躍的socket纔會主動的去調用fd的callback函數,
3，省去不必要的內存拷貝：epoll通過內核與用戶空間mmap同一塊內存實現。

• epoll 實現：
epoll是一種IO多路複用技術，可以非常高效的處理數以百萬計的socket句柄，非常適合監視大量在線用戶，也就是長連接，少量活躍用戶的情況。

首先要調用epoll_create建立一個epoll對象。然後通過epoll_ctl可以操作建立的epoll，例如，將剛建立的socket加入到epoll中讓其監控，或者把epoll正在監控的某個socket句柄移出epoll，不再監控它等等。epoll_wait在調用時，在給定的timeout時間內，當在監控的句柄中有事件發生時，就返回用戶態的進程。

epoll比select的優越之處：select每次調用時都要將用戶態的socket列表copy到內核態，非常低效；而我們調用epoll_wait時就不用傳遞socket句柄給內核，因爲內核已經在epoll_ctl中拿到了要監控的socket句柄列表。

相關問題：
• connect會阻塞，怎麼解決?(提示：1，使用計時器；2，設置非阻塞，返回之後用select檢測狀態)
• 如果select返回可讀，結果只讀到0字節，什麼情況？（某個套接字集合沒有準備好，可能select內存用FD_CLR將該位清爲0）.

selec,poll和epoll區別總結：http://www.cnblogs.com/Anker/p/3265058.html

邊沿觸發和水平觸發

邊緣觸發是指每當狀態變化時發生一個 io 事件，條件觸發是隻要滿足條件就發生一個 io 事件

邊緣觸發（ET）：使用此種模式，只能獲取一次就緒通知，如果沒有處理完全部數據，並且再次調用epoll_wait()的時候，它將會阻塞，因爲就緒事件已經釋放出來了。ET的效能更高，但是要求也更高。在ET模式下，必須一次性處理完所有事件。ET只支持非阻塞socket）
水平觸發（LT，也叫條件觸發）：使用此種模式，當數據可讀的時候，epoll_wait()將會一直返回就緒事件。如果你沒有處理完全部數據，並且再次在該 epoll實例上調用epoll_wait()才監聽描述符的時候，它將會再次返回就緒事件，因爲有數據可讀。

概念：

同步、異步、阻塞、非阻塞

同步和異步關注的是消息通信機制。
同步是A發出一個調用後等待B完成返回結果再繼續向下執行；
異步是A不需等待返回結果，繼續處理其他事情，等B完成後再取回結果。

阻塞和非阻塞關注的是程序在等待調用結果（消息，返回值）時的狀態.
阻塞是指調用結果返回之前，當前線程會被掛起，線程只有在得到結果之後纔會返回。
非阻塞指沒有得到返回結果之前，該調用不會阻塞當前線程。

計算機從電源加載開始的啓動過程

啓動引導程序BIOS-開機自檢-加載操作系統（從磁盤讀到RAM中）-讀取配置文件）

C/C++

關鍵字static的作用

在c語言中，static關鍵字的作用：

函數體內static變量的作用範圍爲該函數體，該變量的內存只被分配一次，因此其值在下次調用時人維持上次的值。
在模塊內的static全局變量可以被模塊內的所有函數訪問，但不能被模塊外的其他函數訪問。
在模塊內的static函數只可被這一模塊內的其它函數調用，這個函數的使用範圍被限制在申明它的模塊內
在類中的static成員變量屬於整個類所擁有，對類的所有對象只有一份拷貝
在類中的static成員函數屬於整個類所擁有，這個函數不接收this指針，因而只能訪問類的static成員變量

C++中：

隱藏函數，所有未加static的全局變量和函數都具有全局可見性。
保持變量內容的持久性。共有兩種變量存儲在靜態存儲區：全局變量和static變量。存儲在靜態數據區的變量會在程序剛開始時完成唯一的一次初始化。static可以控制變量的課件範圍(隱藏)
靜態數據成員是靜態存儲的，所以必須對它進行初始化。static變量默認默認初始化爲0.

注：C++成員函數不能同時又static和const進行修飾。因爲static表示該函數是靜態成員函數，爲類所有，而const是用於修飾成員函數的，兩者矛盾。

關鍵字const的作用

c語言中，const關鍵字的作用主要有以下幾點：

（1）可以定義const常量，具有不可變性。例如： const int Max=100; int Array[Max];
（2）便於進行類型檢查，使編譯器對處理內容有更多瞭解，消除了一些隱患。例如： void f(const int i) { ………} 編譯器就會知道i是一個常量，不允許修改；
（3）可以避免意義模糊的數字出現，同樣可以很方便地進行參數的調整和修改。
（4）可以保護被修飾的東西，防止意外的修改，增強程序的健壯性。還是上面的例子，如果在函數體內修改了i，編譯器就會報錯；例如：
void f(const int i) { i=10;//error! }
（5）爲函數重載提供了一個參考。
class A { ……
void f(int i) {……} //一個函數
void f(int i) const {……} //上一個函數的重載 ……
};
（6）可以節省空間，避免不必要的內存分配。例如：

<code class="hljs cs has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">#<span class="hljs-keyword" style="box-sizing: border-box;">define</span> PI 3.14159 //常量宏 </span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">const</span> doulbe Pi=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">3.14159</span>; <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//此時並未將Pi放入ROM中 ...... </span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">double</span> i=Pi; <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//此時爲Pi分配內存，以後不再分配！ </span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">double</span> I=PI; <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//編譯期間進行宏替換，分配內存 </span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">double</span> j=Pi; <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//沒有內存分配 </span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">double</span> J=PI; <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//再進行宏替換，又一次分配內存！ </span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li></ul>

const定義常量從彙編的角度來看，只是給出了對應的內存地址，而不是象#define一樣給出的是立即數，所以，const定義的常量在程序運行過程中只有一份拷貝，而#define定義的常量在內存中有若干個拷貝。
（7）提高了效率。編譯器通常不爲普通const常量分配存儲空間，而是將它們保存在符號表中，這使得它成爲一個編譯期間的常量，沒有了存儲與讀內存的操作，使得它的效率也很高。

const define inline的區別

本質：define只是字符串替換，const參與編譯運行，inline由編譯器控制。

（1）define：僅僅是宏替換，不做類型檢查；不佔用內存
（2）const：擁有類型，會執行相應的類型；佔用內存；（const內存效率更高，編譯器通常將const變量保存在符號表中，使它成爲一個編譯期間的常量，沒有存儲和讀取的操作）
（3）inline：會真正地編譯到代碼中；inline函數是否展開由編譯器決定，有時候函數太大時編譯器可能會選擇不展開相應的函數。

如何

用 gdb 調試

使用編譯器（cc/gcc/g++）的 -g 參數把調試信息加到可執行文件中。
使用gdb 指令啓動GDB。
gdb的使用

如何調試運行中的程序

用 gdb調試運行狀態下的程序，核心的是gdb內部的attach命令，例如 attach pid

運行了幾天的程序崩掉，如何分析錯誤

首先在調試環境的console或log文件中，根據錯誤信息的內容初步判斷錯誤類型與位置，比如實際爲null的內存被使用，當然也可能是其他錯誤，在這個位置加入斷點，一旦執行該行，程序即崩潰（無法調試的環境下則加入充分的debug信息），再次運行程序，在這一點上監視各個變量，找到導致崩潰的變量值，向上追溯，找到賦值操作的根源時，錯誤的原因也就找到了，接下來就是討論對策與解決方案

程序編譯與鏈接

Bulid過程可以分解爲4個步驟:預處理(Prepressing), 編譯(Compilation)、彙編(Assembly)、鏈接(Linking)

以c語言爲例:

1 預處理

預編譯過程主要處理那些源文件中的以“#”開始的預編譯指令，主要處理規則有：

將所有的“#define”刪除，並展開所用的宏定義
處理所有條件預編譯指令，比如“#if”、“#ifdef”、 “#elif”、“#endif”
處理“#include”預編譯指令，將被包含的文件插入到該編譯指令的位置，注：此過程是遞歸進行的
刪除所有註釋
添加行號和文件名標識，以便於編譯時編譯器產生調試用的行號信息以及用於編譯時產生編譯錯誤或警告時可顯示行號
保留所有的#pragma編譯器指令。

2 編譯

編譯過程就是把預處理完的文件進行一系列的詞法分析、語法分析、語義分析及優化後生成相應的彙編代碼文件。這個過程是整個程序構建的核心部分。

3 彙編

彙編器是將彙編代碼轉化成機器可以執行的指令，每一條彙編語句幾乎都是一條機器指令。經過編譯、鏈接、彙編輸出的文件成爲目標文件(Object File)

4 鏈接

鏈接的主要內容就是把各個模塊之間相互引用的部分處理好，使各個模塊可以正確的拼接。
鏈接的主要過程包塊地址和空間的分配（Address and Storage Allocation）、符號決議(Symbol Resolution)和重定位(Relocation)等步驟。

靜態鏈接

靜態鏈接就是在編譯鏈接時直接將需要的執行代碼拷貝到調用處，優點就是在程序發佈的時候就不需要的依賴庫，也就是不再需要帶着庫一塊發佈，程序可以獨立執行，但是體積可能會相對大一些。
靜態庫的鏈接可以使用靜態鏈接，動態鏈接庫也可以使用這種方法鏈接導入庫

動態鏈接

動態鏈接就是在編譯的時候不直接拷貝可執行代碼，而是通過記錄一系列符號和參數，在程序運行時將需要的動態庫加載到內存中，當程序運行到指定的代碼時，去執行已加載的動態庫可執行代碼，最終達到運行時連接的目的。優點是多個程序可以共享同一段代碼，而不需要在磁盤上存儲多個拷貝，程序初始化時間較短，但運行期間的性能比不上靜態鏈接的程序。

什麼是庫

所謂庫就是一些功能代碼經過編譯連接後的可執行形式：
靜態庫：在程序編譯時會被連接到目標代碼中，程序運行時將不再依賴靜態庫。
動態庫：在程序編譯時並不會被連接到目標代碼中，而是在程序運行是才被載入，因此在程序運行時還需要動態庫存在

• 標準庫函數和系統調用的區別？
庫是可重用的模塊,處於用戶態;系統調用是os提供的服務,處於內核態,是指最底層的一個調用.庫函數中有很大部分是對系統調用的封裝

如何生成靜態庫？如何生成動態庫？

生成靜態庫：首先由源文件編譯生成.o文件，使用ar命令將.o轉換成.a文件，生成靜態庫（以lib開頭，以.a結尾）；
動態庫的後綴是.so，編譯生成動態庫的命令爲：gcc (-fpic) -shared -o libmyfunction.so myfunction.c （-fpic 使輸出的對象模塊是按照可重定位地址方式生成的。 -shared指定把對應的源文件生成對應的動態鏈接庫文件）

•引用動態庫時爲什麼編譯能通過，而運行不能通過：編譯是按你指定的路徑去編譯，而運行時是通過環境變量去找，所以這時候就要指定路徑，把路徑加到環境變量中就OK了。

• 如何查看鏈接的動態庫（ldd a 會列出a所依賴的動態庫）

makefile

文件的作用是什麼？

makefile帶來的好處就是“自動化編譯”。
makefile定義了一系列的規則來指定哪些文件需要先編譯，哪些文件需要後編譯，哪些文件需要重新編譯，甚至於進行更復雜的功能操作。因爲makefile就像一個Shell腳本一樣，其中也可以執行操作系統的命令。一旦寫好，只需要一個make命令，整個工程完全自動編譯，極大地提高了軟件開發的效率。

如何編寫 makefile

makefile的語法:
target（目標） : prerequisites.（依賴文件）
command（shell命令）

<code class="hljs avrasm has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;">
vim makefile
<span class="hljs-label" style="box-sizing: border-box;">hello.o:</span>hello<span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">.c</span> hello<span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">.h</span>
gcc –c hello<span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">.o</span> -Lm
make
./hello</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li></ul>

Makefile的規則：

　　目標：需要的條件（注意冒號兩邊有空格）
　　命令　　（注意前面用tab鍵開頭）

　　解釋一下：
　　1 目標可以是一個或多個，可以是Object File，也可以是執行文件，甚至可以是一個標籤。
　　2 需要的條件就是生成目標所需要的文件或目標
　　3 命令就是生成目標所需要執行的腳本

i++

是否是原子操作？

不是。.i++分爲三個階段：內存到寄存器；寄存器自增；寫回內存。這三個階段中間都可以被中斷分離開.而原子操作是不可分割的，不加鎖互斥是不行的

算法與數據結構

數組和鏈表

從邏輯結構來看：
1. 數組必須事先定義固定的長度（元素個數），不能適應數據動態地增減的情況。當數據增加時，可能超出原先定義的元素個數；當數據減少時，造成內存浪費；數組根據下標查找方便，訪問效率高。
2. 鏈表動態地進行內存分配，需要時可以用new分配內存空間，不需要時用delete將已分配的空間釋放，不會造成內存空間的浪費。且可以方便地插入、刪除操作項。（數組中插入、刪除數據項時，需要移動其它數據項，非常繁瑣；鏈表根據next指針找到下一個元素）

從內存存儲來看：
1. (靜態)數組從棧中分配空間, 對於程序員方便快速,但是自由度小
2. 鏈表從堆中分配空間, 自由度大但是申請管理比較麻煩

綜上，如果需要快速訪問數據，很少或不插入和刪除元素，就應該用數組；相反，如果需要經常插入和刪除元素就需要用鏈表數據結構了。

數組和集合

數組：長度固定可以存儲基本數據類型和引用數據類型（存儲的元素必須是同一數據類型）；
集合：長度可變，只能存儲引用數據類型（數組，類，接口）（存儲的元素可以是不同數據類型）；

二叉樹

●二叉搜索/查找樹：左子樹的所有節點值均小於根節點值，右子樹的所有節點值均不小於根節點值；或是一顆空樹
●完全二叉樹：只有最下面一層的節點度可以小於2，且都集中在最左邊的若干位置
●平衡二叉樹（AVL）：左右子樹的深度差不超過1,；或爲空樹。（windows對進程地址空間的管理用到了AVL樹）
●紅黑樹：是一種自平衡的二叉查找樹，追求局部平衡，通過對任何一條從根節點到葉子節點的簡單路徑上的各個節點的顏色進行約束，確保一個節點的兩顆子樹高度差不會相差兩倍，保證每次插入最多隻需3次旋轉就能達到平衡。典型的應用是關聯數組。
性質：
1）結點或者是紅的或者是黑的；
2）根結點是黑的；
3）每個葉結點（即空節點NIL）是黑的；
4）如果一個結點是紅的，則它的兩個孩子都是黑的；
5）對每個結點，從該結點到其他子結點的所有路徑上包含相同數目的黑結點。

●B樹：是一種多路查找樹，一般用於數據庫系統中，分支多層數少，降低I/O耗時
●B+樹：是B樹的變種樹，數據只保存在葉子節點中，其他節點中含有關鍵字，每個關鍵字不保存數據只用來索引，爲文件系統而生。
●Trie樹：又名單詞查找樹，主要處理字符串，將字符串的相同前綴保存在相同節點中，經常被搜索引擎系統用於文本詞頻統計。
●哈夫曼樹（最優二叉樹）：給定n個權值的葉子結點，構造一棵二叉樹，若樹的帶權路徑長度達到最小，稱這樣的二叉樹爲最優二叉樹，也稱爲哈夫曼樹(Huffman Tree)。哈夫曼樹是帶權路徑長度最短的樹，權值較大的結點離根較近。

結點的帶權路徑長度：結點到樹根之間的路徑長度與該結點上權的乘積.

下面演示了用Huffman算法構造一棵Huffman樹的過程：

用一個類似於樹杈的“樹枝”連接兩個最小權值。在頂點處計算出這兩個數字的和並寫在上面。然後再比較剩下的數字和這個和的大小，如果該和正好是下一步的兩個最小數的其中一個那麼這個樹直接往上生長就可以了。如果該數不是下一步的兩個最小數的其中一個那麼，就並列生長。

通過哈夫曼樹來構造的編碼稱爲哈弗曼編碼：
霍夫曼編碼是一種無前綴的不定長的編碼。解碼時不會混淆。其主要應用在數據壓縮，加密解密等場合。
使用頻度較高的字符分配較短的編碼，使用頻度較低的字符分配較長的編碼。但當信息源各符號出現的概率很不平均的時候，哈夫曼編碼的效果才明顯。

假如我有A,B,C,D,E五個字符，出現的頻率（即權值）分別爲5,4,3,2,1,取兩個最小權值作爲左右子樹依次建立哈夫曼樹，如下圖：

其中各個權值替換對應的字符即爲下圖：

所以各字符對應的編碼爲：A->11,B->10,C->00,D->011,E->010

排序算法與字符串匹配算法

交換排序：冒泡排序、快速排序
選擇排序：簡單選擇排序、堆排序
插入排序：直接插入排序、二分法插入排序、希爾排序
歸併排序、基數排序

詳見：http://blog.csdn.net/qq_15437629/article/details/52433062

最短路徑算法

1，Dijkstra（迪傑斯特拉）算法

Dijkstra算法（迪傑斯特拉）是典型的最短路徑路由算法，用於計算一個節點到其他所有節點的最短路徑。其採用的是貪心算法的策略，主要特點是以起始點爲中心向外層層擴展，找出距起始點最近的點，直到擴展到終點爲止。
Dijkstra算法能得出最短路徑的最優解，但由於它遍歷計算的節點很多，所以效率低。可以用堆優化。

大概過程：
創建兩個表，OPEN, CLOSE。
OPEN表保存所有已生成而未考察的節點，CLOSED表中記錄已訪問過的節點。
1．訪問路網中距離起始點最近且沒有被檢查過的點，把這個點放入OPEN組中等待檢查。
2．從OPEN表中找出距起始點最近的點，找出這個點的所有子節點，把這個點放到CLOSE表中。
3．遍歷考察這個點的子節點。求出這些子節點距起始點的距離值，放子節點到OPEN表中。
4．重複第2和第3步,直到OPEN表爲空，或找到目標點。

2，Floyd算法\Floyd-Warshall算法

Floyd算法又稱爲插點法，是一種利用動態規劃的思想尋找給定的加權圖中多源點之間最短路徑的算法，與Dijkstra算法類似。

優點：容易理解，可以算出任意兩個節點之間的最短距離，代碼編寫簡單。
缺點：時間複雜度比較高，不適合計算大量數據。時間複雜度:O(n^3)；空間複雜度:O(n^2)

Floyd算法適用於APSP(All Pairs Shortest Paths，多源最短路徑)，是一種動態規劃算法，稠密圖效果最佳，邊權可正可負。此算法簡單有效，由於三重循環結構緊湊，對於稠密圖，效率要高於執行|V|次Dijkstra算法，也要高於執行V次SPFA算法。

算法過程：
　　1，從任意一條單邊路徑開始。所有兩點之間的距離是邊的權，如果兩點之間沒有邊相連，則權爲無窮大。
　　2，對於每一對頂點 u 和 v，看看是否存在一個頂點 w 使得從 u 到 w 再到 v 比已知的路徑更短。如果是更新它。
　　把圖用鄰接矩陣G表示出來，如果從Vi到Vj有路可達，則G[i,j]=d，d表示該路的長度；否則G[i,j]=無窮大。定義一個矩陣D用來記錄所插入點的信息，D[i,j]表示從Vi到Vj需要經過的點，初始化D[i,j]=j。把各個頂點插入圖中，比較插點後的距離與原來的距離，G[i,j] = min( G[i,j], G[i,k]+G[k,j] )，如果G[i,j]的值變小，則D[i,j]=k。在G中包含有兩點之間最短道路的信息，而在D中則包含了最短通路徑的信息。
　　比如，要尋找從V5到V1的路徑。根據D，假如D(5,1)=3則說明從V5到V1經過V3，路徑爲{V5,V3,V1}，如果D(5,3)=3，說明V5與V3直接相連，如果D(3,1)=1，說明V3與V1直接相連。

３，SPFA算法\Bellman-Ford算法

SPFA（Shortest Path Faster Algorithm）（隊列優化）算法是求單源最短路徑的一種算法，它還有一個重要的功能是判負環（在差分約束系統中會得以體現），在Bellman-ford算法的基礎上加上一個隊列優化，減少了冗餘的鬆弛操作，是一種高效的最短路算法。

對SPFA的一個很直觀的理解就是由無權圖的BFS轉化而來。在無權圖中，BFS首先到達的頂點所經歷的路徑一定是最短路(也就是經過的最少頂點數)，所以此時利用數組記錄節點訪問可以使每個頂點只進隊一次，但在帶權圖中，最先到達的頂點所計算出來的路徑不一定是最短路。一個解決方法是放棄數組，此時所需時間自然就是指數級的，所以我們不能放棄數組，而是在處理一個已經在隊列中且當前所得的路徑比原來更好的頂點時，直接更新最優解。

SPFA算法有兩個優化策略SLF和LLL——SLF：Small Label First 策略，設要加入的節點是j，隊首元素爲i，若dist(j)< dist(i)，則將j插入隊首，否則插入隊尾； LLL：Large Label Last 策略，設隊首元素爲i，隊列中所有dist值的平均值爲x，若dist(i)>x則將i插入到隊尾，查找下一元素，直到找到某一i使得dist(i)<=x，則將i出隊進行鬆弛操作。 SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高約 50%。在實際的應用中SPFA的算法時間效率不是很穩定，爲了避免最壞情況的出現，通常使用效率更加穩定的Dijkstra算法。

4，A*算法

A*算法；A*（A-Star)算法是一種靜態路網中求解最短路徑最有效的直接搜索方法，也是解決許多搜索問題的有效算法。算法中的距離估算值與實際值越接近，最終搜索速度越快。

數據庫

範式

第一範式：原子性，字段不可分割
第二範式：就是完全依賴，不能部分依賴；
第三範式：不能存在傳遞依賴

第一範式(例如：學生信息表)：

<code class="hljs avrasm has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;">學生編號    姓名  性別         聯繫方式 
<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">20080901</span>  張三    男   email:zs<span class="hljs-localvars" style="box-sizing: border-box;">@126</span><span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">.com</span>,phone:<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">88886666</span> 
<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">20080902</span>  李四    女   email:ls<span class="hljs-localvars" style="box-sizing: border-box;">@126</span><span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">.com</span>,phone:<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">66668888</span>  </code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li></ul>

以上的表就不符合，第一範式：聯繫方式字段可以再分，所以變更爲正確的是：

<code class="hljs avrasm has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;">學生編號   姓名  性別     電子郵件     電話 
<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">20080901</span>  張三  男   zs<span class="hljs-localvars" style="box-sizing: border-box;">@126</span><span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">.com</span>  <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">88886666</span> 
<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">20080902</span>  李四  女   ls<span class="hljs-localvars" style="box-sizing: border-box;">@126</span><span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">.com</span>  <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">66668888</span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li></ul>

第二範式(例如：學生選課表):

<code class="hljs css has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;">學生    課程      教師    教師職稱      教材             教室  上課時間 
李四    <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Spring</span>  張老師   <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">java</span>講師  《<span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Spring</span>深入淺出》    ３０１   08<span class="hljs-pseudo" style="color: rgb(0, 0, 0); box-sizing: border-box;">:00</span> 
張三    <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Struts</span>  楊老師   <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">java</span>講師  《<span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Struts</span> <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">in</span> <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Action</span>》 ３０２   13<span class="hljs-pseudo" style="color: rgb(0, 0, 0); box-sizing: border-box;">:30</span>  </code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li></ul>

這裏通過（學生，課程）可以確定教師、教師職稱，教材，教室和上課時間，所以可以把（學生，課程）作爲主鍵。但是，教材並不完全依賴於（學生，課程），只拿出課程就可以確定教材，因爲一個課程，一定指定了某個教材。這就叫不完全依賴，或者部分依賴。出現這種情況，就不滿足第二範式。
修改後：

<code class="hljs css has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;">選課表：
學生     課程    教師    教師職稱   教室  上課時間 
李四    <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Spring</span>  張老師   <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">java</span>講師  ３０１ 08<span class="hljs-pseudo" style="color: rgb(0, 0, 0); box-sizing: border-box;">:00</span> 
張三    <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Struts</span>  楊老師   <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">java</span>講師  ３０２ 13<span class="hljs-pseudo" style="color: rgb(0, 0, 0); box-sizing: border-box;">:30</span> 

課程表： 
 課程      教材         
<span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Spring</span>  《<span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Spring</span>深入淺出》  
<span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Struts</span>  《<span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Struts</span> <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">in</span> <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Action</span>》
</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li><li style="box-sizing: border-box; padding: 0px 5px;">9</li><li style="box-sizing: border-box; padding: 0px 5px;">10</li></ul>

所以，第二範式可以說是消除部分依賴。可以減少插入異常，刪除異常和修改異常。

第三範式：
上例中修改後的選課表中，一個教師能確定一個教師職稱。這樣，教師依賴於（學生，課程），而教師職稱又依賴於教師，這叫傳遞依賴。第三範式就是要消除傳遞依賴。
修改後：

<code class="hljs css has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;">選課表：  
學生     課程    教師    教室  上課時間 
李四    <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Spring</span>  張老師   ３０１ 08<span class="hljs-pseudo" style="color: rgb(0, 0, 0); box-sizing: border-box;">:00</span> 
張三    <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">Struts</span>  楊老師   ３０２ 13<span class="hljs-pseudo" style="color: rgb(0, 0, 0); box-sizing: border-box;">:30</span> 

教師表： 
教師    教師職稱 
張老師   <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">java</span>講師 
楊老師   <span class="hljs-tag" style="color: rgb(0, 0, 0); box-sizing: border-box;">java</span>講師  </code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li><li style="box-sizing: border-box; padding: 0px 5px;">9</li></ul>

這樣，新教師的職稱在沒被選課的時候也有地方存了，沒人選這個教師的課的時候教師的職稱也不至於被刪除，修改教師職稱時只修改教師表就可以了。

數據庫的基本鎖

（1）共享（S)鎖：多個事務可封鎖一個共享頁；通常是該頁被讀取完畢，S鎖立即被釋放。
它是非獨佔的，允許其他事務同時讀取其鎖定的資源，但不允許其他事務修改它。
（2）排它（X)鎖：僅允許一個事務封鎖此頁；X鎖一直到事務結束才能被釋放，其他任何事務必須等到X鎖被釋放才能對該頁進行訪問。適用於修改數據的場合。
（3）更新（U)鎖：更新鎖在的初始化階段用來鎖定可能要被修改的資源，避免使用共享鎖造成的死鎖現象。
用來預定要對此頁施加X鎖，它允許其他事務讀，但不允許再施加U鎖或X鎖；當被讀取的頁將要被更新時，則升級爲X鎖；U鎖一直到事務結束時才能被釋放。

數據庫帶來的併發問題

丟失更新

當兩個或多個事務選擇同一行，然後基於最初選定的值更新該行時，會發生丟失更新問題。每個事務都不知道其它事務的存在。最後的更新將重寫由其它事務所做的更新，這將導致數據丟失。　　

例如：事務A和事務B同時修改某行的值，事務A將數值改爲1並提交,事務B將數值改爲2並提交。這時數據的值爲2，事務A所做的更新將會丟失。

如何解決呢？基本兩種思路，一種是悲觀鎖，另外一種是樂觀鎖；

悲觀鎖：假定併發衝突總是發生，屏蔽一切可能違反數據完整性的操作
樂觀鎖：假設不會發生併發衝突，只在提交操作時檢查是否違反數據完整性。

髒讀

當一個事務讀取另一個事務尚未提交的修改時，產生髒讀。

例如：
1.Mary的原工資爲1000, 財務人員將Mary的工資改爲了8000(但未提交事務)
2.Mary讀取自己的工資 ,發現自己的工資變爲了8000，歡天喜地！
3.而財務發現操作有誤，回滾了事務,Mary的工資又變爲了1000
像這樣,Mary記取的工資數8000是一個髒數據。

解決辦法：在一個事務提交前，任何其他事務不可讀取其修改過的值，則可以避免該問題。

不可重複讀

　同一查詢在同一事務中多次進行，由於其他提交事務所做的修改或刪除，每次返回不同的結果集，此時發生非重複讀。

例如：
在事務1中，Mary 讀取了自己的工資爲1000,操作並沒有完成，這時財務人員修改了Mary的工資爲2000,並提交了事務.在事務1中，Mary 再次讀取自己的工資時，工資變爲了2000

解決辦法：只有在修改事務完全提交之後纔可以讀取數據，則可以避免該問題。

幻讀　

　同一查詢在同一事務中多次進行，由於其他提交事務所做的插入操作，每次返回不同的結果集，此時發生幻像讀。
　當對某行執行插入或刪除操作，而該行屬於某個事務正在讀取的行的範圍時，會發生幻像讀問題。事務第一次讀的行範圍顯示出其中一行已不復存在於第二次讀或後續讀中，因爲該行已被其它事務刪除。同樣，由於其它事務的插入操作，事務的第二次或後續讀顯示有一行已不存在於原始讀中。

例如：目前工資爲1000的員工有10人。

事務1,讀取所有工資爲1000的員工。
這時事務2向employee表插入了一條員工記錄，工資也爲1000。事務1再次讀取所有工資爲1000的員工共讀取到了11條記錄。

解決辦法：在操作事務完成數據處理之前，任何其他事務都不可以添加新數據，則可避免該問題

sql基本語句

SQL (結構化查詢語言)是用於執行查詢的語法。但是 SQL 語言也包含用於更新、插入和刪除記錄的語法。可以把 SQL 分爲兩個部分：數據操作語言 (DML) 和數據定義語言 (DDL)。

查詢和更新指令構成了 SQL 的 DML 部分：
SELECT - 從數據庫表中獲取數據
UPDATE - 更新數據庫表中的數據
DELETE - 從數據庫表中刪除數據
INSERT INTO - 向數據庫表中插入數據

SQL 的數據定義語言 (DDL) 部分使我們有能力創建或刪除表格。我們也可以定義索引（鍵），規定表之間的鏈接，以及施加表間的約束。
SQL 中最重要的 DDL 語句:
CREATE DATABASE - 創建新數據庫
ALTER DATABASE - 修改數據庫
CREATE TABLE - 創建新表
ALTER TABLE - 變更（改變）數據庫表
DROP TABLE - 刪除表
CREATE INDEX - 創建索引（搜索鍵）
DROP INDEX - 刪除索引

基本語法：

下面的例子是一個名爲 “Persons” 的表：

註釋：SQL 語句對大小寫不敏感。SELECT 等效於 select。

1,獲取名爲 “LastName” 和 “FirstName” 的列的內容（從名爲 “Persons” 的數據庫表）：

<code class="hljs ruleslanguage has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> LastName,FirstName <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons
</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li></ul>

2，如果有多個city相同，僅需列出一次的話(distinct)：

<code class="hljs sql has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-operator" style="box-sizing: border-box;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">DISTINCT</span> City <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons </span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li></ul>

3,顯示所有姓爲 “Carter” 並且名爲 “Thomas” 的人：

<code class="hljs sql has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-operator" style="box-sizing: border-box;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> * <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">WHERE</span> FirstName=<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Thomas'</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">AND</span> LastName=<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Carter'</span></span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li></ul>

4，以字母順序顯示

<code class="hljs sql has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-operator" style="box-sizing: border-box;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> * <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">ORDER</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">BY</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">Year</span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> * <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">ORDER</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">BY</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">Year</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">DESC</span> (逆序)</span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li></ul>

5，insert；update；delete

<code class="hljs sql has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-operator" style="box-sizing: border-box;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">INSERT</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">INTO</span> Persons <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">VALUES</span> (<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Gates'</span>, <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Bill'</span>, <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Xuanwumen 10'</span>, <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Beijing'</span>，<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'1986'</span>)
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">INSERT</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">INTO</span> Persons (LastName, Address) <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">VALUES</span> (<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Wilson'</span>, <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Champs-Elysees'</span>)       #在指定列中插入
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">UPDATE</span> Persons <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SET</span> FirstName = <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Fred'</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">WHERE</span> LastName = <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Wilson'</span> #爲 lastname 是 <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"Wilson"</span> 的人添加 firstname
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">DELETE</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Person <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">WHERE</span> LastName = <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Wilson'</span> 

</span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li></ul>

高級語法：

1，top：

<code class="hljs vbnet has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> TOP <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">2</span> * <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons     <span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">#從"Persons" 表中選取頭兩條記錄</span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> TOP <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">50</span> PERCENT * <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons   <span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">#選出前50%的記錄</span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li></ul>

2，like：

<code class="hljs sql has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-operator" style="box-sizing: border-box;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> * <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">WHERE</span> City <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">LIKE</span> <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'N%'</span>   #選取居住在以 <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"N"</span> 開頭的城市裏的人
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> * <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">WHERE</span> City <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">LIKE</span> <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'%g'</span>    #選取居住在以 <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"g"</span> 結尾的城市裏的人
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> * <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">WHERE</span> City <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">LIKE</span> <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'%lon%'</span>   #選取居住在包含 <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"lon"</span> 的城市裏的人
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> * <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">WHERE</span> City <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">NOT</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">LIKE</span> <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'%lon%'</span>   #選取居住在不包含 <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"lon"</span> 的城市裏的人
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> * <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">WHERE</span> City <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">LIKE</span> <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'[ALN]%'</span>    #選取居住在以 <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"A、L或N"</span> 開頭的城市裏的人</span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li></ul>

通配符說明：

3，in：從表中選取姓氏爲 Adams 和 Carter 的人：

<code class="hljs sql has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-operator" style="box-sizing: border-box;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> * <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">WHERE</span> LastName <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">IN</span> (<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Adams'</span>,<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'Carter'</span>)</span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li></ul>

4，join：用於根據兩個或多個表中的列之間的關係，從這些表中查詢數據。

“Persons” 表：

“Orders” 表：

“Id_O” 列是 Orders 表中的的主鍵，同時，”Orders” 表中的 “Id_P” 列用於引用 “Persons” 表中的人，而無需使用他們的確切姓名。請留意，”Id_P” 列把上面的兩個表聯繫了起來。

我們可以從兩個表中獲取數據：誰訂購了產品，和訂購了什麼產品

<code class="hljs avrasm has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;">SELECT Persons<span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">.LastName</span>, Persons<span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">.FirstName</span>, Orders<span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">.OrderNo</span> FROM Persons, Orders WHERE Persons<span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">.Id</span>_P = Orders<span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">.Id</span>_P </code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li></ul>

除了上面的方法，我們也可以使用關鍵詞 JOIN 來從兩個表中獲取數據：

<code class="hljs sql has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-operator" style="box-sizing: border-box;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">SELECT</span> Persons.LastName, Persons.FirstName, Orders.OrderNo <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">FROM</span> Persons <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">INNER</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">JOIN</span> Orders <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">ON</span> Persons.Id_P = Orders.Id_P <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">ORDER</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">BY</span> Persons.LastName</span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li></ul>

補充：INNER JOIN；LEFT JOIN；RIGHT JOIN：
(1)INNER JOIN 返回兩表符合匹配條件的行
(2)LEFT JOIN 關鍵字會從左表 (table_name1) 那裏返回所有的行，即使在右表 (table_name2) 中沒有匹配的行。
(3)RIGHT JOIN 關鍵字會右表 (table_name2) 那裏返回所有的行，即使在左表 (table_name1) 中沒有匹配的行。

1 事務

數據庫事務(Database Transaction) ，是指作爲單個邏輯工作單元執行的一系列操作，要麼完全地執行，要麼完全地不執行。

2 數據庫索引

MySQL索引背後的數據結構及算法原理

聚集索引,非聚集索引,B-Tree,B+Tree,最左前綴原理

高併發

如何在j2ee項目中處理高併發量訪問？

1、HTML靜態化。因爲純靜態化的html頁面是效率最高、消耗最小的。
2、圖片服務器分離。圖片是最消耗資源的，我們有必要將圖片與頁面進行分離，基本上大型網站都會有獨立的、甚至很多臺的圖片服務器。
3、在面對大量訪問的時候，數據庫的瓶頸很快就能顯現出來，我們可以使用數據庫集羣或者庫表散列。
（數據庫集羣在架構、成本、擴張性方面都會受到所採用數據庫類型的限制，庫表散列是從應用程序的角度來考慮改善系統架構，通過在應用程序中安裝功能模塊將數據庫進行分離，不同的模塊對應不同的數據庫或者表，再按照一定的策略對某個頁面或者功能進行更小的數據庫散列，比如一個論壇就可以對帖子、用戶按照板塊和ID進行散列數據庫和表，這樣就能夠低成本的提升系統的性能並且有很好的擴展性。）
4、緩存。Linux上提供的Memory Cache是常用的緩存接口，比如用Java開發的時候就可以調用MemoryCache對一些數據進行緩存和通訊共享。
5、搭建鏡像站點，數據進行定時更新或者實時更新
6、CDN加速技術。通過在現有的網絡中增加一層新的網絡架構，將網站的內容發佈到最接近用戶的網絡“邊緣”，使用戶可以就近取得所需的內容，提高用戶訪問網站的響應速度。
7、負載均衡技術，將整個區間段的業務流分配到合適的應用服務器進行處理：

負載均衡方式

(1)、DNS負載均衡，在DNS中爲多個地址配置同一個名字，查詢這個名字的客戶機將得到其中一個地址，使得不同的客戶訪問不同的服務器，達到負載均衡的目的(DNS負載均衡是一種簡單而有效的方法，但是它不能區分服務器的差異，也不能反映服務器的當前運行狀態)。
(2)、使用代理服務器，將用戶請求轉發給多臺服務器，從而達到負載均衡的目的，提升網頁的訪問速度。
(3)、NAT負載均衡，通過網絡地址轉換的網關，將一個外部IP地址映射爲多個內部IP地址，對每次連接請求動態使用其中一個內部地址，達到負載均衡的目的。
(4)、協議內部支持負載均衡，比如HTTP協議中的重定向能力等，HTTP運行於TCP連接的最高層。
(5)、對於大型網絡，可以採用混合型負載均衡，由於多個服務器羣內硬件設備、各自的規模、提供的服務等的差異，我們可以考慮給每個服務器羣採用最合適的負載均衡方式，然後又在這多個服務器羣間再一次負載均衡向外界提供服務，從而達到最佳的性能

如何設計一個高併發的系統

① 數據庫的優化，包括合理的事務隔離級別、SQL語句優化、索引的優化
② 使用緩存，儘量減少數據庫 IO
③ 分佈式數據庫、分佈式緩存
④ 服務器的負載均衡

海量數據處理問題

2.5億個整數中找出不重複的整數的個數，內存空間不足以容納這2.5億個整數

有點像鴿巢原理，整數個數爲2^32,也就是，我們可以將這2^32個數，劃分爲2^8個區域(比如用單個文件代表一個區域)，然後將數據分離到不同的區域，然後不同的區域在利用bitmap就可以直接解決了。也就是說只要有足夠的磁盤空間，就可以很方便

二進制文件中有2.5億個數字，其中只有10個數字重複。
解決思路如下:
採用2-Bitmap（每個數分配2bit，00表示不存在，01表示出現一次，10表示多次，11無意義）進行。然後掃描這2.5億個整數，查看Bitmap中相對應位，如果是00變01，01變10，10保持不變。所描完事後，查看bitmap，把對應位是01的整數輸出即可。
映射關係如下：

<code class="hljs 1c has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">|00 00 00 00| //映射|3 2 1 0|</span>
<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">|00 00 00 00| //映射|7 6 5 4|</span>
……
<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">|00 00 00 00| </span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li></ul>

因此，每個char字符可表示4個數字。
代碼如下：

<code class="hljs cpp has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">#include<stdio.h></span>
<span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">#include<memory.h></span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> n=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">250000000</span>; <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//數據個數</span>
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">unsigned</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">char</span> flags[<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">250000000</span>/<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">4</span>];<span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//需要n/4個字符</span>

<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">unsigned</span> get_val(<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> idx) <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//獲取數字出現次數</span>

{
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> i=idx/<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">4</span>;
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> j=idx%<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">4</span>;
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">unsigned</span> ret=(flags[i]&(<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0x3</span><<(<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">2</span>*j)))>>(<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">2</span>*j); <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//位運算</span>
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">return</span> ret;
}

<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">unsigned</span> set_val(<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> idx,<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">unsigned</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> val) <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//在8bit中設置數字出現次數</span>
{
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> i=idx/<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">4</span>; <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//確定數字在字符數組中的位置</span>
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> j=idx%<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">4</span>; <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//確定數字在8bit中的位置</span>
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">unsigned</span> tmp=(flags[i]&~((<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0x3</span><<(<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">2</span>*j)))) | (((val%<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">4</span>)<<(<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">2</span>*j))); <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//位運算</span>
  flags[i]=tmp;
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">return</span> <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>;
}

<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">unsigned</span> add_one(<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> idx) <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//數字出現次數+1,如果大於2,不變</span>
{
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> i=get_val(idx);
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">if</span> (i>=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">2</span>)
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">return</span> <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>;
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">else</span>
  {
    set_val(idx,i+<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>);
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">return</span> <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>;
  }
}

<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> main()
{
  FILE *fp;
  fp=fopen(<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"number.bin"</span>,<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"rb"</span>); <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//讀取二進制數據文件</span>
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> i;
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> s=<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">sizeof</span>(<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span>);
  <span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box;">memset</span>(flags,<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>,<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">sizeof</span>(flags));
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">while</span>(!feof(fp))
  {
    fread(&i,s,<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>,fp);
    add_one(i);
  }
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> all=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>;
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">for</span>(i=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>;i<n;i++)
  {
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">if</span>(get_val(i)==<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>) <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//出現次數等於1，統計輸出</span>
      all++;
  }
  <span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box;">printf</span>(<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"%d\n"</span>,all);
  fclose(fp);
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">return</span> <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>;
}</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li><li style="box-sizing: border-box; padding: 0px 5px;">9</li><li style="box-sizing: border-box; padding: 0px 5px;">10</li><li style="box-sizing: border-box; padding: 0px 5px;">11</li><li style="box-sizing: border-box; padding: 0px 5px;">12</li><li style="box-sizing: border-box; padding: 0px 5px;">13</li><li style="box-sizing: border-box; padding: 0px 5px;">14</li><li style="box-sizing: border-box; padding: 0px 5px;">15</li><li style="box-sizing: border-box; padding: 0px 5px;">16</li><li style="box-sizing: border-box; padding: 0px 5px;">17</li><li style="box-sizing: border-box; padding: 0px 5px;">18</li><li style="box-sizing: border-box; padding: 0px 5px;">19</li><li style="box-sizing: border-box; padding: 0px 5px;">20</li><li style="box-sizing: border-box; padding: 0px 5px;">21</li><li style="box-sizing: border-box; padding: 0px 5px;">22</li><li style="box-sizing: border-box; padding: 0px 5px;">23</li><li style="box-sizing: border-box; padding: 0px 5px;">24</li><li style="box-sizing: border-box; padding: 0px 5px;">25</li><li style="box-sizing: border-box; padding: 0px 5px;">26</li><li style="box-sizing: border-box; padding: 0px 5px;">27</li><li style="box-sizing: border-box; padding: 0px 5px;">28</li><li style="box-sizing: border-box; padding: 0px 5px;">29</li><li style="box-sizing: border-box; padding: 0px 5px;">30</li><li style="box-sizing: border-box; padding: 0px 5px;">31</li><li style="box-sizing: border-box; padding: 0px 5px;">32</li><li style="box-sizing: border-box; padding: 0px 5px;">33</li><li style="box-sizing: border-box; padding: 0px 5px;">34</li><li style="box-sizing: border-box; padding: 0px 5px;">35</li><li style="box-sizing: border-box; padding: 0px 5px;">36</li><li style="box-sizing: border-box; padding: 0px 5px;">37</li><li style="box-sizing: border-box; padding: 0px 5px;">38</li><li style="box-sizing: border-box; padding: 0px 5px;">39</li><li style="box-sizing: border-box; padding: 0px 5px;">40</li><li style="box-sizing: border-box; padding: 0px 5px;">41</li><li style="box-sizing: border-box; padding: 0px 5px;">42</li><li style="box-sizing: border-box; padding: 0px 5px;">43</li><li style="box-sizing: border-box; padding: 0px 5px;">44</li><li style="box-sizing: border-box; padding: 0px 5px;">45</li><li style="box-sizing: border-box; padding: 0px 5px;">46</li><li style="box-sizing: border-box; padding: 0px 5px;">47</li><li style="box-sizing: border-box; padding: 0px 5px;">48</li><li style="box-sizing: border-box; padding: 0px 5px;">49</li><li style="box-sizing: border-box; padding: 0px 5px;">50</li><li style="box-sizing: border-box; padding: 0px 5px;">51</li><li style="box-sizing: border-box; padding: 0px 5px;">52</li><li style="box-sizing: border-box; padding: 0px 5px;">53</li><li style="box-sizing: border-box; padding: 0px 5px;">54</li><li style="box-sizing: border-box; padding: 0px 5px;">55</li><li style="box-sizing: border-box; padding: 0px 5px;">56</li><li style="box-sizing: border-box; padding: 0px 5px;">57</li></ul>

運行結果如下：

<code class="hljs d has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;"><span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">249999980</span>

<span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box;">real</span>    <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>m35.566s
user    <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>m31.694s
sys    <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>m1.300s</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li></ul>

可見，利用位運算、二進制數據文件，可以高效地解決這個問題。

linux常用命令

lsof

lsof（list open files）：列出當前系統打開文件（普通文件、目錄、管道、socket、網絡文件）。因爲打開文件的描述符列表提供了大量關於這個應用程序本身的信息，因此通過lsof工具能夠查看這個列表對系統監測以及排錯將是很有幫助的。

在linux環境下，任何事物都以文件的形式存在，通過文件不僅僅可以訪問常規數據，還可以訪問網絡連接和硬件。所以如傳輸控制協議 (TCP) 和用戶數據報協議 (UDP) 套接字等，系統在後臺都爲該應用程序分配了一個文件描述符，無論這個文件的本質如何，該文件描述符爲應用程序與基礎操作系統之間的交互提供了通用接口。因爲應用程序打開文件的描述符列表提供了大量關於這個應用程序本身的信息，因此通過lsof工具能夠查看這個列表對系統監測以及排錯將是很有幫助的。

netstat

Netstat 命令用於顯示各種網絡相關信息，如網絡連接，路由表，接口狀態 (Interface Statistics)，masquerade 連接，多播成員 (Multicast Memberships) 等等。

一些常用的netstat選項包括：

<code class="hljs haml has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;">-<span class="ruby" style="box-sizing: border-box;">a <span class="hljs-symbol" style="color: rgb(0, 102, 102); box-sizing: border-box;">:</span> 顯示所有socke信息
</span>-<span class="ruby" style="box-sizing: border-box;">r <span class="hljs-symbol" style="color: rgb(0, 102, 102); box-sizing: border-box;">:</span> 顯示路由信息
</span>-<span class="ruby" style="box-sizing: border-box;">i <span class="hljs-symbol" style="color: rgb(0, 102, 102); box-sizing: border-box;">:</span> 顯示網卡藉口統計
</span>-<span class="ruby" style="box-sizing: border-box;">s <span class="hljs-symbol" style="color: rgb(0, 102, 102); box-sizing: border-box;">:</span> 顯示網絡協議統計</span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li></ul>

實用命令實例：

列出所有端口 (包括監聽和未監聽的)
列出所有端口 netstat -a
列出所有 tcp 端口 netstat -at
列出所有 tcp 端口 netstat -au
列出所有處於監聽狀態的 Sockets
只顯示監聽端口 netstat -l
只列出所有監聽 tcp 端口 netstat -lt
只列出所有監聽 udp 端口 netstat -lu
只列出所有監聽 UNIX 端口 netstat -lx
顯示每個協議的統計信息
顯示所有端口的統計信息 netstat -s
顯示 TCP 或 UDP 端口的統計信息 netstat -st 或 -su
在 netstat 輸出中顯示 PID 和進程名稱 netstat -p

strace

strace可以跟蹤到一個進程產生的系統調用,包括參數，返回值，執行消耗的時間。

在Linux中，進程不能直接訪問硬件設備，當進程需要訪問硬件設備(比如讀取磁盤文件，接收網絡數據等等)時，必須由用戶態模式切換至內核態模式，通過系統調用訪問硬件設備。strace可以跟蹤到進程執行時的系統調用和所接收的信號。

ptrace系統調用

1，功能描述：
ptrace 提供了一種機制使得父進程可以觀察和控制子進程的執行過程，同時提供查詢和修改子進程的鏡像和寄存器的能力。主要用於執行斷點調試和系統調用跟蹤。

2，ptrace 的使用流程：
父進程 fork() 出子進程，子進程中執行我們所想要 trace 的程序，子進程需要先調用一次 ptrace，以 PTRACE_TRACEME 爲參數，來告訴內核當前進程已經正在被 traced，最後使用 exec 等操作來初始化一個進程跟蹤。

當子進程執行 execve() 之後，子進程會進入暫停狀態，把控制權轉給它的父進程(SIG_CHLD信號), 而父進程在fork()之後，就調用 wait() 等子進程停下來，當 wait() 返回後，父進程就可以去查看子進程的寄存器或者對子進程做其它的事情了。

3，用法：

<code class="hljs cpp has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;">  <span class="hljs-preprocessor" style="color: rgb(68, 68, 68); box-sizing: border-box;">#include <sys/ptrace.h></span>
  <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">long</span> ptrace(<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">enum</span> __ptrace_request request, pid_t pid, <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">void</span> *addr, <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">void</span> *data);

參數說明：
request：請求執行的行爲，
pid：目標進程標識。
addr：執行 peek 和 poke 操作的目標地址。
data：對於 poke 操作，存放數據的地方。對於 peek 操作，獲取數據的地方。

request 可能的選擇有：  
  PTRACE_TRACEME    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//指示父進程跟蹤某個子進程的執行。任何傳給子進程的信號將導致其停止執行，同時父進程調用 wait() 時會得到通告。之後，子進程調用 exec() 時，核心會給它傳送 SIGTRAP 信號，在新程序開始執行前，給予父進程控制的機會。pid, addr, 和 data參數被忽略。</span>

    以上是唯一由子進程使用的請求，剩下部分將由父進程使用的請求。
PTRACE_PEEKTEXT, PTRACE_PEEKDATA    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//從子進程內存空間 addr 指向的位置讀取一個字，並作爲調用的結果返回。Linux 內部對文本段和數據段不加區分，所以目前這兩個請求相等。data 參數被忽略。</span>

    PTRACE_PEEKUSR    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//從子進程的用戶區 addr 指向的位置讀取一個字，並作爲調用的結果返回。</span>

    PTRACE_POKETEXT, PTRACE_POKEDATA    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//將 data 指向的字拷貝到子進程內存空間由 addr 指向的位置。</span>

    PTRACE_POKEUSR    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//將 data 指向的字拷貝到子進程用戶區由 addr 指向的位置。</span>

    PTRACE_GETREGS, PTRACE_GETFPREGS    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//將子進程通用和浮點寄存器的值拷貝到父進程內由 data 指向的位置。addr 參數被忽略。</span>

    PTRACE_GETSIGINFO    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//獲取導致子進程停止執行的信號信息，並將其存放在父進程內由 data 指向的位置。addr 參數被忽略。</span>

    PTRACE_SETREGS, PTRACE_SETFPREGS    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//從父進程內將 data 指向的數據拷貝到子進程的通用和浮點寄存器。addr 參數被忽略。</span>

    PTRACE_SETSIGINFO    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//將父進程內由 data 指向的數據作爲 siginfo_t 結構體拷貝到子進程。addr 參數被忽略。</span>

    PTRACE_SETOPTIONS    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//將父進程內由 data 指向的值設定爲 ptrace 選項，data 作爲位掩碼來解釋，由下面的標誌指定。</span>

    PTRACE_O_TRACESYSGOOD    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//當轉發 syscall 陷阱 (traps) 時，在信號編碼中設置位7，即第一個字節的最高位。例如：SIGTRAP | 0x80。這有利於追蹤者識別一般的陷阱和那些由 syscall 引起的陷阱。</span>

    PTRACE_O_TRACEFORK    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//通過 (SIGTRAP | PTRACE_EVENT_FORK << 8) 使子進程下次調用 fork() 時停止其執行，並自動跟蹤開始執行時就已設置 SIGSTOP 信號的新進程。新進程的 PID 可以通過 PTRACE_GETEVENTMSG 獲取。</span>

    PTRACE_O_TRACEVFORK    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//通過 (SIGTRAP | PTRACE_EVENT_VFORK << 8) 使子進程下次調用 vfork() 時停止其執行，並自動跟蹤開始執行時就已設置 SIGSTOP 信號的新進程。新進程的 PID 可以通過 PTRACE_GETEVENTMSG 獲取。</span>

    PTRACE_O_TRACECLONE    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//通過 (SIGTRAP | PTRACE_EVENT_CLONE << 8) 使子進程下次調用 clone() 時停止其執行，並自動跟蹤開始執行時就已設置 SIGSTOP 信號的新進程。新進程的 PID 可以通過 PTRACE_GETEVENTMSG 獲取。</span>

    PTRACE_O_TRACEEXEC    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//通過 (IGTRAP | PTRACE_EVENT_EXEC << 8) 使子進程下次調用 exec() 時停止其執行。</span>

    PTRACE_O_TRACEVFORKDONE <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//通過 (SIGTRAP | PTRACE_EVENT_VFORK_DONE << 8) 使子進程下次調用 exec() 並完成時停止其執行。</span>
PTRACE_O_TRACEEXIT    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//通過 (SIGTRAP | PTRACE_EVENT_EXIT << 8) 使子進程退出時停止其執行。子進程的退出狀態可通過 PTRACE_GETEVENTMSG 。</span>

    PTRACE_GETEVENTMSG    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//獲取剛發生的 ptrace 事件消息，並存放在父進程內由 data 指向的位置。addr參數被忽略。</span>

    PTRACE_CONT    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//重啓動已停止的進程。如果 data 指向的數據並非0，同時也不是 SIGSTOP 信號，將會作爲傳遞給子進程的信號來解釋。那樣，父進程可以控制是否將一個信號發送給子進程。addr 參數被忽略。</span>

    PTRACE_SYSCALL, PTRACE_SINGLESTEP    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//如同 PTRACE_CONT 一樣重啓子進程的執行，但指定子進程在下個入口或從系統調用退出時，或者執行單個指令後停止執行，這可用於實現單步調試。addr 參數被忽略。</span>

    PTRACE_SYSEMU, PTRACE_SYSEMU_SINGLESTEP    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//用於用戶模式的程序仿真子進程的所有系統調用。</span>

    PTRACE_KILL    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//給子進程發送 SIGKILL 信號，從而終止其執行。data，addr 參數被忽略。</span>

    PTRACE_ATTACH    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//銜接到pid指定的進程，從而使其成爲當前進程的追蹤目標。</span>

    PTRACE_DETACH    <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">// PTRACE_ATTACH 的反向操作。</span></code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right: 1px solid rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li><li style="box-sizing: border-box; padding: 0px 5px;">9</li><li style="box-sizing: border-box; padding: 0px 5px;">10</li><li style="box-sizing: border-box; padding: 0px 5px;">11</li><li style="box-sizing: border-box; padding: 0px 5px;">12</li><li style="box-sizing: border-box; padding: 0px 5px;">13</li><li style="box-sizing: border-box; padding: 0px 5px;">14</li><li style="box-sizing: border-box; padding: 0px 5px;">15</li><li style="box-sizing: border-box; padding: 0px 5px;">16</li><li style="box-sizing: border-box; padding: 0px 5px;">17</li><li style="box-sizing: border-box; padding: 0px 5px;">18</li><li style="box-sizing: border-box; padding: 0px 5px;">19</li><li style="box-sizing: border-box; padding: 0px 5px;">20</li><li style="box-sizing: border-box; padding: 0px 5px;">21</li><li style="box-sizing: border-box; padding: 0px 5px;">22</li><li style="box-sizing: border-box; padding: 0px 5px;">23</li><li style="box-sizing: border-box; padding: 0px 5px;">24</li><li style="box-sizing: border-box; padding: 0px 5px;">25</li><li style="box-sizing: border-box; padding: 0px 5px;">26</li><li style="box-sizing: border-box; padding: 0px 5px;">27</li><li style="box-sizing: border-box; padding: 0px 5px;">28</li><li style="box-sizing: border-box; padding: 0px 5px;">29</li><li style="box-sizing: border-box; padding: 0px 5px;">30</li><li style="box-sizing: border-box; padding: 0px 5px;">31</li><li style="box-sizing: border-box; padding: 0px 5px;">32</li><li style="box-sizing: border-box; padding: 0px 5px;">33</li><li style="box-sizing: border-box; padding: 0px 5px;">34</li><li style="box-sizing: border-box; padding: 0px 5px;">35</li><li style="box-sizing: border-box; padding: 0px 5px;">36</li><li style="box-sizing: border-box; padding: 0px 5px;">37</li><li style="box-sizing: border-box; padding: 0px 5px;">38</li><li style="box-sizing: border-box; padding: 0px 5px;">39</li><li style="box-sizing: border-box; padding: 0px 5px;">40</li><li style="box-sizing: border-box; padding: 0px 5px;">41</li><li style="box-sizing: border-box; padding: 0px 5px;">42</li><li style="box-sizing: border-box; padding: 0px 5px;">43</li><li style="box-sizing: border-box; padding: 0px 5px;">44</li><li style="box-sizing: border-box; padding: 0px 5px;">45</li><li style="box-sizing: border-box; padding: 0px 5px;">46</li><li style="box-sizing: border-box; padding: 0px 5px;">47</li><li style="box-sizing: border-box; padding: 0px 5px;">48</li><li style="box-sizing: border-box; padding: 0px 5px;">49</li><li style="box-sizing: border-box; padding: 0px 5px;">50</li><li style="box-sizing: border-box; padding: 0px 5px;">51</li><li style="box-sizing: border-box; padding: 0px 5px;">52</li><li style="box-sizing: border-box; padding: 0px 5px;">53</li><li style="box-sizing: border-box; padding: 0px 5px;">54</li><li style="box-sizing: border-box; padding: 0px 5px;">55</li><li style="box-sizing: border-box; padding: 0px 5px;">56</li><li style="box-sizing: border-box; padding: 0px 5px;">57</li></ul>

gdb的使用

1、首先獲得程序的PID ： ps -ef | grep xxxxx
2、進入調試程序： gdb attach PID
3、gcore命令生成CORE文件
4、進程信息可以用info proc顯示
5、寄存器信息可以用info reg顯示

GDB命令行最基本操作：

● 程序啓動方式：

A.冷啓動：
gdb program （program是執行文件）
gdb –p pid

B.熱啓動：
(gdb) attach pid (調試運行中的程序)

C.傳入命令行參數:
GDB啓動時，可以加上一些GDB的啓動參數：
-symbols/-s : 從指定文件中讀取符號表。
-se file : 從指定文件中讀取符號表信息，並把他用在可執行文件中。
-core/-c : 調試時core dump的core文件。
-directory/-d : 加入一個源文件的搜索路徑。默認搜索路徑是環境變量中PATH所定義的路徑。

● 設置觀察點：
○ w Expression，當Expression是一個變量名時，這個變量變化時會停止執行；你也可以使用條件來限定，比如w (z>28)，當z大於28時，程序停止。注意觀察點一般使用在更大範圍上的變量，而不是本地變量，因爲在局部變量上設置的觀察點在局部結束時（比如該變量所在的函數執行結束時）就被取消了。
○ 當然這並不包含main的情況，因爲main函數執行結束後程序就結束了。
● 查看棧幀：
○ 棧幀指的是在一個函數調用時，該函數調用的運行信息（包含本地變量、參數以及函數被調用的位置）存儲的地方。每當一個函數被調用時，一個新的幀就被系統壓入一個由系統維護的幀，在這個棧的頂端是現在正在運行的函數信息，當該函數調用結束時被彈出並析構。
○ 在GDB中，frame 0爲當前幀，frame 1爲當前幀的父幀，frame 2爲父幀的父幀，等等，用down命令則是反向的。這是一個很有用的信息，因爲在早期的一些幀中的信息可能會給你一些提示。
○ backtrace(bt/ where)查看整個幀棧
○ 注意：在幀中來回並不影響程序的執行。

一，多線程調試可能是問得最多的。其實，重要就是下面幾個命令：
● info thread 查看當前進程的線程。
● thread ID 切換調試的線程爲指定ID的線程。
● break file.c : 100 thread all 在file.c文件第100行處爲所有經過這裏的線程設置斷點。
● set scheduler-locking off|on|step，這個是問得最多的。在使用step或者continue命令調試當前被調試線程的時候，其他線程也是同時執行的，怎麼只讓被調試程序執行呢？通過這個命令就可以實現這個需求。
○ off 不鎖定任何線程，也就是所有線程都執行，這是默認值。
○ on 只有當前被調試程序會執行。
○ step 在單步的時候，除了next過一個函數的情況(熟悉情況的人可能知道，這其實是一個設置斷點然後continue的行爲)以外，只有當前線程會執行。

二，調試宏：
這個問題超多。在GDB下，我們無法print宏定義，因爲宏是預編譯的。但是我們還是有辦法來調試宏，這個需要GCC的配合。
●在GCC編譯程序的時候，加上-ggdb3參數，這樣，就可以調試宏了。
另外，你可以使用下述的GDB的宏調試命令來查看相關的宏。
● info macro – 可以查看這個宏在哪些文件裏被引用了，以及宏定義是什麼樣的。
● macro – 可以查看宏展開的樣子。

性能監控和優化命令

內存：top，free，sar，pmap，vmstat，mpstat，iostat，
cpu：top，vmstat，mpstat，iostat，sar
I/O：vmstat，mpstat，iostat，sar
進程：ps，top，ipcs，ipcrm
系統運行負載：uptime，w

●ps：列出系統中正在運行的進程.ps告訴我們每個進程使用的內存量以及所消耗的CPU時間。
●top：動態顯示進程信息，對進程實時監控

●free：顯示系統使用和空閒的內存情況
●pmap：可以顯示進程佔用的內存量。可以通過pmap找到佔用內存量最多的進程。

●sar：多方面對系統活動進行報告，包括磁盤IO，cpu效率，內存使用情況，系統調用情況，文件讀寫情況。
●ipcs：提供進程間通信方式的信息，包括消息隊列、共享內存、信號等
●ipcrm：刪除一個消息對象（消息隊列、信號集或者共享內存標識）

●vmstat：是Virtual Meomory Statistics（虛擬內存統計）的縮寫，可對操作系統的虛擬內存、進程、CPU活動進行監控。它是對系統的整體情況進行統計，不足之處是無法對某個進程進行深入分析。

●iostat：既可以顯示CPU使用情況，也可以看到每個磁盤的IO情況.

iostat是I/O statistics（輸入/輸出統計）的縮寫，iostat工具將對系統的磁盤操作活動進行監視。它的特點是彙報磁盤活動統計情況，同時也會彙報出CPU使用情況。同vmstat一樣，iostat也有一個弱點，就是它不能對某個進程進行深入分析，僅對系統的整體情況進行分析

●mpstat：mpstat用在多處理器的服務器上，用來顯示每一個CPU的狀態。另外，mpstat也會顯示所有處理器的平均狀況。

mpstat是MultiProcessor Statistics的縮寫，是實時系統監控工具。其報告與CPU的一些統計信息，這些信息存放在/proc/stat文件中。在多CPU系統裏，其不但能查看所有CPU的平均狀況信息，而且能夠查看特定CPU的信息。

●uptime：顯示系統已經運行了多長時間，它依次顯示下列信息：當前時間、系統已經運行了多長時間、目前有多少登陸用戶、系統在過去的1分鐘、5分鐘和15分鐘內的平均負載。

●w：查詢登錄當前系統的用戶信息，以及這些用戶目前正在做什麼操作，另外load average後面的三個數字則顯示了系統最近1分鐘、5分鐘、15分鐘的系統平均負載情況。

其它

<code class="hljs lasso has-numbering" style="display: block; padding: 0px; background: transparent; color: inherit; box-sizing: border-box; font-family: "Source Code Pro", monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal;">獲取文件夾的大小:
ls <span class="hljs-attribute" style="box-sizing: border-box;">-lh</span>
du <span class="hljs-attribute" style="box-sizing: border-box;">-sh</span></code>

站內首發文章

struggle6688

發佈了18 篇原創文章 · 獲贊 24 · 訪問量 5萬+

私信關注

程序員技術面常用知識點