如何实现某个线程在其他线程执行完毕之后再执行?

最新推荐文章于 2024-04-19 13:35:23 发布
最新推荐文章于 2024-04-19 13:35:23 发布
阅读量5.3k 收藏 11
点赞数 2
分类专栏： 并发编程 文章标签： 多线程 并发编程 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36184373/article/details/105608561
版权

我们都知道, 在使用多线程编程的时候,每个线程运行的顺序都是随机的, 它由CPU的线程调度机制决定执行哪个线程;
我们可以看看正常使用多线程编程时程序的运行顺序:

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchTest {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //CountDownLatch countDownLatch = new CountDownLatch(3);
        try {
            for (int i = 0; i < 3; i++) {

                executorService.submit(new Callable<List<String>>() {

                    @Override
                    public List<String> call() throws Exception {
                        try {
                            //doSomeThing()
                            //Thread.sleep(1000);
                            System.out.println(Thread.currentThread().getName() + "线程开始执行");
                        } catch (Exception e) {

                        } finally {
                           //countDownLatch.countDown();

                        }
                        return new ArrayList<>();

                    }

                });
            }

            //countDownLatch.await();
            //System.out.println("主线程执行");

            executorService.submit(new Callable<List<String>>() {

                @Override
                public List<String> call() throws Exception {
                    try {
                        //doSomeThing()
                        //countDownLatch.await();
                        System.out.println("测试线程开始执行");
                    } catch (Exception e) {

                    } finally {

                    }
                    return new ArrayList<>();

                }

            });

        } catch (Exception e) {

        }finally {
            executorService.shutdown();
        }

    }
}

执行结果:
在这里插入图片描述
在这里插入图片描述
可以看到,线程的执行顺序是随机的,他们执行的顺序并不固定.
那么现在有一个需求, 我想让测试线程必须执行在其他三个线程执行完毕之后才执行, 也就是测试线程必须执行在其他三个线程的后面. 该怎么实现呢?

有一个通俗一点的例子: 有三个工人在为老板干活，这个老板有一个习惯，就是当三个工人把一天的活都干完了的时候，他就来检查所有工人所干的活。记住这个条件：三个工人先全部干完活，老板才检查。
如何实现以上的需求呢?

CountDownLatch

CountDownLatch的一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个CountDownLatch对象上的countDown()方法，这个调用await()方法的任务将一直阻塞等待，直到这个CountDownLatch对象的计数值减到0为止。

CountDownLatch有两个核心的方法, countDown()和await()方法.在使用CountDownLatch的时候, 必须要传入一个数值型参数作为计数器的值. 调用countDown()方法可以将值减1. 而调用了await()方法的线程,在计数器的值为0之前, 会被一直阻塞. 直到计数器的值为0时才会被唤醒. 因此.可以通过CountDownLatch来实现某个线程在其他线程执行完毕之后再执行.

那么使用CountDownLatch之后会怎么样呢?

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchTest {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
         //初始化CountDownLatch 计数器的值
        CountDownLatch countDownLatch = new CountDownLatch(3);
        try {
            for (int i = 0; i < 3; i++) {
//创建三个线程, 每个线程执行完后调用countDownLatch 对象的countDown()方法将计数器减1
                executorService.submit(new Callable<List<String>>() {

                    @Override
                    public List<String> call() throws Exception {
                        try {
                            //doSomeThing()
                            Thread.sleep(1000);
                            System.out.println(Thread.currentThread().getName() + "线程开始执行");
                        } catch (Exception e) {

                        } finally {
                           countDownLatch.countDown();

                        }
                        return new ArrayList<>();

                    }

                });
            }
            
            executorService.submit(new Callable<List<String>>() {

                @Override
                public List<String> call() throws Exception {
                    try {
                        //doSomeThing()
                        //当计数器的值变为0之后,调用同一个countDownLatch对象的await()方法的主线程将会被唤醒
                        countDownLatch.await();
                        System.out.println("测试线程开始执行");
                    } catch (Exception e) {

                    } finally {

                    }
                    return new ArrayList<>();

                }

            });

        } catch (Exception e) {

        }finally {
            executorService.shutdown();
        }

    }
}

