2. 程式人生 > >Java之多執行緒的常用操作

Java之多執行緒的常用操作

阿新 • • 發佈：2018-12-22

執行緒命名與取得

在Thread類中提供有如下的執行緒名稱方法：
在這裡插入圖片描述
在Thread類中還提供有一個方法取得當前執行緒物件：

public static native Thread currentThread();

範例：設定和取得執行緒的名稱

class MyThread implements Runnable{
    @Override
    public void run() {
       for(int i=0;i<2;i++){
           System.out.println(Thread.currentThread().getName()+" "+i);
       }
    }
}
class Test{
    public static void main(String[] args){
     MyThread myThread=new MyThread();

     //直接通過物件呼叫run()方法
     new Thread(myThread).run();
     
     //通過執行緒呼叫run()方法
    Thread thread=new Thread(myThread,"執行緒1");//構造方法設定名字
    thread.start();
    thread.setName("A");//普通方法設定名字
    System.out.println(thread.getName());
    new Thread(myThread).start();//沒有設定名字
    new Thread(myThread).start();//沒有設定名字
    }
}

執行結果：
在這裡插入圖片描述
觀察上面程式碼，總結：
1.如果沒有設定執行緒名字，則會自動分配一個執行緒名字，執行緒啟動之後也可以改變執行緒的名字
2.主方法本身就是一個執行緒，所以執行緒都是通過主執行緒建立並啟動的。

執行緒休眠(sleep())

執行緒休眠：指的是讓執行緒暫緩執行一下，等到了預計時間之後再恢復執行.執行緒休眠會交出CPU，讓CPU去執行其他的任務。但是有一點要非常注意，sleep方法不會釋放鎖，也就是說如果當前執行緒持有對某個物件的鎖，則即使呼叫sleep方法，其他執行緒也無法訪問這個物件。
從執行態到阻塞態，休眠結束後從阻塞狀態到執行狀態
方法：

public static native void sleep(long millis) throws InterruptedException

休眠時間使用毫秒作為單位。
範例：實現休眠操作

class MyThread implements Runnable{
    @Override
    public void run() {
       for(int i=0;i<10;i++){
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println(Thread.currentThread().getName()+" "+i);
       }
    }
}
class Test{
    public static void main(String[] args){
     MyThread myThread=new MyThread();
    new Thread(myThread).start();
    new Thread(myThread).start();
    }
}

執行結果：一個執行緒不會連續列印
在這裡插入圖片描述

執行緒讓步(yield())

暫停當前正在執行的執行緒物件，並執行其他執行緒。意思就是呼叫yield方法會讓當前執行緒交出CPU許可權，讓CPU去執行其他的執行緒。它跟sleep方法類似，同樣不會釋放鎖。但是yield不能控制具體的交出CPU的時間，另外，yield方法只能讓擁有相同優先順序的執行緒有獲取CPU執行時間的機會。從執行狀態返回到就緒狀態
範例：使用執行緒讓步

class MyThread implements Runnable{
    @Override
    public void run() {
       for(int i=0;i<5;i++){
           Thread.yield();
           System.out.println(Thread.currentThread().getName()+" "+i);
       }
    }
}
class Test{
    public static void main(String[] args){
     MyThread myThread=new MyThread();
    new Thread(myThread).start();
    new Thread(myThread).start();
    }
}

執行結果：一個執行緒會連續列印
在這裡插入圖片描述
注意，呼叫yield方法並不會讓執行緒進入阻塞狀態，而是讓執行緒重回就緒狀態，它只需要等待重新獲取CPU執行時間，會立馬交出CPU，這一點是和sleep方法不一樣的。

等待其他方法終止( join())

