2. 程式人生 > >【java多執行緒】執行緒常用操作方法總結

【java多執行緒】執行緒常用操作方法總結

阿新 • • 發佈：2019-01-07

文章目錄


多執行緒的主要操作方法都在Thread類中定義了。

執行緒的命名與獲取

      多線的的執行狀態是不確定的，那麼在程式的開發之中為了可以獲取一些需要使用執行緒就只能夠依靠執行緒的名字來進行操作。所以執行緒的名字是一個至關重要的概念，這樣在Thread類之中就提供有執行緒名稱的處理：

  • 建構函式
    ：public Thread （Runnable target,String name）;
  • 設定名字：public final void setName(String name);
  • 取得名字： public final String getName();
          對於執行緒物件的獲得是不可能只是依靠一個this來完成的，因為執行緒的狀態不可控，但是有一點是明確的，所有的執行緒一定要執行run（）方法，難麼這個時候可以考慮獲取當前執行緒，在Tread類中有獲取執行緒的方法：
  • 獲取當前執行緒： public static Thread currentThread（）;

範例： 觀察執行緒的命名操作

class MyThread implements Runnable {//執行緒主體類
    @Override
    public void run() {//執行緒的主體方法
        System.out.println(Thread.currentThread().getName());
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread mt  = new MyThread();
        new Thread(mt,"執行緒A").start();
        new Thread(mt).start();
        new Thread(mt,"執行緒B").start();
    }
}

      當開發者為執行緒設定名字的時候就使用這個設定的名字，而如果沒有設定名字就自動生成一個不重複的名字，這種自動的屬性命名主要是依靠static屬性完成的，在Thread類裡面有定義如下操作：

  private static int threadInitNumber;
    private static synchronized int nextThreadNum() {
        return threadInitNumber++;
    }

範例：觀察一個程式的執行

class MyThread implements Runnable {//執行緒主體類
    @Override
    public void run() {//執行緒的主體方法
        System.out.println(Thread.currentThread().getName());
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread mt  = new MyThread();
        new Thread(mt,"執行緒A").start();
        mt.run();
    }
}

輸出結果：

main
執行緒A

      通過此時的程式碼可以發現當使用了“mt.run()”直接在主方法之中呼叫執行緒類物件中的run（）方法，所獲得的執行緒的名字為“main”,所以可以的得出一個結論：主方法也是一個執行緒，那麼現在的問題來了，所有的執行緒都是在程序上的一個劃分，那麼程序在哪裡？每當使用java命令執行程式的時候就表示啟動了一個JVM的程序，一臺電腦上可以啟動若干個JVM程序，所以JVM的程序都會有個自的執行緒。
在這裡插入圖片描述
      在任何的開發之中，主執行緒可以建立若干個子執行緒，建立子執行緒的目的是可以將一些複雜邏輯或者比較耗時的程式處理：

範例：子執行緒的處理

public class ThreadDemo {
    public static void main(String[] args) {
        System.out.println("1、執行操作任務一");
        new Thread(() -> {
            int temp = 0;
            for(int x = 0 ; x < 10 ; x ++) {
                temp += x;
                System.out.println(temp);
            }
        }).start();
        System.out.println("2、執行操作任務二");
        System.out.println("N、執行操作任務N");
    }
}

主執行緒負責處理整體流程，而子執行緒負責處理耗時操作。

執行緒休眠

      如果說現在希望某一個執行緒可以暫緩執行，那麼就可以使用休眠的處理，在Thread中定義的休眠方法如下：

  • 休眠： public static void sleep(long millis) throws InterruptedException;
  • 休眠： public static void sleep(long millis,int nanos)throws InterruptedException;
          在進行休眠的時候，有可能會產生中斷異常“InterruptedException”，中斷異常屬於Exception的子類，所以該異常必須進行處理。

範例： 觀察休眠處理

public class ThreadDemo {
    public static void main(String[] args) {
        new Thread(() -> {
            for(int x = 0 ; x < 10 ; x ++) {
                System.out.println(Thread.currentThread().getName() + "、x = " + x);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        },"執行緒物件").start();
    }
}

