konhon

可以到此網站得到自己的個性化email標志
http://services.nexodyne.com/email/icon/

這是我的

JAVA精華區(qū)分類匯總

http://bbs.chinaunix.net/forum/viewtopic.php?t=176605&show_type=new

六：線程的阻塞

   為了解決對共享存儲區(qū)的訪問沖突，Java 引入了同步機制，現(xiàn)在讓我們來考察多個線程對共享資源的訪問，顯然同步機制已經不夠了，因為在任意時刻所要求的資源不一定已經準備好了被訪問，反過來，同一時刻準備好了的資源也可能不止一個。為了解決這種情況下的訪問控制問題，Java 引入了對阻塞機制的支持。
    阻塞指的是暫停一個線程的執(zhí)行以等待某個條件發(fā)生（如某資源就緒），學過操作系統(tǒng)的同學對它一定已經很熟悉了。Java 提供了大量方法來支持阻塞，下面讓我們逐一分析。

　　1. sleep() 方法：sleep() 允許 指定以毫秒為單位的一段時間作為參數(shù)，它使得線程在指定的時間內進入阻塞狀態(tài)，不能得到CPU 時間，指定的時間一過，線程重新進入可執(zhí)行狀態(tài)。
　　典型地，sleep() 被用在等待某個資源就緒的情形：測試發(fā)現(xiàn)條件不滿足后，讓線程阻塞一段時間后重新測試，直到條件滿足為止。
　　2. suspend() 和 resume() 方法：兩個方法配套使用，suspend()使得線程進入阻塞狀態(tài)，并且不會自動恢復，必須其對應的resume() 被調用，才能使得線程重新進入可執(zhí)行狀態(tài)。典型地，suspend() 和 resume() 被用在等待另一個線程產生的結果的情形：測試發(fā)現(xiàn)結果還沒有產生后，讓線程阻塞，另一個線程產生了結果后，調用 resume() 使其恢復。
　　3. yield() 方法：yield() 使得線程放棄當前分得的 CPU 時間，但是不使線程阻塞，即線程仍處于可執(zhí)行狀態(tài)，隨時可能再次分得 CPU 時間。調用 yield() 的效果等價于調度程序認為該線程已執(zhí)行了足夠的時間從而轉到另一個線程。
　　4. wait() 和 notify() 方法：兩個方法配套使用，wait() 使得線程進入阻塞狀態(tài)，它有兩種形式，一種允許 指定以毫秒為單位的一段時間作為參數(shù)，另一種沒有參數(shù)，前者當對應的 notify() 被調用或者超出指定時間時線程重新進入可執(zhí)行狀態(tài)，后者則必須對應的 notify()被調用。
   初看起來它們與 suspend() 和 resume() 方法對沒有什么分別，但是事實上它們是截然不同的。區(qū)別的核心在于，前面敘述的所有方法，阻塞時都不會釋放占用的鎖（如果占用了的話），而這一對方法則相反。 　上述的核心區(qū)別導致了一系列的細節(jié)上的區(qū)別。

    首先，前面敘述的所有方法都隸屬于 Thread 類，但是這一對卻直接隸屬于 Object 類，也就是說，所有對象都擁有這一對方法。初看起來這十分不可思議，但是實際上卻是很自然的，因為這一對方法阻塞時要釋放占用的鎖，而鎖是任何對象都具有的，調用任意對象的 wait() 方法導致線程阻塞，并且該對象上的鎖被釋放。而調用 任意對象的notify()方法則導致因調用該對象的 wait() 方法而阻塞的線程中隨機選擇的一個解除阻塞（但要等到獲得鎖后才真正可執(zhí)行）。
    其次，前面敘述的所有方法都可在任何位置調用，但是這一對方法卻必須在 synchronized 方法或塊中調用，理由也很簡單，只有在synchronized 方法或塊中當前線程才占有鎖，才有鎖可以釋放。同樣的道理，調用這一對方法的對象上的鎖必須為當前線程所擁有，這樣才有鎖可以釋放。因此，這一對方法調用必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖對象就是調用這一對方法的對象。若不滿足這一條件，則程序雖然仍能編譯，但在運行時會出現(xiàn)IllegalMonitorStateException 異常。
    wait() 和 notify() 方法的上述特性決定了它們經常和synchronized 方法或塊一起使用，將它們和操作系統(tǒng)的進程間通信機制作一個比較就會發(fā)現(xiàn)它們的相似性：synchronized方法或塊提供了類似于操作系統(tǒng)原語的功能，它們的執(zhí)行不會受到多線程機制的干擾，而這一對方法則相當于 block 和wakeup 原語（這一對方法均聲明為 synchronized）。它們的結合使得我們可以實現(xiàn)操作系統(tǒng)上一系列精妙的進程間通信的算法（如信號量算法），并用于解決各種復雜的線程間通信問題。
