2. 程式人生 > >java 多執行緒Thread類

java 多執行緒Thread類

阿新 • • 發佈：2018-11-27

Thread類之前在部落格簡單介紹了下,本篇重點介紹幾個常用方法:

先看構造方法:

Thread() 建立新的執行緒物件

Thread(String name) 基於指定的名字建立一個執行緒物件

Thread(Runnable target)基於Runnable介面實現類的例項(可以是匿名內部類)建立一個執行緒物件

Thread(Runnable t,String name) 根據給定的Runnable介面實現類的例項和指定的名字建立一個執行緒物件

常用屬性和方法:

private int priority;執行緒優先順序
private boolean daemon = false;是否是保護執行緒
public static final int MIN_PRIORITY = 1;最小優先順序
public static final int NORM_PRIORITY = 5;中等優先順序
public static final int MAX_PRIORITY = 10;最大優先順序
synchronized void start() 啟動執行緒
void run() 如果建立執行緒時使用的是繼承Tread類建立的,要重寫run方法,執行緒體放在run方法裡
final synchronized void setName(String name) 設定執行緒名字
final String getName() 獲取執行緒名字,不能在Runnable介面的實現類或者匿名內部類中重寫的run方法中呼叫
static native void yield(); 禮讓,暫停當前執行緒,多個執行緒(包括當前執行緒)再次搶佔cpu使用權
static native void sleep(long millis) throws InterruptedException;該方法可以使當前執行緒睡眠，執行緒睡眠後，裡面的任務不會執行，待睡眠時間過後會自動甦醒，從而繼續執行任務。引數為毫秒,在run方法中不能丟擲該異常,只能捕獲該異常,因為Thread類中run方法不能丟擲異常,重寫的方法不能比父類異常型別大
static void sleep(long millis, int nanos)throws InterruptedException,第一個引數毫秒,第二個引數納秒,可以設定更精確的睡眠時間
void interrupt()//喚醒睡眠的執行緒,會丟擲InterruptedException異常(好像人睡覺,誰都不希望突然被叫醒)
final void setPriority(int newPriority)//設定執行緒的優點級,從1到10這10中優先順序,10的優先順序最高,優先順序高的並不是就先執行完,而是cpu會分給它較多的時間去執行
final int getPriority()//獲取優先順序等級
final void join() throws InterruptedException//讓執行緒A加入,加入後要一次性執行完這個加入的執行緒A,再接著執行剛才沒執行完的執行緒,繼承Thread類的自定義類中重寫的run方法中只能捕獲該異常,而不能丟擲
final void setDaemon(boolean on),設定守護執行緒,當其他非守護執行緒都執行完成時,守護執行緒自動退出,比如java虛擬機器的垃圾回收器就是守護執行緒
final boolean isDaemon()//判斷是否為守護執行緒

以下的演示如果設計到兩個類就寫一個繼承Thread的類寫一個匿名內部類

sleep()休眠

public class ThreadSleepTest01 {
    public static void main(String[] args){
            Thread t1=new Thread("t1"){
                @Override
                public void run() {
                    for (int i=0;i<10;i++){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println( "Thread  "+this.getName()+"will sleep");
                    }
                }
            };
            SleepThread st=new SleepThread("sleepThread");
            t1.start();
            st.start();
    }
}
class SleepThread extends Thread{
    public SleepThread(String name){
        super(name);
    }
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println( this.getName()+" is Sleeping");
        }
    }
}
out:
Thread  t1will sleep
Thread  t1will sleep
Thread  t1will sleep
Thread  t1will sleep
Thread  t1will sleep
sleepThread is Sleeping
sleepThread is Sleeping
sleepThread is Sleeping
sleepThread is Sleeping
sleepThread is Sleeping

結果說明,在SleeoThread執行緒還在休眠時,Threadt1執行緒已經執行完畢

interrupt()喚醒,將正在休眠的執行緒喚醒,會丟擲異常

