運行看結果，慢慢了解
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;


public class Testone {
public static void main(String args[]){
A a=new A();
//a.test();
//SoftReference sr = new SoftReference(a);
ReferenceQueue<A> rq = new ReferenceQueue<A>();
WeakReference<A> wr = new WeakReference<A>(a, rq);
a = null;
System.out.println(wr.get());
System.out.println(rq.poll());
System.gc();
System.runFinalization();
System.out.println(wr.get());
System.out.println(rq.poll());
if (wr != null) {
a = (A)wr.get();
System.out.println("asdasdas");
a.test();
}
else{
a = new A();
System.out.println("123123");
a.test();
a = null;
wr = new WeakReference<A>(a);
}

}
}
class A{
void test(){
System.out.println("A.test()");
}
}

垃圾回收與強引用，軟引用，弱引用，幻引用的關系（一）

Java 2 平臺引入了 java.lang.ref 包，其中包括的類可以讓您引用對象，而不將它們留在內存中。這些類還提供了與垃圾收集器（garbage collector）之間有限的交互。Peter Haggar 在本文中分析了 SoftReference、WeakReference 和 PhantomReference 類的功能和行為，并就這些類的使用給出了一些編程風格上的建議。
當在 Java 2 平臺中首次引入 java.lang.ref 包（其中包含 SoftReference、WeakReference 和 PhantomReference 類）時，它的實用性顯然被過分夸大了。它包含的類可能是有用的，但這些類具有的某些局限性會使它們顯得不是很有吸引力，而且其應用程序也將特別局限于解決一類特定的問題。

垃圾收集概述
引用類的主要功能就是能夠引用仍可以被垃圾收集器回收的對象。在引入引用類之前，我們只能使用強引用（strong reference）。舉例來說，下面一行代碼顯示的就是強引用 obj：


Object obj = new Object();




obj 這個引用將引用堆中存儲的一個對象。只要 obj 引用還存在，垃圾收集器就永遠不會釋放用來容納該對象的存儲空間。

當 obj 超出范圍或被顯式地指定為 null 時，垃圾收集器就認為沒有對這個對象的其它引用，也就可以收集它了。然而您還需要注意一個重要的細節：僅憑對象可以被收集并不意味著垃圾收集器的一次指定運行就能夠回收它。由于各種垃圾收集算法有所不同，某些算法會更頻繁地分析生存期較短的對象，而不是較老、生存期較長的對象。因此，一個可供收集的對象可能永遠也不會被回收。如果程序在垃圾收集器釋放對象之前結束，這種情況就可能會出現。因此，概括地說，您永遠無法保證可供收集的對象總是會被垃圾收集器收集。

這些信息對于您分析引用類是很重要的。由于垃圾收集有著特定的性質，所以引用類實際上可能沒有您原來想像的那么有用，盡管如此，它們對于特定問題來說還是很有用的類。軟引用（soft reference）、弱引用（weak reference）和虛引用（phantom reference）對象提供了三種不同的方式來在不妨礙收集的情況下引用堆對象。每種引用對象都有不同的行為，而且它們與垃圾收集器之間的交互也有所不同。此外，這幾個新的引用類都表現出比典型的強引用“更弱”的引用形式。而且，內存中的一個對象可以被多個引用（可以是強引用、軟引用、弱引用或虛引用）引用。在進一步往下討論之前，讓我們來看看一些術語：

強可及對象（strongly reachable）：可以通過強引用訪問的對象。


軟可及對象（softly reachable）：不是強可及對象，并且能夠通過軟引用訪問的對象。


弱可及對象（weakly reachable）：不是強可及對象也不是軟可及對象，并且能夠通過弱引用訪問的對象。


虛可及對象（phantomly reachable）：不是強可及對象、軟可及對象，也不是弱可及對象，已經結束的，可以通過虛引用訪問的對象。


清除：將引用對象的 referent 域設置為 null，并將引用類在堆中引用的對象聲明為可結束的。
SoftReference 類
SoftReference 類的一個典型用途就是用于內存敏感的高速緩存。SoftReference 的原理是：在保持對對象的引用時保證在 JVM 報告內存不足情況之前將清除所有的軟引用。關鍵之處在于，垃圾收集器在運行時可能會（也可能不會）釋放軟可及對象。對象是否被釋放取決于垃圾收集器的算法以及垃圾收集器運行時可用的內存數量。 

WeakReference 類
WeakReference 類的一個典型用途就是規范化映射（canonicalized mapping）。另外，對于那些生存期相對較長而且重新創建的開銷也不高的對象來說，弱引用也比較有用。關鍵之處在于，垃圾收集器運行時如果碰到了弱可及對象，將釋放 WeakReference 引用的對象。然而，請注意，垃圾收集器可能要運行多次才能找到并釋放弱可及對象。

PhantomReference 類
PhantomReference 類只能用于跟蹤對被引用對象即將進行的收集。同樣，它還能用于執行 pre-mortem 清除操作。PhantomReference 必須與 ReferenceQueue 類一起使用。需要 ReferenceQueue 是因為它能夠充當通知機制。當垃圾收集器確定了某個對象是虛可及對象時，PhantomReference 對象就被放在它的 ReferenceQueue 上。將 PhantomReference 對象放在 ReferenceQueue 上也就是一個通知，表明 PhantomReference 對象引用的對象已經結束，可供收集了。這使您能夠剛好在對象占用的內存被回收之前采取行動。  

垃圾收集器和引用交互
垃圾收集器每次運行時都可以隨意地釋放不再是強可及的對象占用的內存。如果垃圾收集器發現了軟可及對象，就會出現下列情況：

SoftReference 對象的 referent 域被設置為 null，從而使該對象不再引用 heap 對象。


SoftReference 引用過的 heap 對象被聲明為 finalizable。


當 heap 對象的 finalize() 方法被運行而且該對象占用的內存被釋放，SoftReference 對象就被添加到它的 ReferenceQueue（如果后者存在的話）。
如果垃圾收集器發現了弱可及對象，就會出現下列情況：

WeakReference 對象的 referent 域被設置為 null，從而使該對象不再引用 heap 對象。


WeakReference 引用過的 heap 對象被聲明為 finalizable。


當 heap 對象的 finalize() 方法被運行而且該對象占用的內存被釋放時，WeakReference 對象就被添加到它的 ReferenceQueue（如果后者存在的話）。
如果垃圾收集器發現了虛可及對象，就會出現下列情況：

PhantomReference 引用過的 heap 對象被聲明為 finalizable。


與軟引用和弱引用有所不同，PhantomReference 在堆對象被釋放之前就被添加到它的 ReferenceQueue。（請記住，所有的 PhantomReference 對象都必須用經過關聯的 ReferenceQueue 來創建。）這使您能夠在堆對象被回收之前采取行動。
請考慮清單 1 中的代碼。

清單 1. 使用 WeakReference 及 ReferenceQueue 的示例代碼
//Create a strong reference to an object
MyObject obj = new MyObject(); //1

//Create a reference queue
ReferenceQueue rq = new ReferenceQueue(); //2

//Create a weakReference to obj and associate our reference queue
WeakReference wr = new WeakReference(obj, rq); //3



行 //1 創建 MyObject 對象，而行 //2 則創建 ReferenceQueue 對象。行 //3 創建引用其引用對象 MyObject 的 WeakReference 對象，還創建它的 ReferenceQueue。請注意，每個對象引用（obj、rq 及 wr）都是強引用。要利用這些引用類，您必須取消對 MyObject 對象的強引用，方法是將 obj 設置為 null。前面說過，如果不這樣做，對象 MyObject 永遠都不會被回收，引用類的任何優點都會被削弱。

每個引用類都有一個 get() 方法，而 ReferenceQueue 類有一個 poll() 方法。get() 方法返回對被引用對象的引用。在 PhantomReference 上調用 get() 總是會返回 null。這是因為 PhantomReference 只用于跟蹤收集。poll() 方法返回已被添加到隊列中的引用對象，如果隊列中沒有任何對象，它就返回 null。因此，執行清單 1 之后再調用 get() 和 poll() 的結果可能是：


wr.get(); //returns reference to MyObject
rq.poll(); //returns null




現在我們假定垃圾收集器開始運行。由于 MyObject 對象沒有被釋放，所以 get() 和 poll() 方法將返回同樣的值；obj 仍然保持對該對象進行強引用。實際上，對象布局還是沒有改變，和圖 1 所示的差不多。然而，請考慮下面的代碼：


obj = null;
System.gc(); //run the collector







現在，調用 get() 和 poll() 將產生與前面不同的結果：


wr.get(); //returns null
rq.poll(); //returns a reference to the WeakReference object




這種情況表明，MyObject 對象（對它的引用原來是由 WeakReference 對象進行的）不再可用。這意味著垃圾收集器釋放了 MyObject 占用的內存，從而使 WeakReference 對象可以被放在它的 ReferenceQueue 上。這樣，您就可以知道當 WeakReference 或 SoftReference 類的 get() 方法返回 null 時，就有一個對象被聲明為 finalizable，而且可能（不過不一定）被收集。只有當 heap 對象完全結束而且其內存被回收后，WeakReference 或 SoftReference 才會被放到與其關聯的 ReferenceQueue 上。清單 2 顯示了一個完整的可運行程序，它展示了這些原理中的一部分。這段代碼本身就頗具說明性，它含有很多注釋和打印語句，可以幫助您理解。

清單 2. 展示引用類原理的完整程序
import java.lang.ref.*;
class MyObject
{
protected void finalize() throws Throwable
{
System.out.println("In finalize method for this object: " +
this);
}
}

