精华内容
下载资源
问答
  • Java等待线程池终止

    万次阅读 2018-08-21 00:22:42
    1、轮询isTerminated: while (!service.isTerminated()) { TimeUnit.SECONDS.sleep(1); } 2、轮询awaitTermination: while (!service.awaitTermination(1, TimeUnit.SECONDS)) {...

    1、轮询isTerminated:

            while (!service.isTerminated()) {
                TimeUnit.SECONDS.sleep(1);
            }

    2、轮询awaitTermination:

            while (!service.awaitTermination(1, TimeUnit.SECONDS)) {
            }

    service表示线程池对象,当线程池终止时将自动跳出while循环。这两个方法的实现原理其实是一致的。我这里设置了每隔1s轮询一次,你可以控制轮询的间隔时间尽可能小,以便及时响应线程池终止后的逻辑。由于这两个方法都是阻塞的,所以别忘了处理中断异常。

    展开全文
  • Java 并发编程专栏系列笔记,系统性学习可访问个人复盘笔记-技术博客 Java 并发编程 CountDownLatch 是什么 CountDownLatch 允许一个或多个线程等待其他线程完成操作。 CountDownLatch 如何使用 CountDownLatch 的...

    专栏原创出处:github-源笔记文件 github-源码 ,欢迎 Star,转载请附上原文出处链接和本声明。

    Java 并发编程专栏系列笔记,系统性学习可访问个人复盘笔记-技术博客 Java 并发编程

    CountDownLatch 是什么

    CountDownLatch 允许一个或多个线程等待其他线程完成操作。

    CountDownLatch 如何使用

    • CountDownLatch 的构造方法需要传入一个计数值,计数值即需要等待的线程数量。
    • 任务封装为线程模式异步运行,每个任务完成后调用 countDown 方法(计数值 -1)
    • 调用 await 方法,当前线程进入等待状态
    • 计数值为 0 时,将从 await 方法返回,继续执行后续逻辑

    我们模拟一个方法,可以解析 excel 工作簿 ,每个工作簿解析由单独线程完成,全部完成后返回执行结果,伪代码如下:

    public class CountDownLatchExample {
        // 线程池
        private final ExecutorService executor = Executors.newFixedThreadPool(2);
    
        //  解析 excel 工作簿,sheets 为多个工作簿
        public boolean resolveExcel(List<Object> sheets) {
    
            // 每个工作簿解析为一个计数
            final CountDownLatch latch = new CountDownLatch(sheets.size());
    
            // 每个工作簿封装为一个工作线程提交到线程池,完成后计数 -1
            sheets.forEach(o ->
                executor.submit(() -> {
                    log.info("解析工作簿... {}", o);
                    latch.countDown(); // 完成后计数 -1
                }));
    
            try {
                return latch.await(2, TimeUnit.MINUTES); // 等待 2 min
            } catch (InterruptedException e) {
                log.warn("解析超时,当前计数[{}]", latch.getCount());
            }
            return false;
        }
    }
    

    CountDownLatch 实现原理

    部分关键源码解读,需要 AbstractQueuedSynchronizer(AQS) 基础知识:

    public class CountDownLatch {
        // 基于 AQS 实现的共享式同步状态相关操作
        private static final class Sync extends AbstractQueuedSynchronizer
    
        // 创建 CountDownLatch ,需指定计数器
        public CountDownLatch(int count)
        
        // 进入等待状态。
        // 共享式的获取同步状态,响应中断
        public void await() throws InterruptedException
        
        // 进入等待状态,在 await 基础上支持超时等待。
        public boolean await(long timeout, TimeUnit unit) throws InterruptedException 
        
        // 当前计数 -1 ,底层表现为,同步状态值 -1 
        public void countDown()
    
        // 获取当前计数结果 ,底层表现为,当前同步状态值
        public long getCount()
    }
    

    主要逻辑为:

    • 初始化一个共享式锁,初始化时同步状态设置为计数值 N(理解为:初始化后已经被 N 个线程持有锁了)
    • 调用 wait 方法后,当前线程进入等待状态,等待同步状态为 0 时获取锁
    • 每个线程完成后调用 countDown 方法,即同步状态 -1
    • 所有线程完成后,同步状态为 0,wait 方法所在线程获取锁继续执行

    CountDownLatch 和 join 的区别

    join 用于让当前执行线程等待 join 线程执行结束。其实现原理是不停检查 join 线程是否存活,如果 join 线程存活则让当前线程永远等待。

    • 调用 join 方法需要等待 thread 执行完毕才能继续向下执行
    • CountDownLatch 只需要检查计数器的值为零就可以继续向下执行

    相比之下,CountDownLatch 更加灵活一些,可以实现一些更加复杂的业务场景。

    应用场景

    • 需要等待多个线程完成后继续执行的场景。
    展开全文
  • 我们会什么会用到等待

    在我们做自动化测试时,一定会出现一种情况取不到界面元素,主要愿意在与界面元素的加载与我们访问页面的时机不一致,一后一前。有可能是界面要素过多或者网络较慢,界面加载中;为此selenium提供了等待方式来解决此种问题,分为显式等待与隐式等待。

    显式等待

    处理方式1:通过线程等待函数,让自动化测试做一定时间的等待,Thread.sleep(1000);

    使用此方法会出现两种不能避免的情况:1.若设置的时间较短,仍不能解决上述问题;2.若设置时间较长,会花费大量的等待时间。我们很难去确定等待时间的长度,因为加载时间的长度会受到外部环境的影响,比如:网络情况,应用的大小,主机的配置情况,主机的内存和CPU的消耗情况。

    处理方式2:就是明确的等到界面某元素出现或者某可点击等条件为止,否则一致等待至设定的时间之后跑出异常情况。

     采用WebDriverWait类 + ExceptedConditions接口,

    方法1:在10秒以内等到该元素出现,则往下执行;否则超过10秒,依然找不到,就抛出异常.

    new WebDriverWait(driver,10).until(
    				ExpectedConditions.presenceOfElementLocated(By.cssSelector("css locator")));
     	
    

    可以改编为更为简洁的方式:

    WebElement elementId = (new WebDriverWait( driver, 10)).until(
    				new ExpectedCondition(){
    					@Override
    					public WebElement apply(WebDriver d){
    						return d.findElement( By.id("id locator"));
    						} 
    					}
    				);
    

    隐式等待

    先看一个例子

    driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS); 
    

    表示为,程序等待5秒继续执行,个人不建议使用该方式。

    以下为相关的方法简要说明

    //		waitForElementPresent locator 等待直到某个元素在页面中存在 
    //		waitForElementNotPresent locator 等待直到某个元素在页面中不存在 
    //		   
    //		waitForTextPresent text 等待直到某个文本在页面中存在 
    //		waitForTextNotPresent text 等待直到某个文本在页面中不存在 
    //		 
    //		waitForText locator text 等待直到locator指定元素内的文本符合text  
    //		waitForNotText locator text 等待直到locator指定元素内的文本不符合text 
    //		 
    //		waitForVisible locator 等待直到locator指定元素在页面中可见 
    //		waitForNotVisible locator 等待直到locator指定元素在页面中不可见 
    //		 
    //		waitForTitle title 等待直到页面标题符合所指定的title 
    //		waitForNotTitle title 等待直到页面标题不符合所指定的title 
    //		waitForLocation url 等待直到页面的地址符合所指定的url 
    //		waitForNotLocation url 等待直到页面的地址不符合所指定的url 
    //		 
    //		waitForValue locator value 等待直到locator指定的元素的value值符合指定的值 
    //		waitForNotValue locator value 等待直到locator指定的元素的value值不符合指定的值 
    //		 
    //		waitForAttribute locator@attr value 等待直到locator指定的元素的attr属性值符合指定的值 
    //		waitForNotAttribute locator@attr value 等待直到locator指定的元素的attr属性值不符合指定的值 
    //		 
    //		waitForChecked locator 等待直到locator指定的radio或checkbox成为选中状态 
    //		waitForNotChecked locator 等待直到locator指定的radio或checkbox成为非选中状态 
    //		 
    //		waitForEditable locator 等待直到locator指定的input或textarea元素可编辑 
    //		waitForNotEditable locator 等待直到locator指定的input或textarea元素不可编辑 
    //		waitForXpathCount xpath count 等待直到页面符合xpath的数量为count 
    //		waitForNotXpathCount xpath count 等待直到页面符合xpath的数量不为count 
    //		  
    //		waitForEval script pattern 等待直到script的执行结果符合pattern 
    //		waitForNotEval script pattern 等待直到script的执行结果不符合pattern  
    

     

     

    展开全文
  • java 等待所有线程执行完毕

    千次阅读 2017-01-22 16:34:55
    问题的由来主线程等待所有线程都运行完后,再执行逻辑,这个需求很普遍。比如,在处理数据时,为了效率期间,起了10个线程,分别处理一块数据,这样能缩短处理时间,10个线程都执行完后,继续进行下边的逻辑(有点...

    #问题的由来
    主线程等待所有线程都运行完后,再执行逻辑,这个需求很普遍。比如,在处理数据时,为了效率期间,起了10个线程,分别处理一块数据,这样能缩短处理时间,10个线程都执行完后,继续进行下边的逻辑(有点map/reduce的意思)。这里我们就需要用到java的线程同步类 CountDownLatch ,count down是计数的意思,latch是门闩的意思,合起来也就是计数的开关。我们看一下CountDownLatch的API。

    #CountDownLatch API介绍

    一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。

    用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法,所以在当前计数到达零之前,await
    方法会一直受阻塞。之后,会释放所有等待的线程,await
    的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数,请考虑使用 CyclicBarrier。

    CountDownLatch 是一个通用同步工具,它有很多用途。将计数 1 初始化的 CountDownLatch
    用作一个简单的开/关锁存器,或入口:在通过调用 countDown() 的线程打开入口前,所有调用 await 的线程都一直在入口处等待。用
    N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待,或者使其在某项操作完成 N
    次之前一直等待。

    CountDownLatch 的一个有用特性是,它不要求调用 countDown
    方法的线程等到计数到达零时才继续,而在所有线程都能通过之前,它只是阻止任何线程继续通过一个 await。

    从中可以看出,最重要的几个步骤,

    第一,创建门闩,
    
    第二,开启门闩,阻塞所有线程,
    
    第三,其它线程递减次数,减为0时,门闩打开,主线程继续执行放开门闩
    

    #样例

    public class TestCountDownLatch {
    
    	
    	public static void main(String[] args) {
    		
    		int count = 5;
    		final CountDownLatch latch = new CountDownLatch(count);//创建门闩
    		
    		//execute thread
    		for(int i=0; i<count; i++){
    			new Thread(new Worker(latch)).start();
    		}
    		//
    		System.out.println("进入等待");
    		
    		
    		try {
    			latch.await();//开启门闩,阻塞所有线程,
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		
    		//dosomething
    		System.out.println("都执行完了");
    	}
    	
    	
    	
    }
    
    class Worker implements Runnable{
    	
    	private final CountDownLatch latch;
    	
    	
    	
    	public Worker(CountDownLatch latch) {
    		super();
    		this.latch = latch;
    	}
    	
    	
    	
    	@Override
    	public void run() {
    		
    		
    		//do something
    		System.out.println(Thread.currentThread().getName());
    		
    		try {
    			Thread.sleep(5000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		
    		/*
    		其它线程递减次数,减为0时,门闩打开,主线程继续执行放开门闩。
    		每调用一次countdown()计数就减一次
    		*/
    		latch.countDown();//递减
    	}
    	
    	
    }
    

    输出结果

    这里写图片描述

    #后续
    这里,我们没有往线程中传值、也没有获取线程的计算结果,所以比较简单。如果需要往线程中传值,使用构造函数方法传参或者公共方法传参;获取其它线程的计算结果,可以使用Future

    展开全文
  • Java 等待多个子线程 join

    千次阅读 2016-02-19 17:30:11
    thread.Join把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join... //等待 t 线程,等待时间是1000毫秒 要想主线程main等待若干线程结束之后再执行,需
  • java 等待线程/线程池执行完毕

    千次阅读 2017-08-07 15:43:54
    翻译为中文大意就是,等待线程执行完毕! 2.等待线程池执行完毕 等待线程池执行完毕我们需要用到 CountDownLatch这个类 且看代码: public static void main (String args[]) throws ...
  • 实际开发中,经常会碰到这种问题,某个线程需要等待所有的线程执行结束了,才可以继续执行。要实现这个效果,Java中有很多方案,下面我列举一些我所知道的方案: 方案一:join。代码如下: Thread thread1=new ...
  • 等待-通知机制java在多线程开发当中对锁等待的一种完善。 当一个线程无法满足当前工作的条件的时候,可以让其进入对象等待池,并释放掉当前锁对象。当其他线程调用notifyAll() 或者notify()的时候就会唤醒线程,将...
  • 在实际开发过过程中,我们会经常遇见将一个“庞大”的任务拆分成多个子任务,各个子任务在独立的子线...代码如下:WorkThread.javapublic class WorkThread extends Thread { @Override public void run() { try {
  • JavaScript脚本: function XXX() { displayMessage(); } function displayMessage() { if (navigator.... ()" value="显示等待信息"> 下面是实现效果: 图片素材:
  • private void waitForAlertAndCloseAlert(WebDriver driver) throws InterruptedException { int i=0; while(i++) { try { Alert alert = driver.swi
  • //未消费等待 }catch(InterruptedException e){ this.c=c; writeable=false;//标记已经生产 notify();//通知消费者已经生产,可以消费 } } } public synchronized char getShareChar(){ if...
  • java 异步等待_Java中的异步等待

    千次阅读 2020-07-02 11:05:52
    java 异步等待 编写异步代码很困难。 试图了解异步代码应该做什么的难度更大。 承诺是尝试描述延迟执行流程的一种常见方式:首先做一件事,然后再做另一件事,以防万一出错时再做其他事情。 在许多语言中,承诺已...
  • java线程等待与通知

    2013-04-11 14:47:46
    java 等待,通知机制 下面先介绍下Object class 中的method。   void wait():等待条件的发生,该method必须从synchronized method或块中调用。 void wait(long timeout):等待条件的发生,假如,没有在...
  • Java等待时间

    2020-08-11 23:29:37
    JAVA中想让代码等待一段时间再继续执行,可以通过让当前线程睡眠一段时间的方式。 方法一:通过线程的sleep方法。 Thread.currentThread().sleep(1000); 在需要程序等待的地方加入这个语句,实现让程序等待,这里的...
  • Java线程的等待状态

    2014-08-28 16:52:56
    Java线程有两种等待状态,分为
  • Java等待唤醒机制

    千次阅读 2018-05-30 17:58:49
    使用的是继承自Object的两个方法public final void wait() throws InterruptedException线程等待public final void notify()唤醒在此对象监视器上等待的单个线程自定义类,定义信息public class People { ...
  • Java 线程池等待队列问题

    千次阅读 2019-09-20 15:38:48
    该线程池的等待队列最大长度默认为int的最大值,随口默写出来就是2147483647(2^31 -1,高中物理老师说过一句话,记住一些固定的数字可以预判一些问题)。线程池在提交任务时,如果线程池未达到最大线程数,则起线程...
  • Java中的等待/通知机制

    千次阅读 2018-06-12 20:37:14
    Java中的等待/通知机制
  • Java代码等待3秒

    千次阅读 2019-07-17 17:18:21
    try { Thread.currentThread().sleep(3000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } 一行代码就可以解决,本质上就是让当前线程睡眠3秒。...
  • java 多线程等待返回结果,类比C#的Task @Repository public class XXXXService { @Autowired private ThreadPoolTaskExecutor tranExecutor; public RequestResult BigSrceen() { BigScreenDTO ...
  • Java 用“等待-通知”机制优化循环等待等待不消息CPU的情况下, 最好的方案应该是: 如果线程要求的条件不满足,则线程阻塞自己,进入等待状态; 当线程要求的条件满足后,通知等待的线程重新执行。 就医流程...
  • Java线程等待唤醒机制(加深理解)

    万次阅读 多人点赞 2019-08-04 16:28:06
    今天看源码的时候遇到这样一个场景,某线程里面的逻辑需要等待异步处理结果返回后才能继续执行。或者说想要把一个异步的操作封装成一个同步的过程。这里就用到了线程等待唤醒机制,下面具体看一下。 等待唤醒机制...
  • Java CyclicBarrier 设置线程等待

    千次阅读 2011-11-02 17:26:48
    一组线程互相等待,直到到达某个公共屏障点 (common barrier point)后,再继续执行   import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import java.util....
  • Java——等待,超时,通知模型

    千次阅读 2018-01-16 21:47:14
    在原有的等待通知模型上,我们可以加上等待的时间,来避免长时间的等待:/** * \* Created: liuhuichao * \* Date: 2018/1/16 * \* Time: 下午6:09 * \* Description:等待,通知,超时模型 * \ */ public ...
  • Java-线程Thread等待与唤醒

    千次阅读 2017-03-29 17:13:37
    Java线程的等待与唤醒主要包括几个方法:(1)notify():唤醒在此对象监视器上等待的单个线程。(2)notifyAll():唤醒在此对象监视器上等待的所有线程。(3)wait():让当前线程处于阻塞状态,同时释放它所持有的锁...
  • java多线程的等待

    千次阅读 2016-02-23 08:50:30
    下面的这个简单的java程序完成四项不相关的任务。这样的程序有单个控制线程,控制在这四个任务之间线性地移动。此外。因为所需的资源-打印机、磁盘、数据库和显示屏--由于硬件和软件的限制都有内在的潜伏时间,所以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,268
精华内容 14,107
关键字:

java等待

java 订阅