public class ThreadInterruptTest01 {
    public static void main(String[] args){
        SleepInterrupt si =new SleepInterrupt("睡眠喚醒執行緒");
        si.start();
        si.interrupt();

    }
}
class SleepInterrupt extends Thread{
    public SleepInterrupt(String name){
        super(name);
    }
    @Override
    public void run() {
            try {
                Thread.sleep(100000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i=0;i<10;i++){

            System.out.println(this.getName()+i );
        }
    }
}
out:
java.lang.InterruptedException: sleep interrupted
	at java.base/java.lang.Thread.sleep(Native Method)
	at ThreadMethodTest.SleepInterrupt.run(ThreadInterruptTest01.java:18)
睡眠喚醒執行緒0
睡眠喚醒執行緒1
睡眠喚醒執行緒2
睡眠喚醒執行緒3
睡眠喚醒執行緒4
睡眠喚醒執行緒5
睡眠喚醒執行緒6
睡眠喚醒執行緒7
睡眠喚醒執行緒8
睡眠喚醒執行緒9

setPriority()方法設定執行緒的優先順序,Thread提供了三個靜態int變數,從1到10的共10個等級,執行緒優先順序高的cpu分配給其較多的執行時間

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

示例:

package ThreadMethodTest;

public class ThreadPriorityTest01 {
    public static void main(String[] args){
        Thread t=new Thread("執行緒t"){

            @Override
            public void run() {

                for (int i=0;i<100;i++){
                    System.out.println( this.getName()+" : "+i);
                }
            }
        };
        MyThread3 mt3=new MyThread3("執行緒mt3");
        t.setPriority(2);
        mt3.setPriority(10);
        t.start();
        mt3.start();

    }
}

class MyThread3 extends Thread{
    public MyThread3(String name){
        super(name);
    }
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println( this.getName()+" : "+i);
        }
    }
}

yield()禮讓,該方法執行時,只是暫停了此執行緒,但不會保證多個執行緒(包括當前執行緒)誰能拿到cpu控制權,優先讓其他執行緒執行,

public class ThreadYieldTest01 {
    public static void main(String[] args){
        Thread t1=new Thread("執行緒t1"){
            @Override
            public void run() {
                for (int i=0;i<100;i++){
                    System.out.println( this.getName()+" : "+i);
                }
            }
        };
        MyThread4 mt4=new MyThread4("執行緒mt4");
        t1.start();
        mt4.start();
    }
}
class MyThread4 extends  Thread{
    public MyThread4(String name){
        super(name);
    }
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                Thread.yield();//禮讓,讓寫的執行緒執行
            }
            System.out.println(this.getName()+" : "+i );
        }
    }
}
out:
結果太長,不貼出來了,但執行緒t1先執行完

join()加入執行緒,當A執行緒正在執行中加入B執行緒時,cpu先去執行B執行緒,B執行緒執行完再來執行A執行緒,加入之前時cpu排程執行執行緒

示例:

public class ThreadJoinTest01 {
    public static void main(String[] args){
        Thread t=new Thread("執行緒t"){
            @Override
            public void run() {
                for (int i=0;i<100;i++){
                    System.out.println(this.getName()+" : "+i );
                }
                
            }
        };
        MyThread5 mt5=new MyThread5("執行緒mt5",t);
        t.start();
        mt5.start();
    }
}
class MyThread5 extends Thread{
    Thread t1;
    public MyThread5(String name,Thread t1){
        super(name);
        this.t1=t1;
    }
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i==10){
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println( this.getName()+" : "+i);
        }
    }
}
out:
結果太長,就不貼出來了
執行緒mt5執行到i=10時,不再執行,開始執行執行緒t,等執行緒t執行完成後,再繼續執行mt5

使用兩個匿名內部類來演示join方法:

package ThreadMethodTest;

