0039 Java學習筆記-多線程-線程控制、線程組

join線程

• 假設A線程要B線程去完成一項義務，在B線程完成前往之前，不停止下一步執行，那麼就可以調用B線程的join()辦法
• join()辦法的重載：
  • join()：等候不限時間
  • join(long millis)：等候millis毫秒
  • join(long millis,int nanos)：很少用，等候毫秒+毫微秒
• 看示例：

package testpack;
public class Test2  { 
    public static void main(String[] args) throws InterruptedException{ 
        System.out.println("如今線程是： "+Thread.currentThread().getName());
        A a=new A();
        Thread t1=new Thread(a,"被join線程");
        t1.start();                            //先start，後join
        t1.join();                             //調用join()辦法
        System.out.println("主線程執行終了");  //主線程要等t1線程執行終了，才執行這條語句；假如不調用join()，能夠主線程執行完了這條語句，才會執行t1
    }
}
class A implements Runnable{
    public void run(){
        for (int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+"  輸入： "+i);
        }
    }
}

後台線程

• 後台線程，又叫守護線程，假如一切的前台線程都執行終了，那麼不管後台線程執行終了與否，都直接進入死亡形態
• 前台創立的子線程是前台線程，後台線程創立的子線程是後台線程
• setDaemon(boolean on)：能否將該線程設為後台(true)線程，該辦法要在start之前調用，否則拋出IllegalThreadStateException異常
• isDaemon()：判別該線程是不是後台線程
• 看示例：

package testpack;
public class Test2  { 
    public static void main(String[] args) throws InterruptedException{ 
        Thread t=new Thread(new A(),"後台線程");
        t.setDaemon(true);    //start之前調用setDaemon辦法
        t.start();
        for (int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+" output： "+i);
        }
    }
}
class A implements Runnable{
    public void run(){
        for (int i=0;i<50;i++){
            System.out.println(Thread.currentThread().getName()+"  輸入： "+i);
        }
    }
}

輸入：

main output： 0
main output： 1
main output： 2
main output： 3
main output： 4
main output： 5
main output： 6
後台線程 輸入： 0
main output： 7
後台線程 輸入： 1
後台線程 輸入： 2
後台線程 輸入： 3
main output： 8
main output： 9
後台線程 輸入： 4
後台線程 輸入： 5 //後台線程本應執行到49，獨一的前台線程主線程完畢後，後台線程也跟著死亡

線程sleep

• sleep(long millis)：
• sleet(long millis,int nanos)：
• 該辦法讓線程暫停執行，交出cpu的執行權，，進入阻塞形態，不釋放鎖，醒來之後進入就緒形態，不一定能立即失掉執行，看線程調度
• 示例：

package testpack;

import java.util.Date;

public class Test2  { 
    public static void main(String[] args) throws InterruptedException{ 
        System.out.println("以後時間："+new Date());
        Thread.sleep(3000);
        System.out.println("以後時間："+new Date());
    }
}

輸入：

以後時間：Thu Dec 08 09:44:02 CST 2016
以後時間：Thu Dec 08 09:44:05 CST 2016 //主線程暫停執行3秒

線程yield

• 線程退讓，會使線程從運轉形態進入就緒形態，不會進入阻塞形態，這時會讓線程優先級相反或更高的線程執行
• 示例

package testpack;
public class Test2  { 
    public static void main(String[] args) throws InterruptedException{ 
        A a1=new A("線程 低");
        A a2=new A("線程 中");
        A a3=new A("線程 高");
        a1.setPriority(Thread.MIN_PRIORITY);
        a2.setPriority(Thread.NORM_PRIORITY);
        a3.setPriority(Thread.MAX_PRIORITY);
        a1.start();
        a2.start();
        a3.start();
    }
}
class A extends Thread{
    A(String name){
        super(name);
    }
    public void run(){
        for (int i=1;i<10;i++){
            System.out.println(getName()+" 輸入： "+i);
            if (i==3){
                Thread.yield();
            }
        }
    }
}

輸入：