等待其他執行緒終止。意思就是如果在主執行緒中呼叫該方法時就會讓主執行緒休眠，讓呼叫該方法的執行緒run方法先執行完畢之後在開始執行主執行緒。
從執行態到阻塞態，會釋放物件鎖，其他方法執行完畢之後從阻塞態到就緒態
join()方法只是對Object類提供的wai()方法做了一層包裝而已。
範例：使用join()方法

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println("主執行緒休眠。。。。");
        Test.printTime();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主執行緒休眠結束。。。。");
        Test.printTime();
    }
}
class Test{
    public static void main(String[] args){
        System.out.println("主執行緒開始。。。。");
        MyThread myThread=new MyThread();
        Thread thread=new Thread(myThread,"子執行緒");
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主執行緒結束。。。。");
    }
    public static void printTime(){
        Date date=new Date();
        DateFormat dateFormat=new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
        String str=dateFormat.format(date);
        System.out.println(str);
    }
}

執行結果：
在這裡插入圖片描述

執行緒停止

多執行緒中有三種方式可以停止執行緒。

設定標記位，可以是執行緒正常退出。

範例：使用標記位使執行緒退出

class MyThread implements Runnable{
    private boolean flag=true;
    @Override
    public void run() {
        int i=1;
       while(flag){
           System.out.println(Thread.currentThread().getName()+"第"+i+"次執行");
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           i++;
       }
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}
class Test{
    public static void main(String[] args){
        MyThread myThread=new MyThread();
        Thread thread=new Thread(myThread,"A");
        thread.start();
        //主執行緒睡5秒鐘
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //設定子執行緒flag為false，結束執行緒
        myThread.setFlag(false);
    }
}

執行結果:
在這裡插入圖片描述

stop()

呼叫Thread類的stop方法強制使執行緒退出，但是該方法不太安全所以已經被廢棄了。
**為什麼說不安全呢？**因為stop會解除由執行緒獲取的所有鎖定，當在一個執行緒物件上呼叫stop()方法時，這個執行緒物件所執行的執行緒就會立即停止，假如一個執行緒正在執行：synchronized void { x = 3; y = 4;} 由於方法是同步的，多個執行緒訪問時總能保證x,y被同時賦值，而如果一個執行緒正在執行到x = 3;時，被呼叫了 stop()方法，即使在同步塊中，它也會馬上stop了，這樣就產生了不完整的殘廢資料。

interrupt()

使用Thread類中的一個interrupt() 可以中斷執行緒。 interrupt()只是將執行緒狀態設定為中斷狀態而已，他不會中斷一個正在執行的執行緒。此方法只是給執行緒傳遞一箇中斷訊號，程式可以根據此訊號來判斷是否需要終止。
範例：

class MyThread implements Runnable{

    @Override
    public void run() {
        int i=1;
       while(true){
       //判斷執行緒是否被中斷
           boolean bool=Thread.currentThread().isInterrupted();
           System.out.println(Thread.currentThread().getName()+"第"+i+"次執行");
           System.out.println(bool);
           //如果執行緒中斷，手動退出執行緒（如果不手動退出，系統可能不會是執行緒退出）
           if(bool){
               System.out.println("執行緒退出");
               break;
           }
           i++;
       }
    }
}
class Test{
    public static void main(String[] args){
        MyThread myThread=new MyThread();
        Thread thread=new Thread(myThread,"A");
        thread.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();
    }
}

執行結果：interrupt() 方法只是改變中斷狀態而已，它不會中斷一個正在執行的執行緒。
在這裡插入圖片描述

當執行緒中使用了wait、sleep、join方法導致此執行緒阻塞，則interrupt()會線上程中丟擲InterruptException，並且將執行緒的中斷狀態由true置為false。
範例：

class MyThread implements Runnable{