      休眠的主要特點是可以自動實現執行緒的喚醒，以繼續進行後續的處理。但是需要注意的是，如果現在有多個執行緒物件，休眠也是有多個先後順序的。

**範例：**產生多個執行緒物件進行休眠處理。

public class ThreadDemo {
    public static void main(String[] args) {
        for( int i = 0; i < 5; i ++) {
            new Thread(() -> {
                for(int x = 0 ; x < 10 ; x ++) {
                    System.out.println(Thread.currentThread().getName() + "、x = " + x);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            },"執行緒物件 - " + i).start();
        }

    }
}

      此時將產生五個執行緒物件，並且這五個執行緒物件執行的方法體是相同的。此時從程式執行的感覺上來看是一起進行了休眠，而後一起進行了自動喚醒，但是實際上是有差別的。
在這裡插入圖片描述

執行緒中斷

      在之前發現執行緒的休眠裡面提供有一箇中斷異常，實際上就證明執行緒的休眠是可以打斷的，而這種打斷肯定是由其他執行緒完成的，在Thread類裡面提供有這種中斷執行的方法：

  • 判斷執行緒是否被中斷： public boolean isInterrupted();
  • 中斷執行緒執行： public void interrupt();

**範例：**觀察執行緒的中斷處理操作

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("*** 狂歡了72小時我需要睡覺");
            try {
                Thread.sleep(10000);  //睡眠10秒
                System.out.println("睡足了，要繼續初五禍害別人");
            } catch (InterruptedException e) {
                System.out.println("敢打擾老子睡覺，宰了你");
            }

        });
        thread.start();
        Thread.sleep(1000);
        if( !thread.isInterrupted()) {
            System.out.println("打擾你一下");
            thread.interrupt();
        }
    }
}

      所有正在執行的執行緒都是可以被中斷的，中斷執行緒必須進行異常處理。

執行緒強制執行

      所謂的執行緒的強制執行，指的當滿足某些條件之後，某一個執行緒物件將一直可以獨佔資源，一直到該執行緒的程式執行結束。
範例： 觀察一個沒有被強制執行的程式

public class TestThread {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
           for(int x = 0 ; x < 100 ; x ++) {
               System.out.println(Thread.currentThread().getName() + "、 x = " + x);
           }
        },"玩耍的執行緒");
        thread.start();
        for(int x = 0; x < 100; x ++) {
            System.out.println("【霸道的main主執行緒】 x = "+ x);
        }
    }
}

       這個時候主執行緒和子執行緒都在交替執行著，但是如果你希望主線獨佔執行。那麼就是利用Thread類中方法強制執行。

  • 強制執行：public final void join()throws InterruptedException;
    範例： 強制執行的程式碼示例
public class TestThread {
    public static void main(String[] args) {
        Thread mainThread = Thread.currentThread(); //獲得主執行緒
        Thread thread = new Thread(() -> {
           for(int x = 0 ; x < 100 ; x ++) {
               if(x == 3) {  //如果x == 3，就強制執行主執行緒
                   try {
                       mainThread.join();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
               System.out.println(Thread.currentThread().getName() + "、 x = " + x);
           }
        },"玩耍的執行緒");
        thread.start();
        for(int x = 0; x < 100; x ++) {
            System.out.println("【霸道的main主執行緒】 x = "+ x);
        }
    }
}

      在進行執行緒強制執行的時候，一定要獲取強制執行執行緒物件之後才可以執行join（）的呼叫。

執行緒禮讓

      執行緒的禮讓指的是先將執行緒的資源讓出去，讓別的執行緒先執行。執行緒的禮讓可以使用Thread中提供的方法：

  • 禮讓： public static void yield();

**範例：**使用禮讓操作

public class TestThread {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for(int x = 0 ; x < 100 ; x ++) {
                if(x % 3 == 0){
                    Thread.yield(); //執行緒禮讓
                    System.out.println("玩耍執行緒禮讓執行 ***********************");
                }
                System.out.println(Thread.currentThread().getName() + "、 x = " + x);
            }
        },"玩耍的執行緒");
        thread.start();
        for(int x = 0; x < 100; x ++) {
            System.out.println("【霸道的main主執行緒】 x = "+ x);
        }
    }
}

      禮讓執行的時候每一次呼叫yield（）方法都只會禮讓一次當前資源。

