1.TheServerside.com? 依然是地位無可動搖的CCTV1。

2.InfoQ.com Floyd Marinescu 在離開 TSS 后另起爐灶，2006年中最重要推薦。視野不再局限于Java 而是包括Java,.Net, Ruby ,SOA, Agile方法等熱門話題。

3.JDJ的電子雜志?在JDJ首頁的最底處訂閱，文章質量不低于5-7的傳統三強。

4.SWik.net? 收集了大量OpenSource Project的資源聚合。其中如Spring，Hibernate的更新度非常高，出現什么和Spring有關的blog,article,project都會馬上被聚合。

5.IBM DeveloperWorks?傳統、穩定的Java文章來源地。

6.JavaWorld 傳統、穩定的Java文章來源地。

7.OnJava? 傳統、穩定的Java文章來源地。

8.Artima.com?類似于TSS而略遜，其中Spotlight 文章值得關注，而Java News是聚合了所有其他Java站點的大聚合。

9.JavaLobby? 站內的Announcements?是大大小小Java? Project的發布聲明區，Trips and Tricks?有很多的Tips。

10. No Fluff Just Stuff 的Blogs 聚合 一直缺一個所有優秀Java Blogger的rss總聚合，NFJS這里勉強算一個。

一、jdbc驅動程序
共有有4種
1、thin驅動程序
thin驅動程序是所有驅動程序中資源消耗最小的，而且完全用java編寫的。
該驅動程序只使用tcp/ip且要求oracle net。被稱為第4類驅動程序。
它使用ttc協議與oracle數據庫進行通信。能夠在applet、application中使用。
2、oci驅動程序
oci驅動比thin需要資源要多，但性能通常好一點。oci驅動適合于部署在
中間層的軟件，如web服務器。不能在applet中使用oci驅動。是第2類驅動程序。
不完全用java寫的，還包含了c代碼。該驅動有許多附加的性能增強特性，
包括高級的連接緩沖功能。
注意：oci驅動要求在客戶計算機上安裝它。
3、服務器內部驅動程序
服務器內部驅動程序提供對數據庫的直接訪問，oracle jvm使用它與數據庫進行通信。
oracle jvm是與數據庫集成的java virtual machine，可以使用oracle jvm將
java類裝載進數據庫，然后公布和運行這個類中包含的方法。
4、服務器thin驅動程序
服務器端thin驅動程序也是由oracle jvm使用的，它提供對遠程數據庫的訪問。
也是完全用java編寫的。

二、導入jdbc包
三、注冊oracle jdbc驅動程序
必須先向java程序注冊oracle jdbc驅動程序，然后才能打開數據庫連接。
有兩種注冊oracle jdbc驅動程序的辦法。
1、使用java.lang.class的forname()方法
例子：class.forname(oracle.jdbc.oracledriver);
2、使用jdbc drivermanager類的registerdriver()方法。
例子：drivermanager.registerdriver(new oracle.jdbc.oracledriver());
如果使用oracle8i jdbc驅動程序，那么需要導入oracle.jdbc.driver.oracledriver類，
然后注冊這個類的實例。
例子：
import oracle.jdbc.driver.oracledriver;
drivermanager.registerdriver(new oracle.jdbc.oracledriver());
注意：從jdbc2.0開始，只用jdbc驅動程序的更標準辦法是通過數據源。
四、打開數據庫連接
必須先打開數據庫連接，然后才能在java程序中執行sql語句。打開數據庫連接
的主要辦法。
1、drivermanager類的getconnection()方法。
drivermanager.getconnection(url,username,passwrod);
url:程序要連接的數據庫，以及要使用的jdbc驅動程序
url的結構依賴于jdbc驅動程序的生產商。對于oracle jdbc驅動程序，數據庫url的結構：

