Java Thread.join的作用和原理

很多人对Thread.join的作用以及实现了解得很少，毕竟这个api我们很少使用。这篇文章仍然会结合使用及原理进行深度分析

内容导航

  • Thread.join的作用
  • Thread.join的实现原理
  • 什么时候会使用Thread.join

Thread.join的作用

之前有人问过我一个这样的面试题

Java中如何让多线程按照自己指定的顺序执行？

这个问题最简单的回答是通过Thread.join来实现，久而久之就让很多人误以为Thread.join是用来保证线程的顺序性的。 下面这段代码演示了Thread.join的作用

  1. public class JoinDemo extends Thread{
  2.    int i;
  3.    Thread previousThread; //上一个线程
  4.    public JoinDemo(Thread previousThread,int i){
  5.        this.previousThread=previousThread;
  6.        this.i=i;
  7.    }
  8.    @Override
  9.    public void run() {
  10.        try {
  11.          //调用上一个线程的join方法，大家可以自己演示的时候可以把这行代码注释掉
  12.            previousThread.join();
  13.        } catch (InterruptedException e) {
  14.            e.printStackTrace();
  15.        }
  16.        System.out.println("num:"+i);
  17.    }
  18.    public static void main(String[] args) {
  19.        Thread previousThread=Thread.currentThread();
  20.        for(int i=0;i<10;i++){
  21.            JoinDemo joinDemo=new JoinDemo(previousThread,i);
  22.            joinDemo.start();
  23.            previousThread=joinDemo;
  24.        }
  25.    }
  26. }

上面的代码，注意 previousThread.join部分，大家可以把这行代码注释以后看看运行效果，在没有加join的时候运行的结果是不确定的。加了join以后，运行结果按照递增的顺序展示出来。

thread.join的含义是当前线程需要等待previousThread线程终止之后才从thread.join返回。简单来说，就是线程没有执行完之前，会一直阻塞在join方法处。

Thread.join的实现原理