class ReferenceUsage
{
public static void main(String args[])
{
hold();
release();
}

public static void hold()
{
System.out.println("Example of incorrectly holding a strong " +
"reference");
//Create an object
MyObject obj = new MyObject();
System.out.println("object is " + obj);

//Create a reference queue
ReferenceQueue rq = new ReferenceQueue();

//Create a weakReference to obj and associate our reference queue
WeakReference wr = new WeakReference(obj, rq);

System.out.println("The weak reference is " + wr);

//Check to see if it´s on the ref queue yet
System.out.println("Polling the reference queue returns " +
rq.poll());
System.out.println("Getting the referent from the " +
"weak reference returns " + wr.get());

System.out.println("Calling GC");
System.gc();
System.out.println("Polling the reference queue returns " +
rq.poll());
System.out.println("Getting the referent from the " +
"weak reference returns " + wr.get());
}

public static void release()
{
System.out.println("");
System.out.println("Example of correctly releasing a strong " +
"reference");
//Create an object
MyObject obj = new MyObject();
System.out.println("object is " + obj);

//Create a reference queue
ReferenceQueue rq = new ReferenceQueue();

//Create a weakReference to obj and associate our reference queue
WeakReference wr = new WeakReference(obj, rq);

System.out.println("The weak reference is " + wr);

//Check to see if it´s on the ref queue yet
System.out.println("Polling the reference queue returns " +
rq.poll());
System.out.println("Getting the referent from the " +
"weak reference returns " + wr.get());

System.out.println("Set the obj reference to null and call GC");
obj = null;
System.gc();
System.out.println("Polling the reference queue returns " +
rq.poll());
System.out.println("Getting the referent from the " +
"weak reference returns " + wr.get());
}
}




用途和風格
這些類背后的原理就是避免在應用程序執行期間將對象留在內存中。相反，您以軟引用、弱引用或虛引用的方式引用對象，這樣垃圾收集器就能夠隨意地釋放對象。當您希望盡可能減小應用程序在其生命周期中使用的堆內存大小時，這種用途就很有好處。您必須記住，要使用這些類，您就不能保留對對象的強引用。如果您這么做了，那就會浪費這些類所提供的任何好處。

另外，您必須使用正確的編程風格以檢查收集器在使用對象之前是否已經回收了它，如果已經回收了，您首先必須重新創建該對象。這個過程可以用不同的編程風格來完成。選擇錯誤的風格會導致出問題。請考慮清單 3 中從 WeakReference 檢索被引用對象的代碼風格：

清單 3. 檢索被引用對象的風格
obj = wr.get();
if (obj == null)
{
wr = new WeakReference(recreateIt()); //1
obj = wr.get(); //2
}
//code that works with obj




研究了這段代碼之后，請看看清單 4 中從 WeakReference 檢索被引用對象的另一種代碼風格：

清單 4. 檢索被引用對象的另一種風格
obj = wr.get();
if (obj == null)
{
obj = recreateIt(); //1
wr = new WeakReference(obj); //2
}
//code that works with obj




請比較這兩種風格，看看您能否確定哪種風格一定可行，哪一種不一定可行。清單 3 中體現出的風格不一定在所有情況下都可行，但清單 4 的風格就可以。清單 3 中的風格不夠好的原因在于，if 塊的主體結束之后 obj 不一定是非空值。請考慮一下，如果垃圾收集器在清單 3 的行 //1 之后但在行 //2 執行之前運行會怎樣。recreateIt() 方法將重新創建該對象，但它會被 WeakReference 引用，而不是強引用。因此，如果收集器在行 //2 在重新創建的對象上施加一個強引用之前運行，對象就會丟失，wr.get() 則返回 null。

清單 4 不會出現這種問題，因為行 //1 重新創建了對象并為其指定了一個強引用。因此，如果垃圾收集器在該行之后（但在行 //2 之前）運行，該對象就不會被回收。然后，行 //2 將創建對 obj 的 WeakReference。在使用這個 if 塊之后的 obj 之后，您應該將 obj 設置為 null，從而讓垃圾收集器能夠回收這個對象以充分利用弱引用。清單 5 顯示了一個完整的程序，它將展示剛才我們描述的風格之間的差異。（要運行該程序，其運行目錄中必須有一個“temp.fil”文件。

清單 5. 展示正確的和不正確的編程風格的完整程序。
import java.io.*;
import java.lang.ref.*;

