------<a href="http://www.itheima.com" target="blank">Java培訓、Android培訓、iOS培訓、.Net培訓</a>、期待與您交流！ -------

要想了解執行緒，先了解程序的概念程序：

程序：是一個正在執行中的程式。每一個程序執行都有一個執行順序，該順序是一個執行路徑，或者叫一個控制單元。

1、執行緒的概念：

執行緒：就是程序中的一個獨立的控制單元，執行緒在控制著程序的執行；一個程序中至少有一個執行緒。

java中要想實現多執行緒，有兩種手段，

一種是繼續Thread類，另外一種是實現Runable介面。

通過繼承Thread類來建立執行緒的方法。類Thread1宣告為Thread的子類，它的構造方法定義執行緒名和起始引數。 

程式如下：

public class Thread1 extends Thread { 
     int k=0; 
     public Thread1(String name,int k)     { 
          super(name);         
           this.k = k;     } 
            public void run()                        //覆蓋run方法的執行緒體
             int i = k; 
           System.out.println(); 
           System.out.print(getName()+":  ");         while (i<50)         { 
            System.out.print(i+"  ");           
              i+=2;         } 
             System.out.println(getName() +"  end!");     } 
              public static void main (String args[])     { 
            Thread1 t1 = new Thread1("Thread1",1);     //建立執行緒物件       
              Thread1 t2 = new Thread1("Thread2",2);
               t1.start();                                //啟動執行執行緒     
               t2.start();
              System.out.println("activeCount="+t2.activeCount());     } }
 

2、建立執行緒的步驟： 

      1.定義一個類實現Runnable介面，重寫介面中的run()方法。在run()方法中加入具體的任務程式碼或處理邏輯。 

       2.建立Runnable介面實現類的物件。 

       3.建立一個Thread類的物件，需要封裝前面Runnable介面實現類的物件。（介面可以實現多繼承） 

       4.呼叫Thread物件的start()方法，啟動執行緒 

public class Thread1 extends Thread 
{ 
   int k=0; 
   public Thread1(String name,int k) 
   { 

     super(name); 
     this.k = k; 
  } 
 
public void run() 
 ｝
 

新狀態: 一個新產生的執行緒從新狀態開始了它的生命週期。它保持這個狀態知道程式start這個執行緒。

執行狀態:當一個新狀態的執行緒被start以後，執行緒就變成可執行狀態，一個執行緒在此狀態下被認為是開始執行其任務

就緒狀態:當一個執行緒等待另外一個執行緒執行一個任務的時候，該執行緒就進入就緒狀態。當另一個執行緒給就緒狀態的執行緒傳送訊號時，該執行緒才重新切換到執行狀態。

休眠狀態: 由於一個執行緒的時間片用完了，該執行緒從執行狀態進入休眠狀態。當時間間隔到期或者等待的時間發生了，該狀態的執行緒切換到執行狀態。

終止狀態: 一個執行狀態的執行緒完成任務或者其他終止條件發生，該執行緒就切換到終止狀態。

4、執行緒的使用：

4.1、建立一個執行緒，最簡單的方法是建立一個實現Runnable介面的類一個建立執行緒並開始讓它執行的例項：

// 建立一個新的執行緒
class NewThread implements Runnable {
   Thread t;
   NewThread() {
      // 建立第二個新執行緒
      t = new Thread(this, "Demo Thread");
      System.out.println("Child thread: " + t);
      t.start(); // 開始執行緒
   }
  
   // 第二個執行緒入口
   public void run() {
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Child Thread: " + i);
            // 暫停執行緒
            Thread.sleep(50);
         }
     } catch (InterruptedException e) {
         System.out.println("Child interrupted.");
     }
     System.out.println("Exiting child thread.");
   }
}
 
