JAVA多線程之方法 JOIN詳解及實例代碼

發(fā)布時間：2020-10-08 04:42:50 來源：腳本之家閱讀：171 作者：lqh 欄目：編程語言

JAVA多線程 JOIN

對于Java開發(fā)人員，多線程應(yīng)該是必須熟練應(yīng)用的知識點，特別是開發(fā)基于Java語言的產(chǎn)品。本文將深入淺出的表述Java多線程的知識點，在后續(xù)的系列里將側(cè)重于Java5由Doug Lea教授提供的Concurrent并行包的設(shè)計思想以及具體實現(xiàn)與應(yīng)用。

如何才能深入淺出呢，我的理解是帶著問題，而不是泛泛的看。所以該系列基本以解決問題為主，當(dāng)然我也非常希望讀者能夠提出更好的解決問題的方案以及提出更多的問題。由于水平有限，如果有什么錯誤之處，請大家提出，共同討論，總之，我希望通過該系列我們能夠深入理解Java多線程來解決我們實際開發(fā)的問題。

作為開發(fā)人員，我想沒有必要討論多線程的基礎(chǔ)知識，比如什么是線程？如何創(chuàng)建等，這些知識點是可以通過書本和Google獲得的。本系列主要是如何理深入解多線程來幫助我們平時的開發(fā)，比如線程池如何實現(xiàn)？如何應(yīng)用鎖等。

（1）方法Join是干啥用的？簡單回答，同步，如何同步？怎么實現(xiàn)的？下面將逐個回答。
自從接觸Java多線程，一直對Join理解不了。JDK是這樣說的：

  join
  public final void join(long millis)throws InterruptedException
  Waits at most millis milliseconds for this thread to die. A timeout of 0 means to wait forever.

大家能理解嗎？字面意思是等待一段時間直到這個線程死亡，我的疑問是那個線程，是它本身的線程還是調(diào)用它的線程的，上代碼：

package concurrentstudy;
/**
 *
 * @author vma
 */
public class JoinTest {
  public static void main(String[] args) {
    Thread t = new Thread(new RunnableImpl());
    t.start();
    try {
      t.join(1000);
      System.out.println("joinFinish");
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
   
    }
  }
}
class RunnableImpl implements Runnable {

  @Override
  public void run() {
    try {
      System.out.println("Begin sleep");
      Thread.sleep(1000);
      System.out.println("End sleep");
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

  }
}

結(jié)果是：

Begin sleep
End sleep
joinFinish

明白了吧，當(dāng)main線程調(diào)用t.join時，main線程等待t線程，等待時間是1000，如果t線程Sleep 2000呢

 public void run() {
    try {
      System.out.println("Begin sleep");
      // Thread.sleep(1000);
      Thread.sleep(2000);
      System.out.println("End sleep");
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

  }

結(jié)果是：

Begin sleep
joinFinish
End sleep

也就是說main線程只等1000毫秒，不管T什么時候結(jié)束，如果是t.join()呢，看代碼：

public final void join() throws InterruptedException {
  join(0);
  }

就是說如果是t.join() = t.join(0) 0　JDK這樣說的 A timeout of 0 means to wait forever 字面意思是永遠(yuǎn)等待，是這樣嗎？
其實是等到t結(jié)束后。

這個是怎么實現(xiàn)的嗎？看JDK代碼：

 /**
   * Waits at most <code>millis</code> milliseconds for this thread to 
   * die. A timeout of <code>0</code> means to wait forever. 
   *
   * @param   millis  the time to wait in milliseconds.
   * @exception InterruptedException if any thread has interrupted
   *       the current thread. The <i>interrupted status</i> of the
   *       current thread is cleared when this exception is thrown.
   */
  public final synchronized void join(long millis) 
  throws InterruptedException {
  long base = System.currentTimeMillis();
  long now = 0;

  if (millis < 0) {
      throw new IllegalArgumentException("timeout value is negative");
  }

  if (millis == 0) {
    while (isAlive()) {
    wait(0);
    }
  } else {
    while (isAlive()) {
    long delay = millis - now;
    if (delay <= 0) {
      break;
    }
    wait(delay);
    now = System.currentTimeMillis() - base;
    }
  }
  }

其實Join方法實現(xiàn)是通過wait（小提示：Object 提供的方法）。當(dāng)main線程調(diào)用t.join時候，main線程會獲得線程對象t的鎖（wait 意味著拿到該對象的鎖),調(diào)用該對象的wait(等待時間)，直到該對象喚醒main線程，比如退出后。

這就意味著main 線程調(diào)用t.join時，必須能夠拿到線程t對象的鎖，如果拿不到它是無法wait的，剛開的例子t.join(1000)不是說明了main線程等待1秒，如果在它等待之前，其他線程獲取了t對象的鎖，它等待時間可不就是1毫秒了。上代碼介紹：

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package concurrentstudy;
/**
 *
 * @author vma
 */
public class JoinTest {
  public static void main(String[] args) {
    Thread t = new Thread(new RunnableImpl());
    new ThreadTest(t).start();
    t.start();
    try {
      t.join();
      System.out.println("joinFinish");
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
   
    }
  }
}
class ThreadTest extends Thread {

  Thread thread;

  public ThreadTest(Thread thread) {
    this.thread = thread;
  }

  @Override
  public void run() {
    holdThreadLock();
  }

  public void holdThreadLock() {
    synchronized (thread) {
      System.out.println("getObjectLock");
      try {
        Thread.sleep(9000);

      } catch (InterruptedException ex) {
       ex.printStackTrace();
      }
      System.out.println("ReleaseObjectLock");
    }

  }
}

class RunnableImpl implements Runnable {

  @Override
  public void run() {
    try {
      System.out.println("Begin sleep");
      Thread.sleep(2000);
      System.out.println("End sleep");
    } catch (InterruptedException e) {
      e.printStackTrace();
    }


  }
}

在main方法中通過new ThreadTest(t).start();實例化ThreadTest 線程對象，它在holdThreadLock()方法中，通過synchronized (thread)，獲取線程對象t的鎖，并Sleep（9000）后釋放，這就意味著，即使main方法t.join(1000),等待一秒鐘，它必須等待ThreadTest 線程釋放t鎖后才能進(jìn)入wait方法中，它實際等待時間是9000+1000 MS

運行結(jié)果是：

getObjectLock
Begin sleep
End sleep
ReleaseObjectLock
joinFinish

小結(jié)：

本節(jié)主要深入淺出join及ＪＤＫ中的實現(xiàn)。

感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！

向AI問一下細(xì)節(jié)

JAVA多線程之方法 JOIN詳解及實例代碼

猜你喜歡

最新資訊

相關(guān)推薦

相關(guān)標(biāo)簽