java线程研究---(6)暂停Thread：join

最新推荐文章于 2023-11-07 20:04:33 发布
最新推荐文章于 2023-11-07 20:04:33 发布
阅读量1.1k 收藏 1
点赞数 2
分类专栏： java Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/miqi770/article/details/47952955
版权

暂停Thread


join方法，会让线程线程暂停，具体如下：

  • 调用方法：Thread对象.join()
  • 比如，当前有一个线程对象son，当调用了son.join()方法之后（不是child.start()方法哦），
  • 会让线程对象son的父级线程对象mother，从执行（running）状态进入暂停（blocked）状态。
  • 并且mother线程对象，会获取到线程对象son的执行完毕时刻，再从暂停（blocked）状态，进入等待执行（runnable）状态
  •  
  • 所以join方法的使用场景是：
    • 有两个线程对象mother和son
    • mother线程对象先开始执行，在执行期间，希望让son线程对象执行，
    • 在调用son.join()之后，mother线程对象进入暂停状态等待son线程对象执行完毕，
    • 当son线程对象执行完毕之后，mother线程对象会被通知，继续执行，
    • mother对象线程执行完毕。


先来温习一下状态图吧：



-----------------------------------------------------------------------------------------------------------------------------测试1：

测试场景如下：
  1. 妈妈(MotherThread)准备炒菜
  2. 发现没有酱油，就让儿子(SonThread)去买回来
  3. 期间妈妈一直在等待儿子归来
  4. 儿子买回来之后，妈妈开始继续炒菜。


测试代码如下：


MotherThread.java

package thread;

public class MotherThread implements Runnable {

	@Override
	public void run() {
		System.out.println("妈妈准备炒菜");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("妈妈发现没有酱油");

		System.out.println("妈妈让儿子去买酱油");
		Thread son = new Thread(new SonThread());
		son.start();

		try {
			son.join(); // 这里MotherThread线程对象，进入暂停，并且让MotherThread线程,获取SonThread线程执行完毕的时刻
		} catch (InterruptedException e) {
			System.err.println("儿子发生异常！妈妈中断炒菜");
			System.exit(1);
		}
		
		System.out.println("妈妈开始炒菜");
		System.out.println("菜炒完毕了~~~");
		
	}

}

SonThread.java 

package thread;

public class SonThread implements Runnable {
	public void run() {
		System.out.println("儿子开始买酱油");
		System.out.println("买酱油需要5分钟：");
		try {
			for (int i = 1; i <= 5; i++) {
				Thread.sleep(1000);
				System.out.print("过去" + i + "分钟, ");
			}
		} catch (InterruptedException e) {
			System.err.println("儿子发生意外");
		}
		System.out.println("");
		System.out.println("儿子买酱油回来了！");
	}
}

Cooking.java 

package thread;

public class Cooking {
	public static void main(String abc[]) {
		Thread mother = new Thread(new MotherThread());
		mother.start();
	}
}

打印结果：

妈妈准备炒菜
妈妈发现没有酱油
妈妈让儿子去买酱油
儿子开始买酱油
买酱油需要5分钟：
过去1分钟, 过去2分钟, 过去3分钟, 过去4分钟, 过去5分钟, 
儿子买酱油回来了！
妈妈开始炒菜
菜炒完毕了~~~



-----------------------------------------------------------------------------------------------------------------------------测试2：
这里的例子，我主要想强调一下。
调用son.start()之后，mother线程并不是暂停的，mother线程其实是和son线程并行执行的（比如，mother在让son去买酱油之后，可以去看电视或上厕所）。
（之前的例子，只不过在调用son.start()之后，马上又调用son.join()方法了。所以给大家的感觉是，son在去买酱油之后，mother啥都不能干，只能等待。。。）
注意，
  • 只有在调用son.join()之后，mother线程才“等待”son线程执行完毕，
  • 在调用son.join()之前，mother可以干其他的事情
