JAVA培訓:Java 多線程編程

日期:2020-12-04 10:33作者:北大青鳥西安建大IT學院

摘要:Java 多線程編程 Java給多線程編程提供了內置的支持。一個多線程程序包含兩個或多個能并發運行的部分。程序的每一部分都稱作一個線程,并且每個線程定義了一個獨立的執行路徑。
關鍵詞: 西安北大青鳥 北大青鳥西安校區 陜西北大青鳥 北大青鳥java培訓

Java 多線程編程

Java給多線程編程提供了內置的支持。一個多線程程序包含兩個或多個能并發運行的部分。程序的每一部分都稱作一個線程,并且每個線程定義了一個獨立的執行路徑。

多線程是多任務的一種特別的形式。多線程比多任務需要更小的開銷。

這里定義和線程相關的另一個術語:進程:一個進程包括由操作系統分配的內存空間,包含一個或多個線程。一個線程不能獨立的存在,它必須是進程的一部分。一個進程一直運行,直到所有的非守候線程都結束運行后才能結束。

多線程能滿足程序員編寫非常有效率的程序來達到充分利用CPU的目的,因為CPU的空閑時間能夠保持在最低限度。


一個線程的生命周期

線程經過其生命周期的各個階段。下圖顯示了一個線程完整的生命周期。

線程

  • 新建狀態: 一個新產生的線程從新狀態開始了它的生命周期。它保持這個狀態直到程序start這個線程。

  • 運行狀態:當一個新狀態的線程被start以后,線程就變成可運行狀態,一個線程在此狀態下被認為是開始執行其任務

  • 就緒狀態:當一個線程等待另外一個線程執行一個任務的時候,該線程就進入就緒狀態。當另一個線程給就緒狀態的線程發送信號時,該線程才重新切換到運行狀態。

  • 休眠狀態: 由于一個線程的時間片用完了,該線程從運行狀態進入休眠狀態。當時間間隔到期或者等待的事件發生了,該狀態的線程切換到運行狀態。

  • 終止狀態: 一個運行狀態的線程完成任務或者其他終止條件發生,該線程就切換到終止狀態。


線程的優先級

每一個Java線程都有一個優先級,這樣有助于操作系統確定線程的調度順序。Java優先級在MIN_PRIORITY(1)和MAX_PRIORITY(10)之間的范圍內。默認情況下,每一個線程都會分配一個優先級NORM_PRIORITY(5)。

具有較高優先級的線程對程序更重要,并且應該在低優先級的線程之前分配處理器時間。然而,線程優先級不能保證線程執行的順序,而且非常依賴于平臺。


創建一個線程

Java提供了三種創建線程方法:

  • 通過實現Runnable接口;

  • 通過繼承Thread類本身;

  • 通過 Callable 和 Future 創建線程。


通過實現Runnable接口來創建線程

創建一個線程,最簡單的方法是創建一個實現Runnable接口的類。

為了實現Runnable,一個類只需要執行一個方法調用run(),聲明如下:

public void run()

你可以重寫該方法,重要的是理解的run()可以調用其他方法,使用其他類,并聲明變量,就像主線程一樣。

在創建一個實現Runnable接口的類之后,你可以在類中實例化一個線程對象。

Thread定義了幾個構造方法,下面的這個是我們經常使用的:

Thread(Runnable threadOb,String threadName);

這里,threadOb 是一個實現Runnable 接口的類的實例,并且 threadName指定新線程的名字。

新線程創建之后,你調用它的start()方法它才會運行。

void start();

實例

下面是一個創建線程并開始讓它執行的實例:

// 創建一個新的線程
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.

通過繼承Thread來創建線程

創建一個線程的第二種方法是創建一個新的類,該類繼承Thread類,然后創建一個該類的實例。

繼承類必須重寫run()方法,該方法是新線程的入口點。它也必須調用start()方法才能執行。該方法盡管被列為一種多線程實現方式,但是本質上也是實現了 Runnable 接口的一個實例。

實例

// 通過繼承 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.

Thread 方法

下表列出了Thread類的一些重要方法:

序號 方法描述
1 public void start() 
使該線程開始執行;Java 虛擬機調用該線程的 run 方法。
2 public void run() 
如果該線程是使用獨立的 Runnable 運行對象構造的,則調用該 Runnable 對象的 run 方法;否則,該方法不執行任何操作并返回。
3 public final void setName(String name) 
改變線程名稱,使之與參數 name 相同。
4 public final void setPriority(int priority) 
 更改線程的優先級。
