当前位置： 移动技术网 > IT编程>开发语言>Java > JAVA多线程之方法 JOIN详解及实例代码

JAVA多线程之方法 JOIN详解及实例代码

2019年07月22日  | 移动技术网IT编程  | 我要评论

java多线程 join

 对于java开发人员，多线程应该是必须熟练应用的知识点，特别是开发基于java语言的产品。本文将深入浅出的表述java多线程的知识点，在后续的系列里将侧重于java5由doug lea教授提供的concurrent并行包的设计思想以及具体实现与应用。

    如何才能深入浅出呢，我的理解是带着问题，而不是泛泛的看。所以该系列基本以解决问题为主，当然我也非常希望读者能够提出更好的解决问题的方案以及提出更多的问题。由于水平有限，如果有什么错误之处，请大家提出，共同讨论，总之，我希望通过该系列我们能够深入理解java多线程来解决我们实际开发的问题。

    作为开发人员，我想没有必要讨论多线程的基础知识，比如什么是线程？ 如何创建等 ，这些知识点是可以通过书本和google获得的。本系列主要是如何理深入解多线程来帮助我们平时的开发，比如线程池如何实现？ 如何应用锁等。 

（1）方法join是干啥用的？ 简单回答，同步，如何同步？ 怎么实现的？ 下面将逐个回答。
    自从接触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);
      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) 0　jdk这样说的 a timeout of 0 means to wait forever 字面意思是永远等待，是这样吗？
其实是等到t结束后。

这个是怎么实现的吗？ 看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方法实现是通过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

小结：

本节主要深入浅出join及ｊｄｋ中的实现。

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网