public class ThreadJoinTest02 {
    public static void main(String[] args){


    Thread t1=new Thread("執行緒t1"){
        @Override
        public void run() {
            for (int i=0;i<100;i++){
                System.out.println( this.getName()+" : "+i);
            }
        }
    };
    Thread t2=new Thread("執行緒t2"){
        @Override
        public void run() {
            for (int i=0;i<100;i++){
                if (i==10){
                    try {
                    //    t1.start(); //如果t1.start放在這裡,t2會先列印到9,然後t1開始執行,t1執行完後再執行t2
                        t1.join();

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(this.getName()+" : "+i);
            }
        }
    };
    t1.start();//剛開始執行時兩個執行緒搶佔cpu,但當t2的i到10時,開始執行t1執行緒,執行完t1後才繼續執行t2
    t2.start();
}
}

setDaemon(boolean on),設定守護執行緒

package ThreadMethodTest;

public class ThreadDeamonTest01 {
    public static void main(String[] args){
        MyThread6 mt6=new MyThread6("執行緒mt6");
        Thread t=new Thread("執行緒t"){
            @Override
            public void run() {
                for (int i=0;i<100;i++) {
                    System.out.println(this.getName() + "是" + (this.isDaemon() ? "守護執行緒" : "非守護執行緒"));
                }
            }
        };
        t.setDaemon(true);
        t.start();
        mt6.start();
    }
}
class MyThread6 extends Thread{

    public MyThread6(String name){
        super(name);
    }

    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println( this.getName()+"是"+(this.isDaemon()?"守護執行緒":"非守護執行緒"));
        }
    }
}
out:
執行緒mt6是非守護執行緒
執行緒t是守護執行緒
執行緒mt6是非守護執行緒
執行緒t是守護執行緒
執行緒mt6是非守護執行緒
執行緒t是守護執行緒
執行緒mt6是非守護執行緒
執行緒t是守護執行緒
執行緒mt6是非守護執行緒
執行緒t是守護執行緒
執行緒mt6是非守護執行緒
執行緒t是守護執行緒
執行緒mt6是非守護執行緒
執行緒t是守護執行緒
執行緒mt6是非守護執行緒
執行緒t是守護執行緒
執行緒mt6是非守護執行緒
執行緒t是守護執行緒
執行緒mt6是非守護執行緒
執行緒t是守護執行緒
執行緒t是守護執行緒
執行緒t是守護執行緒
執行緒t是守護執行緒
執行緒t是守護執行緒
執行緒t是守護執行緒
執行緒t是守護執行緒
執行緒t是守護執行緒
執行緒t是守護執行緒
執行緒t是守護執行緒

可以看到當非守護執行緒結束後,守護執行緒執行了一段時間,還沒執行完就不再執行了

 

參考:http://www.monkey1024.com/javase/670

相關推薦

java 多執行緒Thread類