　　關于 wait() 和 notify() 方法最后再說明兩點：

第一：調用 notify() 方法導致解除阻塞的線程是從因調用該對象的 wait() 方法而阻塞的線程中隨機選取的，我們無法預料哪一個線程將會被選擇，所以編程時要特別小心，避免因這種不確定性而產生問題。

第二：除了 notify()，還有一個方法 notifyAll() 也可起到類似作用，唯一的區(qū)別在于，調用 notifyAll() 方法將把因調用該對象的wait() 方法而阻塞的所有線程一次性全部解除阻塞。當然，只有獲得鎖的那一個線程才能進入可執(zhí)行狀態(tài)。
   談到阻塞，就不能不談一談死鎖，略一分析就能發(fā)現(xiàn)，suspend() 方法和不指定超時期限的 wait() 方法的調用都可能產生死鎖。遺憾的是，Java 并不在語言級別上支持死鎖的避免，我們在編程中必須小心地避免死鎖。
   以上我們對 Java 中實現(xiàn)線程阻塞的各種方法作了一番分析，我們重點分析了 wait() 和 notify() 方法，因為它們的功能最強大，使用也最靈活，但是這也導致了它們的效率較低，較容易出錯。實際使用中我們應該靈活使用各種方法，以便更好地達到我們的目的。

　　七：守護線程

    守護線程是一類特殊的線程，它和普通線程的區(qū)別在于它并不是應用程序的核心部分，當一個應用程序的所有非守護線程終止運行時，即使仍然有守護線程在運行，應用程序也將終止，反之，只要有一個非守護線程在運行，應用程序就不會終止。守護線程一般被用于在后臺為其它線程提供服務。
　　可以通過調用方法 isDaemon() 來判斷一個線程是否是守護線程，也可以調用方法 setDaemon() 來將一個線程設為守護線程。

　　八：線程組

      線程組是一個 Java 特有的概念，在 Java 中，線程組是類ThreadGroup 的對象，每個線程都隸屬于唯一一個線程組，這個線程組在線程創(chuàng)建時指定并在線程的整個生命期內都不能更改。你可以通過調用包含 ThreadGroup 類型參數(shù)的 Thread 類構造函數(shù)來指定線程屬的線程組，若沒有指定，則線程缺省地隸屬于名為 system 的系統(tǒng)線程組。
   在 Java 中，除了預建的系統(tǒng)線程組外，所有線程組都必須顯式創(chuàng)建。在 Java 中，除系統(tǒng)線程組外的每個線程組又隸屬于另一個線程組，你可以在創(chuàng)建線程組時指定其所隸屬的線程組，若沒有指定，則缺省地隸屬于系統(tǒng)線程組。這樣，所有線程組組成了一棵以系統(tǒng)線程組為根的樹。
   Java 允許我們對一個線程組中的所有線程同時進行操作，比如我們可以通過調用線程組的相應方法來設置其中所有線程的優(yōu)先級，也可以啟動或阻塞其中的所有線程。
