join() 和 sleep() 區別

來源於《Java多線程編程核心技術》

一、join() 作用

在很多情況，主線程創建並啟動子線程，如果子線程中需要進行大量的耗時計算，主線程往往早於子線程結束。這時，如果主線程想等待子線程執行結束之后再結束，比如子線程處理一個數據，主線程要取得這個數據，就要用待jion() 方法。

方法join()的作用是等待線程對象的銷毀

二、區別

　　sleep(long)方法在睡眠時不釋放對象鎖

　　join(long)方法在等待的過程中釋放對象鎖

三、實例

　　創建join_sleep_1項目

　　

　　類ThreadA.java代碼如下

package extthread;

public class ThreadA extends Thread {

    private ThreadB b;

    public ThreadA(ThreadB b) {
        super();
        this.b = b;
    }

    @Override
    public void run() {
        try {
            synchronized (b) {
                b.start();
                Thread.sleep(6000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

類ThreadB.java代碼如下

package extthread;

public class ThreadB extends Thread {

    @Override
    public void run() {
        try {
            System.out.println("   b run begin timer="
                    + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("   b run   end timer="
                    + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public void bService() {
        System.out.println("��ӡ��bService timer=" + System.currentTimeMillis());
    }

}

類ThreadC.java代碼如

package extthread;

public class ThreadC extends Thread {

    private ThreadB threadB;

    public ThreadC(ThreadB threadB) {
        super();
        this.threadB = threadB;
    }

    @Override
    public void run() {
        threadB.bService();
    }
}

Run.java 代碼

package test.run;

import extthread.ThreadA;
import extthread.ThreadB;
import extthread.ThreadC;

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

        try {
            ThreadB b = new ThreadB();

            ThreadA a = new ThreadA(b);
            a.start();

            Thread.sleep(1000);

            ThreadC c = new ThreadC(b);
            c.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

結果

由於線程ThreadA使用Thread.sleep(long)方法一直持有ThreadB對象的鎖，時間達到6秒，所以線程C只有在ThreadA時間到達6秒后釋放ThreadB的鎖時，才可以調用ThreadB中的同步方法Synchronized public void bService()

上面實驗證明Thread.sleep(long)不釋放鎖

---

 

 下面實驗修改ThreadA.java

package extthread;

public class ThreadA extends Thread {

    private ThreadB b;

    public ThreadA(ThreadB b) {
        super();
        this.b = b;
    }

    @Override
    public void run() {
        try {
            synchronized (b) {
                b.start();
                b.join();
                for (int i = 0; i < Integer.MAX_VALUE; i++) {
                    String newString = new String();
                    Math.random();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

結果如下

由於線程ThreadA釋放了ThreadB的鎖，所以線程ThreadC可以調用ThreadB中的同步方法synchronized public void bService()

實驗證明join(long)方法具有釋放鎖的特點