執行緒優先順序

      從理論上來講，執行緒的優先順序越高越有可能先執行（越有可能先搶佔到資源）。在Thread類李曼針對優先順序的操作有兩個操作方法：

  • 設定優先順序：public final void setPriority(int newPriority);
  • 獲取優先順序：public final int getPriority（）;
          在進行優先順序定義的時候都是通過int型的數字來完成的，而對於此數字的選擇在Thread類裡面就定義有三個常量：
  • 最高優先順序： public static final int MAX_PRIORITY;(10)
  • 中等優先順序： public static final int NORM_PRIORITY;(5)
  • 最低優先順序： public static final int MIN_PRIORITY;(1)

範例：觀察優先順序

public class ThreadDem {
    public static void main(String[] args) {
         Runnable run = () ->{
             for(int x = 0; x < 100; x ++) {
                 System.out.println(Thread.currentThread().getName() + "、 x = " + x);
             }
         };
        Thread threadA = new Thread(run,"執行緒物件A");
        Thread threadB = new Thread(run,"執行緒物件B");
        Thread threadC = new Thread(run,"執行緒物件C");
        threadA.setPriority(Thread.MIN_PRIORITY);
        threadB.setPriority(Thread.MIN_PRIORITY);
        threadC.setPriority(Thread.MAX_PRIORITY);
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

      主方法值一個主執行緒，那麼主執行緒的優先順序呢？

public class ThreadDem {
    public static void main(String[] args) {
        System.out.println("預設執行緒的優先順序：" + new Thread().getPriority());
        System.out.println("主方法執行緒優先順序：" + Thread.currentThread().getPriority());
}
}

輸出結果：

預設執行緒的優先順序：5
主方法執行緒優先順序：5

**      主執行緒是屬於中等優先順序，而預設建立的執行緒也是中等優先順序。
**

相關推薦

【java多執行緒】執行緒常用操作方法總結

文章目錄 執行緒的命名與獲取 執行緒休眠 執行緒中斷 執行緒強制執行 執行緒禮讓 執行緒優先順序 多執行緒的主要操作方法都在Thread類中定義了。 執行緒的

【java併發程式設計實戰】—–執行緒基本概念

轉自 http://cmsblogs.com/?p=1638 共享和可變 要編寫執行緒安全的程式碼，其核心在於對共享的和可變的狀態進行訪問。 “共享”就意味著變數可以被多個執行緒同時訪問。我們知道系統中的資源是有限的，不同的執行緒對資源都是具有著同等的使用權。有限、公平就意味著競爭

【JAVA與C#比較】執行緒

1.java中執行緒更多體現的是類的思想，所以可以通過繼承Thread類，和實現Runnable介面來建立執行緒。使用繼承Thread類的方法來建立執行緒類時，多個執行緒間無法共享執行緒類的例項變數。而

【java多線程】多線程的創建三種方式--筆記

admin auth nbsp 主線程 實現類 如果 nts 名稱 就是 申明：線程的概念以及進程的相關概念，可以參考網絡上其他資料，這裏只討論多線程是怎麽實現。 一、多線程的簡單理解 明白什麽是多線程，小生通俗一點的理解為：在一個程序裏，我想同時讓這個程序完成多個任務

【java多線程】（3）---synchronized、Lock

arraylist arr nal 調用 BE [] div 請求 timeunit synchronized、Lock 一、概述 1、出現線程不安全的原因是什麽？ 如果我們創建的多個線程，存在著共享數據，那麽就有可能出現線程的安全問題：當其中一個

【Java多線程】AtomicLong和LongAdder

fan cor 新的 fps get 答案 ext 進行 方式 AtomicLong簡要介紹 AtomicLong是作用是對長整形進行原子操作，顯而易見，在java1.8中新加入了一個新的原子類LongAdder，該類也可以保證Long類型操作的原子性，相對於Atomic

Java IO流常用操作方法總結

一、簡介 在實際工作中，基本上每個專案難免都會有檔案相關的操作，比如檔案上傳、檔案下載等，這些操作都是使用IO流進行操作的，本文將通過簡單的示例對常用的一些IO流進行總結。 二、使用詳解 【a】FileInputStream與FileOutputStream 首先通過檢視jdk文件，

【Java多執行緒】執行緒狀態、執行緒池狀態

執行緒狀態：     執行緒共包括以下5種狀態。1. 新建狀態(New)　　執行緒物件被建立後，就進入了新建狀態。例如，Thread thread = new Thread()。2. 就緒狀態(Runnable)　　也被稱為“可執行狀態”。執行緒物件被建立後，

【Java多執行緒】ReentrantReadWriteLock

概述 　　ReentrantReadWriteLock是Lock的另一種實現方式，ReentrantLock是一個排他鎖，同一時間只允許一個執行緒訪問，而ReentrantReadWriteLock允許多個讀執行緒同時訪問，但不允許寫執行緒和讀執行緒、寫執行緒和寫執行緒同時訪問。相對於排他鎖，提高了併發性。

【JAVA多執行緒問題之死鎖】

  一、死鎖是什麼？ 舉個例子：兩個人一起吃飯，每個人都拿了一隻筷子，雙方都在等待對方將筷子讓給自己，結果兩個人都吃不了飯。這種情況和計算機中的死鎖情況很相似。 假設有兩個執行緒，互相等待對方釋放佔有的鎖，但是釋放鎖的條件又不可能形成，這時候死鎖就形成了。 還是買票的問題，有的時候時會發生死

【Java多執行緒併發總結】Thread類的常用方法(join、yield等)---執行緒的基礎操作篇

 啟動(start)   最基本的操作，呼叫Runnable中的run方法，無返回值。 new Thread(new Test()).start(); 休眠(sleep)  使當前執行緒休眠一段時間，預設為毫秒級，最高可以精確到納秒，呼叫的方法為slee

【Java多執行緒程式設計核心技術】第一章(多執行緒技能suspend,resume,yield)

1.8 暫停執行緒      在多執行緒中，suspend是暫停執行緒，resume是恢復執行緒的執行． 　１.8.1suspend方法和resume方法的使用 public class MyThread extends Thread { private lon

【Java多執行緒程式設計核心技術】第一章(多執行緒技能 執行緒的優先順序)

1.8　執行緒的優先順序 　在作業系統中，執行緒可以劃分優先順序，優先順序較高的執行緒得到的cpu的資源較多，也就是cpu優先執行優先順序較高的執行緒物件中的任務． 　在Java中，執行緒優先順序分為1~10個等級，如果小於1大於10，則JDK丟擲異常,原始碼如下:

【JAVA多執行緒】如何解決一個生產者與消費者問題

                             如何解決一個生產者與消費者問題 生產者與消費者問題是多執行緒同步的一個經典問題。生產者和消費者同時使用一塊緩衝區，生產者生產商品放入緩衝區，消費者從緩衝區中取出商品。我們需要保證的是，當緩衝區滿時，生產者不可生產商品

輸出三角形【 Java 多執行緒 】

題目： 利用多執行緒輸出兩個三角形，要求控制兩個執行緒的發生，判斷第一個執行緒是否結束。 並且在第一個執行緒沒結束時，使用 sleep 方法或者 join 方法。 1、sleep 方法。 public class Main { public static

各視窗共同賣票 【 Java 多執行緒 】

現實中也存在這樣的情況： 模擬一個火車站的售票系統，假如當日從A地發往B地的火車票只有10張，且允許所有視窗賣這10張票，每一個視窗也相當於一個執行緒。 1、Runnable介面實現 public class Main { public static void

各視窗單獨賣票 【 Java 多執行緒 】

多視窗賣票，需求如下： 假設一個影院有三個售票口，分別用於向兒童、成人和老人售票。 影院為每個視窗放有10張電影票，分別是兒童票、成人票和老人票。 三個視窗需要同時賣票， 而現在只有一個售票員，這個售票員就相當於一個CPU，三個視窗就相當於三個執行緒。 1 通過擴充套件T

【Java 單例模式】Java 單例模式在多執行緒環境中可能存在的問題

在多執行緒環境下，使用延遲載入的方式實現單例模式，會出現錯誤。 例如，使用如下方式實現單例類： package study20170307; /** * Created by apple on 17/3/7. */ public class Sin

【java多執行緒】守護執行緒、執行緒停止、volatile的深入瞭解

文章目錄 執行緒的優雅停止 守護執行緒 volatile關鍵字 執行緒的優雅停止       在多執行緒的操作之中如果要啟動多執

【Java多執行緒】執行緒池的工作原理詳解（下）

接著上篇文章，我接下來繼續介紹執行緒池的工作原理，如果你還沒有看上篇，我建議最好瀏覽一下：執行緒池的工作原理詳解（上） Executors 工具類 1.定義 Executors是java執行緒池的工廠類，通過它可以快速初始化一個符合業務需求的執行緒池。