　　Java 的線程組機制的另一個重要作用是線程安全。線程組機制允許我們通過分組來區(qū)分有不同安全特性的線程，對不同組的線程進行不同的處理，還可以通過線程組的分層結構來支持不對等安全措施的采用。Java 的 ThreadGroup 類提供了大量的方法來方便我們對線程組樹中的每一個線程組以及線程組中的每一個線程進行操作。

　　九：總結

    在本文中，我們講述了 Java 多線程編程的方方面面，包括創(chuàng)建線程，以及對多個線程進行調度、管理。我們深刻認識到了多線程編程的復雜性，以及線程切換開銷帶來的多線程程序的低效性，這也促使我們認真地思考一個問題：我們是否需要多線程？何時需要多線程？
   多線程的核心在于多個代碼塊并發(fā)執(zhí)行，本質特點在于各代碼塊之間的代碼是亂序執(zhí)行的。我們的程序是否需要多線程，就是要看這是否也是它的內在特點。
    假如我們的程序根本不要求多個代碼塊并發(fā)執(zhí)行，那自然不需要使用多線程；假如我們的程序雖然要求多個代碼塊并發(fā)執(zhí)行，但是卻不要求亂序，則我們完全可以用一個循環(huán)來簡單高效地實現(xiàn)，也不需要使用多線程；只有當它完全符合多線程的特點時，多線程機制對線程間通信和線程管理的強大支持才能有用武之地，這時使用多線程才是值得的

一：理解多線程

   多線程是這樣一種機制，它允許在程序中并發(fā)執(zhí)行多個指令流，每個指令流都稱為一個線程，彼此間互相獨立。 線程又稱為輕量級進程，它和進程一樣擁有獨立的執(zhí)行控制，由操作系統(tǒng)負責調度，區(qū)別在于線程沒有獨立的存儲空間，而是和所屬進程中的其它線程共享一個存儲空間，這使得線程間的通信遠較進程簡單。
  多個線程的執(zhí)行是并發(fā)的，也就是在邏輯上“同時”，而不管是否是物理上的“同時”。如果系統(tǒng)只有一個CPU，那么真正的“同時”是不可能的，但是由于CPU的速度非常快，用戶感覺不到其中的區(qū)別，因此我們也不用關心它，只需要設想各個線程是同時執(zhí)行即可。多線程和傳統(tǒng)的單線程在程序設計上最大的區(qū)別在于，由于各個線程的控制流彼此獨立，使得各個線程之間的代碼是亂序執(zhí)行的，由此帶來的線程調度，同步等問題，將在以后探討。

二：在Java中實現(xiàn)多線程
  我們不妨設想，為了創(chuàng)建一個新的線程，我們需要做些什么？很顯然，我們必須指明這個線程所要執(zhí)行的代碼，而這就是在Java中實現(xiàn)多線程我們所需要做的一切！
   真是神奇！Java是如何做到這一點的？通過類！作為一個完全面向對象的語言，Java提供了類 java.lang.Thread 來方便多線程編程，這個類提供了大量的方法來方便我們控制自己的各個線程，我們以后的討論都將圍繞這個類進行。
   那么如何提供給 Java 我們要線程執(zhí)行的代碼呢？讓我們來看一看 Thread 類。Thread 類最重要的方法是 run() ，它為Thread 類的方法start() 所調用，提供我們的線程所要執(zhí)行的代碼。為了指定我們自己的代碼，只需要覆蓋它！

　　方法一：繼承 Thread 類，覆蓋方法 run()，我們在創(chuàng)建的 Thread 類的子類中重寫 run() ,加入線程所要執(zhí)行的代碼即可。下面是一個