    @Override
    public void run() {
        int i=1;
       while(true){
           try {
               Thread.sleep(1000);
               boolean bool=Thread.currentThread().isInterrupted();
               if(bool){
                   System.out.println("執行緒退出");
                   break;
               }
               System.out.println(Thread.currentThread().getName()+"第"+i+"次執行");
               System.out.println(bool);
               i++;
           } catch (InterruptedException e) {
               System.out.println("異常丟擲，執行緒停止");
               boolean bool=Thread.currentThread().isInterrupted();
               System.out.println("Catch塊中中斷為"+bool);
               return ;
           }
       }
    }
}
class Test{
    public static void main(String[] args)throws InterruptedException {
        MyThread myThread=new MyThread();
        Thread thread=new Thread(myThread,"A");
        thread.start();
        Thread.sleep(3000);

        thread.interrupt();
    }
}

執行結果:
在這裡插入圖片描述

執行緒優先順序

執行緒優先順序是指優先順序越高就有可能先執行，但是僅僅是有可能而已！！！

  • 設定優先順序
  public final void setPriority(int newPriority);
  • 取得優先順序
public final int getPriority();

對於優先順序設定的內容可以通過Thread類的幾個常量來決定

1. 最高優先順序：public final static int MAX_PRIORITY = 10;
2. 中等優先順序：public final static int NORM_PRIORITY = 5;
3. 最低優先順序：public final static int MIN_PRIORITY = 1;

範例：優先順序的設定與獲取

class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"執行緒正在執行");
    }
}
class Test{
    public static void main(String[] args)throws InterruptedException {
        MyThread myThread=new MyThread();
        //得到主方法的執行緒優先順序
        System.out.println(Thread.currentThread().getPriority());
        Thread thread1=new Thread(myThread,"A");
        Thread thread2=new Thread(myThread,"B");
        Thread thread3=new Thread(myThread,"C");
        thread1.setPriority(Thread.MIN_PRIORITY);
        thread2.setPriority(Thread.NORM_PRIORITY);
        thread3.setPriority(Thread.MAX_PRIORITY);
        System.out.println("A的執行緒優先順序"+thread1.getPriority());
        System.out.println("B的執行緒優先順序"+thread2.getPriority());
        System.out.println("C的執行緒優先順序"+thread3.getPriority());
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

執行結果：
在這裡插入圖片描述
觀察上述程式碼的執行結果，我們發現主執行緒只是一個普通中等優先順序而已，最主要的是，雖然設計了A、B、C執行緒的優先順序從小到大但是執行緒在執行的時候並沒有按照這個優先順序的順序來執行。
執行緒具有繼承性：只是繼承優先順序而已（從A執行緒啟動B執行緒，則B和A的執行緒優先順序是一樣的）
範例：觀察執行緒的繼承性

class A implements Runnable{

    @Override
    public void run() {
        System.out.println("A的優先順序"+Thread.currentThread().getPriority());
        Thread thread=new Thread(new B());
        thread.start();
    }
}
class B implements Runnable{
    @Override
    public void run() {
        System.out.println("B的優先順序"+Thread.currentThread().getPriority());
    }
}
class Test{
    public static void main(String[] args)throws InterruptedException {
       A a=new A();
       Thread thread=new Thread(a);
       thread.setPriority(Thread.MAX_PRIORITY);
       thread.start();
    }
}

執行結果：在沒有設定執行緒A的優先順序之前，A和B的優先順序都是5，因為A繼承了主執行緒的優先順序，B又繼承了A的優先順序
在這裡插入圖片描述

守護執行緒

守護執行緒是一種特殊的執行緒，又稱為一種陪伴執行緒。Java中共分為兩種執行緒：使用者執行緒和守護執行緒。
Thread類中提供了isDaemon()區別兩種執行緒：返回false，表示該執行緒為使用者執行緒，返回true就是守護執行緒。典型守護執行緒就是垃圾回收執行緒。
只要當前JVM程序中存在任何一個使用者執行緒沒有結束，守護執行緒就在工作；只有當最後一個使用者執行緒結束時，守護執行緒才會隨著JVM一同停止工作。
Thread提供**setDaemon()**將使用者執行緒設定成為守護執行緒。
注意：主執行緒main是使用者執行緒
範例：

class A implements Runnable{
   private int i;
    @Override
    public void run() {
        try{
        while (true) {
            i++;
            System.out.println("執行緒名稱：" + Thread.currentThread().getName() + ",i=" + i +
                    ",是否為守護執行緒:"
                    + Thread.currentThread().isDaemon());
            Thread.sleep(1000);
        }
    } catch (InterruptedException e) {
        System.out.println("執行緒名稱：" + Thread.currentThread().getName() + "中斷執行緒了");
    }
    }
}

class Test{
    public static void main(String[] args)throws InterruptedException {
        Thread thread1 = new Thread(new A(),"子執行緒A");
         // 設定執行緒A為守護執行緒，此語句必須在start方法之前執行
       thread1.setDaemon(true);
        thread1.start();

        Thread thread2 = new Thread(new A(),"子執行緒B");
        thread2.start();
        Thread.sleep(3000);
        // 中斷非守護執行緒,非守護執行緒結束
        thread2.interrupt();


        Thread.sleep(10000);
        System.out.println("程式碼結束");

    }
}

執行結果：
在這裡插入圖片描述
從上面的程式碼可以看出來，B是使用者執行緒當它中斷了之後守護執行緒還沒有結束，是因為主執行緒（使用者執行緒）還沒有結束，所以說明是所有的使用者執行緒結束之後守護執行緒才會結束。

相關推薦

Java之多執行緒的常用操作

執行緒命名與取得 在Thread類中提供有如下的執行緒名稱方法： 在Thread類中還提供有一個方法取得當前執行緒物件： public static native Thread currentThread(); 範例：設定和取得執行緒的名稱 class M

Java 多執行緒常用操作方法

1.多執行緒常用方法：    currentThread() :  獲取當前執行的執行緒    getName() ： 獲取執行緒名稱    setName() ： 設定執行緒名稱    sleep(long millis) :  是一個靜態方法，使當前執行執行緒進入睡眠狀態

多執行緒常用操作方法（sleep、yield、join）

執行緒的命名與取得 執行緒的命名： 通過構造方法在建立執行緒時設定執行緒名稱 直接繼承Thread類： public Thread (String name); Runable或者Callable介面實現多執行緒： public Thread (Run

Android開發之多執行緒的操作方式Thread,TimerTask,AsyncTask

雨鬆MOMO原創文章如轉載，請註明：轉載至我的獨立域名部落格雨鬆MOMO程式研究院，原文地址:http://www.xuanyusong.com/archives/344 Android研究院之遊戲開發多執行緒（十六）   遊戲開發與軟體開發多執行緒的重要性  &

Java之多執行緒安全（屌絲版，兩大解決思路，要麼不去競爭（開闢執行緒副本）、要麼有順序的競爭資源（用鎖規定執行緒秩序））

0、多執行緒安全，如果多個執行緒操作一個變數，每次都能達到預期的結果，那麼說明當前這個類起碼是執行緒安全的，我這白話的，可能有點噁心。   1、看看牛人是怎麼說的，為什麼多執行緒併發是不安全的？ 在作業系統中，執行緒是不再擁有資源的，程序是擁有資源的。而執行緒是由程序建立的

JAVA之多執行緒概念及其幾種實現方法優劣分析

1. 多執行緒 程式：指令集，靜態的概念 程序：作業系統調動程式，是程式的一次動態執行過程，動態的概念 執行緒：在程序內的多條執行路徑 Ps：單核的話程序都是虛擬模擬出來的，多核處理器才可以執行真正的多執行緒 單核通過CPU排程時間片實現虛擬模擬的多執行緒，比如執行main函式和GC在底層就是多執行

Java之多執行緒易範錯誤

public class mainTestImpl { /* * 任何執行緒一般具有五種狀態，即建立、就緒、執行、阻塞、終止 執行緒 呼叫stop()方法時或run()方法執行 * 結束後，執行緒即處於死亡狀態。 處於死亡狀態的執行緒不具有繼續執行的能力。

Java之多執行緒、執行緒池

多執行緒 執行緒：執行緒是程序中的一個執行單元，負責當前程序中程式的執行，一個程序中至少一個執行緒（main），但是可以有多個執行緒的，則這個程式稱為多執行緒程式。每一個執行緒執行不同的任務，多執行緒程式並不能提高程式的執行速度，可以提高程式的執行效率。 CPU處理可以分為

Java之多執行緒(二)

一.多執行緒的兩種實現方式對比第一種方式:       1)自定義類MyThread類,繼承自Thread類       2)重寫Thread類中的run()方法       3)建立MyThread類物件,分別去啟動執行緒注意:      1)啟動執行緒的時候,為什麼不使用

java基礎-JAVA之多執行緒

------<a href="http://www.itheima.com" target="blank">Java培訓、Android培訓、iOS培訓、.Net培訓</a>、期待與您交流！ ------- 要想了解執行緒，先了解程序的概念程序： 程

Java之多執行緒記憶體可見性_2(synchronized可見性原理)

可見性：要實現共享變數的可見性，必須保證2點：1.執行緒修改後的共享變數值能夠及時從工作記憶體重新整理到主記憶體中。2.其他執行緒能夠及時把共享變數的最新值從主記憶體更新到自己的工作記憶體中。 以下的記錄都是來源於慕課網-細說java多執行緒之記憶體可見性 Java語言層

Java之多執行緒面試題

很多核心Java面試題來源於多執行緒(Multi-Threading)和集合框架(Collections Framework)，理解核心執行緒概念時，嫻熟的實際經驗是必需的。這篇文章收集了 Java 執行緒方面一些典型的問題，這些問題經常被高階工程師所問到。 0.Java

Java併發多執行緒常用包、類和介面

Java.util.concurrent.locks.Lock          Lock介面          ReadWriteLock介面          Condition介面          ReentrantLock Java.util.concurrent

多執行緒——常用操作方法（二）

多執行緒常用操作可以總結成一下七種。 1、取得當前執行緒物件： public static native Thread currentThread();  2、執行緒的命名和取得當前執行緒的名字：public Thread（Runnable terget,String n

java之多執行緒中Thread類和Runnable介面使用方法

java提供了兩種執行緒方式，一種是繼承java.lang包下的Thread類，覆寫Thread類的run()方法，在run()方法中實現執行線上程上的程式碼!第二種是實現Runnable介面建立多執行

java之多執行緒

1、執行緒概述 幾乎所有的作業系統都支援同時執行多個任務，一個任務通常就是一個程式，每個執行中的程式就是一個程序。當一個程式執行時，內部可能包含了多個順序執行流，每個順序執行流就是一個執行緒。   2、執行緒與程序 程序概述： 幾乎所有的作業系統都支援程序的概念，所有執行中的任務通常對應一個程

Java之多執行緒（一）

一，前言 ​ 今天總結一些關於執行緒方面的知識，說到執行緒可謂是無人不知，畢竟這東西不管是在工作開發中，還是實際生活中都時時存在著。關於執行緒方面的內容非常多，從簡單的單執行緒，多執行緒，執行緒安全以及到高併發等等，當然也包括資訊通訊。 ​ 當然這次從執行緒的基本開始，後面也會慢慢的補充執行緒的高階使用，這也

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

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

java面試/筆試題目之多執行緒及鎖 (持續更新中)

前言：這一模組可以參照徐劉根大佬的部落格。 一.執行緒和程序的概念、並行和併發的概念 1.程序：是計算機中的程式關於某資料集合上的一次執行活動，是系統 進行資源分配和排程的基本單位，是作業系統結構的基礎。程式是指令、資料及其組織形式的描述，程序是程式的實體。 2.執行緒：是程式執行流的

java多執行緒系列翻譯之java併發/多執行緒教程

原文地址：http://tutorials.jenkov.com/java-concurrency/index.html 以前計算機都是單核，同時只能執行一個程式。之後出現了多重任務處理，這意味著計算機同時可以處理多個程式（又名任務或流程）。但這不是真正的“同時執行”，只是單個CPU被多個程式共