driver_name是程序使用的oracle jdbc驅動程序的名稱。如：
jdbc:oracle:thin oracle jdbc thin驅動程序
jdbc:oracle:oci oracle jdbc oci驅動程序
jdbc:oracle:oci8 oracle jdbc oci驅動程序
driver_information是連接數據庫所需的驅動程序特有的信息。這依賴于使用的驅動程序。
對于oracle jdbc thin驅動程序，可以用
host_name:port:database_sid 或者 oracle net關鍵字-值對
(description=(address=(host=host_name)(protocol=tcp)(port=port()
(connect_data=(sid=database_sid)))
host_name: 運行數據庫的機器的名稱
port: net數據庫監聽器等待這個端口上的請求，默認是1521
database_sid: 要連接的數據庫實例的oracle sid。
username: 程序連接數據庫時使用的數據庫用戶名
passwrod: 用戶名的口令
例子：
connection myconnection=drivermanager.getconnection(
jdbc:oracle:thin:@localhost:1521:orcl,
store_user,
store_password);
connection myconnection=drivermanager.getconnection(
jdbc:oracle:oci:@(description=(address=(host=localhost)
(protocol=tcp)(port=1521))(connect_data=(sid=orcl))),
store_user,
store_password);
2、使用oracle數據源對象，必須先創建這個對象，然后連接它。使用這種方法
采用了一種設置數據庫連接信息的標準化方式，oracle數據源對象可以與
java naming and directory interface(java名字與目錄接口，jndi)一起使用。

一、基礎問答

　　1.下面哪些類可以被繼承?

　　　java.lang.Thread (T)
　　　java.lang.Number (T)
　　　java.lang.Double (F)
　　　java.lang.Math  (F)
　　　java.lang.Void  (F)
　　　java.lang.Class  (F)
　　　java.lang.ClassLoader (T)

　　2.抽象類和接口的區別

　　(1)接口可以被多重implements,抽象類只能被單一extends
　　(2)接口只有定義,抽象類可以有定義和實現
　　(3)接口的字段定義默認為:public static final, 抽象類字段默認是"friendly"(本包可見)

　　3.Hashtable的原理,并說出HashMap與Hashtable的區別

　　HashTable的原理:通過節點的關鍵碼確定節點的存儲位置,即給定節點的關鍵碼k,通過一定的函數關系H(散列函數),得到函數值H(k),將此值解釋為該節點的存儲地址.
HashMap 與Hashtable很相似,但HashMap 是非同步(unsynchronizded)和可以以null為關鍵碼的.

　　4.forward和redirect的區別

　　forward: an internal transfer in servlet
　　redirect: 重定向,有2次request,第2次request將丟失第一次的attributs/parameters等

　　5.什么是Web容器?

　　實現J2EE規范中web協議的應用.該協議定義了web程序的運行時環境,包括:并發性,安全性,生命周期管理等等.

　　6.解釋下面關于J2EE的名詞

　　(1)JNDI:Java Naming & Directory Interface,JAVA命名目錄服務.主要提供的功能是：提供一個目錄系統，讓其它各地的應用程序在其上面留下自己的索引，從而滿足快速查找和定位分布式應用程序的功能.
　　(2)JMS：Java Message Service,JAVA消息服務.主要實現各個應用程序之間的通訊.包括點對點和廣播.
　　(3)JTA：Java Transaction API,JAVA事務服務.提供各種分布式事務服務.應用程序只需調用其提供的接口即可.
　　(4)JAF: Java Action FrameWork,JAVA安全認證框架.提供一些安全控制方面的框架.讓開發者通過各種部署和自定義實現自己的個性安全控制策略.
　　(5)RMI:Remote Method Interface,遠程方法調用

　　7.EJB是基于哪些技術實現的？并說 出SessionBean和EntityBean的區別，StatefulBean和StatelessBean的區別.

　　EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技術實現.

　　SessionBean在J2EE應用程序中被用來完成一些服務器端的業務操作，例如訪問數據庫、調用其他EJB組件.EntityBean被用來代表應用系統中用到的數據.對于客戶機，SessionBean是一種非持久性對象，它實現某些在服務器上運行的業務邏輯;EntityBean是一種持久性對象，它代表一個存儲在持久性存儲器中的實體的對象視圖，或是一個由現有企業應用程序實現的實體.

　　Session Bean 還可以再細分為 Stateful Session Bean 與 Stateless Session Bean .這兩種的 Session Bean都可以將系統邏輯放在 method之中執行，不同的是 Stateful Session Bean 可以記錄呼叫者的狀態，因此通常來說，一個使用者會有一個相對應的 Stateful Session Bean 的實體.Stateless Session Bean 雖然也是邏輯組件，但是他卻不負責記錄使用者狀態，也就是說當使用者呼叫 Stateless Session Bean 的時候，EJB Container 并不會找尋特定的 Stateless Session Bean 的實體來執行這個 method.換言之，很可能數個使用者在執行某個 Stateless Session Bean 的 methods 時，會是同一個 Bean 的 Instance 在執行.從內存方面來看， Stateful Session Bean 與 Stateless Session Bean 比較， Stateful Session Bean 會消耗 J2EE Server 較多的內存，然而 Stateful Session Bean 的優勢卻在于他可以維持使用者的狀態.

　　8.XML的解析方法

　　Sax,DOM,JDOM

　　9.什么是Web Service?

　　Web Service就是為了使原來各孤立的站點之間的信息能夠相互通信、共享而提出的一種接口。
Web Service所使用的是Internet上統一、開放的標準，如HTTP、XML、SOAP（簡單對象訪問協議）、WSDL等，所以Web Service可以在任何支持這些標準的環境（Windows,Linux）中使用。

　　注：SOAP協議（Simple Object Access Protocal,簡單對象訪問協議）,它是一個用于分散和分布式環境下網絡信息交換的基于XML的通訊協議。在此協議下，軟件組件或應用程序能夠通過標準的HTTP協議進行通訊。它的設計目標就是簡單性和擴展性，這有助于大量異構程序和平臺之間的互操作性，從而使存在的應用程序能夠被廣泛的用戶訪問。

　　優勢：

　　(1).跨平臺。
　　(2).SOAP協議是基于XML和HTTP這些業界的標準的，得到了所有的重要公司的支持。
　　(3).由于使用了SOAP，數據是以ASCII文本的方式而非二進制傳輸，調試很方便；并且由于這樣，它的數據容易通過防火墻，不需要防火墻為了程序而單獨開一個“漏洞”。
　　(4).此外，WebService實現的技術難度要比CORBA和DCOM小得多。
　　(5).要實現B2B集成，EDI比較完善與比較復雜；而用WebService則可以低成本的實現，小公司也可以用上。
　　(6).在C/S的程序中，WebService可以實現網頁無整體刷新的與服務器打交道并取數。

　　缺點：

　　(1).WebService使用了XML對數據封裝，會造成大量的數據要在網絡中傳輸。
　　(2).WebService規范沒有規定任何與實現相關的細節，包括對象模型、編程語言，這一點，它不如CORBA。

　　10.多線程有幾種實現方法,都是什么?同步有幾種實現方法,都是什么?

　　答：多線程有兩種實現方法，分別是繼承Thread類與實現Runnable接口
　　同步的實現方面有兩種，分別是synchronized,wait與notify

　　11.JSP中動態INCLUDE與靜態INCLUDE的區別？

　　動態INCLUDE用jsp:include動作實現

<jsp:include page="included.jsp" flush="true"/>

　　它總是會檢查所含文件中的變化，適合用于包含動態頁面，并且可以帶參數

　　靜態INCLUDE用include偽碼實現,定不會檢查所含文件的變化，適用于包含靜態頁面

　　<%@ include file="included.htm" %>

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

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

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

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

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

　　七：守護線程

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

　　八：線程組

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

　　九：總結

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

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

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

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

例子：
public class MyThread extends Thread {
　int count= 1, number;
　public MyThread(int num) {
　　number = num;
　　System.out.println("創建線程 " + number);
　}
　public void run() {
　　while(true) {
　　　System.out.println("線程 " + number + ":計數 " + 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 類，這時如果我們又不想建立一個新的類，應該怎么辦呢？
    我們不妨來探索一種新的方法：我們不創建 Thread 類的子類，而是直接使用它，那么我們只能將我們的方法作為參數傳遞給 Thread 類的實例，有點類似回調函數。但是 Java 沒有指針，我們只能傳遞一個包含這個方法的類的實例。那么如何限制這個類必須包含這一方法呢？當然是使用接口！（雖然抽象類也可滿足，但是需要繼承，而我們之所以要采用這種新方法，不就是為了避免繼承帶來的限制嗎？） Java 提供了接口 java.lang.Runnable 來支持這種方法。

　　方法二：實現 Runnable 接口

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

Thread(Runnable target);來實現。下面是一個例子：
public class MyThread implements Runnable {
　int count= 1, number;
　public MyThread(int num) {
　　number = num;
　　System.out.println("創建線程 " + number);
　}
　public void run() {
　　while(true) {
　　　System.out.println("線程 " + number + ":計數 " + 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();
　}
}

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

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

　三：線程的四種狀態

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

　　四：線程的優先級

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

　　五：線程的同步

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

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

public synchronized void accessVal(int newVal);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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的值還是可能被同時執行i=i+1的多線程中斷打擾(在第4步)。

double 和long 變量是非原子型的(non-atomic)。數組是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()的區別是：wait()方法被調用時會解除鎖定，但是我們能使用它的地方只是在一個同步的方法或代碼塊內。

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

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

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

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

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

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

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

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

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

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

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

Use Threading Tricks to Improve Programs