join方法的功能就是使异步执行的线程变成同步执行。也就是说,当调用线程实例的start方法后,这个方法会立即返回,如果在调用start方法后后需要使用一个由这个线程计算得到的值,就必须使用join方法。如果不使用join方法,就不能保证当执行到start方法后面的某条语句时,这个线程一定会执行完。而使用join方法后,直到这个线程退出,程序才会往下执行。下面的代码演示了join的用法。

package mythread;

public class JoinThread extends Thread
{
    public static int n = 0;

static synchronized void inc()
    {
        n++;
    }
    public void run()
    {
        for (int i = 0; i < 10; i++)
            try
            {
                inc();
                sleep(3);  // 为了使运行结果更随机,延迟3毫秒
                
            }
            catch (Exception e)
            {
            }                                      
    }
    public static void main(String[] args) throws Exception
    {
   
        Thread threads[] = new Thread[100];
        for (int i = 0; i < threads.length; i++)  // 建立100个线程
            threads[i] = new JoinThread();
        for (int i = 0; i < threads.length; i++)   // 运行刚才建立的100个线程
            threads[i].start();
        if (args.length > 0)  
            for (int i = 0; i < threads.length; i++)   // 100个线程都执行完后继续
                threads[i].join();
        System.out.println("n=" + JoinThread.n);
    }
}

在例程2-8中建立了100个线程,每个线程使静态变量n增加10。如果在这100个线程都执行完后输出n,这个n值应该是1000。

1.  测试1

使用如下的命令运行上面程序:

java mythread.JoinThread

程序的运行结果如下:

这个运行结果可能在不同的运行环境下有一些差异,但一般n不会等于1000。从上面的结果可以肯定,这100个线程并未都执行完就将n输出了。

2.  测试2

使用如下的命令运行上面的代码:

在上面的命令行中有一个参数join,其实在命令行中可以使用任何参数,只要有一个参数就可以,这里使用join,只是为了表明要使用join方法使这100个线程同步执行。

程序的运行结果如下:

无论在什么样的运行环境下运行上面的命令,都会得到相同的结果:n=1000。这充分说明了这100个线程肯定是都执行完了,因此,n一定会等于1000。

多线程之join方法

join方法用得不多,当A线程执行到了B线程的join()方法时,A就会等待,等B线程都运行完,A线程才会执行。使用join()方法时,会产生异常。

用一个小程序说明join方法的使用技巧:

class Demo implements Runnable
{
 public void run()
 {
  for(int x=1;
x<100; x++)
  {
    
  System.out.println(Thread.currentThread().getName()
+ "..." + x);
  }
 }
}

public class JoinDemo
{
 public static void main(String[] args) throws
Exception
 {
  Demo d = new Demo();
  Thread t1 = new
Thread(d);
  Thread t2 = new
Thread(d);
  
  t1.start();
  
  t1.join();
  
  t2.start();
  
  for(int x=1;
x<100; x++)
  {
   System.out.println(Thread.currentThread().getName()
+ "..." + x);
  }
 }
}

主线程向下转时,碰到了t1.join(),t1要申请加入到运行中来,就是要CPU执行权。这时候CPU执行权在主线程手里,主线程就把CPU执行权给放开,陷入冻结状态。活着的只有t1了,只有当t1拿着执行权把这些数据都打印完了,主线程才恢复到运行中来。

join方法可以用于临时加入线程,一个线程在运算过程中,如果满足于条件,我们可以临时加入一个线程,让这个线程运算完,另外一个线程再继续运行。

如果将t1.join()和t2.start()位置互换,又会怎样呢?主线程开启了t1、t2,这时候CPU执行权还在主线程手里。当主线程碰到了t1.join(),释放执行权,处于冻结状态。活着的t1、t2都具备执行资格,这时候CPU便对t1和t2交替执行。主线程要等到t1结束才能活,至于t2结不结束,与主线程没有丝毫关系。如果t1结束了,t2还没结束,主线程就会和t2抢执行权执行。主线程碰到谁的join,它就等谁。也就是说,谁让它把执行权放出来,它就等谁死。至于谁去抢,它不管。

