Thread中的join()方法

最新推荐文章于 2023-03-17 17:54:58 发布
最新推荐文章于 2023-03-17 17:54:58 发布
阅读量772 收藏
点赞数 1
分类专栏： 实战教程 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Eye9093/article/details/80474162
版权

在对于join()方法是否会释放"锁标识"问题，可以这样认为，一定要看有无synchronized关键字的前提下，大致分为四种情况:

1.没有synchronized关键字，访问的也不是同一资源

这种情况下是不存在什么锁的，因为访问的不是同一资源，两个不同的对象。那么可以理解成是等待调用join()方法的线程结束，再执行。代码如下:

public class TestThreadJoinMethod implements Runnable {

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+"执行"+i+"次");
		}
	}

}
public class Test {
	public static void main(String[] args) {
		TestThreadJoinMethod t = new TestThreadJoinMethod();
		Thread r = new Thread(t,"线程一");
		r.start();
		for (int i = 0; i < 10; i++) {
			System.out.println("主线程执行到第"+i+"步");
			if(i>2){
				try {
					r.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}

执行结果:

主线程执行到第0步
线程一执行0次
主线程执行到第1步
线程一执行1次
主线程执行到第2步
线程一执行2次
主线程执行到第3步
线程一执行3次
线程一执行4次
线程一执行5次
线程一执行6次
线程一执行7次
线程一执行8次
线程一执行9次
主线程执行到第4步
主线程执行到第5步
主线程执行到第6步
主线程执行到第7步
主线程执行到第8步
主线程执行到第9步

结果显示:在join()之前，两个不同的线程一直都是在交叉执行的，争夺CPU执行权。在遇到join()方法后，调用了r的线程直至结束才调用主线程的。

2.没有synchronized关键字，访问的是同一资源

public class TestThreadJoinMethod implements Runnable {

	@Override
	public void run() {//注意这里是没有用synchronized关键字的

		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+"执行"+i+"次");
		}
	}

}
public class Test {
	public static void main(String[] args) {
		TestThreadJoinMethod r = new TestThreadJoinMethod();
		Thread t1 = new Thread(r,"线程一");
		Thread t2 = new Thread(r,"线程二");
		Thread t3 = new Thread(r,"线程三");
		t1.start();
		t2.start();
		try {
			t2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t3.start();
//这里的三个线程都是访问的同一资源，创建对象都是r

结果:

线程一执行0次
线程二执行0次
线程一执行1次
线程二执行1次
线程二执行2次
线程一执行2次
线程二执行3次
线程一执行3次
线程一执行4次
线程一执行5次
线程一执行6次
线程一执行7次
线程一执行8次
线程一执行9次
线程二执行4次
线程二执行5次
线程二执行6次
线程二执行7次
线程二执行8次
线程二执行9次
线程三执行0次
线程三执行1次
线程三执行2次
线程三执行3次
线程三执行4次
线程三执行5次
线程三执行6次
线程三执行7次
线程三执行8次
线程三执行9次

前面线程一和二交叉执行，最后才是线程三执行，因为join()方法出现在线程一和线程三中间，所以，线程三总得等到线程二执行完毕才能执行。

3.有synchronized关键字，访问不是同一资源

//线程一
public class TestThreadJoinMethod implements Runnable {

	@Override
	public synchronized void run() {
		for (int i = 0; i < 10; i++) {
			TestThreadJoinMethod2 joinMethod2 = new TestThreadJoinMethod2();
			Thread c = new Thread(joinMethod2);
			System.out.println(Thread.currentThread().getName()+"执行"+i+"次");
			if(i == 5){
				c.start();
				try {
                                c.join();
                            } catch (InterruptedException e) {
e.printStackTrace();}}}}}//线程二class TestThreadJoinMethod2 implements Runnable{@Overridepublic void run() {System.out.println("我是来插队的");}} 
public class Test {
	public static void main(String[] args) {
		TestThreadJoinMethod r = new TestThreadJoinMethod();
		Thread t1 = new Thread(r,"线程一");
		Thread t2 = new Thread(r,"线程二");
		Thread t3 = new Thread(r,"线程三");
		t1.start();
		t2.start();
		t3.start();

结果:

线程一执行0次
线程一执行1次
线程一执行2次
线程一执行3次
线程一执行4次
线程一执行5次
我是来插队的
线程一执行6次
线程一执行7次
线程一执行8次
线程一执行9次
线程三执行0次
线程三执行1次
线程三执行2次
线程三执行3次
线程三执行4次
线程三执行5次
我是来插队的
线程三执行6次
线程三执行7次
线程三执行8次
线程三执行9次
线程二执行0次
线程二执行1次
线程二执行2次
线程二执行3次
线程二执行4次
线程二执行5次
我是来插队的
线程二执行6次
线程二执行7次
线程二执行8次
线程二执行9次

结论:因为两个是访问的不同的锁对象，所以没有释放不释放锁标识这一说。跟第一种情况类似

4.有synchronized关键字，访问的是同一资源

public class TestThreadJoinMethod implements Runnable {

	@Override
	public synchronized void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+"执行"+i+"次");
		}
	}

}

public class Test {
	public static void main(String[] args) {
		TestThreadJoinMethod r = new TestThreadJoinMethod();
		Thread t1 = new Thread(r,"线程一");
		Thread t2 = new Thread(r,"线程二");
		Thread t3 = new Thread(r,"线程三");
		t1.start();
		t2.start();
		t3.start();

结果:

线程一执行0次
线程一执行1次
线程一执行2次
线程一执行3次
线程一执行4次
线程一执行5次
线程一执行6次
线程一执行7次
线程一执行8次
线程一执行9次
线程三执行0次
线程三执行1次
线程三执行2次
线程三执行3次
线程三执行4次
线程三执行5次
线程三执行6次
线程三执行7次
线程三执行8次
线程三执行9次
线程二执行0次
线程二执行1次
线程二执行2次
线程二执行3次
线程二执行4次
线程二执行5次
线程二执行6次
线程二执行7次
线程二执行8次
线程二执行9次

结论:线程三在执行线程二之前，这说明，在第一时间三个线程是一起争夺CPU执行权的，线程一抢到之后，拿到了对象的锁，线程二和线程三只能等待线程一释放锁，才有机会执行。跟抢厕所一个道理。大笑



5.补充一点额外，不用join()，访问同一资源，卖票例子类同。只是突然想到了，就试了一下。跟本题没有关系

public class TestThreadJoinMethod implements Runnable {

	@Override
	public void run() {//注意这里是没有用synchronized关键字的

		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+"执行"+i+"次");
		}
	}

}
public class Test {
	public static void main(String[] args) {
		TestThreadJoinMethod r = new TestThreadJoinMethod();
		Thread t1 = new Thread(r,"线程一");
		Thread t2 = new Thread(r,"线程二");
		Thread t3 = new Thread(r,"线程三");
		t1.start();
		t2.start();
		t3.start();
//这里的三个线程都是访问的同一资源，创建对象都是r

结果如下:

线程一执行0次
线程二执行0次
线程三执行0次
线程三执行1次
线程二执行1次
线程一执行1次
线程一执行2次
线程二执行2次
线程三执行2次
线程二执行3次
线程二执行4次
线程二执行5次
线程二执行6次
线程二执行7次
线程二执行8次
线程一执行3次
线程二执行9次
线程三执行3次
线程三执行4次
线程三执行5次
线程三执行6次
线程一执行4次
线程三执行7次
线程一执行5次
线程三执行8次
线程一执行6次
线程三执行9次
线程一执行7次
线程一执行8次
线程一执行9次

从结果来看，三个线程访问同一个资源，交叉执行，争夺CPU资源。这个跟卖票的例子类同。会出现卖重票的错误。




田螺小伙丶
关注
专栏目录
Java Thread中的join()方法解释
wenhonglian的博客
08-28 8180
Join作用 join是定义在Thread类中的方法，作用是阻塞当前线程的执行，等到被调用join的线程对象执行完毕才执行继续执行当前线程。在Java源码中的定义如下： public final void join() throws InterruptedException { join(0); } public final synchronized void join(long millis) throws InterruptedException 接下来我们先来看看join的简单使用，这样能
java中的join方法 转载
Java 初学者
04-26 145
原创 浅析 Java Thread.join() 收藏 一、在研究join的用法之前，先明确两件事情。 1.join方法定义在Thread类中，则调用者必须是一个线程， 例如： Thread t = new CustomThread();//这里一般是自定义的线程类 t.start();//线程起动 t.join();//此处会抛出InterruptedEx...
Java坑点： Thread.currentThread().join()
hi_你好
10-11 4820
Thread.currentThread().join() join方法的作用是阻塞，即等待线程结束，才继续执行。 t.join() 的作用是 谁执行t.join()方法就等待t执行完毕 坑点在于： Thread.currentThread().join()； 线程一直在阻塞，无法终止。自己等待自己结束。 ...
addShutdownHook()和Thread.currentThread().join()
weixin_33936401的博客
12-15 211
2019独角兽企业重金招聘Python工程师标准>>> ...
Thread 的 join() 方法
热门推荐
STRANGE-P 的博客
06-06 1万+
关于 Thread 的 join 方法 1、join() 方法说明2、代码演示2.1 添加 join() 方法后2.2 添加 join() 方法前2.3 对比说明3、源码理解   线程模块，计划用一个系列博文整理总结。上一篇博文：  《线程系列1：创建线程》     1、join() 方法说明   join() 是Thread的实例方...
Java中Thread.join()的使用方法
08-18
Java 中 Thread.join() 的使用方法 Thread.join() 是 Java 中的一个重要方法，该方法允许一个线程等待另一个线程的执行完成。下面我们将详细介绍 Thread.join() 的使用方法、源码分析和示例代码。 1. join() 的...
c++11中关于std::thread的join的详解
08-26
C++11中关于std::thread的join详解 C++11引入了std::thread库，提供了对多线程编程的支持。std::thread库提供了两个基本操作：join和detach。join操作用于回收线程资源，避免资源泄露；detach操作用于将线程与创建...
java 中Thread.join()的使用方法
08-30
在Java编程语言中，`Thread.join()`方法是一个非常重要的同步工具，它允许一个线程（调用者）等待另一个线程（被调用者）执行完成。`Thread.join()`的使用能够有效地解决多线程环境中的顺序执行问题，确保线程间的...
Java之Thread的join方法实例
09-04
在Java多线程编程中，`Thread.join()`方法是一个非常重要的同步工具，它允许一个线程等待另一个线程结束执行后再继续执行。这个方法在处理并发控制和线程协作时非常有用，确保线程间的执行顺序。下面我们将深入探讨`...
java currenthread,在Java中使用Thread.currentThread().join()
weixin_34384824的博客
02-25 533
The following code is taken from an example in the Jersey project. See here.public class App {private static final URI BASE_URI = URI.create("http://localhost:8080/base/");public static final String R...
关于C#中Thread.Join()的一点理解
weixin_30512043的博客
07-17 274
今天是第一次在C#中接触Thread，自己研究了一下其中Thread.Join()这个方法，下面谈谈自己的理解。 Thread.Join()在MSDN中的解释很模糊：Blocks the calling thread until a thread terminates 有两个主要问题：1.什么是the calling thread? ...
Thread.Join() 方法
weixin_34163553的博客
06-27 64
MSDN：Blocks the calling thread until a thread terminates 1. 什么是 the calling thread? 2. 什么是 a thread?   运行一个程序，即开启了一个进程和至少一个线程，干活的是线程而非进程！the calling thread 我们可以认为是MainThread（或者调用线程的线程，是不是有点绕？呵呵），a...
Thread.join用法
Event driven
04-10 252
Thread.join(): 用来让主线程等待子线程执行完毕再执行下面的操作。 顾名思义，join会让子线程加入MainThread.   适用场景： 主线程需要等子线程执行完毕后，再执行下一步操作。 比如：主线程需要统计子线程的执行时间，或需要统计子线程的执行结果等。   join() 的作用是等待该线程终止，即该线程存活的时候一直等待，等待线程死亡，好残忍 。。 JDK的源...
Thread中join()使用
zys1440298847的博客
03-17 852
我以前也有过类似需要等待子线程执行完，然后执行主线程的需求，当时应该是直接让主线程等待的。有了这个threadB.join()方法，这样就合理多了，避免了主线程等待时的空自旋；比如当子线程中业务逻辑处理的时间很长时，那么主线程就会先于子线程提前结束，而如果想要主线程在子线程处理完以后再结束（比如需要子线程中返回的数据），那就可以使用 Thread threadSon.join()；然后就深入地了解下join()方法，从一个地方拓展到其他地方；，即阻塞主线程继续执行，直到子线程处理结束；
Thread.join()
zzaric的博客
02-11 4908
线程的Thread.join 含义： 当前线程A等待thread线程终止之后才能从thread.join()返回。线程Thread除了提供join()方法之外，还提供了join(long millis)和join(long millies,int nanos)两个具备超时特性的方法。这两个超时方法标识，如果线程thread在给定的超时时间里没有终止，那么将会从该超时方法中返回。 在下面的代码清单中...
Thread线程的join
智三岁的博客
01-15 255
java线程join的方法简单讲解 1、作用 Thread类中的join方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行(也就是同时只执行一个)。具体看代码： public class JoinTest { public static void main(String [] args) throws InterruptedException { Thre...
Thread.join()详解
Poxi_Zhang的博客
06-19 418
话不多说，直接上代码。 /** * 等待线程死亡。 */ public final void join() throws InterruptedException { // 参数0表示永久等待 join(0); } /** * 下面才是正戏 * 等待最多millis的时间,如果millis为0,则一直等待 * * 通过调用控制条件为isAlive()的wait()方法来实现.当线程终止时,就
about thread.join
08-20 489
 thread.join() 方法的使用对这个方法一直没搞明白，而然在CNBLOGS上看到  线程的插入 Join()函数终于明白。。Thread类的join 方法能够将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的join()方法 ，将线程A插入到线程B中，直到线程A执行完毕后，才会继续执行线程B。 using System;using Syst
Thread的join()方法
weixin_28760063的博客
08-24 255
版权声明：本文为CSDN博主「2的32次方」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/a158123/article/details/78633772 join简介 join()方法是Thread类中的一个方法，该方法的定义是等待该线程终止。其实就是join()方法将挂起调用线程的执行，直到被调用...
Thread的join方法
最新发布
07-12
Thread类的join方法是用来等待线程执行完毕的方法。调用该方法会阻塞当前线程，直到被调用的线程执行完毕。 具体使用方法是调用Thread对象的join()方法，例如： ```python thread.join() ``` 调用join方法后，当前...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值