执行结果:
在这里插入图片描述
在这里插入图片描述
可以看到, 测试线程都是在前三个线程执行完毕之后才执行的
如上面的代码中所示. 测试线程在计数器的值变为0之前, 会一直处于阻塞状态.只有当计数器值变为0时才会被唤醒. 也就是说, 测试线程是必须要运行在前三个线程之后的.

了解到CountDownLatch的作用以及使用机制之后, 我们可以看看源码,看看CountDownLatch是如何实现阻塞测试线程, 并且在计数器为0时再唤醒测试线程的.

CountDownLatch: wait()方法：

       

         public void await() throws InterruptedException {
         sync.acquireSharedInterruptibly(1);
         }

         public final void acquireSharedInterruptibly(int arg)
         throws InterruptedException {
         if (Thread.interrupted())
         throw new InterruptedException();
         if (tryAcquireShared(arg) < 0)	//计数器state不等于0时
         doAcquireSharedInterruptibly(arg);	//阻塞线程
         }

         protected int tryAcquireShared(int acquires) {
         return (getState() == 0) ? 1 : -1;
         }

         private void doAcquireSharedInterruptibly(int arg)
         throws InterruptedException {
         final Node node = addWaiter(Node.SHARED);//1. 将该线程加入阻塞队列中
         boolean failed = true;
         try {
         for (;;) {
         final Node p = node.predecessor();//获取前一个节点
         if (p == head) {
         int r = tryAcquireShared(arg);//2. 判断state是否为0; r>=0说明为0
         if (r >= 0) {
         //把当前节点设置成head节点，并传播 唤醒 所有被await()方法阻塞的节点
         setHeadAndPropagate(node, r);
         p.next = null; // help GC
         failed = false;
         return;
         }
         }

         //2. 到此处,说明state != 0
         //检查是否应该阻塞节点
         if (shouldParkAfterFailedAcquire(p, node) &&
         //阻塞节点
         parkAndCheckInterrupt())
         throw new InterruptedException();
         }
         } finally {
         if (failed)
         cancelAcquire(node);
         }
         }

         await()流程：
         判断state（即计数器的数量是否等于0）
         不等于0则将线程加入阻塞队列中
         等于0则唤醒所有被await()方法阻塞的线程

我们来看看CountDownLatch类的结构:
在这里插入图片描述
可以看到CountDownLatch类中有一个继承自AQS抽象类的Sync类. AQS中实现了对同步代码中的各类操作.

先从await()方法看起:

         public void await() throws InterruptedException {
         sync.acquireSharedInterruptibly(1);
         }

可以看到,await()方法中调用了Sync的acquireSharedInterruptibly(1)方法;
acquireSharedInterruptibly()方法:

         public final void acquireSharedInterruptibly(int arg)
         throws InterruptedException {
         if (Thread.interrupted())
         throw new InterruptedException();
         if (tryAcquireShared(arg) < 0)	//计数器state不等于0时
         doAcquireSharedInterruptibly(arg);	//阻塞线程
         }

         protected int tryAcquireShared(int acquires) {
         return (getState() == 0) ? 1 : -1;
         }