例子：
public class MyThread extends Thread {
　int count= 1, number;
　public MyThread(int num) {
　　number = num;
　　System.out.println("創(chuàng)建線程 " + number);
　}
　public void run() {
　　while(true) {
　　　System.out.println("線程 " + number + ":計數(shù) " + count);
　　　if(++count== 6) return;
　　}
　}
　public static void main(String args[]) {
　　for(int i = 0; i < 5; i++) new MyThread(i+1).start();
　}
}

   這種方法簡單明了，符合大家的習慣，但是，它也有一個很大的缺點，那就是如果我們的類已經從一個類繼承（如小程序必須繼承自Applet 類），則無法再繼承 Thread 類，這時如果我們又不想建立一個新的類，應該怎么辦呢？
    我們不妨來探索一種新的方法：我們不創(chuàng)建 Thread 類的子類，而是直接使用它，那么我們只能將我們的方法作為參數(shù)傳遞給 Thread 類的實例，有點類似回調函數(shù)。但是 Java 沒有指針，我們只能傳遞一個包含這個方法的類的實例。那么如何限制這個類必須包含這一方法呢？當然是使用接口！（雖然抽象類也可滿足，但是需要繼承，而我們之所以要采用這種新方法，不就是為了避免繼承帶來的限制嗎？） Java 提供了接口 java.lang.Runnable 來支持這種方法。

　　方法二：實現(xiàn) Runnable 接口

   Runnable 接口只有一個方法 run()，我們聲明自己的類實現(xiàn) Runnable 接口并提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務。但是 Runnable 接口并沒有任何對線程的支持，我們還必須創(chuàng)建 Thread 類的實例，這一點通過 Thread 類的構造函數(shù)public

Thread(Runnable target);來實現(xiàn)。下面是一個例子：
public class MyThread implements Runnable {
　int count= 1, number;
　public MyThread(int num) {
　　number = num;
　　System.out.println("創(chuàng)建線程 " + number);
　}
　public void run() {
　　while(true) {
　　　System.out.println("線程 " + number + ":計數(shù) " + count);
　　　if(++count== 6) return;
　　}
　}
　public static void main(String args[]) {
　　for(int i = 0; i < 5; i++) new Thread(new MyThread(i+1)).start();
　}
}

   嚴格地說，創(chuàng)建 Thread 子類的實例也是可行的，但是必須注意的是，該子類必須沒有覆蓋 Thread 類的 run 方法，否則該線程執(zhí)行的將是子類的 run 方法，而不是我們用以實現(xiàn)Runnable 接口的類的 run 方法，對此大家不妨試驗一下。
　　使用 Runnable 接口來實現(xiàn)多線程使得我們能夠在一個類中包容所有的代碼，有利于封裝，它的缺點在于，我們只能使用一套代碼，若想創(chuàng)建多個線程并使各個線程執(zhí)行不同的代碼，則仍必須額外創(chuàng)建類，如果這樣的話，在大多數(shù)情況下也許還不如直接用多個類分別繼承 Thread

來得緊湊。
　　綜上所述，兩種方法各有千秋，大家可以靈活運用。
　　下面讓我們一起來研究一下多線程使用中的一些問題。

　三：線程的四種狀態(tài)

　　1. 新狀態(tài)：線程已被創(chuàng)建但尚未執(zhí)行（start() 尚未被調用）。
　　2. 可執(zhí)行狀態(tài)：線程可以執(zhí)行，雖然不一定正在執(zhí)行。CPU 時間隨時可能被分配給該線程，從而使得它執(zhí)行。
　　3. 死亡狀態(tài)：正常情況下 run() 返回使得線程死亡。調用 stop()或 destroy() 亦有同樣效果，但是不被推薦，前者會產生異常，后者是強制終止，不會釋放鎖。
      4. 阻塞狀態(tài)：線程不會被分配 CPU 時間，無法執(zhí)行。

