Thread類提供了多個方法來維護執行緒的狀態。你可以使用這些方法來精細化的控制執行緒流。
以下是常用的執行緒方法：
方法
簡介
public final String getName（）
返回執行緒的名稱
public final int getPriority（）
返回執行緒的優先順序
public Thread。State getState（）
返回執行緒的狀態。這個方法主要是為了監控系統的狀態，而不是為了同步控制
public final boolean isAlive（）
檢查執行緒是否存活。只要執行緒已經開始，也沒有被銷燬，那麼它就是存活的
public final void join（） throws InterruptedException
這個方法會一直等待，直到執行緒被銷燬
public void run（）
執行執行緒
public final void setName（String name）
設定執行緒的名稱
public final void setPriority（int newPriority）
設定執行緒的優先順序
public static void sleep（long millis） throws InterruptedException
讓當前執行的執行緒休眠。這個函式接收一個毫秒數字，表示該執行緒要休眠的時長
public static void yield（）
這個方法可以讓當前正在執行的執行緒暫停，然後讓其他執行緒執行
sleep 方法
class ThreadExample extends Thread { override def run（）： Unit = { for （i <- 0 to 4） { println（i） Thread。sleep（1000） } }}object _51_Scala_Thread { def main（args： Array［String］）： Unit = { var t1 = new ThreadExample（） var t2 = new ThreadExample（） t1。start（） t2。start（） }}
0011223344
在程式執行時，可以明顯感覺到程式碼並不是一下子就執行完的。而是沒輸出一組數字都會停頓一段時間，這就是sleep方法的效果。
join 方法
class ThreadExample extends Thread { override def run（）： Unit = { for （i <- 0 to 4） { println（i） Thread。sleep（1000） } }}object _51_Scala_Thread { def main（args： Array［String］）： Unit = { var t1 = new ThreadExample（） var t2 = new ThreadExample（） var t3 = new ThreadExample（） t1。start（） t1。join（） t2。start（） t3。start（） }}
012340011223344
從執行的結果來看，輸出的數字並不是三個0，三個1，三個2這樣的輸出。也就是說三個執行緒並不是都開始運行了。而是第一個執行緒先執行，等第一個執行緒執行完後，後面兩個執行緒在同事執行。因為在程式的第 17 行讓第一個執行緒的物件呼叫了join 方法。這個方法就會等待這個執行緒執行完後被銷燬了，其他執行緒才會開始執行。
setName / getName 方法
class ThreadExample extends Thread { override def run（）： Unit = { for （i <- 0 to 4） { println（this。getName（） + “ - ” + i） Thread。sleep（1000） } }}object _51_Scala_Thread { def main（args： Array［String］）： Unit = { var t1 = new ThreadExample（） var t2 = new ThreadExample（） t1。setName（“Thread One”） t2。setName（“Thread Two”） t1。start（） t2。start（） }}
Thread One - 0Thread Two - 0Thread Two - 1Thread One - 1Thread Two - 2Thread One - 2Thread Two - 3Thread One - 3Thread One - 4Thread Two - 4
getPriority / getPriority 方法
設定和獲取執行緒的優先順序
class ThreadExample extends Thread { override def run（）： Unit = { for （i <- 0 to 4） { println（this。getName（） + “ - ” + i） println（this。getPriority（）） Thread。sleep（1000） } }}object _51_Scala_Thread { def main（args： Array［String］）： Unit = { var t1 = new ThreadExample（） var t2 = new ThreadExample（） t1。setName（“Thread One”） t2。setName（“Thread Two”） t1。setPriority（Thread。MIN_PRIORITY） t2。setPriority（Thread。MAX_PRIORITY） t1。start（） t2。start（） }}
Thread Two - 0Thread One - 0110Thread Two - 1Thread One - 1110Thread Two - 2Thread One - 2110Thread Two - 3Thread One - 3110Thread Two - 410Thread One - 41
從執行結果可以看出變化。因為給第二個執行緒物件設定了最大的優先順序，所以在執行執行緒時，總是第二個執行緒先執行。
用執行緒執行多工
可以透過線上程類中定義多個函式，然後分別呼叫這些函式來實現多工。
class ThreadExample extends Thread { override def run（）： Unit = { for （i <- 0 to 4） { println（“run： ” + i） Thread。sleep（1000） } } def task（）： Unit = { for （i <- 0 to 5） { println（“task： ” + i） Thread。sleep（500） } }}object _51_Scala_Thread { def main（args： Array［String］）： Unit = { var t1 = new ThreadExample（） t1。start（） t1。task（） }}
run： 0task： 0task： 1run： 1task： 2task： 3run： 2task： 4task： 5run： 3run： 4
從輸出的結果可以看出，run方法和自定義的task方法並不會按照固定的順序執行，這兩個方法執行的順序是隨機的。
在main方法中，只要讓Thread的子類物件呼叫start方法，那麼它的run方法就會執行。然後還需要在呼叫一下自定義的task方法，這樣執行緒類就有了兩個任務，一個是run，另一個是task。這樣就實現了用執行緒執行多工操作。