但是mother这个“等待”时间或者长或短，为什么说呢：
  • mother线程（在调用son.start()方法之后）和son线程既然并行的，
  • 那么这两个线程就有执行时间长短不同的问题：
    • son线程执行时间长，mother线程（在调用son.start()方法之后）执行时间短：
      • son买酱油需要10分钟，同时mother看了5分钟的电视
      • 看了5分钟电视之后，才调用son.join()，那么mother就再等5分钟，儿子买酱油回来
    • mother线程（在调用son.start()方法之后）执行时间长，son线程执行时间短：
      • son买酱油需要5分钟，同时mother看10分钟的电视
      • 看了10分钟电视之后，才调用son.join()，那么mother不需要等待son执行完毕，
      • 因为son线程已经执行完毕了——儿子已经5分钟买酱油回来了，只不过一直在门外敲门微笑


子线程执行时间长（son10分钟），主线程执行时间短（mother5分钟）测试场景如下：----------------------------------------------
  1. 妈妈(MotherThread)准备炒菜
  2. 发现没有酱油，就让儿子(SonThread)去买回来----需要10分钟
  3. 期间妈妈一直在看电视-------看5分钟
  4. 看完5分钟电视之后，妈妈没干别的事情，只是焦急的等待儿子回来。
  5. 等了5分钟之后，儿子买酱油回来
  6. 妈妈开始继续炒菜。


测试代码如下：

MotherThread.java

package thread;

public class MotherThread implements Runnable {