public class ThreadDemo {
   public static void main(String args[]) {
      new NewThread(); // 建立一個新執行緒
      try {
         for(int i = 5; i > 0; i--) {
           System.out.println("Main Thread: " + i);
           Thread.sleep(100);
         }
      } catch (InterruptedException e) {
         System.out.println("Main thread interrupted.");
      }
      System.out.println("Main thread exiting.");
   }
}

Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread.
Main Thread: 2
Main Thread: 1
Main thread exiting.

4.2、通過繼承Thread來建立執行緒：

建立一個執行緒的第二種方法是建立一個新的類，該類繼承Thread類，然後建立一個該類的例項。

繼承類必須重寫run()方法，該方法是新執行緒的入口點。它也必須呼叫start()方法才能執行。

// 通過繼承 Thread 建立執行緒
class NewThread extends Thread {
   NewThread() {
      // 建立第二個新執行緒
      super("Demo Thread");
      System.out.println("Child thread: " + this);
      start(); // 開始執行緒
   }
 
   // 第二個執行緒入口
   public void run() {
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Child Thread: " + i);
                            // 讓執行緒休眠一會
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Child interrupted.");
      }
      System.out.println("Exiting child thread.");
   }
}
 
public class ExtendThread {
   public static void main(String args[]) {
      new NewThread(); // 建立一個新執行緒
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Main Thread: " + i);
            Thread.sleep(100);
         }
      } catch (InterruptedException e) {
         System.out.println("Main thread interrupted.");
      }
      System.out.println("Main thread exiting.");
   }
}

Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread.
Main Thread: 2
Main Thread: 1
Main thread exiting.

有效利用多執行緒的關鍵是理解程式是併發執行而不是序列執行的。例如：程式中有兩個子系統需要併發執行，這時候就需要利用多執行緒程式設計。

通過對多執行緒的使用，可以編寫出非常高效的程式。不過請注意，如果建立太多的執行緒，程式執行的效率實際上是降低了，而不是提升了。

其中上下文的切換開銷也很重要，如果建立了太多的執行緒，CPU花費在上下文的切換的時間將多於執行程式的時間！

// 檔名 : DisplayMessage.java
// 通過實現 Runnable 介面建立執行緒
public class DisplayMessage implements Runnable
{
   private String message;
   public DisplayMessage(String message)
   {
      this.message = message;
   }
   public void run()
   {
      while(true)
      {
         System.out.println(message);
      }
   }
}
// 檔名 : GuessANumber.java
// 通過繼承 Thread 類建立執行緒

public class GuessANumber extends Thread
{
   private int number;
   public GuessANumber(int number)
   {
      this.number = number;
   }
   public void run()
   {
      int counter = 0;
      int guess = 0;
      do
      {
          guess = (int) (Math.random() * 100 + 1);
          System.out.println(this.getName()
                       + " guesses " + guess);
          counter++;
      }while(guess != number);
      System.out.println("** Correct! " + this.getName()
                       + " in " + counter + " guesses.**");
   }
}
// 檔名 : ThreadClassDemo.java
public class ThreadClassDemo
{
   public static void main(String [] args)
   {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
     
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();
 
      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try
      {
         thread3.join();
      }catch(InterruptedException e)
      {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
     
           thread4.start();
      System.out.println("main() is ending...");
   }
}

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Thread-2 guesses 27
Hello
** Correct! Thread-2 in 102 guesses.**
Hello
Starting thread4...
Hello
Hello
..........remaining result produced.

6、synchronized:

格式：
synchronized（物件）
{
需要同步的程式碼；
}

格式：
在函式上加上synchronized修飾符即可。

同步可以解決安全問題的根本原因就在那個物件上。
該物件如同鎖的功能。

6.1、同步特點： 

前提：多個執行緒 

解決問題注意：多個執行緒使用的是同一個鎖物件

6.2、同步好處： 

同步解決了多執行緒的安全問題

6.3、同步的弊端： 

當執行緒很多時，因為每個執行緒都會去判斷同步上的鎖，很消耗資源，降低程式的執行效率