Thread類之前在部落格簡單介紹了下,本篇重點介紹幾個常用方法: 先看構造方法: Thread() 建立新的執行緒物件 Thread(String name) 基於指定的名字建立一個執行緒物件 Thread(Runnable target)基於Runnable介面實現類的例項(可以

Java 多執行緒——Thread類和Runable介面

在java中可有兩種方式實現多執行緒，一種是繼承Thread類，一種是實現Runnable介面； Thread類是在java.lang包中定義的。一個類只要繼承了Thread類同時覆寫了本類中的 run()方法就可以實現多執行緒操作了，但是一個類只能繼承一個父類，這是此方法

java 多執行緒 Timer類

Timer類               需要處理按計劃時間執行的任務時，可使用Timer類。任務TimerTask      

java多執行緒Thread

認識多執行緒,首先要從程式是如何在CPU中進行排程說起,眾所周知,我們自己的筆記本中只有一個CPU,這個CPU在你電腦開機的時候開始就執行著許多程式,比如作業系統,可是一個CPU在某一單位時間只能執行一個程式,而電腦中這麼多的程式CPU是如何安排工作的呢?這就涉及到了併發的概念. 併發:有

java多執行緒-Thread的yield方法

yield表示當前執行緒申請交出執行權，但並不是一定會交出，依賴於系統的執行緒排程。 因此該方法並不穩定。 class Test { public static void main(String[] args) throws InterruptedException { Te

java多執行緒-Thread的sleep方法

public static native void sleep(long millis) throws InterruptedException; sleep是本地靜態方法。sleep的作用是讓執行緒進入TIME_WAITING狀態，引數是多少毫秒。 class Test { pu

Java多執行緒-----Thread常用方法

   1.public Thread(Runnable target,String name) 建立一個有名稱的執行緒物件 package com.thread.mothed; public class ThreadMethod {

java多執行緒Thread與Runnable的區別與使用深入理解

首先，多執行緒的實現方式兩種：一種是繼承Thread類，另一種是實現Runnable介面。 那麼這兩種方法的區別何在？該如何選擇？ 第一：他們之間的關係 檢視J2EE的API看到 Thread類中：  public class Thread extends Objec

java多執行緒-Thread兩個執行緒交換資料Exchanger

/** * 2017-4-21 * author:饒為 * Administrator */package Thread;import java.util.concurrent.Exchanger;/** * 2017-4-21 * author:饒為 * Administrator */public cla

java多執行緒—Thread.Join()和Thread.Sleep()

其實我想要   一種美夢睡不著   一種心臟的狂跳   瓦解界線不被撂倒 奔跑 依靠   我心中最想要   看你看過的浪潮   陪你放肆地年少   ——林俊杰【偉大的渺小】 ------------

九、JAVA多執行緒：類的載入過程

           ClassLoader的主要職責就是負責載入各種class檔案到jvm中,ClassLoader是一個抽象的class,給定一個class的二進位制檔名,ClassLoader會嘗試載入並且在JVM中生成構成這個類

JAVA多執行緒Thread VS Runnable詳解

要求 必備知識 本文要求基本瞭解JAVA程式設計知識。 開發環境 windows 7/EditPlus 演示地址 原始檔 程序與執行緒 程序是程式在處理機中的一次執行。一個程序既包括其所要執行的指令，也包括了執行指令所需的系統資源，不同程序所

java多執行緒工具類，可用該多執行緒同時處理相同且數量多的任務

package zrh4; public class ThreadModel {private static int maxThread = 4;protected static int currentThread = 0;private static ThreadMode

Java多執行緒-Thread.yield詳解

http://blog.csdn.net/dabing69221/article/details/17426953 Thread.yield( )方法： 使當前執行緒從執行狀態（執行狀態）變為可執行態（就緒狀態）。cpu會從眾多的可執行態裡選擇，也就是說，當前也就

Java 多執行緒工具類

一、CountDownLatch CountDownLatch 可用於倒計數 getCount()：獲取當前計數器剩餘計數 countDown()：倒計數器釋放一次 await()：用在多執行緒執行的後面，只有當 CountDownLatch 計數器全部釋放，及 ge

Java多執行緒原理及Thread類的使用

一、程序與執行緒的區別 1.程序是應用程式在記憶體總分配的空間。（正在執行中的程式） 2.執行緒是程序中負責程式執行的執行單元、執行路徑。 3.一個程序中至少有一個執行緒在負責程序的執行。 4.一個程序中有多個執行緒在執行的程式，為多執行緒程式。 5.多執行緒技術是為了解決多部分程式碼同時執行。

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

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

Java多執行緒（2）—— 執行緒實現之繼承Thread類

1.1、使用多執行緒 一個程序在執行時至少會有1個執行緒在執行，執行緒會在後臺執行；例如呼叫public static void main() 方法的執行緒就是如此，而且由JVM建立。 package

java 多執行緒之利用Thread類建立執行緒（Day02）

前言：在一個程式中，如果一次只完成一件事情，很容易實現，但現實生活中很多事情都是同時進行的，所以在java中為了模擬這種狀態，引入了執行緒機制，簡單的說，當程式同時完成很多事情時，就是所謂的多執行緒。 實現執行緒的兩種方式：一是通過繼承Thread類來建立執行緒，另一種方法

Java多執行緒的實現（程序與執行緒的概念、Java繼承Thread類實現多執行緒、Java實現Runnable介面實現多執行緒、Thread與Runnable的區別、實現Callable介面實現多執行緒）

1 程序與執行緒 1.1 程序與執行緒的概念 什麼是程序？   程序： 作業系統中一個程式的執行週期。（比如我們想要在電腦上登入QQ，從雙擊qq按鈕---->關閉qq這個過程就是一個程序）   多程序： 同一時刻跑多個程式。   在DOS（磁碟作業系統時