執行緒是作業系統運作的基本單位，它被封裝在行程中，一個行程可以包含多個執行緒。即使我們不手動創造線程，進程也會有一個預設的線程在運行。
對JVM來說，當我們寫一個單執行緒的程式去運行時，JVM中也是有至少兩個執行緒在運行，一個是我們創建的程序，一個是垃圾回收。
線程基本訊息
我們可以透過Thread.currentThread()方法來取得目前執行緒的一些信息，並對其進行修改。
我們來看以下程式碼：
Thread.currentThread().setName("Test");
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
name = Thread.currentThread().getName();
priority = Thread.currentThread().getPriority();
groupName = Thread.currentThread().getThreadGroup().getName();
isDaemon = Thread.currentThread().isDaemon();
System.out.println("Thread Name:" + name);
System.out.println("Priority:" + priority);
GroupName ，每個執行緒都會預設在一個執行緒組裡，我們也可以明確的建立執行緒組，一個執行緒組中也可以包含子執行緒組，這樣執行緒和執行緒組，就構成了一個樹狀結構。
Name ，每個線程都會有一個名字，如果不明確指定，那麼名字的規則是「Thread-xxx」。
Priority ，每個執行緒都會有自己的優先級，JVM對優先順序的處理方式是「搶佔式」的。當JVM發現優先順序高的線程時，馬上運行該線程；對於多個優先權相等的線程，JVM對其進行輪詢處理。 Java的執行緒優先權從1到10，預設是5，Thread類別定義了2個常數：MIN_PRIORITY和MAX_PRIORITY來表示最高和最低優先權。
我們可以看下面的程式碼，它定義了兩個不同優先順序的執行緒：
Thread thread2 = new Thread("high")
{
public void run()
{
for (int i = 0; i < 5; i++)
{
System.out.println("Thread 2 is running.");
}
}
};
thread1.setPriority(Thread.MIN_PRIORITY);
thread2.setPriority(Thread.MAX_PRIORITY);
thread1.start();
thread2.start();
}
thread1.start();
}
如何創建線程
上面的內容，都是演示預設線程中的一些信息，那麼應該如何創建線程呢？在Java中，我們有3種方式可以用來建立執行緒。
Java中的執行緒要嘛繼承Thread類，要嘛實作Runnable接口，我們一一道來。
使用內部類別來創建線程
我們可以使用內部類別的方式來建立線程，過程是宣告一個Thread類型的變量，並重寫run方法。範例程式碼如下：
我們可以從Thread中派生一個類，重寫其run方法，這種方式和上面相似。範例程式碼如下：
public static void createThreadBySubClass()
{
MyThread thread = new MyThread();
thread.start();
}
我們可以定義一個類，使其實作Runnable接口，然後將該類的實例作為建構Thread變數建構函式的參數。範例程式碼如下：
public static void createThreadByRunnable()
{
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();
}
這涉及到Java中多執行緒的運行模式，對於Java來說，多執行緒在運行時，有「多物件多執行緒」和「單物件多執行緒」的區別：
多對像多線程，程式在運行過程中創建多個線程對象，每個對像上運行一個線程。
單對像多線程，程式在運行過程中創建一個線程對象，在其上運行多個線程。
顯然，從執行緒同步和調度的角度來看，多物件多執行緒要簡單一些。上述3種執行緒建立方式，前兩種都屬於“多物件多執行緒”，第三種既可以使用“多物件多執行緒”，也可以使用“單物件單執行緒”。
我們來看下面的範例程式碼，裡面會用到Object.notify方法，這個方法會喚醒物件上的一個執行緒；而Object.notifyAll方法，則會喚醒物件上的所有執行緒。
public static void main(String[] args) throws InterruptedException
{
notifyTest();
notifyTest2();
notifyTest3();
}
private static void notifyTest() throws InterruptedException
{
MyThread[] arrThreads = new MyThread[3];
for (int i = 0; i < arrThreads.length; i++)
{
arrThreads[i] = new MyThread();
arrThreads[i].id = i;
arrThreads[i].setDaemon(true);
arrThreads[i].start();
}
Thread.sleep(500);
for (int i = 0; i < arrThreads.length; i++)
{
synchronized(arrThreads[i])
{
arrThreads[i].notify();
}
}
}
private static void notifyTest2() throws InterruptedException
{
MyRunner[] arrMyRunners = new MyRunner[3];
Thread[] arrThreads = new Thread[3];
for (int i = 0; i < arrThreads.length; i++)
{
arrMyRunners[i] = new MyRunner();
arrMyRunners[i].id = i;
arrThreads[i] = new Thread(arrMyRunners[i]);
arrThreads[i].setDaemon(true);
arrThreads[i].start();
}
Thread.sleep(500);
for (int i = 0; i < arrMyRunners.length; i++)
{
synchronized(arrMyRunners[i])
{
arrMyRunners[i].notify();
}
}
}
private static void notifyTest3() throws InterruptedException
{
MyRunner runner = new MyRunner();
Thread[] arrThreads = new Thread[3];
for (int i = 0; i < arrThreads.length; i++)
{
arrThreads[i] = new Thread(runner);
arrThreads[i].setDaemon(true);
arrThreads[i].start();
}
Thread.sleep(500);
synchronized(runner)
{
runner.notifyAll();
}
}
}
class MyThread extends Thread
{
public int id = 0;
public void run()
{
System.out.println("第" + id + "個執行緒準備休眠5分鐘。");
try
{
synchronized(this)
{
this.wait(5*60*1000);
}
}
catch(InterruptedException ex)
{
ex.printStackTrace();
}
System.out.println("第" + id + "個執行緒被喚醒。");
}
}
class MyRunner implements Runnable
{
public int id = 0;
public void run()
{
System.out.println("第" + id + "個執行緒準備休眠5分鐘。");
try
{
synchronized(this)
{
this.wait(5*60*1000);
}
}
catch(InterruptedException ex)
{
ex.printStackTrace();
}
System.out.println("第" + id + "個執行緒被喚醒。");
}
}
notifyAll方法適用於「單物件多執行緒」的情景，因為notify方法只會隨機喚醒物件上的一個執行緒。
線程的狀態切換
對於線程來講，從我們創建它一直到線程運行結束，在這個過程中，線程的狀態可能是這樣的：
創建：已經有Thread實例了， 但CPU還有為其分配資源和時間片。
就緒：執行緒已經獲得了運作所需的所有資源，只等CPU進行時間調度。
運行：執行緒位於目前CPU時間片中，正在執行相關邏輯。
休眠：一般是呼叫Thread.sleep後的狀態，這時執行緒仍持有運作所需的各種資源，但是不會被CPU調度。
掛起：一般是呼叫Thread.suspend後的狀態，和休眠類似，CPU不會調度該線程，不同的是，這種狀態下，線程會釋放所有資源。
死亡：執行緒運行結束或呼叫了Thread.stop方法。
下面我們來示範如何進行執行緒狀態切換，首先我們會用到下面方法：
Thread()或Thread(Runnable)：建構執行緒。
Thread.start：啟動線程。
Thread.sleep：將執行緒切換至休眠狀態。
Thread.interrupt：中斷執行緒的執行。
Thread.join：等待某線結束。
Thread.yield：剝奪執行緒在CPU上的執行時間片，等待下一次調度。
Object.wait：將Object上所有執行緒鎖定，直到notify方法才繼續執行。
Object.notify：隨機喚醒Object上的1個執行緒。
Object.notifyAll：喚醒Object上的所有執行緒。
下面，就是演示時間囉！ ！ ！
執行緒等待與喚醒
這裡主要使用Object.wait和Object.notify方法，請參考上面的notify實例。要注意的是，wait和notify都必須針對同一個對象，當我們使用實作Runnable介面的方式來建立執行緒時，應該是在Runnable物件而非Thread物件上使用這兩個方法。
執行緒的休眠與喚醒
public static void main(String[] args) throws InterruptedException
{
sleepTest();
}
private static void sleepTest() throws InterruptedException
{
Thread thread = new Thread()
{
public void run()
{
System.out.println("線程" + Thread.currentThread().getName() + "將要休眠5分鐘。");
try
{
Thread.sleep(5*60*1000);
}
catch(InterruptedException ex)
{
System.out.println("線程" + Thread.currentThread().getName() + "休眠被中斷。");
}
System.out.println("線程" + Thread.currentThread().getName() + "休眠結束。");
}
};
thread.setDaemon(true);
thread.start();
Thread.sleep(500);
thread.interrupt();
}
}
雖然有Thread.stop方法，但該方法是不被建議使用的，我們可以利用上面休眠與喚醒的機制，讓執行緒在處理IterruptedException時，結束執行緒。
public static void main(String[] args) throws InterruptedException
{
stopTest();
}
private static void stopTest() throws InterruptedException
{
Thread thread = new Thread()
{
public void run()
{
System.out.println("執行緒運行中。");
try
{
Thread.sleep(1*60*1000);
}
catch(InterruptedException ex)
{
System.out.println("執行緒中斷，結束執行緒");
return;
}
System.out.println("執行緒正常結束。");
}
};
thread.start();
Thread.sleep(500);
thread.interrupt();
}
}
當我們在主線程中創建了10個子線程，然後我們期望10個子線程全部結束後，主線程在執行接下來的邏輯，這時，就該Thread.join登場了。
public static void main(String[] args) throws InterruptedException
{
joinTest();
}
private static void joinTest() throws InterruptedException
{
Thread thread = new Thread()
{
public void run()
{
try
{
for(int i = 0; i < 5; i++)
{
System.out.println("執行緒在運作。");
Thread.sleep(1000);
}
}
catch(InterruptedException ex)
{
ex.printStackTrace();
}
}
};
thread.setDaemon(true);
thread.start();
Thread.sleep(1000);
thread.join();
System.out.println("主執行緒正常結束。");
}
}
我們知道，一個進程下面的所有執行緒是共享記憶體空間的，那麼我們如何在不同的執行緒之間傳遞訊息呢？在回顧Java I/O時，我們談到了PipedStream和PipedReader，這裡，就是它們發揮作用的地方了。
下面的兩個範例，功能完全一樣，不同的是一個使用Stream，一個使用Reader/Writer。
Thread thread1 = new Thread()
{
public void run()
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try
{
while(true)
{
String message = br.readLine();
pos.write(message.getBytes());
if (message.equals("end")) break;
}
br.close();
pos.close();
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
};
Thread thread2 = new Thread()
{
public void run()
{
byte[] buffer = new byte[1024];
int bytesRead = 0;
try
{
while((bytesRead = pis.read(buffer, 0, buffer.length)) != -1)
{
System.out.println(new String(buffer));
if (new String(buffer).equals("end")) break;
buffer = null;
buffer = new byte[1024];
}
pis.close();
buffer = null;
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
};
thread1.setDaemon(true);
thread2.setDaemon(true);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
}
Thread thread1 = new Thread()
{
public void run()
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try
{
while(true)
{
String message = br.readLine();
bw.write(message);
bw.newLine();
bw.flush();
if (message.equals("end")) break;
}
br.close();
pw.close();
bw.close();
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
};
Thread thread2 = new Thread()
{
public void run()
{
String line = null;
try
{
while((line = br.readLine()) != null)
{
System.out.println(line);
if (line.equals("end")) break;
}
br.close();
pr.close();
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
};
thread1.setDaemon(true);
thread2.setDaemon(true);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
}