計算機基礎知識

時間 2019-12-07

標籤計算機基礎知識简体版

原文原文鏈接

計算機網絡

TCP/IP

模型

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

爲何要給網絡劃分層次？

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

TCP、UDP

比較

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

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

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

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

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

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

可靠性

TCP經過下列方式來提供可靠性：算法

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

（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

區別：
一、Get是從服務器端獲取數據，Post則是向服務器端發送數據。
二、在客戶端，Get方式經過URL提交數據，在URL地址欄能夠看到請求消息，該消息被編碼過；Post數據則是放在Html header內提交。
三、Get方式提交的參數及參數值會在地址欄顯示，不安全，而Post不會，比較安全。
四、對於Get方式，服務器端用Request.QueryString獲取變量的值；對用Post方式，服務器端用Request.Form獲取提交的數據值。
五、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>主要包含三個信息： 一、請求的類型（GET或POST）， 二、要訪問的資源（如\res\img\a.jif）， 三、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;  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的區別

　1、https協議須要到ca申請證書，通常免費證書不多，須要交費。
　2、http和https使用的是徹底不一樣的鏈接方式，用的端口也不同，前者是80，後者是443。
　3、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 等。
　　一、valgrind。valgrind檢測的內存泄漏是很是準的，能夠精肯定位到代碼行甚至是變量。valgrind基於valginrd core框架，這是個很是有強大的框架，他的做用不只僅在於檢測內存泄漏的，強烈建議測試新手通讀下所有的文檔。valgind本身也會有誤報和漏報，全部具體場景須要具體分析。報告中一旦出現definitely lost的標記，就表示必定會有內存泄漏，泄漏的字節數也會報告出來，能夠根據泄漏的內存大小和請求次數計算出究竟是那個變量沒有釋放。
　　二、利用pmap+gdb，pmap能夠列出特定進程的全部內存分配的地址和大小，經過gdb就能夠直接看這些地址屬於什麼變量，經過統計這些內存地址的大小，就能夠很容易的發現問題。利用自動化的gdb調試工具也能夠很方便的定位。
　　三、其餘的還包括memprof、商業工具Purify IBM出品，官方宣傳說的不錯，可是這種不開放的技術，在業界得不到承認，國內大公司通常那都不用，只有人傻錢多的公司在用。
　　四、利用一些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;  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;  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;  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;  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;  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;  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;  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;  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;  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;  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;  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;  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;  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;  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;  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;  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;  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項目中處理高併發量訪問？

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

負載均衡方式

(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;  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;  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;  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;  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;  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的使用

一、首先得到程序的PID ： ps -ef | grep xxxxx
二、進入調試程序： gdb attach PID
三、gcore命令生成CORE文件
四、進程信息能夠用info proc顯示
五、寄存器信息能夠用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分鐘的系統平均負載狀況。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。