acquireSharedInterruptibly方法中,先调用了tryAcquireShared方法来判断state(在CountDownLatch中代表的是计数器的值)的值是否为0 ,不为0时, 调用doAcquireSharedInterruptibly方法阻塞线程;
那么,doAcquireSharedInterruptibly是怎么实现的阻塞线程的呢?

    /**
     *  在共享可中断模式下获取。
     */
    private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.SHARED);//1. 将该线程加入阻塞队列队尾
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();//获取前一个节点
                if (p == head) {
                    int r = tryAcquireShared(arg);//2. 判断state是否为0; r>=0说明为0
                    if (r >= 0) {
                        //把当前节点设置成head节点，并传播 唤醒 所有被await()方法阻塞的节点
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }

                //2. 到此处,说明state != 0
                //检查是否应该阻塞节点
                if (shouldParkAfterFailedAcquire(p, node) &&
                        //阻塞节点
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    private Node addWaiter(Node mode) {
        //创建一个新的节点,封装有当前的线程实例
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;//队尾节点
        if (pred != null) {
            node.prev = pred;
            //采用CAS将当前节点设为队尾节点
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);//向队列队尾处插入节点,此处暂不赘述
        return node;
    }
    
    //挂起线程
    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

从代码中可以看出, AQS中有一个先进先出的队列.而在CountDownLatch类中, 该队列保存的就是被await()方法阻塞的线程. 在执行await()方法之前, 程序会先判断计数器的值是否为0,如果为0则直接执行该线程,反之会将该线程封装到Node节点中,并通过CAS操作将其保存到队列的队尾.然后阻塞该线程. 从这里你是不是猜到了, 既然将阻塞的线程都保存到队列中了,是不是就是为了在计数器值变为0时将其唤醒呢. 没错, 在接下来的countDown()方法中就能找到答案.

countDown()方法:

    public void countDown() {
        sync.releaseShared(1);
    }

    public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {//state(计数器值)减1,且当state为0时返回true
        	//唤醒线程
            doReleaseShared();
            return true;
        }
        return false;
    }
		
        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                //CAS将计数器state的值减1
                if (compareAndSetState(c, nextc))
                //当state为0时返回true
                    return nextc == 0;
            }
        }

可以看到,countDown()方法是利用CAS操作将计数器的值减1,减1成功之后,自然就是判断计数器值是否为0 ,为0时唤醒队列中阻塞的线程了. 那么我们接着看doReleaseShared()方法;

doReleaseShared()

    private void doReleaseShared() {
        /*
         * 确保释放传播,即使有其他进行中的获取/释放。如果它需要信号,则以通常的方式尝试解除头的处理器。但如果不是,状态设置为PROPAGATE以确保在释放后,传播继续。
         * 另外,我们必须循环,以便在我们这样做的时候添加一个新的节点。此外,与unparkSuccessor的其他用法不同,我们需要知道CAS是否重置状态失败,如果这样重新检查。
         * 
         */
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    从头节点开始唤醒队列中的后续线程
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }

唤醒队列中的线程:unparkSuccessor():

    private void unparkSuccessor(Node node) {
        //如果状态为负(即,可能需要信号)尝试在预期的信令中清除。如果这失败或者如果状态通过等待线程而改变,则是OK。
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        Node s = node.next;
        //如果下一个节点不存在或者已经取消等待,那么从尾节点向前遍历,找到离当前节点最近的而且在等待中的节点
        //疑问:为什么从队尾遍历不从当前节点开始遍历?
        //答:因为当前节点的下一个节点可能为空,往下遍历不了
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }

        //唤醒离当前节点最近的且在等待中的节点
        if (s != null)
            LockSupport.unpark(s.thread);
    }

从代码中可以看到, 当计数器值为0 时,会根据队列中的头结点向队尾依次遍历获取阻塞中的节点并唤醒对应节点中的线程. 当下一个节点不存在或者已经取消等待时,会从队尾开始向头结点回溯遍历来唤醒对应的线程.