线程是如何被阻塞的？又是通过什么方法唤醒的呢？先来看看Thread.join方法做了什么事情

  1. public class Thread implements Runnable {
  2.    ...
  3.    public final void join() throws InterruptedException {
  4.        join(0);
  5.    }
  6.    ...
  7.    public final synchronized void join(long millis) throws InterruptedException {
  8.        long base = System.currentTimeMillis();
  9.        long now = 0;
  10.        if (millis < 0) {
  11.            throw new IllegalArgumentException("timeout value is negative");
  12.        }
  13.        if (millis == 0) { //判断是否携带阻塞的超时时间，等于0表示没有设置超时时间
  14.            while (isAlive()) {//isAlive获取线程状态，无线等待直到previousThread线程结束
  15.                wait(0); //调用Object中的wait方法实现线程的阻塞
  16.            }
  17.        } else { //阻塞直到超时
  18.            while (isAlive()) {
  19.                long delay = millis - now;
  20.                if (delay <= 0) {
  21.                    break;
  22.                }
  23.                wait(delay);
  24.                now = System.currentTimeMillis() - base;
  25.            }
  26.        }
  27.    }
  28.    ...

从join方法的源码来看，join方法的本质调用的是Object中的wait方法实现线程的阻塞，wait方法的实现原理我们在后续的文章再说详细阐述。但是我们需要知道的是，调用wait方法必须要获取锁，所以join方法是被synchronized修饰的，synchronized修饰在方法层面相当于synchronized(this),this就是previousThread本身的实例。

有很多人不理解join为什么阻塞的是主线程呢? 不理解的原因是阻塞主线程的方法是放在previousThread这个实例作用，让大家误以为应该阻塞previousThread线程。实际上主线程会持有previousThread这个对象的锁，然后调用wait方法去阻塞，而这个方法的调用者是在主线程中的。所以造成主线程阻塞。

第二个问题，为什么previousThread线程执行完毕就能够唤醒住线程呢？或者说是在什么时候唤醒的？

要了解这个问题，我们又得翻jdk的源码，但是如果大家对线程有一定的基本了解的话，通过wait方法阻塞的线程，需要通过notify或者notifyall来唤醒。所以在线程执行完毕以后会有一个唤醒的操作，只是我们不需要关心。 接下来在hotspot的源码中找到 thread.cpp，看看线程退出以后有没有做相关的事情来证明我们的猜想.

  1. void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
  2.  assert(this == JavaThread::current(),  "thread consistency check");
  3.  ...
  4.  // Notify waiters on thread object. This has to be done after exit() is called
  5.  // on the thread (if the thread is the last thread in a daemon ThreadGroup the
  6.  // group should have the destroyed bit set before waiters are notified).
  7.  ensure_join(this);
  8.  assert(!this->has_pending_exception(), "ensure_join should have cleared");
  9.  ...

观察一下 ensure_join(this)这行代码上的注释，唤醒处于等待的线程对象，这个是在线程终止之后做的清理工作，这个方法的定义代码片段如下

  1. static void ensure_join(JavaThread* thread) {
  2.  // We do not need to grap the Threads_lock, since we are operating on ourself.
  3.  Handle threadObj(thread, thread->threadObj());
  4.  assert(threadObj.not_null(), "java thread object must exist");
  5.  ObjectLocker lock(threadObj, thread);
  6.  // Ignore pending exception (ThreadDeath), since we are exiting anyway
  7.  thread->clear_pending_exception();
  8.  // Thread is exiting. So set thread_status field in  java.lang.Thread class to TERMINATED.
  9.  java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);
  10.  // Clear the native thread instance - this makes isAlive return false and allows the join()
  11.  // to complete once we‘ve done the notify_all below
  12.  //这里是清除native线程，这个操作会导致isAlive()方法返回false
  13.  java_lang_Thread::set_thread(threadObj(), NULL);
  14.  lock.notify_all(thread);//注意这里
  15.  // Ignore pending exception (ThreadDeath), since we are exiting anyway
  16.  thread->clear_pending_exception();
  17. }

ensure_join方法中，调用 lock.notify_all(thread); 唤醒所有等待thread锁的线程，意味着调用了join方法被阻塞的主线程会被唤醒； 到目前为止，我们基本上对join的原理做了一个比较详细的分析

总结，Thread.join其实底层是通过wait/notifyall来实现线程的通信达到线程阻塞的目的；当线程执行结束以后，会触发两个事情，第一个是设置native线程对象为null、第二个是通过notifyall方法，让等待在previousThread对象锁上的wait方法被唤醒。

什么时候会使用Thread.join

在实际应用开发中，我们很少会使用thread.join。在实际使用过程中，我们可以通过join方法来等待线程执行的结果，其实有点类似future/callable的功能。 我们通过以下伪代码来说明join的使用场景

  1. public void joinDemo(){
  2.   //....
  3.   Thread t=new Thread(payService);
  4.   t.start();
  5.   //....
  6.   //其他业务逻辑处理,不需要确定t线程是否执行完
  7.   insertData();
  8.   //后续的处理，需要依赖t线程的执行结果，可以在这里调用join方法等待t线程执行结束
  9.   t.join();
  10. }

原文地址：https://www.cnblogs.com/barrywxx/p/10153776.html

时间： 2024-10-09 07:27:43

Java Thread.join的作用和原理的相关文章

【转】Java Thread.join()详解

http://www.open-open.com/lib/view/open1371741636171.html 一.使用方式. join是Thread类的一个方法,启动线程后直接调用,例如: ? 1 Thread t = new AThread(); t.start(); t.join(); 二.为什么要用join()方法 在很多情况下,主线程生成并起动了子线程,如果子线程里要进行大量的耗时的运算,主线程往往将于子线程之前结束,但是如果主线程处理完其他的事务后,需要用到子线程的处理结果,也就是