java基本教程之join方法详解 java多线程教程

本章涉及到的内容包括:
1. join()介绍
2. join()源码分析(基于JDK1.7.0_40)
3. join()示例

1. join()介绍
join() 定义在Thread.java中。
join() 的作用:让“主线程”等待“子线程”结束之后才能继续运行。这句话可能有点晦涩,我们还是通过例子去理解:

复制代码 代码如下:
// 主线程
public class Father extends Thread {
    public void run() {
        Son s = new Son();
        s.start();
        s.join();
        ...
    }
}
// 子线程
public class Son extends Thread {
    public void run() {
        ...
    }
}

说明:
上面的有两个类Father(主线程类)和Son(子线程类)。因为Son是在Father中创建并启动的,所以,Father是主线程类,Son是子线程类。

Father主线程中,通过new
Son()新建“子线程s”。接着通过s.start()启动“子线程s”,并且调用s.join()。在调用s.join()之后,Father主线程
会一直等待,直到“子线程s”运行完毕;在“子线程s”运行完毕之后,Father主线程才能接着运行。
这也就是我们所说的“join()的作用,是让主线程会等待子线程结束之后才能继续运行”!

2. join()源码分析(基于JDK1.7.0_40)

复制代码 代码如下:
public final void join() throws InterruptedException {
    join(0);
}

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;
        }
    }
}

说明:
从代码中,我们可以发现。当millis==0时,会进入while(isAlive())循环;即只要子线程是活的,主线程就不停的等待。
我们根据上面解释join()作用时的代码来理解join()的用法!
问题:

然s.join()被调用的地方是发生在“Father主线程”中,但是s.join()是通过“子线程s”去调用的join()。那么,join()方
法中的isAlive()应该是判断“子线程s”是不是Alive状态;对应的wait(0)也应该是“让子线程s”等待才对。但如果是这样的
话,s.join()的作用怎么可能是“让主线程等待,直到子线程s完成为止”呢,应该是让"子线程等待才对(因为调用子线程对象s的wait方法
嘛)"?
答案:wait()的作用是让“当前线程”等待,而这里的“当前线程”是指当前在CPU上运行的线程。所以,虽然是调用子线程的wait()方法,但是它是通过“主线程”去调用的;所以,休眠的是主线程,而不是“子线程”!

3. join()示例
在理解join()的作用之后,接下来通过示例查看join()的用法。