　　四：線程的優(yōu)先級

    線程的優(yōu)先級代表該線程的重要程度，當有多個線程同時處于可執(zhí)行狀態(tài)并等待獲得 CPU 時間時，線程調度系統(tǒng)根據(jù)各個線程的優(yōu)先級來決定給誰分配 CPU 時間，優(yōu)先級高的線程有更大的機會獲得 CPU 時間，優(yōu)先級低的線程也不是沒有機會，只是機會要小一些罷了。
   你可以調用 Thread 類的方法 getPriority() 和setPriority()來存取線程的優(yōu)先級，線程的優(yōu)先級界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之間，缺省是5(NORM_PRIORITY)。

　　五：線程的同步

    由于同一進程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴重的問題。Java語言提供了專門機制以解決這種沖突，有效避免了同一個數(shù)據(jù)對象被多個線程同時訪問。
　　由于我們可以通過 private 關鍵字來保證數(shù)據(jù)對象只能被方法訪問，所以我們只需針對方法提出一套機制，這套機制就是 synchronized關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。

　　1. synchronized 方法：通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如：

public synchronized void accessVal(int newVal);

　　synchronized 方法控制對類成員變量的訪問：每個類實例對應一把鎖，每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執(zhí)行，否則所屬線程阻塞，方法一旦執(zhí)行，就獨占該鎖，直到從該方法返回時才將鎖釋放，此后被阻塞的線程方能獲得該鎖，重新進入可執(zhí)行狀態(tài)。這種機制確保了同一時刻對于每一個類實例，其所有聲明為 synchronized 的成員函數(shù)中至多只有一個處于可執(zhí)行狀態(tài)（因為至多只有一個能夠獲得該類實例對應的鎖），從而有效避免了類成員變量的訪問沖突（只要所有可能訪問類成員變量的方法均被聲明為 synchronized）。
　　在 Java 中，不光是類實例，每一個類也對應一把鎖，這樣我們也可將類的靜態(tài)成員函數(shù)聲明為 synchronized ，以控制其對類的靜態(tài)成員變量的訪問。
　　synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法 run() 聲明為synchronized ，由于在線程的整個生命期內它一直在運行，因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以通過將訪問類成員變量的代碼放到專門的方法中，將其聲明為 synchronized ，并在主方法中調用來解決這一問題，但是 Java 為我們提供了更好的解決辦法，那就是 synchronized 塊。

　　2. synchronized 塊：通過 synchronized關鍵字來聲明synchronized 塊。語法如下：

synchronized(syncObject) {
//允許訪問控制的代碼
}

synchronized 塊是這樣一個代碼塊，其中的代碼必須獲得對象 syncObject （如前所述，可以是類實例或類）的鎖方能執(zhí)行，具體機制同前所述。由于可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。

1.多線程中有主內存和工作內存之分， 在JVM中，有一個主內存，專門負責所有線程共享數(shù)據(jù)；而每個線程都有他自己私有的工作內存， 主內存和工作內存分貝在JVM的stack區(qū)和heap區(qū)。

2.線程的狀態(tài)有'Ready', 'Running', 'Sleeping', 'Blocked', 和 'Waiting'幾個狀態(tài)，
'Ready' 表示線程正在等待CPU分配允許運行的時間。

3.線程運行次序并不是按照我們創(chuàng)建他們時的順序來運行的，CPU處理線程的順序是不確定的，如果需要確定，那么必須手工介入，使用setPriority()方法設置優(yōu)先級。

4.我們無從知道一個線程什么時候運行，兩個或多個線程在訪問同一個資源時，需要synchronized

5. 每個線程會注冊自己，實際某處存在著對它的引用，因此，垃圾回收機制對它就“束手無策”了。

6. Daemon線程區(qū)別一般線程之處是：主程序一旦結束，Daemon線程就會結束。

7. 一個對象中的所有synchronized方法都共享一把鎖，這把鎖能夠防止多個方法對通用內存同時進行的寫操作。synchronized static方法可在一個類范圍內被相互間鎖定起來。