Java Thread.join()详解

一.使用方式. 二.为什么要用join()方法 三.join方法的作用 join 四.用实例来理解 打印结果: 打印结果: 五.从源码看join()方法 一.使用方式. join是Thread类的一个方法,启动线程后直接调用,例如: ? 1 Thread t = new AThread(); t.start(); t.join(); 回到顶部 二.为什么要用join()方法 在很多情况下,主线程生成并起动了子线程,如果子线程里要进行大量的耗时的运算,主线程往往将于子线程之前结束,但是如果主线程处

Java Thread join() 的用法

Java Thread中, join() 方法主要是让调用改方法的thread完成run方法里面的东西后, 在执行join()方法后面的代码.示例: Java代码   class ThreadTesterA implements Runnable { private int counter; @Override public void run() { while (counter <= 10) { System.out.print("Counter = " + counter +

浅析 Java Thread.join()

一.在研究join的用法之前,先明确两件事情. 1.join方法定义在Thread类中,则调用者必须是一个线程, 例如: Thread t = new CustomThread();//这里一般是自定义的线程类 t.start();//线程起动 t.join();//此处会抛出InterruptedException异常 2.上面的两行代码也是在一个线程里面执行的. 以上出现了两个线程,一个是我们自定义的线程类,我们实现了run方法,做一些我们需要的工作:另外一个线程,生成我们自定义线程类的对象

Java Thread.join()详解--父线程等待子线程结束后再结束

目录(?)[+] 阅读目录 一.使用方式. 二.为什么要用join()方法 三.join方法的作用 join 四.用实例来理解 打印结果: 打印结果: 五.从源码看join()方法 join是Thread类的一个方法,启动线程后直接调用,例如: ? 1 Thread t = new AThread(); t.start(); t.join(); 回到顶部 在很多情况下,主线程生成并起动了子线程,如果子线程里要进行大量的耗时的运算,主线程往往将于子线程之前结束,但是如果主线程处理完其他的事务后,需

由Thread.join引发的思考

下面是一段司空见惯的代码,创建两个线程A和线程B,使得线程A优先于线程B执行,使得线程B优先于主线程执行 public class Demo52 { public static void main(String[] args) { Thread thread1 = new Thread(()->{ System.out.println("线程:"+Thread.currentThread().getName()); },"A"); Thread thread2

Java线程join示例详解

Java线程的join方法可用于暂停当前线程的执行直至目标线程死亡.Thread中一共有三个join的重载方法. public final void join():该方法将当前线程放入等待队列中,直至被它调用的线程死亡为止.如果该线程被中断,则会抛出InterruptedException异常. public final synchronized void join(long millis):该方法用于让当前线程进入等待状态,直至被它调用的线程死亡或是经过millis毫秒.由于线程的执行依赖于操

thread.join函数，java多线程中的join函数解析

join函数的作用,是让当前线程等待,直到调用join()的 线程结束或者等到一段时间,我们来看以下代码 1 package mian; 2 3 4 public class simpleplela { 5 static void threadMessage(String message) { 6 String threadName = 7 Thread.currentThread().getName(); 8 9 System.out.println(threadName+" "+m

java中synchronize锁 volatile thread.join()方法的使用

对于并发工作,你永远不知道一个线程何时运行,你需要某种方式来避免两个任务访问相同的资源,即要避免资源竞争,至少在关键代码上不能出现这样的情况,否则多个线程同时对某个内存区域操作会导致数据破坏. 程序代码中的临界区是需要互斥访问的,同一时刻只能有一个线程来访问临界区,也就是线程对临界区的访问时互斥的. 竞争条件:当多个线程同时访问某个共享的内存区域并且对其进行读写操作时,就会出现数据破坏.这就是竞争条件.避免竞争条件的方法是synchronized加锁. 样例,设有一个现成,该线程的任务是对共享变