	@Override
	public void run() {
		// 是否儿子去买酱油
		boolean buySoy = false;
		// 是否看电视
		boolean watchTV = false;

		System.out.println("妈妈准备炒菜");
		try {
			Thread.sleep(1000); // 炒菜持续一分钟之后
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.out.println("妈妈发现没有酱油");
		buySoy = true; // 儿子去买酱油
		watchTV = true; // 买酱油期间，看电视

		Thread son = new Thread(new SonThread());
		if (buySoy) {
			System.out.println("妈妈让儿子去买酱油");
			son.start();
		}

		if (watchTV) {
			// 儿子买酱油的同时，妈妈开始看5分钟电视
			System.out.println("儿子买酱油的同时，妈妈开始看5分钟电视：");
			try {
				for (int i = 1; i <= 5; i++) {

					Thread.sleep(1000); //这里用sleep时间代表看电视

					System.out.println("妈妈看电视，过去" + i + "分钟, ");
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		
		try {
			System.out.println("看完电视，5分钟过去了，妈妈焦急的等待儿子回来。");
			son.join();
			System.out.println("妈妈开门，拿到酱油");
		} catch (InterruptedException e) {
			System.err.println("儿子发生异常！妈妈中断炒菜");
			System.exit(1);
		}

		System.out.println("妈妈开始炒菜");
		System.out.println("菜炒完毕了~~~");

	}

}

SonThread.java 

package thread;

public class SonThread implements Runnable {
	public void run() {
		System.out.println("儿子开始买酱油，买酱油需要10分钟：");
		try {
			for (int i = 1; i <= 10; i++) {
				Thread.sleep(1000);  //这里用sleep时间代表买酱油
				System.out.println("儿子买酱油，过去" + i + "分钟, ");
			}
		} catch (InterruptedException e) {
			System.err.println("儿子发生意外");
		}
		
		System.out.println("儿子买酱油回来了，等待妈妈开门");
	}
}

控制台效果：


妈妈准备炒菜
妈妈发现没有酱油
妈妈让儿子去买酱油
儿子买酱油的同时，妈妈开始看5分钟电视：
儿子开始买酱油，买酱油需要10分钟：
妈妈看电视，过去1分钟, 
儿子买酱油，过去1分钟, 
妈妈看电视，过去2分钟, 
儿子买酱油，过去2分钟, 
妈妈看电视，过去3分钟, 
儿子买酱油，过去3分钟, 
妈妈看电视，过去4分钟, 
儿子买酱油，过去4分钟, 
妈妈看电视，过去5分钟, 
看完电视，5分钟过去了，妈妈焦急的等待儿子回来。
儿子买酱油，过去5分钟, 
儿子买酱油，过去6分钟, 
儿子买酱油，过去7分钟, 
儿子买酱油，过去8分钟, 
儿子买酱油，过去9分钟, 
儿子买酱油，过去10分钟, 
儿子买酱油回来了，等待妈妈开门
妈妈开门，拿到酱油
妈妈开始炒菜
菜炒完毕了~~~




主线程执行时间长（mother10分钟），子线程执行时间短（son5分钟）测试场景如下：----------------------------------------------

  1. 妈妈(MotherThread)准备炒菜
  2. 发现没有酱油，就让儿子(SonThread)去买回来----需要5分钟
  3. 期间妈妈一直在看电视-------看10分钟
  4. 儿子过了5分钟之后买回来，在门外敲门，等待妈妈开门
  5. 此时妈妈才看了5分钟的电视
  6. 又过了5分钟之后，妈妈看完电视，才给儿子开门，拿到酱油
  7. 妈妈开始继续炒菜。

测试代码如下：

MotherThread.java


package thread;

public class MotherThread implements Runnable {

	@Override
	public void run() {
		String threadName = Thread.currentThread().getName()+"------>";
		// 是否儿子去买酱油
		boolean buySoy = false;
		// 是否看电视
		boolean watchTV = false;

		System.out.println(threadName+"妈妈准备炒菜");
		try {
			Thread.sleep(1000); // 炒菜持续一分钟之后
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.out.println(threadName+"妈妈发现没有酱油");
		buySoy = true; // 儿子去买酱油
		watchTV = true; // 买酱油期间，看电视

		Thread son = new Thread(new SonThread());
		if (buySoy) {
			System.out.println(threadName+"妈妈让儿子去买酱油");
			son.start();
		}

		if (watchTV) {
			// 儿子买酱油的同时，妈妈开始看10分钟电视
			System.out.println(threadName+"儿子买酱油的同时，妈妈开始看10分钟电视：");
			try {
				for (int i = 1; i <= 10; i++) {

					Thread.sleep(1000); //这里用sleep时间代表看电视
					System.out.println(threadName+"son thread is alive:"+ son.isAlive()); //观察son线程是否已经进入死亡状态
					System.out.println(threadName+"妈妈看电视，过去" + i + "分钟, ");
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		
		try {
			System.out.println(threadName+"看完电视，10分钟过去了，妈妈才想起来，儿子应该5分钟前就已经回来了。");
			son.join();
			System.out.println(threadName+"妈妈开门，拿到酱油");
		} catch (InterruptedException e) {
			System.err.println(threadName+"儿子发生异常！妈妈中断炒菜");
			System.exit(1);
		}

		System.out.println(threadName+"妈妈开始炒菜");
		System.out.println(threadName+"菜炒完毕了~~~");

	}

}



SonThread.java 

package thread;

public class SonThread implements Runnable {
	public void run() {
		String threadName = Thread.currentThread().getName()+"------>";
		System.out.println(threadName+"儿子开始买酱油，买酱油需要5分钟：");
		try {
			for (int i = 1; i <= 5; i++) {
				Thread.sleep(1000); //这里用sleep时间代表买酱油
				System.out.println(threadName+"儿子买酱油，过去" + i + "分钟, ");
			}
		} catch (InterruptedException e) {
			System.err.println(threadName+"儿子发生意外");
		}
		System.out.println(threadName+"儿子买酱油回来了，等待妈妈开门");
	}
}



控制台效果：

Thread-0------>妈妈准备炒菜
Thread-0------>妈妈发现没有酱油
Thread-0------>妈妈让儿子去买酱油
Thread-0------>儿子买酱油的同时，妈妈开始看10分钟电视：
Thread-1------>儿子开始买酱油，买酱油需要5分钟：
Thread-0------>son thread is alive:true
Thread-1------>儿子买酱油，过去1分钟, 
Thread-0------>妈妈看电视，过去1分钟, 
Thread-1------>儿子买酱油，过去2分钟, 
Thread-0------>son thread is alive:true
Thread-0------>妈妈看电视，过去2分钟, 
Thread-1------>儿子买酱油，过去3分钟, 
Thread-0------>son thread is alive:true
Thread-0------>妈妈看电视，过去3分钟, 
Thread-1------>儿子买酱油，过去4分钟, 
Thread-0------>son thread is alive:true
Thread-0------>妈妈看电视，过去4分钟, 
Thread-0------>son thread is alive:true
Thread-1------>儿子买酱油，过去5分钟, 
Thread-0------>妈妈看电视，过去5分钟, 
Thread-1------>儿子买酱油回来了，等待妈妈开门
Thread-0------>son thread is alive:false
Thread-0------>妈妈看电视，过去6分钟, 
Thread-0------>son thread is alive:false
Thread-0------>妈妈看电视，过去7分钟, 
Thread-0------>son thread is alive:false
Thread-0------>妈妈看电视，过去8分钟, 
Thread-0------>son thread is alive:false
Thread-0------>妈妈看电视，过去9分钟, 
Thread-0------>son thread is alive:false
Thread-0------>妈妈看电视，过去10分钟, 
Thread-0------>看完电视，10分钟过去了，妈妈才想起来，儿子应该5分钟前就已经回来了。
Thread-0------>妈妈开门，拿到酱油
Thread-0------>妈妈开始炒菜
Thread-0------>菜炒完毕了~~~


希望大家能够通过测试2的这两个例子，能对join方法有一个深刻的体会。



另外join方法还可以穿入参数！怎么理解？我的如下理解奋斗：

  • 妈妈让儿子去买酱油（儿子买酱油期间，妈妈想干啥都可以，跟join方法不发生关系）
  • 妈妈假定了儿子去买酱油需要10分钟：son.join(10*1000)

  • 如果10分钟之后，儿子还没有买回来酱油。
  • 妈妈就不等了，不用酱油继续炒菜！

  • 如果10分钟之内！儿子买回来酱油。
  • 妈妈用酱油，继续炒菜！
  • 大笑大笑大笑大笑大笑



注意，我例子里面的分钟，其实就是代码里面的秒啦


茜茜770
关注
专栏目录
线程终止 Thread.join()
y394996630的专栏
06-23 4332
今天看到一个线程终止的方式： thread.isRunning = false; try { thread.join(); } catch (InterruptedException e) { e.printStackTrace(); } 线程终止
线程执行Thread.join()
qq_25004825的博客
02-07 271
public class Test { public static void main(String[] args) throws IOException { System.out.println("进入线程"+Thread.currentThread().getName()); Test test = new Test(); M...
三十一、多线程join（ ）方法暂停当前线程
qq_41995845的博客
08-03 112
package demo5; public class TestA { public static void main(String[] args) { // TODO Auto-generated method stub for (int i = 0; i <10; i++) { if (i==5) { A a = new A("name"); try { a.start(); a.join(); } catch (Inter
java并发：Thread中的join方法
qq_51110877的博客
08-15 472
join()方法用于等待调用该方法的线程完成执行。当一个线程调用另一个线程的join()方法时，它会暂停自己的执行，直到被调用的线程完成执行才会继续执行。join()
详解Java线程中的join()方法
热门推荐
wzwjm123的博客
05-17 1万+
对于Java中的join()方法的描述，我们首先来看下源码当中的解释 从源码当中的描述，我们只能知道join方法的作用是让线程陷入等待。其中可以传递以毫秒为单位的等待时间参数，如果传递参数为0，则线程会一直等待。 其实对于join方法，网上有很多解释，大都是只说如何使用，并没有对join当中的实现进行分析。 因此，在此结合网上的各种说法，对线程中的join方法进行源码分析，同时也记录自己的学习过程。 首先先来了解join方法如何使用，以及它的作用。 为了更有对比性的展示，首先来个简单并正常使用（不使
join() 在多线程中的使用
m0_62943934的博客
11-07 2793
在很多情况下，主线程创建并启动子线程，如果子线程中要进行大量的耗时运算，主线程往往将早于子线程结束，这时如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，这个时候就要用到 join() 方法了。方法 join() 的作用是等待线程对象销毁。
Java使用join方法暂停当前线程
08-30
主要为大家详细介绍了Java使用join方法暂停当前线程，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java多线程-Thread类的常用结构及线程优先级
01-27
Java多线程编程是开发高并发应用的基础，其中Thread类是实现多线程的核心类。本文将详细解析Thread类的常用结构以及线程优先级。 一、Thread类的常用结构 1. 线程中的构造器 - `Thread()`：创建一个没有指定名称...
java线程源码-ng-javathread:该存储库是Nextgen关于学习Java线程的文章的源代码。请访问原始文章：
05-25
4. `sleep(long milliseconds)`和`yield()`: `sleep()`使当前线程暂停指定的时间，`yield()`则让当前线程暂停，给其他线程执行的机会。 5. `interrupt()`: 用于中断一个线程。如果线程正在执行的阻塞方法支持中断，...
java-Thread-study-summary.zip_java 多线程
09-24
Java线程有10个优先级，`MIN_PRIORITY`（1），`NORM_PRIORITY`（5）和`MAX_PRIORITY`（10）。较高的优先级并不意味着线程一定先执行，而是增加了获取CPU资源的概率。 5. **守护线程（Daemon）** 守护线程是支持...
Java多线程-多线程知识点总结和企业真题
最新发布
02-04
- `yield()`方法让当前线程暂停执行，并允许具有相同优先级的其他线程运行。 - **题4**：`Thread.currentThread()`方法的作用是什么？ - 返回当前正在执行的线程对象。 - **题5**：`Thread.getName()`和`Thread....
Java多线程-线程的生命周期
01-27
线程状态之间的转换是由Java API的方法调用触发的，如`start()`、`sleep()`、`wait()`、`join()`等。了解这些状态和转换机制对于编写高效的并发程序至关重要，因为它有助于避免死锁、饥饿和其他并发问题。在实际编程...
线程中 sleep()、wait()、join()、yield()的区别
越努力越有钱的博客
06-10 4387
sleep() 　　sleep()方法需要指定等待的时间，它可以让当前正在执行的线程在指定的时间内暂停执行，进入阻塞状态，该方法既可以让其他同优先级或者高优先级的线程得到执行的机会，也可以让低优先级的线程得到执行机会。但是sleep()方法不会释放“锁标志”，也就是说如果有synchronized同步块，其他线程仍然不能访问共享数据。 　　 wait() 　　wait()方法需要和notify()及notifyAll()两个方法一起介绍，这三个方法用于协调多个线程对共享数据的存取，所以必须在synchron
Java并发编程（四）等待线程执行终止的join方法
逆流者的博客
01-19 351
public class JoinTest { public static void main(String[] args) throws InterruptedException { Thread threadOne = new Thread(new Runnable() { @Override public void run() { try { Thread
Java通过join方法来暂停当前线程
weixin_33739627的博客
03-08 153
目标线程的join方法暂停当前线程，直到目前线程完成（从run()方法返回）。   Java代码： package Threads; import java.io.IOException; /** * Created by Frank */ public class Join { public static void main(String[] args) { T...
java暂停的方法_Java使用join方法暂停当前线程
weixin_39927378的博客
02-25 193
目标线程的join方法暂停当前线程，直到目前线程完成(从run()方法返回)，供大家参考，具体内容如下Java代码：package Threads;import java.io.IOException;/*** Created by Frank*/public class Join {public static void main(String[] args) {Thread t = new Th...
操作系统-有关c++多线程基本知识
Schwertlilien的小屋
03-29 1210
文章目录基本语法互斥量手动加锁自动加锁loading... 基本语法 多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下，两种类型的多任务处理：基于进程和基于线程。 基于进程的多任务处理是程序的并发执行。 基于线程的多任务处理是同一程序的片段的并发执行。 多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程，每个线程定义了一个单独的执行路径。 有两种线程阻塞方法join()与detach()。阻塞线程的目的是调节各线程的先后执行顺序
多线程暂停 sleep、yeild、wait、join
itcard的专栏
02-19 1148
sleep sleep 方法是属于Thread 类中的，sleep 过程中线程不会释放锁，只会阻塞线程，让出cpu给其他线程，但是他的监控状态依然保持着，当指定的时间到了又会自动恢复运行状态，可中断，sleep 给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会 yield 和 sleep 一样都是 Thread 类的方法，都是暂停当前正在执行的线程对象，不会释放资源锁，和 sleep 不同的是 yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新.
JavaBean 和 Map 之间互相转换
miqi770的专栏
12-20 1万+
import java.beans.BeanInfo; import java.beans.IntrospectionException; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.InvocationTargetException; import j
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值