8. 對于訪問某個關鍵共享資源的所有方法，都必須把它們設為synchronized，否則就不能正常工作。

9. 假設已知一個方法不會造成沖突，最明智的方法是不要使用synchronized，能提高些性能。

10. 如果一個"同步"方法修改了一個變量，而我們的方法要用到這個變量(可能是只讀),最好將自己的這個方法也設為 synchronized。

11. synchronized不能繼承，　父類的方法是synchronized，那么其子類重載方法中就不會繼承“同步”。

12. 線程堵塞Blocked有幾個原因造成：

(1)線程在等候一些IO操作
(2)線程試圖調用另外一個對象的“同步”方法，但那個對象處于鎖定狀態(tài)，暫時無法使用。

13.原子型操作(atomic), 對原始型變量(primitive)的操作是原子型的atomic. 意味著這些操作是線程安全的， 但是大部分情況下，我們并不能正確使用，來看看 i = i + 1 , i是int型，屬于原始型變量：

(1)從主內存中讀取i值到本地內存.
(2)將值從本地內存裝載到線程工作拷貝中.
(3)裝載變量1.
(4)將i 加 1.
(5)將結果給變量i.
(6)將i保存到線程本地工作拷貝中.
(7)寫回主內存.

注意原子型操作只限于第1步到第2步的讀取以及第6到第7步的寫, i的值還是可能被同時執(zhí)行i=i+1的多線程中斷打擾(在第4步)。

double 和long 變量是非原子型的(non-atomic)。數(shù)組是object 非原子型。

14. 由于13條的原因，我們解決辦法是：

class xxx extends Thread{

//i會被經常修改
private int i;

public synchronized int read(){ return i;}

public synchronized void update(){ i = i + 1;}

..........

}

15. Volatile變量， volatile變量表示保證它必須是與主內存保持一致，它實際是"變量的同步", 也就是說對于volatile變量的操作是原子型的，如用在long 或 double變量前。

16. 使用yield()會自動放棄CPU，有時比sleep更能提升性能。

17. sleep()和wait()的區(qū)別是：wait()方法被調用時會解除鎖定，但是我們能使用它的地方只是在一個同步的方法或代碼塊內。

18. 通過制造縮小同步范圍，盡可能的實現(xiàn)代碼塊同步，wait(毫秒數(shù))可在指定的毫秒數(shù)可退出wait；對于wait()需要被notisfy()或notifyAll()踢醒。

19. 構造兩個線程之間實時通信的方法分幾步：
(1). 創(chuàng)建一個PipedWriter和一個PipedReader和它們之間的管道;
PipedReader in = new PipedReader(new PipedWriter())
(2). 在需要發(fā)送信息的線程開始之前，將外部的PipedWriter導向給其內部的Writer實例out
(3). 在需要接受信息的線程開始之前，將外部的PipedReader導向給其內部的Reader實例in
(4). 這樣放入out的所有東西度可從in中提取出來。

20. synchronized帶來的問題除性能有所下降外，最大的缺點是會帶來死鎖DeadLock，只有通過謹慎設計來防止死鎖，其他毫無辦法，這也是線程難以馴服的一個原因。不要再使用stop() suspend() resume()和destory()方法

21. 在大量線程被堵塞時，最高優(yōu)先級的線程先運行。但是不表示低級別線程不會運行，運行概率小而已。

22. 線程組的主要優(yōu)點是：使用單個命令可完成對整個線程組的操作。很少需要用到線程組。

23. 從以下幾個方面提升多線程的性能：

檢查所有可能Block的地方，盡可能的多的使用sleep或yield()以及wait();

盡可能延長sleep(毫秒數(shù))的時間;

運行的線程不用超過100個，不能太多；

不同平臺linux或windows以及不同JVM運行性能差別很大。

24. 推薦幾篇相關英文文章:

Use Threading Tricks to Improve Programs

不管我是多么喜歡JAVA但是，從實際開發(fā)角度講，Java的多線程確實沒有C++好使。
表現(xiàn)在：
1.Java沒有全局變量；
2.Java 的線程之間的通信比較差，C++提供了多種通信方式；
3.Java的數(shù)據(jù)同步是通過synchronized來實現(xiàn)，但是基本上等于交給了虛擬機來完成，
而C++有很多種：臨界區(qū)、互斥體等。
4. Java的多線程run方法沒有返回值，因此如何能得到子線程的反饋信息，確實令人頭疼。
5.Java的多線程是協(xié)作式，這樣等于操作系統(tǒng)放棄了對線程的控制；

這里談談我在java多線程中的編寫經驗：
1.創(chuàng)建thread時，將主控類或者叫做調用類傳入構造函數(shù)中，例如：
 Class A調用Class B，Class A作為Class B構造函數(shù)的參數(shù)。
這樣再創(chuàng)建一個子線程時，用同樣的方式實現(xiàn)，這樣主控類的實例變量就可以作為
全局變量，當然要注意同步。

2. 類同步中wait(),notify()一定要考慮好邏輯，不然有可能造成阻塞。

3. 如果多個線程調用或者目前不是很清楚有多少個線程進行通信，最好的辦法是
自己實現(xiàn)一個listener，然后調用類調用Listener的一個實例方法進行通信。
工作原理：

   1) Listener接口提供同步方法  例如SynData();
   2) 同步線程提供添加和刪除Listener的方法，同時在線程中對注冊Listener
的類進行輪流通知；
   3) 使用給同步數(shù)據(jù)的線程類，繼承Listener接口，實現(xiàn)其方法，將本線程即將結束的數(shù)據(jù)發(fā)送到同步線程中；

其實這個原理來自于Java Swing技術。
由于時間關系，今天就談到這里，希望能拋磚引玉！！請大家多多指教！
下一次談一談我用上面的方式實現(xiàn)的一個網關實例，謝謝各位！

 

use? master
go
create? proc? killspid? (@dbname? varchar(20))?
as?
begin?
declare? @sql? nvarchar(500),@temp varchar(1000)
declare? @spid? int?
set? @sql='declare? getspid? cursor? for???
select? spid? from? sysprocesses? where? dbid=db_id('''+@dbname+''')
exec? (@sql)?
open? getspid?
fetch? next? from? getspid? into? @spid?
while? @@fetch_status? <? >-1?
begin?
? set @temp='kill? '+rtrim(@spid)
? exec(@temp)
fetch? next? from? getspid? into? @spid?
end?
close? getspid?
deallocate? getspid?
end?

--用法?
use? master?
exec? killspid? '數(shù)據(jù)庫名'

?

J2me游戲編程電子書
J2me游戲編程隨書源碼

1、用StringBuffer代替String，因為String對象不能被更改，任何對String對象的更改都是創(chuàng)建一個新的String對象。
2、直接存取類的變量比通過setter和getter方法快。
3、使用要地變量比使用類或實例變量更有效率。
4、使用變量比使用數(shù)組更有準備準備效率。
5、避免在循環(huán)中進行同步，因為每一次循環(huán)都會有l(wèi)ock和unlock的過程，會嚴重影響程序執(zhí)行效率。
6、循環(huán)中倒數(shù)（遞減）比正數(shù)（遞增）要快。
7、使用類似于x+=1替代x=x+1，因為這樣生成的代碼小。
8、刪除循環(huán)中的常量運算。
9、重復利用對象。
10、把不再使用的對象賦值為null，特別是不再使用的thread。
11、盡量使用內置的方法。比如，想實現(xiàn)將數(shù)據(jù)從一個數(shù)組拷貝到另一個數(shù)組的功能，使用用System.arrraycompy比自己創(chuàng)建新的方法的效率更有效率。