5 public final void setDaemon(boolean on) 
將該線程標記為守護線程或用戶線程。
6 public final void join(long millisec) 
等待該線程終止的時間最長為 millis 毫秒。
7 public void interrupt() 
中斷線程。
8 public final boolean isAlive() 
測試線程是否處于活動狀態。

測試線程是否處于活動狀態。 上述方法是被Thread對象調用的。下面的方法是Thread類的靜態方法。

序號 方法描述
1 public static void yield() 
暫停當前正在執行的線程對象,并執行其他線程。
2 public static void sleep(long millisec) 
在指定的毫秒數內讓當前正在執行的線程休眠(暫停執行),此操作受到系統計時器和調度程序精度和準確性的影響。
3 public static boolean holdsLock(Object x) 
當且僅當當前線程在指定的對象上保持監視器鎖時,才返回 true。
4 public static Thread currentThread() 
返回對當前正在執行的線程對象的引用。
5 public static void dumpStack() 
將當前線程的堆棧跟蹤打印至標準錯誤流。

實例

如下的ThreadClassDemo 程序演示了Thread類的一些方法:

// 文件名 : 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 文件代碼:

// 文件名 : 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 文件代碼:

// 文件名 : 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
Starting thread3...
Hello
Hello
Starting thread4...
Hello
Hello
main() is ending...

通過 Callable 和 Future 創建線程

  • 1. 創建 Callable 接口的實現類,并實現 call() 方法,該 call() 方法將作為線程執行體,并且有返回值。
  • 2. 創建 Callable 實現類的實例,使用 FutureTask 類來包裝 Callable 對象,該 FutureTask 對象封裝了該 Callable 對象的 call() 方法的返回值。
  • 3. 使用 FutureTask 對象作為 Thread 對象的 target 創建并啟動新線程。
  • 4. 調用 FutureTask 對象的 get() 方法來獲得子線程執行結束后的返回值。

實例

public class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循環變量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的線程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子線程的返回值:"+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}

創建線程的三種方式的對比

  • 1. 采用實現 Runnable、Callable 接口的方式創建多線程時,線程類只是實現了 Runnable 接口或 Callable 接口,還可以繼承其他類。
  • 2. 使用繼承 Thread 類的方式創建多線程時,編寫簡單,如果需要訪問當前線程,則無需使用 Thread.currentThread() 方法,直接使用 this 即可獲得當前線程。

線程的幾個主要概念

在多線程編程時,你需要了解以下幾個概念:

  • 線程同步

  • 線程間通信

  • 線程死鎖

  • 線程控制:掛起、停止和恢復


多線程的使用

有效利用多線程的關鍵是理解程序是并發執行而不是串行執行的。例如:程序中有兩個子系統需要并發執行,這時候就需要利用多線程編程。

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

請記住,上下文的切換開銷也很重要,如果你創建了太多的線程,CPU花費在上下文的切換的時間將多于執行程序的時間!

 






轉載請保留本文網址http://www.emeias.com/qqwd/java/389.html
上一篇:JAVA培訓:Java 序列化
下一篇:JAVA培訓:Java Applet基礎
亚洲天堂www,天堂www网最新版资源,天堂va欧美va亚洲va好看va,天堂av在线观看免费 儿子你的好大啊给我吧| 儿子你的好大啊给我吧| 亚洲中文字幕永久在线| 666日本大胆艺术裸体| 午夜免费福利小电影| 亚洲中文av一区二区三区| 在线 偷拍 欧美 动漫| 真人试看做受120秒3分钟| >japantubeschoolHD| 扒开老师的粉嫩泬10p| 特级欧美午夜aa片| 女人喷液抽搐高潮视频| 国产婷婷综合在线视频| 粉嫩虎白女18p| 快穿吃肉一女多男| 无码纯肉视频在线观看| 色狠狠色噜噜噜综合网| 18禁止观看强奷无码视频| 亚洲精品中文字幕乱码| 国产成人av网站网址| 十分钟在线观看免费观看完整| 一级做人爱c视频正版免费| 边吃奶边扎下面动态| 午夜不卡无码中文字幕影院| 在线 亚洲 视频 小说| 久久精品国产免费播| 免费一本到手机在线| 欧美老熟妇欲乱高清视频| 精品久久久久久久久中文字幕| 白肥大腿岳| 国产99视频精品免费视看9| http://www.hlyq2017.com