線程 低 輸入： 1
線程 高 輸入： 1
線程 中 輸入： 1
線程 高 輸入： 2
線程 低 輸入： 2
線程 高 輸入： 3
線程 中 輸入： 2
線程 高 輸入： 4
線程 低 輸入： 3 //低級線程輸入3後，yield，上面讓高線程執行
線程 高 輸入： 5
線程 中 輸入： 3 //中級線程輸入3後，也yield，上面讓高線程執行
線程 高 輸入： 6
線程 高 輸入： 7
線程 高 輸入： 8
線程 高 輸入： 9
線程 低 輸入： 4
線程 中 輸入： 4
線程 中 輸入： 5
.......

sleep與yield的比照

• sleep：運轉->阻塞->就緒；yield：運轉->就緒
• sleep之後，其他線程不管優先級上下，都有能夠失掉執行；yield之後，只要平級或更初級的線程才會被執行
• sleep聲明了拋出InterruptedException異常，yield沒有
• sleep辦法移植性更強，不建議用yield來控制並發線程的執行

線程優先級

• 線程優先級可以是[1,10]的整數，由setPriority(int newPriority)設置
• 三個優先級常量：MAX_PRIORITY、NORM_PRIORITY、MIN_PRIORITY。值辨別是10、5、1
• 每個線程的默許優先級跟創立它的父線程的優先級相反
• 為了更好的可移植性，建議運用優先級常量，少用int優先級
• 檢查優先級：int getPriority()

線程組

• 每個線程都處於一個線程組中，經過線程組，可以對一批線程停止批量控制
• 假如沒有指定線程組，那麼處於默許線程組；子線程和創立它的父線程處於同一個線程組
• 假如要指定一個線程的線程組，應在結構辦法中指定，創立了線程實例後，不能改動線程組
• 如何取得一個線程所屬的線程組：getThreadGroup()
• Thread的結構器中指定線程組
  • Thread(ThreadGroup group,Runnable target)：
  • Thread(ThreadGroup group,Runnable target,String name)：
  • Thread(ThreadGroup group,String name)：
• ThreadGroup的結構器
  • ThreadGroup(String name)：以指定的稱號、以後線程所屬的線程組創立一個線程組
  • ThreadGroup(ThreadGroup parent, String name)：以指定的稱號、指定的父線程組創立一個線程組
• ThreadGroup的幾個辦法
  • getName()：前往該線程組的名字
  • 操作該線程組下的一切線程
    • int activeCount()：前往此線程組中活動線程的數目
    • void interrupt()：中綴該線程組中的一切線程
    • boolean isDaemon()：判別是不是後台線程組
    • void setDaemon(boolean daemon)：設置為後台線程組，其中的最後一個線程死亡之後，該線程組銷毀。特別留意：後台線程組下的線程可不都是後台線程，二者有關
    • void setMaxPriority(int pri)：設置該線程組的最高優先級

System.out.println(Thread.currentThread());

輸入：Thread[main,5,main]：第一個main是線程名；5是線程優先級；第二個main是所屬線程組名

• 示例：

package testpack;
public class Test2  { 
    public static void main(String[] args) throws InterruptedException{ 
        System.out.println("主線程名： "+Thread.currentThread().getName()
                +" ；所屬線程組： "+Thread.currentThread().getThreadGroup().getName()
                +" ；是不是後台線程？"+Thread.currentThread().isDaemon());
        
        ThreadGroup tg=new ThreadGroup("後台線程組");
        tg.setDaemon(true);
        A a=new A(tg,"後台線程組的線程A");
        a.start();
    }
}
class A extends Thread{
    A(ThreadGroup group,String name){
        super(group,name);
    }
    public void run(){
        System.out.println("線程名： "+getName()+" ；所屬線程組："+getThreadGroup().getName()+" ；是不是後台線程？"+isDaemon());
    }
}

輸入：

主線程名： main ；所屬線程組： main ；是不是後台線程？false
線程名： 後台線程組的線程A ；所屬線程組：後台線程組 ；是不是後台線程？false //後台線程組下的線程不一定是後台線程

其他

• 最近發現一個做筆記的中央，螞蟻筆記：https://leanote.com，支持Markdown，還可以把一篇筆記或一個筆記本地下為博客，可以綁定二級域名或許自定義域名，可以導出為PDF，支持團隊協作，甚至是開源的，可以將其部署在自己的服務器上，是一個挺不錯的使用
• 本篇筆記也發布在leanote：在這裡
• 這是我的約請鏈接，假如想注冊，可以經過該鏈接，你我都可以取得30天的旗艦版時間