精华内容
下载资源
问答
  • 14 如何多个线程按顺序执行

    千次阅读 2020-08-12 21:48:06
    如何控制线程的执行顺序? 方法一:使用join()方法让一个线程强制运行 调用一个线程的join()方法就可以让这个线程强制运行,并且它会阻塞主线程的运行。 原理:调用join方法,会调用join(0)方法,当参数为0时,会...

    如何控制多线程的执行顺序?

    方法一:使用join()方法让一个线程强制运行

    调用一个线程的join()方法就可以让这个线程强制运行,并且它会阻塞主线程的运行。
    原理:调用join方法,会调用join(0)方法,当参数为0时,会调用wait方法,使主线程阻塞,等待子线程执行完毕后,主线程结束等待,继续执行。

    wait()的作用是让当前线程进入等待状态,同时,wait()也会让当前线程释放它所持有的锁。
    在这里插入图片描述

    public static void main(String[] args) {
    try {
                System.out.println("main开始运行");
                thread1.start();
                thread1.join(); //让thread1强制执行完毕后,才可以执行后面的代码
                thread2.start();
                thread2.join();
                thread3.start();
                thread3.join();
                System.out.println("main运行结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
    方法二:使用juc包下的Executors线程池保证子线程按顺序执行

    使用Executors中的newSingleThreadExecutor()方法,创建一个单线程的线程池,
    将线程用排队的方式扔进一个线程池里,让所有的任务以单线程的模式,按照FIFO先进先出,也可以达到控制线程执行顺序的目的。

    static ExecutorService executorService = 
      Executors.newSingleThreadExecutor();
    public static void main(String[] args) {
            System.out.println("main开始运行");
            executorService.submit(thread1);
            executorService.submit(thread2);
            executorService.submit(thread3);
            executorService.shutdown();
            System.out.println("main运行结束");
        }
    
    方法三:用CountdownLach保证子线程按顺序执行

    利用CountdownLach可以使一个线程等待其他线程完成某件事情之后才能执行,
    它的内部提供了一个计数器,在构造CountdownLach时必须指定计数器的初始值,且计数器的初始值必须>=0。另外它还提供了一个countDown方法来操作计数器的值,每调用一次countDown方法计数器都会减1,直到计数器的值减为0时,所有因调用await方法而阻塞的线程都会被唤醒。这就是CountDownLatch的内部机制。

    public class ThreadTest2 {
     
    // T1、T2、T3三个线程顺序执行
    public static void main(String[] args) {
        CountDownLatch c0 = new CountDownLatch(0); //计数器为0
        CountDownLatch c1 = new CountDownLatch(1); //计数器为1
        CountDownLatch c2 = new CountDownLatch(1); //计数器为1
     
        Thread t1 = new Thread(new Work(c0, c1));
        //c0为0,t1可以执行。t1的计数器减1
     
        Thread t2 = new Thread(new Work(c1, c2));
        //t1的计数器为0时,t2才能执行。t2的计数器c2减1
     
        Thread t3 = new Thread(new Work(c2, c2));
        //t2的计数器c2为0时,t3才能执行
     
        t1.start();
        t2.start();
        t3.start();
     
    }
     
    //定义Work线程类,需要传入开始和结束的CountDownLatch参数
    static class Work implements Runnable {
        CountDownLatch c1;
        CountDownLatch c2;
     
        Work(CountDownLatch c1, CountDownLatch c2) {
            super();
            this.c1 = c1;
            this.c2 = c2;
        }
     
        public void run() {
            try {
                c1.await();//前一线程为0才可以执行
                System.out.println("thread start:" + Thread.currentThread().getName());
                c2.countDown();//本线程计数器减少
            } catch (InterruptedException e) {
            }
     
        }
     }
    }
    
    方法四:用BlockingQueue

    将线程放入到BlockingQueue中,依次取出BlockingQueue中的线程,执行线程的start方法。

    阻塞队列 (BlockingQueue)是Java util.concurrent包下重要的数据结构,BlockingQueue提供了线程安全的队列访问方式:当阻塞队列进行插入数据时,如果队列已满,线程将会阻塞等待直到队列非满;从阻塞队列取数据时,如果队列已空,线程将会阻塞等待直到队列非空。并发包下很多高级同步类的实现都是基于BlockingQueue实现的。

    public class ThreadTest4 {
    // T1、T2、T3三个线程顺序执行
    public static void main(String[] args) {
        //blockingQueue保证顺序
        BlockingQueue<Thread> blockingQueue = new LinkedBlockingQueue<Thread>();
        Thread t1 = new Thread(new Work());
        Thread t2 = new Thread(new Work());
        Thread t3 = new Thread(new Work());
     
        blockingQueue.add(t1);
        blockingQueue.add(t2);
        blockingQueue.add(t3);
     
        for (int i=0;i<3;i++) {
            Thread t = null;
            try {
                t = blockingQueue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t.start();
            //检测线程是否还活着
            while (t.isAlive());
        }
    }
     
    static class Work implements Runnable {
     
        public void run() {
            System.out.println("thread start:" + Thread.currentThread().getName());
        }
     }
    }
    
    展开全文
  • 多个线程按顺序执行——join()

    千次阅读 2015-09-07 08:30:17
    * 假如有三个线程T1,T2,T3,如何保证T2在T3之前执行完成,T1在T2之前完成? * @author jiangyu 2015年9月7日 * 注意:线程的优先级无法保障线程的执行次序。只不过优先级高的线程获取 CPU 资源的概率大一点而已。...
    package com.jjyy.thread;
    /**
     * 假如有三个线程T1,T2,T3,如何保证T2在T3之前执行完成,T1在T2之前完成?
     * @author jiangyu 2015年9月7日
     * 注意:线程的优先级无法保障线程的执行次序。只不过优先级高的线程获取 CPU 资源的概率大一点而已。
     */
    public class JoinTest {
    	public static void main(String[] args) {
    		
    		final Thread t1 = new Thread(new Runnable() {
    
    			@Override
    			public void run() {
    				System.out.println("thread1");
    			}
    		});
    
    		final Thread t2 = new Thread(new Runnable() {
    
    			@Override
    			public void run() {
    				try {
    					// 引用t1线程,等待t1线程执行完
    					t1.join();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    				System.out.println("thread2");
    			}
    		});
    		Thread t3 = new Thread(new Runnable() {
    
    			@Override
    			public void run() {
    				try {
    					//引用t2线程,等待t2线程执行完
    					t2.join();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    				System.out.println("thread3");
    			}
    		});
    		t3.start();
    		t2.start();
    		t1.start();
    	}
    }
    

    展开全文
  • 多线程按顺序执行的几种方法

    万次阅读 2019-09-05 14:23:58
    文章介绍4种方法,简单易懂,通过4demo抛砖引玉。 目录 在子线程中通过join()方法指定顺序 在主线程中通过join()方法指定顺序 ...通过join()方法使当前线程“阻塞”,等待指定线程执行完毕后继续执行。举例:在...

    文章介绍4种方法,简单易懂,通过4个demo抛砖引玉。

    目录

    在子线程中通过join()方法指定顺序

    在主线程中通过join()方法指定顺序

    通过倒数计时器CountDownLatch实现

    通过创建单一化线程池newSingleThreadExecutor()实现


    在子线程中通过join()方法指定顺序

    通过join()方法使当前线程“阻塞”,等待指定线程执行完毕后继续执行。举例:在线程thread2中,加上一句thread1.join(),其意义在于,当前线程2运行到此行代码时会进入阻塞状态,直到线程thread1执行完毕后,线程thread2才会继续运行,这就保证了线程thread1与线程thread2的运行顺序。

    public class ThreadJoinDemo {
        public static void main(String[] args) throws InterruptedException {
            final Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("打开冰箱!");
                }
            });
    
            final Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        thread1.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("拿出一瓶牛奶!");
                }
            });
    
            final Thread thread3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        thread2.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("关上冰箱!");
                }
            });
    
            //下面三行代码顺序可随意调整,程序运行结果不受影响,因为我们在子线程中通过“join()方法”已经指定了运行顺序。
            thread3.start();
            thread2.start();
            thread1.start();
    
        }
    }

    运行结果:

    打开冰箱!
    拿出一瓶牛奶!
    关上冰箱!

    在主线程中通过join()方法指定顺序

    简单说一下子线程与主线程的区别,子线程指的是发生在Thread内部的代码,主线程指的是发生在main函数中的代码,我们可以在main函数中通过join()方法让主线程阻塞等待以达到指定顺序执行的目的。

    public class ThreadMainJoinDemo {
        public static void main(String[] args) throws InterruptedException {
            final Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("打开冰箱!");
                }
            });
    
            final Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("拿出一瓶牛奶!");
                }
            });
    
            final Thread thread3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("关上冰箱!");
                }
            });
    
            thread1.start();
            thread1.join();
            thread2.start();
            thread2.join();
            thread3.start();
        }
    }

    输出结果:

    打开冰箱!
    拿出一瓶牛奶!
    关上冰箱!

    通过倒数计时器CountDownLatch实现

    CountDownLatch通过计数器提供了更灵活的控制,只要检测到计数器为0当前线程就可以往下执行而不用管相应的thread是否执行完毕。

    public class ThreadCountDownLatchDemo {
    
        private static CountDownLatch countDownLatch1 = new CountDownLatch(1);
    
        private static CountDownLatch countDownLatch2 = new CountDownLatch(1);
    
        public static void main(String[] args) {
            final Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("打开冰箱!");
                    countDownLatch1.countDown();
                }
            });
    
            final Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        countDownLatch1.await();
                        System.out.println("拿出一瓶牛奶!");
                        countDownLatch2.countDown();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            final Thread thread3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        countDownLatch2.await();
                        System.out.println("关上冰箱!");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            //下面三行代码顺序可随意调整,程序运行结果不受影响
            thread3.start();
            thread1.start();
            thread2.start();
        }
    }

    输出结果:

    打开冰箱!
    拿出一瓶牛奶!
    关上冰箱!

    通过创建单一化线程池newSingleThreadExecutor()实现

    单线程化线程池(newSingleThreadExecutor)的优点,串行执行所有任务。

    public class ThreadPoolDemo {
    
       static ExecutorService executorService = Executors.newSingleThreadExecutor();
    
        public static void main(String[] args) {
            final Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("打开冰箱!");
                }
            });
    
            final Thread thread2 =new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("拿出一瓶牛奶!");
                }
            });
    
            final Thread thread3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("关上冰箱!");
                }
            });
            executorService.submit(thread1);
            executorService.submit(thread2);
            executorService.submit(thread3);
            executorService.shutdown();        //使用完毕记得关闭线程池
        }
    
    }

    输出结果:

    打开冰箱!
    拿出一瓶牛奶!
    关上冰箱!

     

    展开全文
  • jmeter之多个线程顺序执行操作

    千次阅读 2019-06-22 09:15:53
    1.测试计划设置:独立运行每个线程组 2.结果树: 目前在两个线程组中,分别加入了两个http信息头管理器,用来记录用户标识,设置独立运行每个线程组只能将每个线程组单独单独运行,无法进行状态和参数的传递。 .....

    1.测试计划设置:独立运行每个线程组
    在这里插入图片描述
    2.结果树:
    在这里插入图片描述
    目前在两个线程组中,分别加入了两个http信息头管理器,用来记录用户标识,设置独立运行每个线程组只能将每个线程组单独单独运行,无法进行状态和参数的传递。

    展开全文
  • 这个题目其实就是指定多个线程执行顺序,基本思路如下: 设定一个orderNum,每个线程执行结束之后,更新orderNum,指明下一个要执行的线程。并且唤醒所有的等待线程。 在每一个线程的开始,要while判断...
  • 个线程依次顺序执行

    万次阅读 热门讨论 2017-07-11 11:08:59
    保证三个线程依次按顺序执行在有一些需求的情况下,我们需要三个线程依次按顺序执行,那么有人就会问了,为什么不把三个线程的run方法依次放到三个方法体中,然后依次执行,顺序调用三个方法体,这样不是同样达到...
  • Python 多个线程按先后顺序执行,并保持各子线程和主线程的通信 摘要 最近有个项目使用pyqt5写的界面,界面展示部分作为项目的主线程,另外通过调用Thread,传入不同的参数又设置了五个子线程,因为第一个子线程的...
  • 题目要求:创建三个线程,每个线程分别打印ABC,并按照ABC的顺序执行十次 题目可以使用多种不同的方式解决,下面我们分别使用 Condition 等待唤醒机制、Semaphore 信号量、CountDownLatch 闭锁、Thread.join() 方法...
  • 多线程按顺序执行

    千次阅读 2019-05-18 16:39:05
    本文使用了5中方法实现在多线程中让线程按顺序运行的方法,涉及到多线程中许多常用的方法,不止为了知道如何让线程按顺序运行,更是让读者对多线程的使用有更深刻的了解。 使用的方法如下: [1] 使用线程的join方法 ...
  • Android中让多个线程顺序执行探究

    千次阅读 2015-09-14 10:27:15
    前言: 不知道从什么时候开始,越来越喜欢把平时学到的一些东西...对于这种问题,我更的是把写博客看成自己技术的总结,因为你总结一技术,肯定是需要查大量资料,而在此过程中你不仅巩固了以前的知识也会不断的
  • 如何让多个线程按照顺序执行

    千次阅读 2018-10-12 19:21:20
     如果有a,b,c三个线程,我们依次执行这三个线程。因为不保证有序性,可能执行出来是混乱的 解决如下: 第一种使用join()方法,这个方法的作用是,让当前执行线程等待直到调用join方法的线程结束运行 代码如下:...
  • 文章目录 ReentrantLock+Condition方式实现 Synchronized+wait/notifyAll方式实现 两者对比 ReentrantLock+Condition方式实现 public class ... 两者对比 使用ReentrantLock+Condition可以更准确的控制唤醒哪一个线程;...
  • 在一个脚本文件中,如果有多个线程组,并且想让他们从上到下依次执行,只需在测试计划页面,勾选“独立运行每个线程组”即可 “Run teardown thread groups after shutdown of main threads”的意思是:主线程关闭...
  • 需求是:main里面的3方法,要按顺序执行。 public class TestThread1 implements Runnable{ public void doSomething(){ ThreadPool pool = new ThreadPool(); for (int i = 0; i ; i++) { pool....
  • 如何保证多线程顺序执行

    千次阅读 2019-03-20 21:39:46
    举个例子:现有T1、T2、T3、主线程四个线程,如何安照T1执行完才执行T2、T2执行完才执行T3、T3执行完最后执行主线程才结束? 答案:使用join()方法,让其他线程等待。使用join的线程会独占执行资源,直到使用完毕,...
  • Java—如何保证线程按顺序执行

    千次阅读 2020-01-08 18:41:09
    多个线程执行任务时,可以通过Thread.join()方法保证多线程的执行顺序,其内部是通过调用主线程的wait方法,使主线程等待;当子线程执行完成后,再唤醒主线程。 下面写一个简单的实例:创建ABCD四个线程,每个线程...
  • 如何保证多个线程按一定顺序执行

    千次阅读 2019-05-13 14:32:19
    假设现在有三个线程t1、t2和t3 让t2在t1完成后执行,t3在t2完成后执行 自定义Thread类 public class Thread extends java.lang.Thread { private String str ; private int time; public Thread(String str,int ...
  • 先来说说线程为什么执行不按顺序执行 由于在同一个进程内存在多个线程,线程都想占有着稀缺的CPU资源去完成任务和工作(有一部分资源是所有线程共享的),但是cpu资源到底分配谁呢?是这样的,多个线程共同竞争CPU...
  • 个线程保证顺序执行

    千次阅读 2018-06-20 22:03:01
    第一种:  用Thread.join() 方法 确定该线程执行完毕,先创建线程1,然后创建线程2,在run()方法里面调用线程2.join(),接着创建线程3,在run()...3个线程存到阻塞队列里面,单个后台线程池,队列先进先出...
  • 多线程多任务顺序执行

    千次阅读 2018-08-03 16:44:33
    ios开发中会用到任务顺序执行,执行完毕在执行其他的线程任务,在面试中也会经常被问到,我这里就将方法代码记录下来作为一笔记 我这里将通过信号量和GCD的Group实现任务顺序执行 1.通过信号量来实现 //通过...
  • 一.线程的join方法作用 ...比如线程A中加入了线程B.join方法,则线程A默认执行wait方法,释放资源进入等待状态,此时线程B获得资源,执行结束后释放资源,线程A重新获取自CPU,继续执行。由此实...
  • jmeter 多个线程执行顺序

    千次阅读 2019-09-09 15:45:13
    当有多个线程组运行时: 1.如果不勾选独立运行每个线程组,则运行顺序每个线程组首字母 的顺序运行 2.勾选独立运行每个线程组,则运行顺序是按照自己设置的线程组的顺序执行 ...
  • java 多线程顺序执行

    千次阅读 2019-06-14 16:22:44
    这道阿里巴巴线程面试题,你学会了没有? 置顶2019年06月14日 15:43:55XingXing_Java阅读数 447 点关注,不迷路;持续更新Java相关技术及资讯!...通过N个线程顺序循环打印从0至100,如给定N=3则输出: threa...
  • 线程池 newSingleThreadExecutor 这个线程处理完一个任务后接着处理下一个任务   具体代码: 第一种: package com.cun; public class JoinTest { public static void main(String
  • 控制多线程执行顺序

    千次阅读 2018-11-01 14:30:58
    示例代码的码云地址:https://gitee.com/suwenguang/test/blob/master/fuxi/src/main/java/多线程/控制多线程顺序执行/App.java 多线程是为了同步完成项任务,不是为了提高运行效率,而是为了提高资源使用效率来...
  • C#多线程顺序依赖执行控制

    千次阅读 2018-10-22 15:57:09
    在开发过程中,经常需要多个任务并行的执行的场景,同时任务之间又需要先后依赖的关系。针对这样的处理逻辑,通常会采用多线程的程序模型来实现。   比如A、B、C三个线程,A和B需要同时启动,并行处理,且B需要...
  • java中如何保证多线程顺序执行

    千次阅读 2019-07-30 17:59:47
    如何保证多线程顺序执行 代码: public class ThreadDemo { static Thread threadA = new Thread(()->{ System.out.println("线程A"); }); ​ static Thread threadB = new Thread(()->{ System.out....
  • 测试例子: package serializer.pattern; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class Main { ... volatile private static int nextPrintWho = ...
  • newSingleThreadExecutor 这线程池,保证线程里面的任务依次执行,这让我发现了新大陆, 立马实践了一下,发现不负所望; public class TestJoin { public static void main(String[] args) throws ...
  • 用Jmeter做自动化测试,一个测试计划中添加多个线程组, 每个线程组的功能测试,希望是一个线程组执行完毕后,接着执行下一个线程组下的请求 Jmeter默认多个线程组之间是并行关系 需要在测试计划下勾选Run ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 485,462
精华内容 194,184
关键字:

多个线程按顺序执行