第一篇：Java程序員必須掌握的線程知識
Java程序員必須掌握的線程知識 Callable和Future Callable和Future出現的原因
創建線程的2種方式，一種是直接繼承Thread，另外一種就是實現Runnable接口。
這2種方式都有一個缺陷就是：在執行完任務之后無法獲取執行結果。如果需要獲取執行結果，就必須通過共享變量或者使用線程通信的方式來達到效果，這樣使用起來就比較麻煩。
而自從Java 1.5開始，就提供了Callable和Future，通過它們可以在任務執行完畢之后得到任務執行結果。
Callable和Future介紹
Callable接口代表一段可以調用并返回結果的代碼;Future接口表示異步任務，是還沒有完成的任務給出的未來結果。所以說Callable用于產生結果，Future用于獲取結果。
Callable接口使用泛型去定義它的返回類型。Executors類提供了一些有用的方法在線程池中執行Callable內的任務。由于Callable任務是并行的（并行就是整體看上去是并行的，其實在某個時間點只有一個線程在執行），我們必須等待它返回的結果。
java.util.concurrent.Future對象為我們解決了這個問題。在線程池提交Callable任務后返回了一個Future對象，使用它可以知道Callable任務的狀態和得到Callable返回的執行結果。Future提供了get()方法讓我們可以等待Callable結束并獲取它的執行結果。
Callable與Runnable
java.lang.Runnable吧，它是一個接口，在它里面只聲明了一個run()方法：
publicinterfaceRunnable{
publicabstractvoid run();}
由于run()方法返回值為void類型，所以在執行完任務之后無法返回任何結果。
Callable位于java.util.concurrent包下，它也是一個接口，在它里面也只聲明了一個方法，只不過這個方法叫做call()：
publicinterfaceCallable
/**
* Computes a result, or throws an exception if unable to do so.*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call()throwsException;}
可以看到，這是一個泛型接口，call()函數返回的類型就是傳遞進來的V類型。
那么怎么使用Callable呢？
一般情況下是配合ExecutorService來使用的，在ExecutorService接口中聲明了若干個submit方法的重載版本：
第一個submit方法里面的參數類型就是Callable。
暫時只需要知道Callable一般是和ExecutorService配合來使用的，具體的使用方法講在后面講述。
一般情況下我們使用第一個submit方法和第三個submit方法，第二個submit方法很少使用。
Future
Future就是對于具體的Runnable或者Callable任務的執行結果進行取消、查詢是否完成、獲取結果。必要時可以通過get方法獲取執行結果，該方法會阻塞直到任務返回結果。
Future類位于java.util.concurrent包下，它是一個接口：
publicinterfaceFuture
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get()throwsInterruptedException,ExecutionException;
V get(long timeout,TimeUnit unit)
throwsInterruptedException,ExecutionException,TimeoutException;}
在Future接口中聲明了5個方法，下面依次解釋每個方法的作用：
cancel方法用來取消任務，如果取消任務成功則返回true，如果取消任務失敗則返回false。參數mayInterruptIfRunning表示是否允許取消正在執行卻沒有執行完畢的任務，如果設置true，則表示可以取消正在執行過程中的任務。如果任務已經完成，則無論mayInterruptIfRunning為true還是false，此方法肯定返回false，即如果取消已經完成的任務會返回false；如果任務正在執行，若mayInterruptIfRunning設置為true，則返回true，若mayInterruptIfRunning設置為false，則返回false；如果任務還沒有執行，則無論mayInterruptIfRunning為true還是false，肯定返回true。isCancelled方法表示任務是否被取消成功，如果在任務正常完成前被取消成功，則返回 true。
isDone方法表示任務是否已經完成，若任務完成，則返回true；
get()方法用來獲取執行結果，這個方法會產生阻塞，會一直等到任務執行完畢才返回；
get(long timeout, TimeUnit unit)用來獲取執行結果，如果在指定時間內，還沒獲取到結果，就直接返回null。
也就是說Future提供了三種功能：
1）判斷任務是否完成；
2）能夠中斷任務；
3）能夠獲取任務執行結果。
因為Future只是一個接口，所以是無法直接用來創建對象使用的，因此就有了下面的FutureTask。FutureTask
FutureTask實現了RunnableFuture接口，這個接口的定義如下：
publicinterfaceRunnableFuture
void run();}
可以看到這個接口實現了Runnable和Future接口，接口中的具體實現由FutureTask來實現。這個類的兩個構造方法如下 ：
publicFutureTask(Callable
if(callable ==null)
thrownewNullPointerException();
sync =newSync(callable);
}
publicFutureTask(Runnable runnable, V result){
sync =newSync(Executors.callable(runnable, result));
} 如上提供了兩個構造函數，一個以Callable為參數，另外一個以Runnable為參數。這些類之間的關聯對于任務建模的辦法非常靈活，允許你基于FutureTask的Runnable特性（因為它實現了Runnable接口），把任務寫成Callable，然后封裝進一個由執行者調度并在必要時可以取消的FutureTask。
FutureTask可以由執行者調度，這一點很關鍵。它對外提供的方法基本上就是Future和Runnable接口的組合：get()、cancel、isDone()、isCancelled()和run()，而run()方法通常都是由執行者調用，我們基本上不需要直接調用它。
一個FutureTask的例子
publicclassMyCallableimplementsCallable
privatelong waitTime;
publicMyCallable(int timeInMillis){
this.waitTime=timeInMillis;
}
@Override
publicString call()throwsException{ Thread.sleep(waitTime);
//return the thread name executing this callable task
returnThread.currentThread().getName();
}
}
publicclassFutureTaskExample{
publicstaticvoid main(String[] args){
MyCallable callable1 =newMyCallable(1000);// 要執行的任務
MyCallable callable2 =newMyCallable(2000);
FutureTask
FutureTask
ExecutorService executor =Executors.newFixedThreadPool(2);// 創建線程池并返回ExecutorService實例
executor.execute(futureTask1);// 執行任務
executor.execute(futureTask2);
while(true){
try{
if(futureTask1.isDone()&& futureTask2.isDone()){// 兩個任務都完成System.out.println(“Done”);
executor.shutdown();// 關閉線程池和服務
return;
}
if(!futureTask1.isDone()){// 任務1沒有完成，會等待，直到任務完成 System.out.println(“FutureTask1 output=”+futureTask1.get());
}
System.out.println(“Waiting for FutureTask2 to complete”);
String s = futureTask2.get(200L,TimeUnit.MILLISECONDS);
if(s!=null){
System.out.println(“FutureTask2 output=”+s);
}
}catch(InterruptedException|ExecutionException e){
e.printStackTrace();
}catch(TimeoutException e){
//do nothing
}
} }}
運行如上程序后，可以看到一段時間內沒有輸出，因為get()方法等待任務執行完成然后才輸出內容.輸出結果如下：
FutureTask1 output=pool-1-thread-1WaitingforFutureTask2 to completeWaitingforFutureTask2 to completeWaitingforFutureTask2 to completeWaitingforFutureTask2 to completeWaitingforFutureTask2 to completeFutureTask2 output=pool-1-thread-2Done
第二篇：Java程序員必須掌握的開發工具
Java程序員必須掌握的開發工具
以下的開發工具，能幫助你成為一名高級java程序開發人員。
1.Eclipse
盡管IntelliJ IDEA、NetBeans和一些其他的IDE正在日益普及，但是有調查表明，Eclipse仍然是幾乎半數Java開發人員首選的開發環境。Eclipse是IDE領域的瑞士軍刀，有著大量定制的接口和無數的插件。它無處不在，后面本文將推薦的其他所有工具都提供Eclipse插件。這也是八維必講的開發工具。
Eclipse的工作流程可分為三個方面：工作臺，工作空間和視角。工作臺作為到IDE的出發點。工作空間將項目、文件和配置設置組合在一個單獨的 目錄下。視角定義工具、視圖和有效設置。雖然新手開發人員可能會覺得相比Netbeans和IntelliJ IDEA，Eclipse使用起來更難，但Eclipse的靈活性，使其成為企業開發的首選IDE。
Luna，Eclipse的最新版本，支持Java
8、分屏編輯、新的黑色主題，以及一個功能齊全的命令行終端。
2.Gradle
Gradle是一個自動化項目工具，建立在Apache Maven和Apache Ant的功能上。雖然Gradle并不是最流行的構建工具（最流行的是Maven，64％的Java開發人員會選擇它），但它的普及速度很快。它也可作為默認的Android構建工具。
Gradle引以為傲的是它的簡單。Gradle使用Groovy編程語言，與Maven和Ant使用XML語法截然相反。
3.Javadoc
Javadoc是Oracle提供的文檔生成器。它可以將特殊格式的注釋解析為HTML文檔。
Javadoc注釋使用開放標簽、關閉標簽，以及一個或多個描述性標簽的格式。開放式標簽類似于標準Java多行注釋標記，使用兩個星號的除外。Javadoc也解析普通的HTML標簽。
Javadoc自動格式化標簽和關鍵字，除非另有規定。Javadoc廣泛使用超鏈接，允許你參考和鏈接到代碼的不同區域。許多IDE--包括 Eclipse--可以自動添加Javadoc注釋模塊到變量、類和方法中。支持Maven、Gradle和Ant的插件在編譯代碼的同時也可以構建 Javadoc HTML。
4.JUnit
JUnit是用于編寫和運行單元測試的開源框架。一個基本的JUnit測試包括測試類、測試方法、以及執行測試的功能。JUnit使用標注來確定測試如何構造和運行。例如，如果你的程序有一個類叫做MathClass，具有乘法和除法的方法，你可以創建JUnit測試來檢 查不符合預期的值。輸入數字2和5到乘法方法，你希望得到的結果為10。當輸入0作為除法方法的第二個參數時，你會期望給出一個數字計算異常的警告因為除 數不能為0：
@Test標注規定，MathClass方法是一個測試用例。在JUnit提供額外的標注，比如@Before，這樣你就可以在測試運行之前設置環境。JUnit還可以設置規則用于定義測試方法的行為。例如，TemporaryFolder規則使得一旦測試完成，由測試創建的文件或文件夾就會被刪除。
5.Cobertura
Cobertura可用于分析Java代碼的測試覆蓋率。Cobertura根據沒有被測試覆蓋的代碼生成基于HTML的報告。
Cobertura提供可用于插裝、檢查和測試代碼的工具。通過監控可測試的代碼，Cobertura允許你使用你選擇的測試框架，甚至不需要測試框架就可以運行程序。
Cobertura根據行、分支和程序包三個方面給出代碼覆蓋報告。每個類別都有一個可自定義的閾值，如果覆蓋面低于閾值，就會觸發警告。Cobertura還集成了Maven和Gradle 的自動檢測功能。
6.FindBugs
FindBugs是一個匹配編譯代碼模式，而非使用bug數據庫的工具。當提供源代碼時，FindBugs還可高亮顯示檢測出bug的代碼行。
在它的3.0.1版本中，FindBugs繼續保持著數以百計的bug描述。根據bug的嚴重程度，FindBugs將bug分為四個水平：相關 的，令人困擾的，可怕的，以及最可怕的。除了圖形用戶界面，FindBugs還提供一個命令行界面，Ant任務，以及Eclipse插件。
7.VisualVM
包含在JDK中的VisualVM是監控和審查Java應用程序性能的工具。VisualVM檢測并重視活躍的JVM實例來檢索有關進程的診斷信息。
VisualVM可以很容易地實時診斷性能問題。它提供了全套的分析工具，包括JConsole、jstack、jmap、jinfo和jstat等。此外，你還可以對JVM做一個快照，這樣以后在任何時都能審查。
8.Groovy
Groovy是一種編程語言，通過添加新的關鍵字，自動導入常用的類，以及可選類型變量聲明，既簡化又擴展了Java。
Groovy的核心優勢之一是它的腳本功能。類可以被編譯為Java字節碼或使用Groovy Shell動態執行。Groovy的Java基礎使得它相較于Jython和JRuby更容易為Java開發人員所接受。
第三篇：PHP程序員必須掌握的知識
PHP5的優點
PHP5的最大特點是引入了面向對象的全部機制，并且保留了向下的兼容性。程序員不必再編寫缺乏功能性的類，并且能夠以多種方法實現類的保護。另外，在對象的集成等方面也不再存在問題。使用PHP5引進了類型提示和異常處理機制，能更有效的處理和避免錯誤的發生。
mysql_fetch_row,mysql_fetch_array,mysql_fetch_assoc的區別
實例代碼
$link=mysql_connect('localhost','root',”);mysql_select_db('abc',$link);$sql = “select * from book”;
$result = mysql_query($sql);
while($row = mysql_fetch_row($result)){
echo $row['cid'].'::'.$row[1].'
';}
$result = mysql_query($sql);
while($row = mysql_fetch_array($result)){
echo $row['cid'].'::'.$row[1].'
';}
$result = mysql_query($sql);
while($row = mysql_fetch_object($result)){
echo $row->cid.'::'.$row->title.”
”;}
$result = mysql_query($sql);
while($row = mysql_fetch_assoc($result)){
echo $row['cid'].'::'.$row[1].'
';}
?>
詳細解釋：
mysql_fetch_row，這個函數是從結果集中取一行作為枚舉數據，從和指定的結果標識關聯的結果集中取得一行數據并作為數組返回。每個結果的列 儲存在一個數組的單元中，偏移量從 0 開始。注意，這里是從0開始偏移，也就是說不能用字段名字來取值，只能用索引來取值，所以如下代碼是取不到值的：
while($row = mysql_fetch_row($res)){
echo $row['cid'].'::'.$row[1].”;
} //這里的$row['cid'] 取不到值。
mysql_fetch_array，從結果集中取得一行作為關聯數組，或數字數組，或二者兼有，除了將數據以數字索引方式儲存在數組中之外，還可以將數據作為關聯索引儲存，用字段名作為鍵名。也就是說他得到的結果像數組一樣，可以用key或者索引來取值，所以
while($row = mysql_fetch_array($res)){ echo $row['cid'].'::'.$row[1].”;
}//這里$row['cid'],$row[1]都能得到相應的值。
mysql_fetch_object,顧名思義，從結果集中取得一行作為對象，并將字段名字做為屬性。所以只有這樣才能取到值
while($row = mysql_fetch_object($res)){ echo $row->cid.'::'.$row->title.”";
}
mysql_fetch_assoc，從結果集中取得一行作為關聯數組，也就是說這個函數不能像mysql_fetch_row那樣用索引來取值，只能用字段名字來取，所以
while($row = mysql_fetch_assoc($res)){ echo $row['cid'].'::'.$row[1].”;} //$row[1]這樣是取不到值的補充一點：
mysql_fetch_array函數是這樣定義的：array mysql_fetch_array(resource result [, int result_type])，返回根據從結果集取得的行生成的數組，如果沒有更多行則返回 FALSE。
mysql_fetch_array()中可選的第二個參數 result_type 是一個常量，可以接受以下值：MYSQL_ASSOC，MYSQL_NUM 和 MYSQL_BOTH。其中：
1、mysql_fetch_assoc($result)==mysql_fetch_array($result,MYSQL_ASSOC);
2、mysql_fetch_row($result)==mysql_fetch_array($result,MYSQL_NUM);
所 以mysql_fetch_array()函數在某種程度上可以算是mysql_fetch_row()與 mysql_fetch_assoc()的集合。另外，mysql_fetch_array()另外還有MYSQL_BOTH參數，將得到一個同時包含關 聯和數字索引的數組。
在來說句 $row = $db->fetch_array($query)；
$db是人數據庫操作 類，$db->fetch_array($query)，fetch_array($query)是那個db類里的方法，$row = $db->fetch_array($query)這句的意思是從記錄集$query中得到數據庫中的一行記錄。
實例代碼：
$conn=@mysql_connect($host,$user,$pass);@mysql_select_db($database,$conn);$query=mysql_query($sql);
while($row=mysql_fetch_array($query)){ $rows[]=$row;}
索引（詳解）
索引的優點：加快查詢速度。
（如果你總結下索引的用途，其實也就這一點了，若是你的面試官說有其他的優點，那你完全可以告訴他，請你回去自己總結下索引這個到底是干什么的吧）
索引類型：
根據數據庫的功能，可以在數據庫設計器中創建四種索引：唯一索引、非唯一索引、主鍵索引和聚集索引。盡管唯一索引有助于定位信息，但為獲得最佳性能結果，建議改用主鍵或唯一約束。
唯一索引：
唯一索引是不允許其中任何兩行具有相同索引值的索引。
當現有數據中存在重復的鍵值時，大多數數據庫不允許將新創建的唯一索引與表一起保存。數據庫還可能防止添加將在表中創建重復鍵值的新數據。例如，如果在 employee 表中職員的姓(lname)上創建了唯一索引，則任何兩個員工都不能同姓。
非唯一索引：
非唯一索引是相對唯一索引，允許其中任何兩行具有相同索引值的索引。
當現有數據中存在重復的鍵值時，數據庫是允許將新創建的索引與表一起保存。這時數據庫不能防止添加將在表中創建重復鍵值的新數據。
主鍵索引：
數據庫表經常有一列或列組合，其值唯一標識表中的每一行。該列稱為表的主鍵。
在數據庫關系圖中為表定義主鍵將自動創建主鍵索引，主鍵索引是唯一索引的特定類型。該索引要求主鍵中的每個值都唯一。當在查詢中使用主鍵索引時，它還允許對數據的快速訪問。
聚集索引（也叫聚簇索引）：
在聚集索引中，表中行的物理順序與鍵值的邏輯（索引）順序相同。一個表只能包含一個聚集索引。
如果某索引不是聚集索引，則表中行的物理順序與鍵值的邏輯順序不匹配。與非聚集索引相比，聚集索引通常提供更快的數據訪問速度。
第四篇：優秀的java程序員必須掌握的十項技能
西安尚學堂
一個優秀的Java程序員必須掌握的10項技能
3G時代迫使IT從業者中的技術人員掌握越來越多的實用技能，作為IT行業的技術創造者，一個優秀的java程序員必須掌握以下的10項技能，方能勝任java程序員的崗位。
1、語法：必須比較熟悉，在寫代碼的時候的編輯器對某一行報錯應該能夠根據報錯信息知道是什么樣的語法錯誤并且知道如何修正。
2、命令：必須熟悉自帶的常用命令及其常用選項，需要熟悉的命令：appletviewer、Htmlonverter、jar、java、javac、javadoc、javap、javaw、native2ascii、serialver，如果這些命令你沒有全部使用過，那么你對java實際上還很不了解。
3、工具：必須至少熟練使用一種IDE的開發工具，例如、Netbeans、JBuilder、Jdeveloper、IDEA、JCreator或者Workshop，包括進行工程管理、常用選項的設置、插件的安裝配置以及進行調試。
4、API：的核心API是非常龐大的，但是有一些內容筆者認為是必須熟悉的，否則不可能熟練的運用Java，包括：
◆java.lang包下的80％以上的類的功能的靈活運用。
◆java.util包下的80％以上的類的靈活運用，特別是集合類體系、規則表達式、zip、以及時間、隨機數、屬性、資源和Timer.◆java.io包下的60％以上的類的使用，理解IO體系的基于管道模型的設計思路以及常用IO類的特性和使用場合。
◆java.math包下的100％的內容。
◆java.net包下的60％以上的內容，對各個類的功能比較熟悉。
◆java.text包下的60％以上的內容，特別是各種格式化類。
◆熟練運用JDBC.8）、java.security包下40％以上的內容，如果對于安全沒有接觸的話根本就不可能掌握java.◆AWT的基本內容，包括各種組件事件、監聽器、布局管理器、常用組件、打印。◆Swing的基本內容，和AWT的要求類似。
◆XML處理，熟悉SAX、DOM以及JDOM的優缺點并且能夠使用其中的一種完成XML的解析及內容處理。
5、測試：必須熟悉使用junit編寫測試用例完成代碼的自動測試。
6、管理：必須熟悉使用ant完成工程管理的常用任務，例如工程編譯、生成javadoc、生成jar、版本控制、自動測試。
7、排錯：應該可以根據信息比較快速的定位問題的原因和大致位置。
8、思想：必須掌握OOP的主要要求，這樣使用Java開發的系統才能是真正的Java系統。
9、規范：編寫的代碼必須符合流行的編碼規范，例如類名首字母大寫，成員和方法名首字母小寫，方法名的第一個單詞一般是動詞，包名全部小寫等，這樣程序的可讀性才比較好。
10、博學：掌握、Oracle、WebLogic、Jboss、、Struts、Hibernate 等流行技術，掌握軟件架構設計思想、搜索引擎優化、緩存系統設計、網站負載均衡、系統性能調優等實用技術。
第五篇：Java線程總結
Java線程總結
首先要理解線程首先需要了解一些基本的東西，我們現在所使用的大多數操作系統都屬于多任務，分時操作系統。正是由于這種操作系統的出現才有了多線程這個概念。我們使用的windows,linux就屬于此列。什么是分時操作系統呢，通俗一點與就是可以同一時間執行多個程序的操作系統，在自己的電腦上面，你是不是一邊聽歌，一邊聊天還一邊看網頁呢？但實際上，并不上cpu在同時執行這些程序，cpu只是將時間切割為時間片，然后將時間片分配給這些程序，獲得時間片的程序開始執行，不等執行完畢，下個程序又獲得時間片開始執行，這樣多個程序輪流執行一段時間，由于現在cpu的高速計算能力，給人的感覺就像是多個程序在同時執行一樣。
一般可以在同一時間內執行多個程序的操作系統都有進程的概念.一個進程就是一個執行中的程序,而每一個進程都有自己獨立的一塊內存空間,一組系統資源.在進程概念中,每一個進程的內部數據和狀態都是完全獨立的.因此可以想像創建并執行一個進程的系統開像是比較大的，所以線程出現了。在java中，程序通過流控制來執行程序流,程序中單個順序的流控制稱為線程,多線程則指的是在單個程序中可以同時運行多個不同的線程,執行不同的任務.多線程意味著一個程序的多行語句可以看上去幾乎在同一時間內同時運行.（你可以將前面一句話的程序換成進程，進程是程序的一次執行過程,是系統運行程序的基本單位）
線程與進程相似,是一段完成某個特定功能的代碼,是程序中單個順序的流控制;但與進程不同的是,同類的多個線程是共享一塊內存空間和一組系統資源,而線程本身的數據通常只有微處理器的寄存器數據,以及一個供程序執行時使用的堆棧.所以系統在產生一個線程,或者在各個線程之間切換時,負擔要比進程小的多,正因如此,線程也被稱為輕負荷進程(light-weight process).一個進程中可以包含多個線程.多任務是指在一個系統中可以同時運行多個程序,即有多個獨立運行的任務,每個任務對應一個進程，同進程一樣,一個線程也有從創建,運行到消亡的過程,稱為線程的生命周期.用線程的狀態(state)表明線程處在生命周期的哪個階段.線程有創建,可運行,運行中,阻塞,死亡五中狀態.通過線程的控制與調度可使線程在這幾種狀態間轉化每個程序至少自動擁有一個線程,稱為主線程.當程序加載到內存時,啟動主線程.[線程的運行機制以及調度模型]
java中多線程就是一個類或一個程序執行或管理多個線程執行任務的能力，每個線程可以獨立于其他線程而獨立運行，當然也可以和其他線程協同運行，一個類控制著它的所有線程，可以決定哪個線程得到優先級，哪個線程可以訪問其他類的資源，哪個線程開始執行，哪個保持休眠狀態。下面是線程的機制圖：
Page 1 of 16
線程的狀態表示線程正在進行的活動以及在此時間段內所能完成的任務.線程有創建,可運行,運行中,阻塞,死亡五中狀態.一個具有生命的線程,總是處于這五種狀態之一： 1.創建狀態
使用new運算符創建一個線程后,該線程僅僅是一個空對象,系統沒有分配資源,稱該線程處于創建狀態(new thread)2.可運行狀態
使用start()方法啟動一個線程后,系統為該線程分配了除CPU外的所需資源,使該線程處于可運行狀態(Runnable)3.運行中狀態
Java運行系統通過調度選中一個Runnable的線程,使其占有CPU并轉為運行中狀態(Running).此時,系統真正執行線程的run()方法.4.阻塞狀態
一個正在運行的線程因某種原因不能繼續運行時,進入阻塞狀態(Blocked)5.死亡狀態
線程結束后是死亡狀態(Dead)
同一時刻如果有多個線程處于可運行狀態,則他們需要排隊等待CPU資源.此時每個線程自動獲得一個線程的優先級(priority),優先級的高低反映線程的重要或緊急程度.可運行狀態的線程按優先級排隊,線程調度依據優先級基礎上的“先到先服務”原則.線程調度管理器負責線程排隊和CPU在線程間的分配,并由線程調度算法進行調度.當線程調度管理器選種某個線程時,該線程獲得CPU資源而進入運行狀態.線程調度是先占式調度,即如果在當前線程執行過程中一個更高優先級的線程進入可運行狀態,則這個線程立即被調度執行.先占式調度分為:獨占式和分時方式.獨占方式下,當前執行線程將一直執行下去,直 到執行完畢或由于某種原因主動放棄CPU,或CPU被一個更高優先級的線程搶占
分時方式下,當前運行線程獲得一個時間片,時間到時,即使沒有執行完也要讓出
Page 2 of 16
CPU,進入可運行狀態,等待下一個時間片的調度.系統選中其他可運行狀態的線程執行
分時方式的系統使每個線程工作若干步,實現多線程同時運行
另外請注意下面的線程調度規則（如果有不理解，不急，往下看）： ①如果兩個或是兩個以上的線程都修改一個對象，那么把執行修改的方法定義為被同步的（Synchronized）,如果對象更新影響到只讀方法，那么只度方法也應該定義為同步的
②如果一個線程必須等待一個對象狀態發生變化，那么它應該在對象內部等待，而不是在外部等待，它可以調用一個被同步的方法，并讓這個方法調用wait()③每當一個方法改變某個對象的狀態的時候，它應該調用notifyAll()方法，這給等待隊列的線程提供機會來看一看執行環境是否已發生改變
④記住wait(),notify(),notifyAll()方法屬于Object類，而不是Thread類，仔細檢查看是否每次執行wait()方法都有相應的notify()或notifyAll()方法，且它們作用與相同的對象 在java中每個類都有一個主線程，要執行一個程序，那么這個類當中一定要有main方法，這個man方法也就是java class中的主線程。你可以自己創建線程，有兩種方法，一是繼承Thread類，或是實現Runnable接口。一般情況下，最好避免繼承，因為java中是單根繼承，如果你選用繼承，那么你的類就失去了彈性，當然也不能全然否定繼承Thread,該方法編寫簡單,可以直接操作線程,適用于單重繼承情況。至于選用那一種，具體情況具體分析。
eg.繼承Thread
public class MyThread_1 extends Thread{ public void run(){ //some code } }
eg.實現Runnable接口
public class MyThread_2 implements Runnable { public void run(){ //some code } }
Page 3 of 16
當使用繼承創建線程，這樣啟動線程：
new MyThread_1().start()
當使用實現接口創建線程，這樣啟動線程：
new Thread(new MyThread_2()).start()
注意，其實是創建一個線程實例，并以實現了Runnable接口的類為參數傳入這個實例，當執行這個線程的時候，MyThread_2中run里面的代碼將被執行。下面是完成的例子：
public class MyThread implements Runnable { public void run(){ System.out.println(“My Name is ”+Thread.currentThread().getName());} public static void main(String[] args){ new Thread(new MyThread()).start();} }
執行后將打印出： My Name is Thread-0
你也可以創建多個線程，像下面這樣
new Thread(new MyThread()).start();new Thread(new MyThread()).start();new Thread(new MyThread()).start();
那么會打印出：
My Name is Thread-0 My Name is Thread-1
Page 4 of 16
My Name is Thread-2
看了上面的結果，你可能會認為線程的執行順序是依次執行的，但是那只是一般情況，千萬不要用以為是線程的執行機制；影響線程執行順序的因素有幾點：首先看看前面提到的優先級別
public class MyThread implements Runnable { public void run(){ System.out.println(“My Name is ”+Thread.currentThread().getName());} public static void main(String[] args){ Thread t1=new Thread(new MyThread());Thread t2=new Thread(new MyThread());Thread t3=new Thread(new MyThread());
t2.setPriority(Thread.MAX_PRIORITY);//賦予最高優先級
t1.start();t2.start();t3.start();} }
再看看結果：
My Name is Thread-1 My Name is Thread-0 My Name is Thread-2
Page 5 of 16
線程的優先級分為10級，分別用1到10的整數代表，默認情況是5。上面的t2.setPriority(Thread.MAX_PRIORITY)等價與t2.setPriority(10）
然后是線程程序本身的設計，比如使用sleep,yield,join，wait等方法（詳情請看JDKDocument)
public class MyThread implements Runnable { public void run(){
try {
int sleepTime =(int)(Math.random()* 100);// 產生隨機數字，Thread.currentThread().sleep(sleepTime);// 讓其休眠一定時間，時間又上面sleepTime決定
// public static void sleep(long millis)throw InterruptedException
//（API）
System.out.println(Thread.currentThread().getName()+ “ 睡了 ”
+ sleepTime);
} catch(InterruptedException ie)
// 由于線程在休眠可能被中斷，所以調用sleep方法的時候需要捕捉異常
Page 6 of 16
{
ie.printStackTrace();
} }
public static void main(String[] args){
Thread t1 = new Thread(new MyThread());
Thread t2 = new Thread(new MyThread());
Thread t3 = new Thread(new MyThread());
t1.start();
t2.start();
t3.start();} }
執行后觀察其輸出： Thread-0 睡了 11 Thread-2 睡了 48 Thread-1 睡了 69
上面的執行結果是隨機的，再執行很可能出現不同的結果。由于上面我在run中添加了休眠語句，當線程休眠的時候就會讓出cpu，cpu將會選擇執行處于runnable狀態中的其他線程，當然也可能出現這種情況，休眠的Thread立即進入了runnable狀態，cpu再次執行它。[線程組概念] 線程是可以被組織的，java中存在線程組的概念，每個線程都是一個線程組的成員,線程組把多個線程集成為一個對象,通過線程組可以同時對其中的多個線程進行操作,如啟動一個線程組的所有線程等.Java的線程組由java.lang包中的Thread——Group類實現.ThreadGroup類用來管理一組線程,包括:線程的數目,線程間的關系,線程正在執行的操作,以及線程將要啟動或終止時間等.線程組還可以包含線程組.在Java的應用程序中,最高層的線程組是名位main的線程組,在main中還可以加入線程或
Page 7 of 16
線程組,在mian的子線程組中也可以加入線程和線程組,形成線程組和線程之間的樹狀繼承關系。像上面創建的線程都是屬于main這個線程組的。借用上面的例子，main里面可以這樣寫：
public static void main(String[] args){
/***************************************
* ThreadGroup(String name)ThreadGroup(ThreadGroup parent, String name)
***********************************/
ThreadGroup group1 = new ThreadGroup(“group1”);
ThreadGroup group2 = new ThreadGroup(group1, “group2”);
Thread t1 = new Thread(group2, new MyThread());
Thread t2 = new Thread(group2, new MyThread());
Thread t3 = new Thread(group2, new MyThread());
t1.start();
t2.start();
t3.start();} 線程組的嵌套，t1,t2,t3被加入group2,group2加入group1。
Page 8 of 16
另外一個比較多就是關于線程同步方面的，試想這樣一種情況，你有一筆存款在銀行，你在一家銀行為你的賬戶存款，而你的妻子在另一家銀行從這個賬戶提款，現在你有1000塊在你的賬戶里面。你存入了1000，但是由于另一方也在對這筆存款進行操作，人家開始執行的時候只看到賬戶里面原來的1000元，當你的妻子提款1000元后，你妻子所在的銀行就認為你的賬戶里面沒有錢了，而你所在的銀行卻認為你還有2000元。看看下面的例子：
class BlankSaving // 儲蓄賬戶 { private static int money = 10000;
public void add(int i){
money = money + i;
System.out.println(“Husband 向銀行存入了 [￥” + i + “]”);}
public void get(int i){
money = money-i;
System.out.println(“Wife 向銀行取走了 [￥” + i + “]”);
if(money < 0)
System.out.println(“余額不足！”);}
Page 9 of 16
public int showMoney(){
return money;} }
class Operater implements Runnable { String name;BlankSaving bs;
public Operater(BlankSaving b, String s){
name = s;
bs = b;
}
public static void oper(String name, BlankSaving bs){
if(name.equals(“husband”)){
try {
for(int i = 0;i < 10;i++){
Page 10 of 16
Thread.currentThread().sleep((int)(Math.random()* 300));
bs.add(1000);
}
} catch(InterruptedException e){
}
} else {
try {
for(int i = 0;i < 10;i++){
Thread.currentThread().sleep((int)(Math.random()* 300));
bs.get(1000);
}
} catch(InterruptedException e){
}
} }
public void run(){
oper(name, bs);}
Page 11 of 16
}
public class BankTest { public static void main(String[] args)throws InterruptedException {
BlankSaving bs = new BlankSaving();
Operater o1 = new Operater(bs, “husband”);
Operater o2 = new Operater(bs, “wife”);
Thread t1 = new Thread(o1);
Thread t2 = new Thread(o2);
t1.start();
t2.start();
Thread.currentThread().sleep(500);} }
下面是其中一次的執行結果：
---------first--------------Husband 向銀行存入了 [￥1000] Wife 向銀行取走了 [￥1000] Wife 向銀行取走了 [￥1000] Husband 向銀行存入了 [￥1000] Wife 向銀行取走了 [￥1000] Husband 向銀行存入了 [￥1000] Wife 向銀行取走了 [￥1000] Husband 向銀行存入了 [￥1000] Wife 向銀行取走了 [￥1000] Husband 向銀行存入了 [￥1000] Husband 向銀行存入了 [￥1000]
Page 12 of 16
Wife 向銀行取走了 [￥1000] Husband 向銀行存入了 [￥1000] Husband 向銀行存入了 [￥1000] Wife 向銀行取走了 [￥1000] Wife 向銀行取走了 [￥1000] Husband 向銀行存入了 [￥1000] Wife 向銀行取走了 [￥1000] Wife 向銀行取走了 [￥1000] Husband 向銀行存入了 [￥1000]
看到了嗎，這可不是正確的需求，在husband還沒有結束操作的時候，wife就插了進來，這樣很可能導致意外的結果。解決辦法很簡單，就是將對數據進行操作方法聲明為synchronized,當方法被該關鍵字聲明后，也就意味著，如果這個數據被加鎖，只有一個對象得到這個數據的鎖的時候該對象才能對這個數據進行操作。也就是當你存款的時候，這筆賬戶在其他地方是不能進行操作的，只有你存款完畢，銀行管理人員將賬戶解鎖，其他人才能對這個賬戶進行操作。
修改public static void oper(String name,BlankSaving bs)為public static void oper(String name,BlankSaving bs)，再看看結果:
Husband 向銀行存入了 [￥1000] Husband 向銀行存入了 [￥1000] Husband 向銀行存入了 [￥1000] Husband 向銀行存入了 [￥1000] Husband 向銀行存入了 [￥1000] Husband 向銀行存入了 [￥1000] Husband 向銀行存入了 [￥1000] Husband 向銀行存入了 [￥1000] Husband 向銀行存入了 [￥1000] Husband 向銀行存入了 [￥1000] Wife 向銀行取走了 [￥1000] Wife 向銀行取走了 [￥1000] Wife 向銀行取走了 [￥1000] Wife 向銀行取走了 [￥1000] Wife 向銀行取走了 [￥1000] Wife 向銀行取走了 [￥1000] Wife 向銀行取走了 [￥1000] Wife 向銀行取走了 [￥1000] Wife 向銀行取走了 [￥1000] Wife 向銀行取走了 [￥1000]
當丈夫完成操作后，妻子才開始執行操作，這樣的話，對共享對象的操作就不會有問題了。
[wait and notify] 你可以利用這兩個方法很好的控制線程的執行流程，當線程調用wait方法后，線
Page 13 of 16
程將被掛起，直到被另一線程喚醒（notify）或則是如果wait方法指定有時間得話，在沒有被喚醒的情況下，指定時間時間過后也將自動被喚醒。但是要注意一定，被喚醒并不是指馬上執行，而是從組塞狀態變為可運行狀態，其是否運行還要看cpu的調度。事例代碼：
class MyThread_1 extends Thread {
Object lock;
public MyThread_1(Object o){
lock = o;}
public void run(){
try {
synchronized(lock){
System.out.println(“Enter Thread_1 and wait”);
lock.wait();
System.out.println(“be notified”);
}
} catch(InterruptedException e){
} }
Page 14 of 16
}
class MyThread_2 extends Thread { Object lock;
public MyThread_2(Object o){
lock = o;}
public void run(){
synchronized(lock){
System.out.println(“Enter Thread_2 and notify”);
lock.notify();
} } }
public class MyThread { public static void main(String[] args){
int[] in = new int[0];// notice
MyThread_1 t1 = new MyThread_1(in);
Page 15 of 16
MyThread_2 t2 = new MyThread_2(in);
t1.start();
t2.start();} }
執行結果如下：
Enter Thread_1 and wait Enter Thread_2 and notify Thread_1 be notified
可能你注意到了在使用wait and notify方法得時候我使用了synchronized塊來包裝這兩個方法，這是由于調用這兩個方法的時候線程必須獲得鎖，也就是上面代碼中的lock[]，如果你不用synchronized包裝這兩個方法的得話，又或則鎖不一是同一把，比如在MyThread_2中synchronized(lock)改為synchronized(this),那么執行這個程序的時候將會拋出java.lang.IllegalMonitorStateException執行期異常。另外wait and notify方法是Object中的，并不在Thread這個類中。最后你可能注意到了這點：int[] in=new int[0];為什么不是創建new Object而是一個0長度的數組，那是因為在java中創建一個0長度的數組來充當鎖更加高效。
Page 16 of 16
點擊咨詢 