class ReferenceIdiom
{
public static void main(String args[]) throws FileNotFoundException
{
broken();
correct();
}

public static FileReader recreateIt() throws FileNotFoundException
{
return new FileReader("temp.fil");
}

public static void broken() throws FileNotFoundException
{
System.out.println("Executing method broken");
FileReader obj = recreateIt();
WeakReference wr = new WeakReference(obj);

System.out.println("wr refers to object " + wr.get());

System.out.println("Now, clear the reference and run GC");
//Clear the strong reference, then run GC to collect obj.
obj = null;
System.gc();

System.out.println("wr refers to object " + wr.get());

//Now see if obj was collected and recreate it if it was.
obj = (FileReader)wr.get();
if (obj == null)
{
System.out.println("Now, recreate the object and wrap it
in a WeakReference");
wr = new WeakReference(recreateIt());
System.gc(); //FileReader object is NOT pinned...there is no
//strong reference to it. Therefore, the next
//line can return null.
obj = (FileReader)wr.get();
}
System.out.println("wr refers to object " + wr.get());
}

public static void correct() throws FileNotFoundException
{
System.out.println("");
System.out.println("Executing method correct");
FileReader obj = recreateIt();
WeakReference wr = new WeakReference(obj);

System.out.println("wr refers to object " + wr.get());

System.out.println("Now, clear the reference and run GC");
//Clear the strong reference, then run GC to collect obj
obj = null;
System.gc();

System.out.println("wr refers to object " + wr.get());

//Now see if obj was collected and recreate it if it was.
obj = (FileReader)wr.get();
if (obj == null)
{
System.out.println("Now, recreate the object and wrap it
in a WeakReference");
obj = recreateIt();
System.gc(); //FileReader is pinned, this will not affect
//anything.
wr = new WeakReference(obj);
}
System.out.println("wr refers to object " + wr.get());
}
}




總結
如果使用得當，引用類還是很有用的。然而，由于它們所依賴的垃圾收集器行為有時候無法預知，所以其實用性就會受到影響。能否有效地使用它們還取決于是否應用了正確的編程風格；關鍵在于您要理解這些類是如何實現的以及如何對它們進行編程。
=================================================================================

Java 對象的狀態有:

    * 已創建(created)
    * 強可達(strong reachable)
    * 不可見(invisible)
    * 不可達(unreachable)
    * 已收集(collected)
    * 終化(finalized)
    * 已回收(deallocated) 

Java對象生命周期的狀態轉換: {image:img=objectstatus.jpg|width=400} 引用對象
三種新的引用類型:

    * 軟引用(soft reference)
    * 弱引用(weak reference)
    * 幻引用(phantom reference) 

強可達(Strong Reachable)
定義: ~An object is strong reachable if it can be reached by some thread without traversing any reference objects. A newly-created object is strong reachable by the thread that created it.~
處于強可達狀態的對象, 在任何情況下都不會被回收掉. 軟可達(Softly Reachable)
定義:~An object is softly reachable if it is not strongly reachable but can be reached by traversing a soft reference.~
含義是:當對象不處于強可達狀態, 并且可以通過軟引用進行訪問時, 即處于軟可達狀態.
當程序申請內存的時候, 垃圾收集器會判斷是否開始回收處于軟可達狀態的對象, 如果決定回收某個對象, 那么垃圾收集器會清除所有指向該對象的軟引用, 如果任何處于其它軟可達狀態的對象可以通過強引用訪問該對象, 那么指向這些對象的軟引用也會被清除掉. 垃圾收集器在決定哪些軟可達狀態的對象被收集時, 采用"最久未被使用"原則, 或稱"最不常使用"原則. 垃圾收集器也保證在OutOfMemeryError產生以前, 所有的軟引用都被清除.

    * 產生和使用一個軟引用 

// createSoftReference sr = new SoftReference(new SomeObject());// getSomeObject o = (SomeObject) sf.get();// create in a reference queue;ReferenceQueue queue = new ReferenceQueue();SoftReference sr = new SoftReference(new SomeObject(), queue);

弱可達(Weakly Reachable)
定義:~An Object is weakly reachable if it is neither strongly nor softly reachable but can be reached by traversing a weak reference.~
垃圾收集器會一次清除所有弱引用. 幻可達(Phantomly Reachable)
定義:~An object is phantomly reachable if it is neither strongly, softly, nor weakly reachable, it has been finalized, and some phantom reference refers to it.~
幻引用不能直接創建. 必須通過向引用隊列等級的途徑來創建:

ReferenceQueue queue = new ReferenceQueue();PhantomReference pr = new PhantomReference (new SomeObject(), queue);

你不可能從幻引用再次得到對象, pr.get()永遠返回null. 另外, 必須調用Reference.clear()手工清除幻引用. All About ReferenceObjects No InterWiki reference defined in properties for Wiki called '[http'!)]
Reference Objects No InterWiki reference defined in properties for Wiki called '[http'!)]
Reference Objects and Garbage Collection No InterWiki reference defined in properties for Wiki called '[http'!)]
\[Jike Thread\?Soft, Weak, and Phantom References|http://www-124.ibm.com/pipermail/jikesrvm-core/2003-May/000365.html]


Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1492810

T-SQL 編碼標準

進行 T-SQL 編程時常常會忽略編碼標準，但這些標準卻是開發小組順利開展工作的關鍵工具。這里介紹的編碼標準是我多年的開發成果。它們當然還沒有得到普遍接受，而且不可否認，有些標準帶有主觀色彩。我的目的實際上更多的是為了提高大家的意識，而不是吹捧自己是 T-SQL 樣式方面的仲裁者：最重要的是要建立某些合理的編碼標準并遵循這些標準。您在這篇文章中會發現有關 T-SQL 編程的一系列不同的編碼標準、技巧和提示。它們并未以任何特定的優先級或重要性順序列出。

讓我們從格式開始。表面上，T-SQL 代碼的格式似乎并不重要，但一致的格式可以使您的同事（不論是同一小組的成員還是更大范圍的 T-SQL 開發團隊的成員）更輕松地瀏覽和理解您的代碼。T-SQL 語句有一個結構，遵循一目了然的結構使您可以更輕松地查找和確認語句的不同部分。統一的格式還使您可以更輕松地在復雜 T-SQL 語句中增刪代碼段，使調試工作變得更容易。下面是 SELECT 語句的格式示例：

       SELECT C.Name
, E.NameLast
, E.NameFirst
, E.Number
, ISNULL(I.Description,'NA') AS Description
FROM tblCompany AS C
JOIN tblEmployee AS E
ON C.CompanyID = E.CompanyID
LEFT JOIN tblCoverage AS V
ON E.EmployeeID = V.EmployeeID
LEFT JOIN tblInsurance AS I
ON V.InsuranceID = I.InsuranceID
WHERE C.Name LIKE @Name
AND V.CreateDate > CONVERT(smalldatetime,
'01/01/2000')
ORDER BY C.Name
, E.NameLast
, E.NameFirst
, E.Number
, ISNULL(I.Description,'NA')
SELECT @Retain = @@ERROR, @Rows = @@ROWCOUNT
IF @Status = 0 SET @Status = @Retain

?一個嵌套代碼塊中的語句使用四個空格的縮進。（上述代碼中的多行 SELECT 語句是一個 SQL 語句。）在同一語句中開始新行時，使 SQL 關鍵字右對齊。將代碼編輯器配置為使用空格，而不是使用制表符。這樣，不管使用何種程序查看代碼，格式都是一致的。

?大寫所有的 T-SQL 關鍵字，包括 T-SQL 函數。變量名稱及光標名稱使用混和大小寫。數據類型使用小寫。

?表名別名要簡短，但意義要盡量明確。通常，使用大寫的表名作為別名，使用 AS 關鍵字指定表或字段的別名。

?當一個 T-SQL 語句中涉及到多個表時，始終使用表名別名來限定字段名。這使其他人閱讀起來更清楚，避免了含義模糊的引用。

?當相關數字出現在連續的代碼行中時（例如一系列 SUBSTRING 函數調用），將它們排成列。這樣容易瀏覽數字列表。

?使用一個（而不是兩個）空行分隔 T-SQL 代碼的邏輯塊，只要需要就可以使用。

?聲明 T-SQL 局部變量（例如 @lngTableID）時，使用適當的數據類型聲明和一致的大寫。

?始終指定字符數據類型的長度，并確保允許用戶可能需要的最大字符數，因為超出最大長度的字符會丟失。

?始終指定十進制數據類型的精度和范圍，否則，將默認為未指定精度和整數范圍。

?使用錯誤處理程序，但要記住行首 (BOL) 中的錯誤檢查示例不會象介紹的那樣起作用。用來檢查 @@ERROR 系統函數的 T-SQL 語句 (IF) 實際上在進程中清除了 @@ERROR 值，無法再捕獲除零之外的任何值。（即使示例起作用，它們也只能捕獲最后發生的一個錯誤，而不是您更想捕獲的第一個錯誤。）必須使用 SET 或 SELECT 立即捕獲錯誤代碼，如前面示例所示。如果狀態變量仍然為零，應轉換到狀態變量。

?避免使用“未聲明的”功能，例如系統表中未聲明的列、T-SQL 語句中未聲明的功能或者未聲明的系統存儲過程或擴展的存儲過程。

?不要依賴任何隱式的數據類型轉換。例如，不能為數字變量賦予字符值，而假定 T-SQL 會進行必要的轉換。相反，在為變量賦值或比較值之前，應使用適當的 CONVERT 函數使數據類型相匹配。另一個示例：雖然 T-SQL 會在進行比較之前對字符表達式進行隱式且自動的 RTRIM，但不能依賴此行為，因為兼容性級別設置非字符表達式會使情況復雜化。

?不要將空的變量值直接與比較運算符（符號）比較。如果變量可能為空，應使用 IS NULL 或 IS NOT NULL 進行比較，或者使用 ISNULL 函數。

?不要使用 STR 函數進行舍入，此函數只能用于整數。如果需要十進制值的字符串形式，應先使用 CONVERT 函數（轉至不同的范圍）或 ROUND 函數，然后將其轉換為字符串。也可以使用 CEILING 和 FLOOR 函數。

?使用數學公式時要小心，因為 T-SQL 可能會將表達式強制理解為一個不需要的數據類型。如果需要十進制結果，應在整數常量后加點和零 (.0)。

?決不要依賴 SELECT 語句會按任何特定順序返回行，除非在 ORDER BY 子句中指定了順序。

?通常，應將 ORDER BY 子句與 SELECT 語句一起使用。可預知的順序（即使不是最方便的）比不可預知的順序強，尤其是在開發或調試過程中。（部署到生產環境中之前，可能需要刪除 ORDER BY 子句。）在返回行的順序無關緊要的情況下，可以忽略 ORDER BY 的開銷。

?不要在 T-SQL 代碼中使用雙引號。應為字符常量使用單引號。如果沒有必要限定對象名稱，可以使用（非 ANSI SQL 標準）括號將名稱括起來。

?在 SQL Server 2000 中，盡量使用表變量來代替臨時表。如果表變量包含大量數據，請注意索引非常有限（只有主鍵索引）。

?先在例程中創建臨時表，最后再顯式刪除臨時表。將 DDL 與 DML 語句混合使用有助于處理額外的重新編譯活動。

?要認識到臨時表并不是不可使用，適當地使用它們可以使某些例程更有效，例如，當需要重復引用大型表或常用表中的某個數據集時。但是，對于一次性事件，最好使用導出表。

?使用表值 UDF 時要小心，因為在變量（而不是常量）中傳遞某個參數時，如果在 WHERE 子句中使用該參數，會導致表掃描。還要避免在一個查詢中多次使用相同的表值 UDF。但是，表值 UDF 確實具有某些非常方便的動態編譯功能。[相關資料：參閱 Tom Moreau 在 2003 年 11 月份“生成序列號”專欄中的“使用 UDF 填充表變量”。－編者按］

?幾乎所有的存儲過程都應在開始時設置 SET NOCOUNT ON，而在結束時設置 SET NOCOUNT OFF。[SET NOCOUNT ON 使 SQL Server 無需在執行存儲過程的每個語句后向客戶端發送 DONE_IN_PROC 消息。- 編者按] 此標準同樣適用于觸發器。

?只要在例程中使用多個數據庫修改語句，包括在一個循環中多次執行一個語句，就應考慮聲明顯式事務。

?使用基于光標的方法或臨時表方法之前，應先尋找基于集的解決方案來解決問題。基于集的方法通常更有效。

?與臨時表一樣，光標并不是不可使用。對小型數據集使用 FAST_FORWARD 光標通常要優于其他逐行處理方法，尤其是在必須引用幾個表才能獲得所需的數據時。在結果集中包括“合計”的例程通常要比使用光標執行的速度快。如果開發時間允許，基于光標的方法和基于集的方法都可以嘗試一下，看哪一種方法的效果更好。

?使用包含序號（從 1 到 N）的表很方便。

?理解 CROSS JOIN 的工作原理并加以利用。例如，您可以在工作數據表和序號表之間有效地使用 CROSS JOIN，結果集中將包含每個工作數據與序號組合的記錄。

?我的結束語是：T-SQL 代碼往往很簡潔，因此如果某個代碼塊看起來很難處理或重復內容較多，那么可能存在一種更簡單，更好的方法。

結論

如果您對我的建議有任何看法，歡迎隨時向我發送電子郵件進行討論，也可以就其他問題提出您的建議。我希望您將此作為談話的開場白。

其他信息：摘自 Karen 2000 年 2 月份的社論

在標準開發的前沿陣地上，有一股以 SQL Server 數據庫管理員 John Hindmarsh 為首的獨立的新生力量。MCT、MCSE 和 MCDBA 都是最值得您花時間去研究的。John 的貢獻是撰寫了一份詳細的白皮書，概述了他對各種 SQL Server 相關標準提出的建議。我所知道的其他唯一提出類似建議的文章是 Andrew Zanevsky 的《Transact-SQL Programming》(ISBN 1-56592-401-0) 中的“Format and Style”一章。Andrew、SQL Server Professional 的投稿人 Tom Moreau 和 Paul Munkenbeck 以及 John 的朋友兼同事 Stephen James 都為 John 的白皮書做出過貢獻。下面是 John 為編寫存儲過程提供的建議示例：

•	使用 SQL-92 標準連接句法。
•	為了提高性能，應優先使用連接，然后使用子查詢或嵌套查詢。
•	確保變量和參數的類型和大小與表數據列相匹配。
•	確保使用所有變量和參數，或者全部刪除。
•	盡可能將臨時對象放置在本地。
•	只使用在存儲過程中創建的臨時表。
•	檢查輸入參數的有效性。
•	優先使用 SELECT...INTO，然后使用 INSERT...SELECT，以避免大量死鎖。
•	維護工作需要的邏輯單元；在可以縮短的情況下，不要創建大量或長時間運行的進程。
•	不要在任何代碼中使用 SELECT *。
•	在過程中使用縮進、塊、制表符和空格（參閱示例腳本）。
•	T-SQL 語句要大寫。
•	在過程中添加大量注釋，確保可以識別進程。在有助于澄清處理步驟的地方使用行注釋。
•	包括事務管理，除非要從 MTS 進程中調用過程。（為 MTS 進程編寫獨立的過程。）
•	監視 @@TRANCOUNT 以確定事務的責任級別。
•	避免使用 GOTO，錯誤處理程序中除外。
•	避免使用嵌套過程。
•	避免隱式解析對象名稱，確保所有對象都歸 dbo 所有。

下載 412BRIAN.ZIP

鏈接至www.microsoft.com/downloads/details.aspx?displayla%20ng=en&familyid=B352EB1F-D3CA-44EE-893E-9E07339C1F22&displaylang=en

有關 SQL Server Professional 和 Pinnacle Publishing 的詳細信息，請訪問其 Web 站點 http://www.pinpub.com/

注意：這不是 Microsoft Corporation 的 Web 站點。Microsoft 對該 Web 站點上的內容不承擔任何責任。

本文轉載自 2004 年 12 月份的 SQL Server Professional。除非另行說明，否則版權所有 2004 Pinnacle Publishing, Inc.。保留所有權利。SQL Server Professional 是 Pinnacle Publishing 獨立發行的刊物。未經 Pinnacle Publishing, Inc. 事先同意，不得以任何方式使用或復制本文的任何部分（評論文章中的簡短引用除外）。如需與 Pinnacle Publishing, Inc. 聯系，請撥打 1-800-788-1900。

© 2005 Microsoft Corporation 版權所有。保留所有權利。使用規定。

原文出處:http://www.microsoft.com/china/msdn/library/data/sqlserver/sp04l9.mspx?mfr=true

  （1）      選擇最有效率的表名順序(只在基于規則的優化器中有效)：

ORACLE 的解析器按照從右到左的順序處理FROM子句中的表名，FROM子句中寫在最后的表(基礎表 driving table)將被最先處理，在FROM子句中包含多個表的情況下,你必須選擇記錄條數最少的表作為基礎表。如果有3個以上的表連接查詢, 那就需要選擇交叉表(intersection table)作為基礎表, 交叉表是指那個被其他表所引用的表.

（2）      WHERE子句中的連接順序．：

ORACLE采用自下而上的順序解析WHERE子句,根據這個原理,表之間的連接必須寫在其他WHERE條件之前, 那些可以過濾掉最大數量記錄的條件必須寫在WHERE子句的末尾.

（3）      SELECT子句中避免使用 ‘ * ‘：

ORACLE在解析的過程中, 會將'*' 依次轉換成所有的列名, 這個工作是通過查詢數據字典完成的, 這意味著將耗費更多的時間

（4）      減少訪問數據庫的次數：

ORACLE在內部執行了許多工作: 解析SQL語句, 估算索引的利用率, 綁定變量 , 讀數據塊等；

（5）      在SQL*Plus , SQL*Forms和Pro*C中重新設置ARRAYSIZE參數, 可以增加每次數據庫訪問的檢索數據量 ,建議值為200

（6）      使用DECODE函數來減少處理時間：

使用DECODE函數可以避免重復掃描相同記錄或重復連接相同的表.

（7）      整合簡單,無關聯的數據庫訪問：

如果你有幾個簡單的數據庫查詢語句,你可以把它們整合到一個查詢中(即使它們之間沒有關系)

（8）      刪除重復記錄：

最高效的刪除重復記錄方法 ( 因為使用了ROWID)例子：

DELETE FROM EMP E WHERE E.ROWID > (SELECT MIN(X.ROWID)

FROM EMP X WHERE X.EMP_NO = E.EMP_NO);

（9）      用TRUNCATE替代DELETE：

當刪除表中的記錄時,在通常情況下, 回滾段(rollback segments ) 用來存放可以被恢復的信息. 如果你沒有COMMIT事務,ORACLE會將數據恢復到刪除之前的狀態(準確地說是恢復到執行刪除命令之前的狀況) 而當運用TRUNCATE時, 回滾段不再存放任何可被恢復的信息.當命令運行后,數據不能被恢復.因此很少的資源被調用,執行時間也會很短. (譯者按: TRUNCATE只在刪除全表適用,TRUNCATE是DDL不是DML)

（10） 盡量多使用COMMIT：

只要有可能,在程序中盡量多使用COMMIT, 這樣程序的性能得到提高,需求也會因為COMMIT所釋放的資源而減少:

COMMIT所釋放的資源:

a. 回滾段上用于恢復數據的信息.

b. 被程序語句獲得的鎖

c. redo log buffer 中的空間

d. ORACLE為管理上述3種資源中的內部花費

（11） 用Where子句替換HAVING子句：

避免使用HAVING子句, HAVING 只會在檢索出所有記錄之后才對結果集進行過濾. 這個處理需要排序,總計等操作. 如果能通過WHERE子句限制記錄的數目,那就能減少這方面的開銷. (非oracle中)on、where、having這三個都可以加條件的子句中，on是最先執行，where次之，having最后，因為on是先把不符合條件的記錄過濾后才進行統計，它就可以減少中間運算要處理的數據，按理說應該速度是最快的，where也應該比having快點的，因為它過濾數據后才進行sum，在兩個表聯接時才用on的，所以在一個表的時候，就剩下where跟having比較了。在這單表查詢統計的情況下，如果要過濾的條件沒有涉及到要計算字段，那它們的結果是一樣的，只是where可以使用rushmore技術，而having就不能，在速度上后者要慢如果要涉及到計算的字段，就表示在沒計算之前，這個字段的值是不確定的，根據上篇寫的工作流程，where的作用時間是在計算之前就完成的，而having就是在計算后才起作用的，所以在這種情況下，兩者的結果會不同。在多表聯接查詢時，on比where更早起作用。系統首先根據各個表之間的聯接條件，把多個表合成一個臨時表后，再由where進行過濾，然后再計算，計算完后再由having進行過濾。由此可見，要想過濾條件起到正確的作用，首先要明白這個條件應該在什么時候起作用，然后再決定放在那里

（12） 減少對表的查詢：

在含有子查詢的SQL語句中,要特別注意減少對表的查詢.例子：

     SELECT TAB_NAME FROM TABLES WHERE (TAB_NAME,DB_VER) = ( SELECT

TAB_NAME,DB_VER FROM TAB_COLUMNS WHERE VERSION = 604)

（13） 通過內部函數提高SQL效率.：

復雜的SQL往往犧牲了執行效率. 能夠掌握上面的運用函數解決問題的方法在實際工作中是非常有意義的

（14） 使用表的別名(Alias)：

當在SQL語句中連接多個表時, 請使用表的別名并把別名前綴于每個Column上.這樣一來,就可以減少解析的時間并減少那些由Column歧義引起的語法錯誤.

（15） 用EXISTS替代IN、用NOT EXISTS替代NOT IN：

在許多基于基礎表的查詢中,為了滿足一個條件,往往需要對另一個表進行聯接.在這種情況下, 使用EXISTS(或NOT EXISTS)通常將提高查詢的效率. 在子查詢中,NOT IN子句將執行一個內部的排序和合并. 無論在哪種情況下,NOT IN都是最低效的 (因為它對子查詢中的表執行了一個全表遍歷). 為了避免使用NOT IN ,我們可以把它改寫成外連接(Outer Joins)或NOT EXISTS.

例子：

（高效）SELECT * FROM EMP (基礎表) WHERE EMPNO > 0 AND EXISTS (SELECT ‘X' FROM DEPT WHERE DEPT.DEPTNO = EMP.DEPTNO AND LOC = ‘MELB')

(低效)SELECT * FROM EMP (基礎表) WHERE EMPNO > 0 AND DEPTNO IN(SELECT DEPTNO FROM DEPT WHERE LOC = ‘MELB')

（16） 識別'低效執行'的SQL語句：

雖然目前各種關于SQL優化的圖形化工具層出不窮,但是寫出自己的SQL工具來解決問題始終是一個最好的方法：

SELECT EXECUTIONS , DISK_READS, BUFFER_GETS,

ROUND((BUFFER_GETS-DISK_READS)/BUFFER_GETS,2) Hit_radio,

ROUND(DISK_READS/EXECUTIONS,2) Reads_per_run,

SQL_TEXT

FROM V$SQLAREA

WHERE EXECUTIONS>0

AND BUFFER_GETS > 0

AND (BUFFER_GETS-DISK_READS)/BUFFER_GETS < 0.8

ORDER BY 4 DESC;

（17） 用索引提高效率：

索引是表的一個概念部分,用來提高檢索數據的效率，ORACLE使用了一個復雜的自平衡B-tree結構. 通常,通過索引查詢數據比全表掃描要快. 當ORACLE找出執行查詢和Update語句的最佳路徑時, ORACLE優化器將使用索引. 同樣在聯結多個表時使用索引也可以提高效率. 另一個使用索引的好處是,它提供了主鍵(primary key)的唯一性驗證.。那些LONG或LONG RAW數據類型, 你可以索引幾乎所有的列. 通常, 在大型表中使用索引特別有效. 當然,你也會發現, 在掃描小表時,使用索引同樣能提高效率. 雖然使用索引能得到查詢效率的提高,但是我們也必須注意到它的代價. 索引需要空間來存儲,也需要定期維護, 每當有記錄在表中增減或索引列被修改時, 索引本身也會被修改. 這意味著每條記錄的INSERT , DELETE , UPDATE將為此多付出4 , 5 次的磁盤I/O . 因為索引需要額外的存儲空間和處理,那些不必要的索引反而會使查詢反應時間變慢.。定期的重構索引是有必要的.：

ALTER INDEX <INDEXNAME> REBUILD <TABLESPACENAME>

（18） 用EXISTS替換DISTINCT：

當提交一個包含一對多表信息(比如部門表和雇員表)的查詢時,避免在SELECT子句中使用DISTINCT. 一般可以考慮用EXIST替換, EXISTS 使查詢更為迅速,因為RDBMS核心模塊將在子查詢的條件一旦滿足后,立刻返回結果. 例子：

       (低效):

SELECT DISTINCT DEPT_NO,DEPT_NAME FROM DEPT D , EMP E

WHERE D.DEPT_NO = E.DEPT_NO

(高效):

SELECT DEPT_NO,DEPT_NAME FROM DEPT D WHERE EXISTS ( SELECT ‘X'

FROM EMP E WHERE E.DEPT_NO = D.DEPT_NO);

（19） sql語句用大寫的；因為oracle總是先解析sql語句，把小寫的字母轉換成大寫的再執行

（20） 在java代碼中盡量少用連接符“＋”連接字符串！

（21） 避免在索引列上使用NOT 通常，　

我們要避免在索引列上使用NOT, NOT會產生在和在索引列上使用函數相同的影響. 當ORACLE”遇到”NOT,他就會停止使用索引轉而執行全表掃描.

（22） 避免在索引列上使用計算．

WHERE子句中，如果索引列是函數的一部分．優化器將不使用索引而使用全表掃描．

舉例:

低效：

SELECT … FROM DEPT WHERE SAL * 12 > 25000;

高效:

SELECT … FROM DEPT WHERE SAL > 25000/12;

（23） 用>=替代>

高效:

SELECT * FROM EMP WHERE DEPTNO >=4

低效:

SELECT * FROM EMP WHERE DEPTNO >3

兩者的區別在于, 前者DBMS將直接跳到第一個DEPT等于4的記錄而后者將首先定位到DEPTNO=3的記錄并且向前掃描到第一個DEPT大于3的記錄.

（24） 用UNION替換OR (適用于索引列)

通常情況下, 用UNION替換WHERE子句中的OR將會起到較好的效果. 對索引列使用OR將造成全表掃描. 注意, 以上規則只針對多個索引列有效. 如果有column沒有被索引, 查詢效率可能會因為你沒有選擇OR而降低. 在下面的例子中, LOC_ID 和REGION上都建有索引.

高效:

SELECT LOC_ID , LOC_DESC , REGION

FROM LOCATION

WHERE LOC_ID = 10

UNION

SELECT LOC_ID , LOC_DESC , REGION

FROM LOCATION

WHERE REGION = “MELBOURNE”

低效:

SELECT LOC_ID , LOC_DESC , REGION

FROM LOCATION

WHERE LOC_ID = 10 OR REGION = “MELBOURNE”

如果你堅持要用OR, 那就需要返回記錄最少的索引列寫在最前面.

（25） 用IN來替換OR 

這是一條簡單易記的規則，但是實際的執行效果還須檢驗，在ORACLE8i下，兩者的執行路徑似乎是相同的．　

低效:

SELECT…. FROM LOCATION WHERE LOC_ID = 10 OR LOC_ID = 20 OR LOC_ID = 30

高效

SELECT… FROM LOCATION WHERE LOC_IN IN (10,20,30);

（26） 避免在索引列上使用IS NULL和IS NOT NULL

避免在索引中使用任何可以為空的列，ORACLE將無法使用該索引．對于單列索引，如果列包含空值，索引中將不存在此記錄. 對于復合索引，如果每個列都為空，索引中同樣不存在此記錄.　如果至少有一個列不為空，則記錄存在于索引中．舉例: 如果唯一性索引建立在表的A列和B列上, 并且表中存在一條記錄的A,B值為(123,null) , ORACLE將不接受下一條具有相同A,B值（123,null）的記錄(插入). 然而如果所有的索引列都為空，ORACLE將認為整個鍵值為空而空不等于空. 因此你可以插入1000 條具有相同鍵值的記錄,當然它們都是空! 因為空值不存在于索引列中,所以WHERE子句中對索引列進行空值比較將使ORACLE停用該索引.

低效: (索引失效)

SELECT … FROM DEPARTMENT WHERE DEPT_CODE IS NOT NULL;

高效: (索引有效)

SELECT … FROM DEPARTMENT WHERE DEPT_CODE >=0;

（27） 總是使用索引的第一個列：

如果索引是建立在多個列上, 只有在它的第一個列(leading column)被where子句引用時,優化器才會選擇使用該索引. 這也是一條簡單而重要的規則，當僅引用索引的第二個列時,優化器使用了全表掃描而忽略了索引

（28） 用UNION-ALL 替換UNION ( 如果有可能的話)：

當SQL 語句需要UNION兩個查詢結果集合時,這兩個結果集合會以UNION-ALL的方式被合并, 然后在輸出最終結果前進行排序. 如果用UNION ALL替代UNION, 這樣排序就不是必要了. 效率就會因此得到提高. 需要注意的是，UNION ALL 將重復輸出兩個結果集合中相同記錄. 因此各位還是要從業務需求分析使用UNION ALL的可行性. UNION 將對結果集合排序,這個操作會使用到SORT_AREA_SIZE這塊內存. 對于這塊內存的優化也是相當重要的. 下面的SQL可以用來查詢排序的消耗量

低效：

SELECT ACCT_NUM, BALANCE_AMT

FROM DEBIT_TRANSACTIONS

WHERE TRAN_DATE = '31-DEC-95'

UNION

SELECT ACCT_NUM, BALANCE_AMT

FROM DEBIT_TRANSACTIONS

WHERE TRAN_DATE = '31-DEC-95'

高效:

SELECT ACCT_NUM, BALANCE_AMT

FROM DEBIT_TRANSACTIONS

WHERE TRAN_DATE = '31-DEC-95'

UNION ALL

SELECT ACCT_NUM, BALANCE_AMT

FROM DEBIT_TRANSACTIONS

WHERE TRAN_DATE = '31-DEC-95'

（29） 用WHERE替代ORDER BY：

ORDER BY 子句只在兩種嚴格的條件下使用索引.

ORDER BY中所有的列必須包含在相同的索引中并保持在索引中的排列順序.

ORDER BY中所有的列必須定義為非空.

WHERE子句使用的索引和ORDER BY子句中所使用的索引不能并列.

例如:

表DEPT包含以下列:

DEPT_CODE PK NOT NULL

DEPT_DESC NOT NULL

DEPT_TYPE NULL

低效: (索引不被使用)

SELECT DEPT_CODE FROM DEPT ORDER BY DEPT_TYPE

高效: (使用索引)

SELECT DEPT_CODE FROM DEPT WHERE DEPT_TYPE > 0

（30） 避免改變索引列的類型.:

當比較不同數據類型的數據時, ORACLE自動對列進行簡單的類型轉換.

假設 EMPNO是一個數值類型的索引列.

SELECT … FROM EMP WHERE EMPNO = ‘123'

實際上,經過ORACLE類型轉換, 語句轉化為:

SELECT … FROM EMP WHERE EMPNO = TO_NUMBER(‘123')

幸運的是,類型轉換沒有發生在索引列上,索引的用途沒有被改變.

現在,假設EMP_TYPE是一個字符類型的索引列.

SELECT … FROM EMP WHERE EMP_TYPE = 123

這個語句被ORACLE轉換為:

SELECT … FROM EMP WHERETO_NUMBER(EMP_TYPE)=123

因為內部發生的類型轉換, 這個索引將不會被用到! 為了避免ORACLE對你的SQL進行隱式的類型轉換, 最好把類型轉換用顯式表現出來. 注意當字符和數值比較時, ORACLE會優先轉換數值類型到字符類型

（31） 需要當心的WHERE子句:

某些SELECT 語句中的WHERE子句不使用索引. 這里有一些例子.

在下面的例子里, (1)‘!=' 將不使用索引. 記住, 索引只能告訴你什么存在于表中, 而不能告訴你什么不存在于表中. (2) ‘||'是字符連接函數. 就象其他函數那樣, 停用了索引. (3) ‘+'是數學函數. 就象其他數學函數那樣, 停用了索引. (4)相同的索引列不能互相比較,這將會啟用全表掃描.

（32） a. 如果檢索數據量超過30%的表中記錄數.使用索引將沒有顯著的效率提高.

b. 在特定情況下, 使用索引也許會比全表掃描慢, 但這是同一個數量級上的區別. 而通常情況下,使用索引比全表掃描要塊幾倍乃至幾千倍!

（33） 避免使用耗費資源的操作:

帶有DISTINCT,UNION,MINUS,INTERSECT,ORDER BY的SQL語句會啟動SQL引擎

執行耗費資源的排序(SORT)功能. DISTINCT需要一次排序操作, 而其他的至少需要執行兩次排序. 通常, 帶有UNION, MINUS , INTERSECT的SQL語句都可以用其他方式重寫. 如果你的數據庫的SORT_AREA_SIZE調配得好, 使用UNION , MINUS, INTERSECT也是可以考慮的, 畢竟它們的可讀性很強

（34） 優化GROUP BY:

提高GROUP BY 語句的效率, 可以通過將不需要的記錄在GROUP BY 之前過濾掉.下面兩個查詢返回相同結果但第二個明顯就快了許多.

低效:

SELECT JOB , AVG(SAL)

FROM EMP

GROUP JOB

HAVING JOB = ‘PRESIDENT'

OR JOB = ‘MANAGER'

高效:

SELECT JOB , AVG(SAL)

FROM EMP

WHERE JOB = ‘PRESIDENT'

OR JOB = ‘MANAGER'

GROUP JOB

 


l l 數據庫回滾段是否足夠？


l l 是否需要建立ORACLE數據庫索引、聚集、散列？


l l 系統全局區（SGA）大小是否足夠？


l l SQL語句是否高效？


2、2、數據倉庫系統（Data Warehousing），這種信息系統的主要任務是從ORACLE的海量數據中進行查詢，得到數據之間的某些規律。數據庫管理員需要為這種類型的ORACLE數據庫著重考慮下述參數：


l l 是否采用B*-索引或者bitmap索引？


l l 是否采用并行SQL查詢以提高查詢效率？


l l 是否采用PL/SQL函數編寫存儲過程？


l l 有必要的話，需要建立并行數據庫提高數據庫的查詢效率


SQL語句的調整原則


SQL語言是一種靈活的語言，相同的功能可以使用不同的語句來實現，但是語句的執行效率是很不相同的。程序員可以使用EXPLAIN PLAN語句來比較各種實現方案，并選出最優的實現方案。總得來講，程序員寫SQL語句需要滿足考慮如下規則：


1、1、盡量使用索引。試比較下面兩條SQL語句：


語句A：SELECT dname, deptno FROM dept WHERE deptno NOT IN


(SELECT deptno FROM emp);


語句B：SELECT dname, deptno FROM dept WHERE NOT EXISTS


(SELECT deptno FROM emp WHERE dept.deptno = emp.deptno);


這兩條查詢語句實現的結果是相同的，但是執行語句A的時候，ORACLE會對整個emp表進行掃描，沒有使用建立在emp表上的deptno索引，執行語句B的時候，由于在子查詢中使用了聯合查詢，ORACLE只是對emp表進行的部分數據掃描，并利用了deptno列的索引，所以語句B的效率要比語句A的效率高一些。


2、2、選擇聯合查詢的聯合次序。考慮下面的例子：


SELECT stuff FROM taba a, tabb b, tabc c


WHERE a.acol between :alow and :ahigh


AND b.bcol between :blow and :bhigh


AND c.ccol between :clow and :chigh


AND a.key1 = b.key1


AMD a.key2 = c.key2;


這個SQL例子中，程序員首先需要選擇要查詢的主表，因為主表要進行整個表數據的掃描，所以主表應該數據量最小，所以例子中表A的acol列的范圍應該比表B和表C相應列的范圍小。


3、3、在子查詢中慎重使用IN或者NOT IN語句，使用where (NOT) exists的效果要好的多。


4、4、慎重使用視圖的聯合查詢，尤其是比較復雜的視圖之間的聯合查詢。一般對視圖的查詢最好都分解為對數據表的直接查詢效果要好一些。


5、5、可以在參數文件中設置SHARED_POOL_RESERVED_SIZE參數，這個參數在SGA共享池中保留一個連續的內存空間，連續的內存空間有益于存放大的SQL程序包。


6、6、ORACLE公司提供的DBMS_SHARED_POOL程序可以幫助程序員將某些經常使用的存儲過程“釘”在SQL區中而不被換出內存，程序員對于經常使用并且占用內存很多的存儲過程“釘”到內存中有利于提高最終用戶的響應時間。


CPU參數的調整


CPU是服務器的一項重要資源，服務器良好的工作狀態是在工作高峰時CPU的使用率在90％以上。如果空閑時間CPU使用率就在90％以上，說明服務器缺乏CPU資源，如果工作高峰時CPU使用率仍然很低，說明服務器CPU資源還比較富余。


使用操作相同命令可以看到CPU的使用情況，一般UNIX操作系統的服務器，可以使用sar –u命令查看CPU的使用率，NT操作系統的服務器，可以使用NT的性能管理器來查看CPU的使用率。


數據庫管理員可以通過查看v$sysstat數據字典中“CPU used by this session”統計項得知ORACLE數據庫使用的CPU時間，查看“OS User level CPU time”統計項得知操作系統用戶態下的CPU時間，查看“OS System call CPU time”統計項得知操作系統系統態下的CPU時間，操作系統總的CPU時間就是用戶態和系統態時間之和，如果ORACLE數據庫使用的CPU時間占操作系統總的CPU時間90％以上，說明服務器CPU基本上被ORACLE數據庫使用著，這是合理，反之，說明服務器CPU被其它程序占用過多，ORACLE數據庫無法得到更多的CPU時間。


數據庫管理員還可以通過查看v$sesstat數據字典來獲得當前連接ORACLE數據庫各個會話占用的CPU時間，從而得知什么會話耗用服務器CPU比較多。


出現CPU資源不足的情況是很多的：SQL語句的重解析、低效率的SQL語句、鎖沖突都會引起CPU資源不足。


1、數據庫管理員可以執行下述語句來查看SQL語句的解析情況：


SELECT * FROM V$SYSSTAT


WHERE NAME IN


('parse time cpu', 'parse time elapsed', 'parse count (hard)');


這里parse time cpu是系統服務時間，parse time elapsed是響應時間，用戶等待時間


waite time = parse time elapsed – parse time cpu


由此可以得到用戶SQL語句平均解析等待時間＝waite time / parse count。這個平均等待時間應該接近于0，如果平均解析等待時間過長，數據庫管理員可以通過下述語句


SELECT SQL_TEXT, PARSE_CALLS, EXECUTIONS FROM V$SQLAREA


ORDER BY PARSE_CALLS;


來發現是什么SQL語句解析效率比較低。程序員可以優化這些語句，或者增加ORACLE參數SESSION_CACHED_CURSORS的值。


2、數據庫管理員還可以通過下述語句：


SELECT BUFFER_GETS, EXECUTIONS, SQL_TEXT FROM V$SQLAREA;


查看低效率的SQL語句，優化這些語句也有助于提高CPU的利用率。


3、3、數據庫管理員可以通過v$system_event數據字典中的“latch free”統計項查看ORACLE數據庫的沖突情況，如果沒有沖突的話，latch free查詢出來沒有結果。如果沖突太大的話，數據庫管理員可以降低spin_count參數值，來消除高的CPU使用率。


內存參數的調整


內存參數的調整主要是指ORACLE數據庫的系統全局區（SGA）的調整。SGA主要由三部分構成：共享池、數據緩沖區、日志緩沖區。


1、 1、 共享池由兩部分構成：共享SQL區和數據字典緩沖區，共享SQL區是存放用戶SQL命令的區域，數據字典緩沖區存放數據庫運行的動態信息。數據庫管理員通過執行下述語句：


select (sum(pins - reloads)) / sum(pins) "Lib Cache" from v$librarycache;


來查看共享SQL區的使用率。這個使用率應該在90％以上，否則需要增加共享池的大小。數據庫管理員還可以執行下述語句：


select (sum(gets - getmisses - usage - fixed)) / sum(gets) "Row Cache" from v$rowcache;


查看數據字典緩沖區的使用率，這個使用率也應該在90％以上，否則需要增加共享池的大小。


2、 2、 數據緩沖區。數據庫管理員可以通過下述語句：


SELECT name, value FROM v$sysstat WHERE name IN ('db block gets', 'consistent gets','physical reads');


來查看數據庫數據緩沖區的使用情況。查詢出來的結果可以計算出來數據緩沖區的使用命中率＝1 - ( physical reads / (db block gets + consistent gets) )。


這個命中率應該在90％以上，否則需要增加數據緩沖區的大小。


3、 3、 日志緩沖區。數據庫管理員可以通過執行下述語句：


select name,value from v$sysstat where name in ('redo entries','redo log space requests');查看日志緩沖區的使用情況。查詢出的結果可以計算出日志緩沖區的申請失敗率：

申請失敗率＝requests/entries，申請失敗率應該接近于0，否則說明日志緩沖區開設太小，需要增加ORACLE數據庫的日志緩沖區。 1、父子二人經過五星級飯店門口，看到一輛十分豪華的進口轎車。兒子不屑地對他的父親說：「坐這種車的人，肚子里一定沒有學問！」父親則輕描淡寫地回答：「說這種話的人，口袋里一定沒有錢！」
    
    (注：你對事情的看法，是不是也反映出你內心真正的態度？）
    
    2、晚飯后，母親和女兒一塊兒洗碗盤，父親和兒子在客廳看電視。突然，廚房里傳來打破盤子的響聲，然后一片沉寂。是兒子望著他父親，說道：「一定是媽媽打破的。」「你怎么知道？」「她沒有罵人。」
    
    （注：我們習慣以不同的標準來看人看己，以致往往是責人以嚴，待己以寬。）
    
    3、有兩個臺灣觀光團到日本伊豆半島旅游，路況很壞，到處都是坑洞。其中一位導游連聲抱歉，說路面簡直像麻子一樣。說而另一個導游卻詩意盎然地對游客說：諸位先生女士，我們現在走的這條道路，正是赫赫有名的伊豆迷人酒窩大道。」
    
    （注：雖是同樣的情況，然而不同的意念，就會產生不同的態度。思想是何等奇妙的事，如何去想，決定權在你。）
    
    4、同樣是小學三年級的學生，在作文中說他們將來的志愿是當小丑。中國的老師斥之為：「胸無大志，孺子不可教也！」而外國的老師則會說：「愿你把歡笑帶給全世界！」
    
    （注：身為長輩的我們，不但容易要求多于鼓勵，更狹窄的界定了成功的定義。）
    
    5、在故宮博物院中，有一個太太不耐煩地對她先生說：「我說你為甚么走得這么慢。原來你老是停下來看這些東西。」
    
    （注：有人只知道在人生的道路上狂奔，結果失去了觀看兩旁美麗花朵的機會。）
    
    6、妻子正在廚房炒菜。丈夫在她旁邊一直嘮叨不停：慢些。小心！火太大了。趕快把魚翻過來。快鏟起來，油放太多了！把豆腐整平一下！「哎呀！」妻子脫口而出，「我懂得怎樣炒菜。」「你當然懂，太太，」丈夫平靜地答道：「我只是要讓你知道，我在開車時，你在旁邊喋喋不休，我的感覺如何。」
    
    （注：學會體諒他人并不困難，只要你愿意認真地站在對方的角度和立場看問題。）
    
    7、一輛載滿乘客的公共汽車沿著下坡路快速前進著，有一個人後面緊緊地追趕著這輛車子。一個乘客從車窗中伸出頭來對追車子的人說：“老兄！算啦，你追不上的！”“我必須追上它，”這人氣喘吁吁地說：“我是這輛車的司機！”
    
    (注：有些人必須非常認真努力，因為不這樣的話，後果就十分悲慘了！然而也正因為必須全力以赴，潛在的本能和不為人知的特質終將充份展現出來。）
    
    8、甲：「新搬來的鄰居好可惡，昨天晚上三更半夜、夜深人靜之時然跑來猛按我家的門鈴。」
    
    　乙：「的確可惡！你有沒有馬上報警？」
    
    　甲：「沒有。我當他們是瘋子，繼續吹我的小喇叭。」
    
    （事出必有因，如果能先看到自己的不是，答案就會不一樣在你面對沖突和爭執時，先想一想是否心中有虧，或許很快就能釋懷了）
    
    9、某日，張三在山間小路開車，正當他悠哉地欣賞美麗風景時，突然迎面開來一輛貨車，而且滿囗黑牙的司機還搖下窗戶對他大罵一聲：“豬！”
    
    張三越想越納悶，也越想越氣，於是他也搖下車窗回頭大罵：“你才是豬！”
    
    才剛罵完，他便迎頭撞上一群過馬路的豬。
    
    　　（不要錯誤的詮釋別人的好意，那只會讓自己吃虧，并且使別人受辱。在不明所以之前，先學會按捺情緒，耐心觀察，以免事後生發悔意。）
    
    10、小男孩問爸爸：“是不是做父親的總比做兒子的知道得多？”
    
    爸爸回答：“當然啦！”
    
    小男孩問：“電燈是誰發明的？”
    
    爸爸：“是愛迪生。”
    
    小男孩又問：“那愛迪生的爸爸怎麼沒有發明電燈？”
    
    （很奇怪，喜歡倚老賣老的人，特別容易栽跟斗。權威往往只是一個經不起考驗的空殼子，尤其在現今這個多元開放的時代。）
    
    11、小明洗澡時不小心吞下一小塊肥皂，他的媽媽慌慌張張地打電話向家庭醫生求助。醫生說：“我現在還有幾個病人在，可能要半小時後才能趕過去。”
    
    小明媽媽說：“在你來之前，我該做甚麼？”
    
    醫生說：“給小明喝一杯白開水，然後用力跳一跳，你就可以讓小明用嘴巴吹泡泡消磨時間了。”
    
    （take it easy，放輕松放輕松些，生活何必太緊張？事情既然已經發生了，何不坦然自在的面對。擔心不如寬心，窮緊張不如窮開心。）
    
    12、一把堅實的大鎖掛在大門上，一根鐵桿費了九牛二虎之力，還是無法將它撬開。鑰匙來了，他瘦小的身子鉆進鎖孔，只輕輕一轉，大鎖就“啪”地一聲打開了。
    
    鐵桿奇怪地問：“為什麼我費了那麼大力氣也打不開，而你卻輕而易舉地就把它打開了呢？”
    
    鑰匙說：“因為我最了解他的心。” 

問題一
如果你家附近有一家餐廳，東西又貴又難吃，桌上還爬著蟑螂，你會因為它很近很方便，就一而再、再而三地光臨嗎？
回答：你一定會說，這是什么爛問題，誰那么笨，花錢買罪受？
可同樣的情況換個場合，自己或許就做類似的蠢事。不少男女都曾經抱怨過他們的情人或配偶品性不端，三心二意，不負責任。明知在一起沒什么好的結果，怨恨已經比愛還多，但卻“不知道為什么”還是要和他攪和下去，分不了手。說穿了，只是為了不甘，為了習慣，這不也和光臨餐廳一樣？
――做人，為什么要過于執著？！
問題二
如果你不小心丟掉100塊錢，只知道它好像丟在某個你走過的地方，你會花200塊錢的車費去把那100塊找回來嗎？
回答：一個超級愚蠢的問題。
可是，相似的事情卻在人生中不斷發生。做錯了一件事，明知自己有問題，卻死也不肯認錯，反而花加倍的時間來找藉口，讓別人對自己的印象大打折扣。被人罵了一句話，卻花了無數時間難過，道理相同。為一件事情發火，不惜損人不利已，不惜血本，不惜時間，只為報復，不也一樣無聊？
失去一個人的感情，明知一切已無法挽回，卻還是那么傷心，而且一傷心就是好幾年，還要借酒澆愁，形銷骨立。其實這樣一點用也沒有，只是損失更多。
――做人，干嗎為難自己？！
問題三
你會因為打開報紙發現每天都有車禍，就不敢出門嗎？
回答：這是個什么爛問題？當然不會，那叫因噎廢食。
然而，有不少人卻曾說：現在的離婚率那么高，讓我都不敢談戀愛了。說得還挺理所當然。也有不少女人看到有關的諸多報道，就對自己的另一半憂心忡忡，這不也是類似的反應？
所謂樂觀，就是得相信：雖然道路多艱險，我還是那個會平安過馬路的人，只要我小心一點，不必害怕過馬路。
――做人，先要相信自己。
問題四
你相信每個人隨便都可以成功立業嗎？
回答：當然不會相信。
但據觀察，有人總是在聽完成功人士絞盡腦汁的建議，比如說，多讀書，多練習之后，問了另一個問題？那不是很難？
我們都想在3分鐘內學好英文，在5分鐘內解決所有難題，難道成功是那么容易的嗎？改變當然是難的。成功只因不怕困難，所以才能出類拔萃。
有一次坐在出租車上，聽見司機看到自己前后都是高檔車，兀自感嘆：“唉，為什么別人那么有錢，我的錢這么難賺？” 我心血來潮，問他：“你認為世上有什么錢是好賺的？”他答不出來，過了半晌才說：好像都是別人的錢比較好賺。
其實任何一個成功者都是艱辛取得。我們實在不該抱怨命運。
――做人，依靠自己！
問題五
你認為完全沒有打過籃球的人，可以當很好的籃球教練嗎？
回答：當然不可能，外行不可能領導內行。
可是，有許多人，對某個行業完全不了解，只聽到那個行業好賺錢，就馬上開起業來了。
我看過對穿著沒有任何口味、或根本不在乎穿著的人，夢想卻是開間服裝店；不知道電腦怎么開機的人，卻想在網上賺錢，結果道聽途說，卻不反省自己是否專業能力不足，只抱怨時不我與。
――做人，量力而行。
問題六
相似但不相同的問題：你是否認為，籃球教練不上籃球場，閉著眼睛也可以主導一場完美的利？
回答：有病啊，當然是不可能的。
可是卻有不少朋友，自己沒有時間打理，卻拼命投資去開咖啡館，開餐廳，開自己根本不懂的公司，火燒一樣急著把辛苦積攢的積蓄花掉，去當一個稀里糊涂的投資人。虧的總是比賺的多，卻覺得自己是因為運氣不好，而不是想法出了問題。
――做人，記得反省自己。
問題七
你寧可永遠后悔，也不愿意試一試自己能否轉敗為勝？
解答：恐怕沒有人會說：“對，我就是這樣的孬種”吧。
然而，我們卻常常在不該打退堂鼓時拼命打退堂鼓，為了恐懼失敗而不敢嘗試成功。
以關穎珊贏得2000年世界花樣滑冰冠軍時的精彩表現為例：她一心想贏得第一名，然而在最后一場比賽前，她的總積分只排名第三位，在最后的自選曲項目上，她選擇了突破，而不是少出錯。在4分鐘的長曲中，結合了最高難度的三周跳，并且還大膽地連跳了兩次。她也可能會敗得很難看，但是她畢竟成功了。
她說：“因為我不想等到失敗，才后悔自己還有潛力沒發揮。”
一個中國偉人曾說；勝利的希望和有利情況的恢復，往往產生于再堅持一下的努力之中。
――做人，何妨放手一搏。
問題八
你的時間無限，長生不老，所以最想做的事，應該無限延期？
回答：不，傻瓜才會這樣認為。
然而我們卻常說，等我老了，要去環游世界；等我退休，就要去做想做的事情；等孩子長大了，我就可以……
我們都以為自己有無限的時間與精力。其實我們可以一步一步實現理想，不必在等待中徒耗生命。如果現在就能一步一步努力接近，我們就不會活了半生，卻出現自己最不想看到的結局。
――做人，要活在當下。

 
做為一名大四的學生,我面試過不少的單位，有成功的也有失敗的，但是對我來說所有的失敗在某種意義上都是一種成功，特別是我下面寫的這些，寫這篇文章的時候，我已經簽了南京的一家軟件公司，但是想起今年2月21日我面試蘇州TW的IT公司的經歷聯想到我們現在學習編程的一些情況我真的深有感觸，這次面試使我深深的體會到了失敗但也收獲了很多。我要說的將分成三部分，1.是我面試的具體經過2.是由面試想到的3.現今我應該做的。當然這些話很大程度上是我個人的意見，不可能完全得到大家的贊同，所以在某些觀點上如果哪位朋友覺得跟我的有很大出入，請不要介意，也不要對我攻擊，就當我沒有說過，歡迎和我聯系共同探討這些問題！我的E-Mail:fvifnmmmm@126.com

1.面試經過

　　大約在年前我接到了TW瑞晟(Realtek)蘇州公司的面試通知，通知我2月21日到蘇州工業園區面試，接到面試后的幾天我把一些專業課溫習了一遍，特別是C++和數據結構，由于大學幾年里，我一直專研這些方面，加上通過了高級程序員的考試，對于一些常用的算法我差不多也達到了爛熟于胸的地步，當時的感覺是如果問了我這些方面的問題我應該是沒有問題的！

　　21日那天我被安排在4：30面試，由一位技術人員單獨給我面試，在問了一些簡單的問題之后他給我出了一道編程題目，題目是這樣的：

　　(由于具體面試的題目比較煩瑣，我將其核心思想提取出來分解成了兩個獨立的簡單的問題，有可能問題分解的不當，請大家見諒，實際面試了一個的問題但比其復雜很多，而且涉及一些高等數學變換) 

　　1) 寫一個函數計算當參數為n(n很大)時的值 1-2+3-4+5-6+7......+n 

　　哼，我的心里冷笑一聲！沒想到這么簡單，我有點緊張的心情頓時放松起來！

　　于是很快我給出我的解法： 

long fn(long n) 
{ 
long temp=0; 
int i,flag=1; 
if(n<=0) 
{ 
printf("error: n must > 0); 
exit(1); 
} 
for(i=1;i<=n;i++) 
{ 
temp=temp+flag*i; 
flag=(-1)*flag; 
} 
return temp; 
} 

　　搞定！當我用期待的目光看著面試官的時候，他微笑著跟我說，執行結果肯定是沒有問題！但當n很大的時候我這個程序執行效率很低， 在嵌入式系統的開發中，程序的運行效率很重要，能讓CPU少執行一條指令都是好的，他讓我看看這個程序還有什么可以修改的地方，把程序優化一下！聽了這些話，我的心情當時變的有點沉重，沒想到他的要求很嚴格，之后我對程序進行了嚴格的分析，給出了改進了的方案！ 

long fn(long n) 
{ 
long temp=0; 
int j=1,i=1,flag=1; 
if(n<=0) 
{ 
printf("error: n must > 0); 
exit(1); 
} 
while(j<=n) 
{ 
temp=temp+i; 
i=-i; 
i>0?i++:i--; 
j++; 
} 
return temp; 
} 

　　雖然我不敢保證我這個算法是最優的，但是比起上一個程序，我將所有涉及到乘法指令的語句改為執行加法指令，既達到要題目的要求而且運算時間上縮短了很多！而代價僅僅是增加了一個整型變量！但是我現在的信心已經受了一點打擊，我將信將疑的看者面試官，他還是微笑著跟我說：“不錯，這個程序確實在效率上有的很大的提高！”我心里一陣暗喜！但他接著說這個程序仍然不能達到他的要求，要我給出更優的方案！天啊！還有優化！我當時真的有點崩潰了，想了一會后，我請求他給出他的方案！然后他很爽快的給出了他的程序！
long fn(long n) 
{ 
if(n<=0) 
{ 
printf("error: n must > 0); 
exit(1); 
} 
if(0==n%2) 
return (n/2)*(-1); 
else 
return (n/2)*(-1)+n; 
} 

　　搞笑，當時我目瞪口呆，沒想到他是這個意思，這么簡單的代碼我真的不會寫嗎，但是我為什么沒有往那方面上想呢！他說的沒有錯，在n很大很大的時候這三個程序運行時間的差別簡直是天壤之別！當我剛想開口說點什么的時候，他卻先開口了：“不要認為CPU運算速度快就把所有的問題都推給它去做，程序員應該將代碼優化再優化，我們自己能做的決不要讓CPU做，因為CPU是為用戶服務的，不是為我們程序員服務的！”多么精辟的語言，我已經不想再說什么了！接著是第二個問題： 

　　2),他要求我用一種技巧性的編程方法來用一個函數實現兩個函數的功能n為如：

fn1(n)=n/2!+n/3!+n/4!+n/5!+n/6! 

fn2(n)=n/5!+n/6!+n/7!+n/8!+n/9! 

　　現在用一個函數fn(int n,int flag)實現，當flag為0時，實現fn1功能，如果flag為1時實現fn2功能！

　　他的要求還是效率，效率，效率！說實在話，如果我心情好的話我應該能給出一種比較好的算法，但我那時真的沒有什么心思再想了，我在紙上胡亂畫了一些諸如6!=6*5!的公式后直截了當的跟他說要他給出他的答案！面試官也沒有說什么，給出了他的思路：

　　定義一個二維數組 float t[2][5]存入[2!,3!,4!,5!,6!},{5!,6!,7!,8!,9!]然后給出一個循環： 

for(i=0;i<6;i++) 
{ 
temp=temp+n/t[flag]; 
} 

　　最后得到計算值！呵呵，典型的空間換時間的算法！

　　這些總共花了50分鐘的時間，還有十分鐘我就跟他很隨意的聊聊天，聊了一些編程以及生活的問題，那時的我已經很放松了，因為我知道這次面試結果只有一個：失敗。5:30的時候面試官要我等通知，于是我離開了他們公司。這就是面試的整個經過！ 

.由面試想到的 

　　真的是很失敗啊！我記得那天下好大的雨，氣溫也很低，我邊走邊想，從5:30一直走到7:30，全身都濕透了，又冷又餓，但是我只是一直走，腦子里面充滿了疑惑，我也想讓雨把自己淋醒！看到這里有些朋友可能覺得那些面試題目不算什么如果讓自己做的話肯定能全部答對，我肯定相信你，因為我從未懷疑過中國程序員的能力，我認為中國有世界上最好的程序員，我也從未認為自己是高手，所以我做不出來不代表中國程序員比TW或者別的地方的程序員差，所以我就從我的角度，我的所見所想來談一些感想： 

　　不錯全世界都有優秀的程序員，中國也不例外，但是我疑惑的是：到底中國和TW或者國外的優秀的程序員的比例到底是多少？TW我不知道，中國100個程序員里有幾個是優秀的呢?我根本算不上，從上面的表現就足以說明一切了！是1個？5個？10個？50個？這個數字我不敢亂猜，恐遭網友一頓痛罵，那么我們國內有多少人學習計算機呢？拿我們學校來說，計算機97級4個班，98級5個班，99級10個班，2000級17個班，人多了，老師怎么辦？我們學校的做法是讓研究生上課，然后呢？補考一抓一大把，大把大把的補考費落入了學校的口袋，還說現在的學生素質低！真是好笑，我都不知道學校這么做是為了什么，為國內培養大量的程序員嗎？學生們能真正學到計算機知識嗎？好了，我敢講，在我們學校學習編程學生和優秀程序員(注意我指的是優秀，只會編幾個糟爛程序的人算不上)的比例應該是100:0.1 。在這種比例下雖然我們中國學習編程的人鋪天蓋地，但是想想有多少個人能真正為中國軟件業發展作出貢獻，有多少人能真正寫出優秀的程序名揚海外！ 

　　我從學習編程以來，不管是自學還是老師指導，從來都是解決問題就好，編出程序來就行，我的疑惑是：我們有真正的強調過程序的效率，程序的質量嗎？我們有仔細分析過我們寫的東西，看看有沒有可以改進的地方，看看有沒有簡單的方法來達到同樣的目的呢？我問心自問，我發現，我從來沒有對我寫出來的程序進行過優化，最多就是進行詳細的測試，然后Debug，但是這就足夠了嗎？這些天我偶爾發現我曾經寫過的一個游戲，那是一年前我剛加入www.vcroad.net做為其中一員時候，感覺應該拿點東西出來，然后花了一個星期的時間寫出來的！程序不算復雜，但是用到了不少數據結構的東西，也用到了一些精彩的算法，加上windows的界面和游戲的可玩性，寫完后受到了不少好評，我當時真的很佩服自己！但是現在看呢：沒有一句注釋，好多丑陋的函數名比如：void chushihua()，好多沒有必要的變量，可以用簡單語句完成工作的我使用華麗的算法，大量使用全局變量.....,說不好聽的話，六百多行的程序除了能運行之外就是一陀屎！如果一年前我能聽到一些反面意見的話，大概我能早一點覺悟，但是自從原代碼在網站發布以來聽到的都是贊美之詞，沒有一個人向我提出程序改進的意見，這又說明了一個什么問題呢？很值得思考啊！

還有一個疑惑是：我們說的和做的真的一樣嗎？我在學校的時候曾經受學院指派承辦過一個計算機大賽，請了一個老師出決賽的題目，主要是一些算法題目，這個老師可能是我上大學以來唯一敬佩的老師了，從程序調試到打分，對于每個程序都仔細分析其時間效率和空間效率，然后綜合打分，四十個人的卷子，老師從下午三點一直調試到晚上十點，在有些寫的精彩的語句后還加上批注。我真是高興很遇到這樣的老師并且和他做深入的交流，但在事后，卻發生了一件不愉快的事，在比賽中獲得第二名的學生找到我，說他程序全部調試成功應該給他滿分，并且應該得第一，我說不過他，最后調出了他的原程序和第一名的原程序對比，不錯，兩個程序都運行的很好，這時，那個同學開口了：“我的程序寫的十分簡捷明了，僅僅數行就完成了題目要求，而他的卻寫了一大堆，為什么給他的分多過給我的分。”我當時很是氣憤，如果不是老師負責的話，那么現在第一名和第二名的位置真的要互調了，拜托，不是程序的行數越少程序的質量就越高，我記得我跟他大談這方面的道理，最后說服他了！哈哈，但是我，只能說說而已，我不知道還有多少人一樣，說起來頭頭是道，但心里卻壓根就從未重視過它！ 

.我打算做的！ 
　　其實那天我想到的遠不止上面那么多，但是我不想再說了，因為我猜想看這篇文章的網友大概都有一肚子的感想，一肚子的抱怨，借用這篇文章發泄可不是我想達到的目的，在上面我把自己罵的一文不值也不是妄自菲薄，但是在某些方面我真的做錯了，或者說是偏離了正確方向，現在是矯正方向和重整旗鼓的時候了，就象我前面說過的，我相信中國有世界上最好的程序員，我也相信我的水平不會一直保持現狀，我現在就收拾起牢騷真正的實干起來！ 
真的很巧，就寫到這里的時候我在網上偶爾發現了這篇手冊，我不知道這預示著什么，但是我想如果我照下面這個基本原則一直踏實做下去，我一定會實現我的理想---一名優秀的軟件設計師! 

　　（下面這些文字不是我的原創，是我偶爾在網上發現的，我真的很幸運能看到這些，這篇文章也隨著下面的文字而結束，我真心的希望您能從這篇文章中得到啟發,這篇文章歡迎大家隨意轉載，您可以不寫作者是誰，但是請您寫上www.vcroad.net原創，謝謝您的支持） 

　　作者：金蝶中間件公司CTO袁紅崗 

　　不知不覺做軟件已經做了十年，有成功的喜悅，也有失敗的痛苦，但總不敢稱自己是高手，因為和我心目中真正的高手們比起來，還差的太遠。世界上并沒有成為高手的捷徑，但一些基本原則是可以遵循的。 

　　1. 扎實的基礎。數據結構、離散數學、編譯原理，這些是所有計算機科學的基礎，如果不掌握他們，很難寫出高水平的程序。據我的觀察，學計算機專業的人比學其他專業的人更能寫出高質量的軟件。程序人人都會寫，但當你發現寫到一定程度很難再提高的時候，就應該想想是不是要回過頭來學學這些最基本的理論。不要一開始就去學OOP，即使你再精通OOP，遇到一些基本算法的時候可能也會束手無策。 

　　2. 豐富的想象力。不要拘泥于固定的思維方式，遇到問題的時候要多想幾種解決問題的方案，試試別人從沒想過的方法。豐富的想象力是建立在豐富的知識的基礎上，除計算機以外，多涉獵其他的學科，比如天文、物理、數學等等。另外，多看科幻電影也是一個很好的途徑。 

　　3. 最簡單的是最好的。這也許是所有科學都遵循的一條準則，如此復雜的質能互換原理在愛因斯坦眼里不過是一個簡單得不能再簡單的公式：E=mc2。簡單的方法更容易被人理解，更容易實現，也更容易維護。遇到問題時要優先考慮最簡單的方案，只有簡單方案不能滿足要求時再考慮復雜的方案。 

　　4. 不鉆牛角尖。當你遇到障礙的時候，不妨暫時遠離電腦，看看窗外的風景，聽聽輕音樂，和朋友聊聊天。當我遇到難題的時候會去玩游戲，而且是那種極暴力的打斗類游戲，當負責游戲的那部分大腦細胞極度亢奮的時候，負責編程的那部分大腦細胞就得到了充分的休息。當重新開始工作的時候，我會發現那些難題現在竟然可以迎刃而解。 

　　5. 對答案的渴求。人類自然科學的發展史就是一個渴求得到答案的過程，即使只能知道答案的一小部分也值得我們去付出。只要你堅定信念，一定要找到問題的答案，你才會付出精力去探索，即使最后沒有得到答案，在過程中你也會學到很多東西。 

　　6. 多與別人交流。三人行必有我師，也許在一次和別人不經意的談話中，就可以迸出靈感的火花。多上上網，看看別人對同一問題的看法，會給你很大的啟發。 

　　7. 良好的編程風格。注意養成良好的習慣，代碼的縮進編排，變量的命名規則要始終保持一致。大家都知道如何排除代碼中錯誤，卻往往忽視了對注釋的排錯。注釋是程序的一個重要組成部分，它可以使你的代碼更容易理解，而如果代碼已經清楚地表達了你的思想，就不必再加注釋了，如果注釋和代碼不一致，那就更加糟糕。 

　　8. 韌性和毅力。這也許是"高手"和一般程序員最大的區別。A good programming is 99 weat and 1?ffee。高手們并不是天才，他們是在無數個日日夜夜中磨練出來的。成功能給我們帶來無比的喜悅，但過程卻是無比的枯燥乏味。你不妨做個測試，找個10000以內的素數表，把它們全都抄下來，然后再檢查三遍，如果能夠不間斷地完成這一工作，你就可以滿足這一條。