join()——化多线程并发执行为顺序执行

本文详细解析了Java中线程的Join方法的作用及其实现原理。解释了如何使用Join方法来控制线程间的执行顺序,并通过示例代码展示了如何确保一个线程等待另一个线程完成。

多线程并发比较常见,但很多时候一个线程的输入可能非常依赖于另外一个线程的输出,此时这个线程就需要等待依赖线程执行完毕再执行。通俗的说,就是合并多个路径为单一路径,变多线程并发为单线程顺序执行。JDK提供了Join()这个Thread类的实例方法来达到这个要求。

join——英文含义为加入,通俗的说就是将一个线程合并到另一个线程。但是还有以下几个问题:

哪个线程加入?

加入到哪个线程?

加入后的效果是啥?

通过下面一段代码可以进行验证:

public class JoinTest extends Thread {
    private static int i = 0;

    @Override
    public void run() {
        while (i < 100000) {
           i++;
        }
    }

    public static void main(String[] args) throws Exception {
        Thread th = new JoinTest();
        //注意:必须先start,再join
        th.start();
        th.join();
        System.out.println(i);
    }
}

       执行结果为:100000       

 验证后可以回答上面三个问题了。

       哪个线程加入?——>调用Join()函数的那个对象开启的线程,注意要先开启线程,才能加入start,也就是start()方法要在join()方法前面。本例中是

JoinTest

     加入到哪个线程?——>加入到当前线程,通俗的说在哪个线程中执行该函数的,就加入哪个线程。

本例中是

main

    加入后的效果?——>阻塞当前线程,直到加入的线程执行完,当前线程继续执行。

    join的本质是让当前线程wait()在调用join方法的那个线程实例的锁上,等到那个线程实例开启的线程跑完,再notify()当前线程继续执行。下面是JDK中join()实现的核心代码片段:

public final synchronized void join(long paramLong)
			throws InterruptedException {
		long l1 = System.currentTimeMillis();
		long l2 = 0L;
		if (paramLong < 0L)
			throw new IllegalArgumentException("timeout value is negative");
	        //过期时间为0
		if (paramLong == 0L)
			while (true) {
                                //isAlive()是一个实例方法,用来判断线程(不是当前main线程,
                                //而是含有该方法的线程实例JoinTest启动的那个线程)是否存活,通俗的说就是run方法有没有跑完
				if (!(isAlive()))
					return;
				//这里是关键,同步方法内调用锁对象的wait()方法阻塞当前线程
				//可能这里会有疑问,阻塞的难道不是JoinTest线程吗?你看,是JoinTest对象里的方法
				//是不是JoinTest线程要看它在不在run方法里面,这个函数在run方法里面吗?显然不是
				super.wait(0L);//被合并线程未结束,当前线程继续等待
			}
		while (isAlive()) {
			long l3 = paramLong - l2;
			if (l3 <= 0L)
				return;
			super.wait(l3);
			l2 = System.currentTimeMillis() - l1;
		}
	}

    之后的流程我们也能猜到,被合并的线程执行完后,会notify()【其实这里是notifyall()】等待线程继续执行。



转载于:https://my.oschina.net/u/2529036/blog/618014

### 多线程环境下的任务顺序执行方法 在多线程环境中,为了保证多个任务按照特定的顺序依次完成,可以通过多种方式来实现。以下是常见的几种解决方案: #### 方法一:使用 `newSingleThreadExecutor` 创建单一线程池 通过创建一个单一线程池 (`newSingleThreadExecutor`) 来管理任务队列,该线程池内部只有一个工作线程,因此提交的任务会被逐个执行,从而自然地保持了任务的顺序[^1]。 ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class SingleThreadExample { public static void main(String[] args) { ExecutorService executor = Executors.newSingleThreadExecutor(); for (int i = 0; i < 5; i++) { final int taskNumber = i; executor.submit(() -> System.out.println("Task " + taskNumber)); } executor.shutdown(); } } ``` --- #### 方法二:利用 `join()` 方法显式指定顺序 当需要手动控制线程执行顺序时,可以借助 `join()` 方法。在一个线程启动之后立即调用其 `join()` 方法,可以让当前线程等待直到目标线程结束再继续运行[^2]。 ```java class Task implements Runnable { private String name; public Task(String name) { this.name = name; } @Override public void run() { try { Thread.sleep(100); // Simulate work System.out.println(name); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } public class JoinExample { public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(new Task("T1")); Thread t2 = new Thread(new Task("T2")); t1.start(); t1.join(); // Wait until T1 finishes t2.start(); t2.join(); // Wait until T2 finishes } } ``` --- #### 方法三:基于同步机制(`wait()` 和 `notifyAll()`) 这种方法依赖于 Java 的内置锁机制。在线程 A 执行完毕后自动释放锁并唤醒其他正在等待的线程 B 继续执行。这种方式适用于更复杂的场景,比如动态调整任务间的依赖关系。 ```java public class SyncOrderExecution { private Object lock = new Object(); public void executeInOrder(Runnable... tasks) { synchronized (lock) { for (Runnable task : tasks) { new Thread(() -> { try { task.run(); lock.notifyAll(); // Notify next thread to proceed } finally { try { lock.wait(); } catch (InterruptedException ignored) {} } }).start(); try { lock.wait(); } catch (InterruptedException ignored) {} // Block current thread till child completes } } } public static void main(String[] args) { var example = new SyncOrderExecution(); example.executeInOrder( () -> System.out.println("First"), () -> System.out.println("Second") ); } } ``` --- #### 方法四:采用计数信号量或屏障(CyclicBarrier/CountDownLatch) 这些工具类提供了更高层次的抽象用于协调并发操作中的流程控制。例如,`CyclicBarrier` 可以用来阻塞一组线程直至它们全部到达某个公共点;而 `CountDownLatch` 则允许某线程等待若干事件发生后再前进。 ```java import java.util.concurrent.CyclicBarrier; public class BarrierExample { public static void main(String[] args) { CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("All threads reached the barrier.")); for(int i=1;i<=3;i++) new Thread(() -> { System.out.println(Thread.currentThread().getName()+" is waiting at barrier."); try{barrier.await();} catch(Exception ex){ex.printStackTrace();} }, "Thread-"+i).start(); } } ``` --- ### 总结 以上介绍了四种主要的技术手段——分别是 **单线程池**、**Join 调度**、**同步原语**以及 **高级同步辅助器** —— 它们各有优劣,在实际开发过程中可以根据具体需求灵活选用合适的策略。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值