裸奔的小强QQ
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java：当前线程运行完毕，再运行后续逻辑
aysk1112的博客
05-14 461
一、问题描述 在程序设计中，可能存在这样的情景：主线程中存在一个子线程，子线程需要在执行完毕后为后续代码逻辑提供参数。但在代码执行时，子进程还没执行完毕，后续的代码已经开始执行了，这时候就会出现参数为空的异常，或是直接报错。 1 public class ThreadTest { 2 public static void main(String[] args) { ...
线程池： 等待线程池内所有线程执行完毕后再继续任务
a1751326的博客
11-02 3422
boolean loop = true; do{ loop=!executorService.awaitTermination(2, TimeUnit.SECONDS); }while(loop); 转载于:https://www.cnblogs.com/xxx-xxx/p/7771959.html
介绍几种等待多线程任务执行完毕的方法
最新发布
2401_84121674的博客
04-19 1139
当程序员容易，当一个优秀的程序员是需要不断学习的，从初级程序员到高级程序员，从初级架构师到资深架构师，或者走向管理，从技术经理到技术总监，每个阶段都需要掌握不同的能力。当程序员容易，当一个优秀的程序员是需要不断学习的，从初级程序员到高级程序员，从初级架构师到资深架构师，或者走向管理，从技术经理到技术总监，每个阶段都需要掌握不同的能力。分析总结：执行join方法的线程的所在线程，一直在等待执行join方法的线程完成。运行程序控制台打印i和k的值都是1万，可以得出结论，线程1，线程2都执行完毕了。
java线程池主线程等待子线程执行完成
热门推荐
yaowj2的专栏
04-06 2万+
原文：http://www.jiacheo.org/blog/262  Java如何等待子线程执行结束 今天讨论一个入门级的话题, 不然没东西更新对不起空间和域名~~ 工作总往往会遇到异步去执行某段逻辑, 然后先处理其他事情, 处理完后再把那段逻辑的处理结果进行汇总的产景, 这时候就需要使用线程了. 一个线程启动之后, 是异步的去执行需要执行的内容的, 不会影响主线程的
java如何让线程等待_如何使Java线程等待另一个线程的输出？
weixin_39747087的博客
02-25 757
我真的建议你经历一个教程，如Sun’s Java Concurrency，你开始在多线程的魔法世界。还有一些好书出来了(google for“Concurrent Programming in Java”，“Java Concurrency in Practice”)。要得到你的答案：在你必须等待dbThread的代码中，你必须有这样的：//do some worksynchronized(obj...
JAVA主线程等待子线程执行完毕再执行[参照].pdf
10-11
JAVA 中的线程控制是非常重要的一部分，而在实际开发中，我们经常会遇到需要主线程等待子线程执行完毕再执行的情况。这种情况下，我们可以使用两种方式来实现：主动式和被动式。 主动式 在主动式中，主线程会主动...
Java并发编程示例(六)：等待线程执行终止
09-04
这样，主线程或其他线程就可以等待特定线程的任务完成后，再继续执行其他任务，避免了在依赖的线程未完成时就开始执行可能导致的问题。 首先，我们创建了一个名为`DataSourcesLoader`的类，实现了`Runnable`接口。...
Java多线程按指定顺序同步执行
08-25
join方法可以使得某个线程A调用join，其他线程就要乖乖等A执行完毕才能执行。示例代码如下： ```java public class Worker implements Runnable { private int number; public Worker(int i) { number = i; } ...
Java判断线程池线程是否执行完毕
08-19
在所有的子线程都执行完成后，我们使用isTerminated方法来判断是否所有的子线程都已经执行完毕。 二、使用CountDownLatch CountDownLatch是Java中的一种闭锁实现，可以用来等待一组事件的发生。在本例中，我们使用...
java 多线程的几种实现方法总结
08-29
继承 Thread 类可以使子类继承 Thread 类的所有方法和变量，并可以覆盖 Thread 类的 run 方法以实现自己的线程执行逻辑。实现 Runnable 接口可以使类实现 Runnable 接口的 run 方法，以便在线程中执行。 二、同步的...
简述线程池的工作过程
starandsea的专栏
01-10 341
一开始来任务，开启核心线程，如果线程池里的线程数小于core size，则创建核心线程，即时有空闲的核心线程，也是创建新线程，直到达到core size。 再来新任务时，如果核心线程有空闲线程，则由空闲核心线程执行；如果没有空闲的核心线程，则加入到队列等待调度。 当队列满时，又来新任务，则开启临时线程，这个新来的任务由临时线程处理。 之后，临时线程和核心线程一起处理队列中的任务。 如果核心线程和临时线程都满负荷且队列已满，又有新任务来，则按reject策略处理（RejectedExecuti
等待多个线程执行完成后再运行的几种方式
dream_xin2013的专栏
11-03 2836
介绍在使用多线程过程中，需要等待多个线程执行完后再执行主线程的几种实现方式，提升系统性能
如何使用多线程，并且能够等待线程执行完之后再走主线程
PCSpiderMan的博客
04-20 745
2.借用CompletableFuture去实现线程并行，并等待线程执行完成。3.附上allOf的源代码和join方法的源代码 ------自己看吧。1.配置一个全局线程池----等待主线程去使用。// 等待所有线程执行完成。
线程池的线程复用，个人理解
qq_38966984的博客
05-23 1322
一个线程一般在执行完任务后就结束了，怎么再让他执行下一个任务呢其实，原理是：   run( ){          while(true){              if(没有任务）{wait( );}            否则 从任务队列取出任务，执行//这样执行完任务后，又回到头，问有没有任务，没任务就等待，直至有任务             }  }下面的代码。我生产了两个 线程作为工人...
java中等待一些线程执行完之后，再去执行别的方法（后者需要使用前者返回的结果）
GXQ的博客
04-30 1243
转：https://blog.csdn.net/jaryle/article/details/74905379 Java主线程等待所有子线程执行完毕在执行，这个需求其实我们在工作中经常会用到，比如用户下单一个产品，后台会做一系列的处理，为了提高效率，每个处理都可以用一个线程来执行，所有处理完成了之后才会返回给用户下单成功。 我们通过以下的几种方法来解决： 一、用sleep方法，让主线程睡眠一段时间...
在线程池中，当等待队列已满并且有新的任务提交时
m0_60641871的博客
08-25 1132
如果等待队列已满，新提交的任务会被阻塞，直到有空闲线程可用或者有任务被执行完成释放出一个线程资源。这种策略可以确保不会创建额外的线程，而是等待队列中的线程执行完任务后再分配线程去执行新任务。总的来说，线程池的行为通常由其配置参数和具体实现方式来决定，但在绝大多数情况下，不会创建临时线程来处理等待队列中的任务。在某些特殊情况下，可能会实现一种临时线程创建策略，但这不是线程池的标准行为。这可以在特定的应用场景中用来处理突发性的任务负载，但需要格外小心管理临时线程的生命周期和资源消耗。
c++主线程等待子线程结束_主线程等待子线程完成后执行的实现方式
weixin_39644021的博客
12-21 1172
被面试是一种狠高效的学习方式。前几天被人面试问到了，我当时直接说用CountDownLatch(后面就呵呵了...)后来阅读了点资料，仔细想了想总结如下。古老的wait notify下面是一个报错的例子。其实完全可以用这种古老的wait notify方式实现。可能用法不太对，欢迎指正。public class ThreadANTest {public static void main(String...
C# 开启一个线程在3秒内执行某个代码
06-10
可以使用C#中的Task类来实现开启一个线程在3秒内执行某个代码的需求，示例代码如下： ``` using System.Threading.Tasks; // 定义需要执行的代码 void MyMethod() { // TODO: 需要执行的代码 } // 开启一个新的线程执行MyMethod方法，等待3秒后结束 Task.Run(() => { MyMethod(); }).Wait(3000); ``` 在这段代码中，我们首先定义了需要执行的代码MyMethod，然后使用Task.Run方法来开启一个新的线程执行该方法。Wait方法用于等待3秒钟，确保MyMethod方法在此期间内执行完毕。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值