學習java的同學注意了?。?！ 學習過程中遇到什么問題或者想獲取學習資源的話，歡迎加入Java學習交流群，群號碼：523047986 我們一起學Java！
在這篇文章里，我們關注多線程。多線程是一個復雜的話題，包含了很多內容，這篇文章主要關注線程的基本屬性、如何創建線程、線程的狀態切換以及線程通信，我們把線程同步的話題留到下一篇文章中。
線程是操作系統運行的基本單位，它被封裝在進程中，一個進程可以包含多個線程。即使我們不手動創造線程，進程也會有一個默認的線程在運行。
對于JVM來說，當我們編寫一個單線程的程序去運行時，JVM中也是有至少兩個線程在運行，一個是我們創建的程序，一個是垃圾回收。
線程基本信息
我們可以通過Thread.currentThread()方法獲取當前線程的一些信息，并對其進行修改。
我們來看以下代碼：
1 String name = Thread.currentThread().getName(); 2 int PRiority = Thread.currentThread().getPriority(); 3 String groupName = Thread.currentThread().getThreadGroup().getName(); 4 boolean isDaemon = Thread.currentThread().isDaemon(); 5 System.out.println("Thread Name:" + name); 6 System.out.println("Priority:" + priority); 7 System.out.println("Group Name:" + groupName); 8 System.out.println("IsDaemon:" + isDaemon); 9 10 Thread.currentThread().setName("Test");11 Thread.currentThread().setPriority(Thread.MAX_PRIORITY);12 name = Thread.currentThread().getName();13 priority = Thread.currentThread().getPriority();14 groupName = Thread.currentThread().getThreadGroup().getName();15 isDaemon = Thread.currentThread().isDaemon();16 System.out.println("Thread Name:" + name);17 System.out.println("Priority:" + priority);其中列出的屬性說明如下：
GroupName，每個線程都會默認在一個線程組里，我們也可以顯式的創建線程組，一個線程組中也可以包含子線程組，這樣線程和線程組，就構成了一個樹狀結構。Name，每個線程都會有一個名字，如果不顯式指定，那么名字的規則是“Thread-xxx”。Priority，每個線程都會有自己的優先級，JVM對優先級的處理方式是“搶占式”的。當JVM發現優先級高的線程時，馬上運行該線程；對于多個優先級相等的線程，JVM對其進行輪詢處理。Java的線程優先級從1到10，默認是5，Thread類定義了2個常量：MIN_PRIORITY和MAX_PRIORITY來表示最高和最低優先級。我們可以看下面的代碼，它定義了兩個不同優先級的線程：1 public static void priorityTest() 2 { 3 Thread thread1 = new Thread("low") 4 { 5 public void run() 6 { 7 for (int i = 0; i < 5; i++) 8 { 9 System.out.println("Thread 1 is running.");10 }11 }12 };13 14 Thread thread2 = new Thread("high")15 {16 public void run()17 {18 for (int i = 0; i < 5; i++)19 {20 System.out.println("Thread 2 is running.");21 }22 }23 };24 25 thread1.setPriority(Thread.MIN_PRIORITY);26 thread2.setPriority(Thread.MAX_PRIORITY);27 thread1.start();28 thread2.start();29 }從運行結果可以看出，是高優先級線程運行完成后，低優先級線程才運行。isDaemon，這個屬性用來控制父子線程的關系，如果設置為true，當父線程結束后，其下所有子線程也結束，反之，子線程的生命周期不受父線程影響。我們來看下面的例子：
1 public static void daemonTest() 2 { 3 Thread thread1 = new Thread("daemon") 4 { 5 public void run() 6 { 7 Thread subThread = new Thread("sub") 8 { 9 public void run()10 {11 for(int i = 0; i < 100; i++)12 {13 System.out.println("Sub Thread Running " + i);14 }15 }16 };17 subThread.setDaemon(true);18 subThread.start();19 System.out.println("Main Thread end.");20 }21 };22 23 thread1.start();24 }上面代碼的運行結果，在和刪除subThread.setDaemon(true);后對比，可以發現后者運行過程中子線程會完成執行后再結束，而前者中，子線程很快就結束了。
如何創建線程
上面的內容，都是演示默認線程中的一些信息，那么應該如何創建線程呢？在Java中，我們有3種方式可以用來創建線程。
Java中的線程要么繼承Thread類，要么實現Runnable接口，我們一一道來。
使用內部類來創建線程
我們可以使用內部類的方式來創建線程，過程是聲明一個Thread類型的變量，并重寫run方法。示例代碼如下：
1 public static void createThreadByNestClass() 2 { 3 Thread thread = new Thread() 4 { 5 public void run() 6 { 7 for (int i =0; i < 5; i++) 8 { 9 System.out.println("Thread " + Thread.currentThread().getName() + " is running.");10 }11 System.out.println("Thread " + Thread.currentThread().getName() + " is finished.");12 }13 };14 thread.start();15 }繼承Thread以創建線程
我們可以從Thread中派生一個類，重寫其run方法，這種方式和上面相似。示例代碼如下：
1 class MyThread extends Thread 2 { 3 public void run() 4 { 5 for (int i =0; i < 5; i++) 6 { 7 System.out.println("Thread " + Thread.currentThread().getName() + " is running."); 8 } 9 System.out.println("Thread " + Thread.currentThread().getName() + " is finished.");10 }11 }12 13 14 public static void createThreadBySubClass()15 {16 MyThread thread = new MyThread();17 thread.start();18 }實現Runnable接口以創建線程
我們可以定義一個類，使其實現Runnable接口，然后將該類的實例作為構建Thread變量構造函數的參數。示例代碼如下：
1 class MyRunnable implements Runnable 2 { 3 public void run() 4 { 5 for (int i =0; i < 5; i++) 6 { 7 System.out.println("Thread " + Thread.currentThread().getName() + " is running."); 8 } 9 System.out.println("Thread " + Thread.currentThread().getName() + " is finished.");10 }11 }12 13 14 public static void createThreadByRunnable()15 {16 MyRunnable runnable = new MyRunnable();17 Thread thread = new Thread(runnable);18 thread.start();19 }上述3種方式都可以創建線程，而且從示例代碼上看，線程執行的功能是一樣的，那么這三種創建方式有什么不同呢？
這涉及到Java中多線程的運行模式，對于Java來說，多線程在運行時，有“多對象多線程”和“單對象多線程”的區別：
多對象多線程，程序在運行過程中創建多個線程對象，每個對象上運行一個線程。單對象多線程，程序在運行過程中創建一個線程對象，在其上運行多個線程。顯然，從線程同步和調度的角度來看，多對象多線程要簡單一些。上述3種線程創建方式，前兩種都屬于“多對象多線程”，第三種既可以使用“多對象多線程”，也可以使用“單對象單線程”。
我們來看下面的示例代碼，里面會用到Object.notify方法，這個方法會喚醒對象上的一個線程；而Object.notifyAll方法，則會喚醒對象上的所有線程。
1 public class NotifySample { 2 3 public static void main(String[] args) throws InterruptedException 4 { 5 notifyTest(); 6 notifyTest2(); 7 notifyTest3(); 8 } 9 10 private static void notifyTest() throws InterruptedException 11 { 12 MyThread[] arrThreads = new MyThread[3]; 13 for (int i = 0; i < arrThreads.length; i++) 14 { 15 arrThreads[i] = new MyThread(); 16 arrThreads[i].id = i; 17 arrThreads[i].setDaemon(true); 18 arrThreads[i].start(); 19 } 20 Thread.sleep(500); 21 for (int i = 0; i < arrThreads.length; i++) 22 { 23 synchronized(arrThreads[i]) 24 { 25 arrThreads[i].notify(); 26 } 27 } 28 } 29 30 private static void notifyTest2() throws InterruptedException 31 { 32 MyRunner[] arrMyRunners = new MyRunner[3]; 33 Thread[] arrThreads = new Thread[3]; 34 for (int i = 0; i < arrThreads.length; i++) 35 { 36 arrMyRunners[i] = new MyRunner(); 37 arrMyRunners[i].id = i; 38 arrThreads[i] = new Thread(arrMyRunners[i]); 39 arrThreads[i].setDaemon(true); 40 arrThreads[i].start(); 41 } 42 Thread.sleep(500); 43 for (int i = 0; i < arrMyRunners.length; i++) 44 { 45 synchronized(arrMyRunners[i]) 46 { 47 arrMyRunners[i].notify(); 48 } 49 } 50 } 51 52 private static void notifyTest3() throws InterruptedException 53 { 54 MyRunner runner = new MyRunner(); 55 Thread[] arrThreads = new Thread[3]; 56 for (int i = 0; i < arrThreads.length; i++) 57 { 58 arrThreads[i] = new Thread(runner); 59 arrThreads[i].setDaemon(true); 60 arrThreads[i].start(); 61 } 62 Thread.sleep(500); 63 64 synchronized(runner) 65 { 66 runner.notifyAll(); 67 } 68 } 69 } 70 71 class MyThread extends Thread 72 { 73 public int id = 0; 74 public void run() 75 { 76 System.out.println("第" + id + "個線程準備休眠5分鐘。"); 77 try 78 { 79 synchronized(this) 80 { 81 this.wait(5*60*1000); 82 } 83 } 84 catch(InterruptedException ex) 85 { 86 ex.printStackTrace(); 87 } 88 System.out.println("第" + id + "個線程被喚醒。"); 89 } 90 } 91 92 class MyRunner implements Runnable 93 { 94 public int id = 0; 95 public void run() 96 { 97 System.out.println("第" + id + "個線程準備休眠5分鐘。"); 98 try 99 {100 synchronized(this)101 {102 this.wait(5*60*1000);103 }104 }105 catch(InterruptedException ex)106 {107 ex.printStackTrace();108 }109 System.out.println("第" + id + "個線程被喚醒。");110 }111 112 }示例代碼中，notifyTest()和notifyTest2()是“多對象多線程”，盡管notifyTest2()中的線程實現了Runnable接口，但是它里面定義Thread數組時，每個元素都使用了一個新的Runnable實例。notifyTest3()屬于“單對象多線程”，因為我們只定義了一個Runnable實例，所有的線程都會使用這個實例。
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對象上使用這兩個方法。
線程的休眠與喚醒
1 public class SleepSample { 2 3 public static void main(String[] args) throws InterruptedException 4 { 5 sleepTest(); 6 } 7 8 private static void sleepTest() throws InterruptedException 9 {10 Thread thread = new Thread()11 {12 public void run()13 {14 System.out.println("線程 " + Thread.currentThread().getName() + "將要休眠5分鐘。");15 try16 {17 Thread.sleep(5*60*1000);18 }19 catch(InterruptedException ex)20 {21 System.out.println("線程 " + Thread.currentThread().getName() + "休眠被中斷。");22 }23 System.out.println("線程 " + Thread.currentThread().getName() + "休眠結束。");24 }25 };26 thread.setDaemon(true);27 thread.start();28 Thread.sleep(500);29 thread.interrupt();30 }31 32 }線程在休眠過程中，我們可以使用Thread.interrupt將其喚醒，這時線程會拋出InterruptedException。
線程的終止
雖然有Thread.stop方法，但該方法是不被推薦使用的，我們可以利用上面休眠與喚醒的機制，讓線程在處理IterruptedException時，結束線程。
1 public class StopThreadSample { 2 3 public static void main(String[] args) throws InterruptedException 4 { 5 stopTest(); 6 } 7 8 private static void stopTest() throws InterruptedException 9 {10 Thread thread = new Thread()11 {12 public void run()13 {14 System.out.println("線程運行中。");15 try16 {17 Thread.sleep(1*60*1000);18 }19 catch(InterruptedException ex)20 {21 System.out.println("線程中斷，結束線程");22 return;23 }24 System.out.println("線程正常結束。");25 }26 };27 thread.start();28 Thread.sleep(500);29 thread.interrupt();30 }31 }線程的同步等待
當我們在主線程中創建了10個子線程，然后我們期望10個子線程全部結束后，主線程在執行接下來的邏輯，這時，就該Thread.join登場了。
1 public class JoinSample { 2 3 public static void main(String[] args) throws InterruptedException 4 { 5 joinTest(); 6 } 7 8 private static void joinTest() throws InterruptedException 9 {10 Thread thread = new Thread()11 {12 public void run()13 {14 try15 {16 for(int i = 0; i < 5; i++)17 {18 System.out.println("線程在運行。");19 Thread.sleep(1000);20 }21 }22 catch(InterruptedException ex)23 {24 ex.printStackTrace();25 }26 }27 };28 thread.setDaemon(true);29 thread.start();30 Thread.sleep(1000);31 thread.join();32 System.out.println("主線程正常結束。");33 }34 }我們可以試著將thread.join();注釋或者刪除，再次運行程序，就可以發現不同了。
線程間通信
我們知道，一個進程下面的所有線程是共享內存空間的，那么我們如何在不同的線程之間傳遞消息呢？在回顧 Java I/O時，我們談到了PipedStream和PipedReader，這里，就是它們發揮作用的地方了。
下面的兩個示例，功能完全一樣，不同的是一個使用Stream，一個使用Reader/Writer。
1 public static void communicationTest() throws IOException, InterruptedException 2 { 3 final PipedOutputStream pos = new PipedOutputStream(); 4 final PipedInputStream pis = new PipedInputStream(pos); 5 6 Thread thread1 = new Thread() 7 { 8 public void run() 9 {10 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));11 try12 {13 while(true)14 {15 String message = br.readLine();16 pos.write(message.getBytes());17 if (message.equals("end")) break;18 }19 br.close();20 pos.close();21 }22 catch(Exception ex)23 {24 ex.printStackTrace();25 }26 }27 };28 29 Thread thread2 = new Thread()30 {31 public void run()32 {33 byte[] buffer = new byte[1024];34 int bytesRead = 0;35 try36 {37 while((bytesRead = pis.read(buffer, 0, buffer.length)) != -1)38 {39 System.out.println(new String(buffer));40 if (new String(buffer).equals("end")) break;41 buffer = null;42 buffer = new byte[1024];43 }44 pis.close();45 buffer = null;46 }47 catch(Exception ex)48 {49 ex.printStackTrace();50 }51 }52 };53 54 thread1.setDaemon(true);55 thread2.setDaemon(true);56 thread1.start();57 thread2.start();58 thread1.join();59 thread2.join();60 }1 private static void communicationTest2() throws InterruptedException, IOException 2 { 3 final PipedWriter pw = new PipedWriter(); 4 final PipedReader pr = new PipedReader(pw); 5 final BufferedWriter bw = new BufferedWriter(pw); 6 final BufferedReader br = new BufferedReader(pr); 7 8 Thread thread1 = new Thread() 9 {10 public void run()11 {12 13 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));14 try15 {16 while(true)17 {18 String message = br.readLine();19 bw.write(message);20 bw.newLine();21 bw.flush();22 if (message.equals("end")) break;23 }24 br.close();25 pw.close();26 bw.close();27 }28 catch(Exception ex)29 {30 ex.printStackTrace();31 }32 }33 };34 35 Thread thread2 = new Thread()36 {37 public void run()38 {39 40 String line = null;41 try42 {43 while((line = br.readLine()) != null)44 {45 System.out.println(line);46 if (line.equals("end")) break;47 }48 br.close();49 pr.close();50 }51 catch(Exception ex)52 {53 ex.printStackTrace();54 }55 }56 };57 58 thread1.setDaemon(true);59 thread2.setDaemon(true);60 thread1.start();61 thread2.start();62 thread1.join();63 thread2.join();64 }
這篇文章就到這里，我們會在下一篇里，討論同步的話題。
學習Java的同學注意了?。?！ 學習過程中遇到什么問題或者想獲取學習資源的話，歡迎加入Java學習交流群，群號碼：523047986 我們一起學Java！
新聞熱點
疑難解答
