Java学习者须知的Java中join方法介绍与用法

    作者:课课家教育更新于: 2016-02-29 20:04:41

    大神带你学编程,欢迎选课

      方法Join 是干啥用的? 简单回答,同步,如何同步? 怎么实现的? 下面将逐个回答。

    Java学习者须知的Java中join方法介绍与用法_java课程标准_java入门教材_课课家

      自从接触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. 大家能理解吗? 字面意思是等待一段时间直到这个线程死亡,我的疑问是那个线程,是它本身的线程还是调用它的线程的,上代码:

      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) ; // 主线程只等1 秒,不管子线程什么时候结束

      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();

      }

      }

      }

      结果是:

      Begin sleep

      End sleep

      joinFinish

      明白了吧, 当main 线程调用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();

      }

      }

      结果是:

      Begin sleep

      joinFinish

      End sleep

      也就是说 main 线程只等1000 毫秒,不管T 什么时候结束 ,如果是t.join() 呢, 看代码:

      public final void join() throws InterruptedException {

      join(0);

      }

      就是说如果是t.join() = t.join(0)  JDK 这样说的 A timeout of 0 means to wait forever 字面意思是永远等待,是这样吗?

      其实是等到t 结束后。

      这个是怎么实现的吗? 看JDK 代码:

      /**

      * Waits at most millis milliseconds for this thread to

      * die. A timeout of 0 means to wait forever.

      *

      * @param millis the time to wait in milliseconds.

      * @exception InterruptedException if any thread has interrupted

      * the current thread. The interrupted status 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 方法实现是通过wait (小提示:Object 提供的方法)。 当main 线程调用t.join 时候,main 线程会获得线程对象t 的锁 (wait 意味着拿到该对象的锁), 调用该对象的wait( 等待时间) ,直到该对象唤醒main 线程,比如退出后。

      这就意味着main 线程调用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 锁后才能进入wait 方法中,它实际等待时间是9000+1000 MS

      运行结果是:

      getObjectLock

      Begin sleep

      End sleep

      ReleaseObjectLock

      joinFinish

课课家教育

未登录

1