复制代码 代码如下:
// JoinTest.java的源码
public class JoinTest{

public static void main(String[] args){
        try {
            ThreadA t1 = new ThreadA("t1"); // 新建“线程t1”

t1.start();                     // 启动“线程t1”
            t1.join();                        // 将“线程t1”加入到“主线程main”中,并且“主线程main()会等待它的完成”
            System.out.printf("%s finish\n", Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

static class ThreadA extends Thread{

public ThreadA(String name){
            super(name);
        }
        public void run(){
            System.out.printf("%s start\n", this.getName());

// 延时操作
            for(int i=0; i <1000000; i++)
               ;

System.out.printf("%s finish\n", this.getName());
        }
    }
}

运行结果:

复制代码 代码如下:
t1 start
t1 finish
main finish

结果说明:
运行流程如图
(01) 在“主线程main”中通过 new ThreadA("t1") 新建“线程t1”。 接着,通过 t1.start() 启动“线程t1”,并执行t1.join()。
(02) 执行t1.join()之后,“主线程main”会进入“阻塞状态”等待t1运行结束。“子线程t1”结束之后,会唤醒“主线程main”,“主线程”重新获取cpu执行权,继续运行。

多线程之join方法的更多相关文章

  1. Java多线程之Join方法阻塞线程

    package org.study2.javabase.ThreadsDemo.status; /** * @Auther:GongXingRui * @Date:2018/9/19 * @Descr ...

  2. java多线程之join方法使用

    看这篇博客:http://www.cnblogs.com/skywang12345/p/3479275.html

  3. Java多线程之join

    1.join方法只有在继承了Thread类的线程中才有. 2.线程必须要start() 后再join才能起作用. 将另外一个线程join到当前线程,则需要等到join进来的线程执行完才会继续执行当前线 ...

  4. java基础---->java多线程之Join(二)

    如果主线程想等待子线程执行完成之后再结束,就可以使用join方法了.它的使用是等待线程对象销毁.今天我们就通过实例来学习一下多线程中join方法的使用.草在结它的种子,风在摇它的叶子.我们站着,不说话 ...

  5. Java线程之join

    简述 Thread类的join方法用来使main线程进入阻塞状态,进而等待调用join方法的线程执行,join有三个重载方法: public final void join() 使主线程进入阻塞状态, ...

  6. java多线程之yield()方法详解

         yiled()方法的作用是放弃当前CPU的资源,将资源让给其它线程,但放弃的时间不确定,有可能刚刚放弃,又马上获得了CPU时间片.下面看一个小例子,看一下具体效果. public stati ...

  7. Java多线程之sleep方法阻塞线程-模拟时钟

    package org.study2.javabase.ThreadsDemo.status; import java.text.SimpleDateFormat; import java.util. ...

  8. 线程之sleep(),wait(),yield(),join()等等的方法的区别

    操作线程的常用方法大体上有sleep(),join(),yield()(让位),wait(),notify(),notifyAll(),关键字synchronized等等.    由于这些方法功能有些 ...

  9. java多线程之yield,join,wait,sleep的区别

    Java多线程之yield,join,wait,sleep的区别 Java多线程中,经常会遇到yield,join,wait和sleep方法.容易混淆他们的功能及作用.自己仔细研究了下,他们主要的区别 ...

随机推荐

  1. .net程序员面试不完全指南

    程序员找工作难,想要被成功聘用更难.最常见的办法是经历一次又一次的面试失败后自己琢磨出面试技巧,当然也可以花钱到一些培训机构去接受专业的书面简历和模拟面试的指导.这些方法可能都会奏效,但是却并不是时间 ...

  2. Windows下用Mingw编译Boost.Regex库

    下载Boost库,解压. 定位到regex库文件夹下. GCC所对应的MAKEFILE为gcc.mak 进入命令提示符下,输入make -f gcc.mak 这是如果直接按回车执行的话,会出现错误: ...

  3. WinSock - 建立无连接的通信

    1.建立一个基于对话框的工程,并在第二步中选择WOSA支持 2.建立客户端 (1)在头文件中添加成员变量 public: CSocket m_clientsocket; (2)每隔一秒钟向服务端发送一 ...

  4. 我在知乎上关于Laser200/310电脑的文章。

    我是30年前从Laser-310起步的,我来回答这个问题. 主要硬件规格: CPU:Z-80A/4.7MHz主频 16K RAM + 2K Video RAM 16K ROM 磁带输出:波特率300 ...

  5. 2006 ACM Northwestern European Programming Contest C题(二分求最大)

    My birthday is coming up and traditionally I'm serving pie. Not just one pie, no, I have a numberN o ...

  6. VC,一条会被鼠标移动的直线

    对话框中的小红线可以被移动的 一.类名是 CBinarizationDlg 二.定义两个变量BOOL m_flag;int nPos;在构造函数初始化m_flag = false;nPos=256;三 ...

  7. spring mvc 提交数组等复杂类型

    使用jquery提交,比如monthIncome的值是一个数组,在Java里用request.getParameterValues("monthIncome");取不到值,要这样才 ...

  8. eclipse Maven plugin 配置

    1. eclipse -> help -> marketpalce -> search 在输入框中输入Maven,回车. 在搜索结果列表中往下拉几个安装 Maven Integrat ...

  9. VirtualBox集群建立和网络配置

    安装 1. 安装 安装Oracle VM VirtualBox之后,新建一个虚拟机,制定好内存等信息,开始安装操作系统,这里安装ubuntu-12.04.2-desktop-i386版本. 2. 拷贝 ...

  10. QT5.6,5.7,5.8的新特征以及展望

    https://wiki.qt.io/New_Features_in_Qt_5.6 (跨平台High-DPI,改进WebEngine到45,支持WIN 10,Canvas3D,3D) https:// ...