精华内容
下载资源
问答
  • Android系统。 Countdownlatch.await不起作用
    2021-04-18 14:45:09

    我不知道我在这里做错了什么。 Countdownlatch.await不起作用。绝对没有等待时间。我已经测试了荒谬的数字(50秒),并且有紧接着后来的电话。我试图在UI线程上使用它。我还有另一个线程正在运行。

    代码:

    private final CountDownLatch latch = new CountDownLatch(1); //called earlier

    void someMethod() {

    //code

    Runnable flashScreen = new Runnable() {

    @Override

    public void run() {

    flashScreen();

    }

    };

    runOnUiThread(flashScreen);

    //Mode code

    }

    private void flashScreen()

    {

    final TextView monthDayYear = (TextView)findViewById(R.id.month_day_year);

    final TextView hourMinuteSecond = (TextView)findViewById(R.id.hour_minute_second);

    //Get date and time

    final SyncModule syncModule = _application.getSyncModule();

    syncModule.start();

    while(counter.intValue() < 150) {

    try {

    //Thread.sleep(10);

    latch.countDown();

    latch.await(10, TimeUnit.MILLISECONDS);

    counter.incrementAndGet();

    } catch (InterruptedException ex) {

    Util.appendLog("SyncActivity: InterruptedException while flashing camera " + ex.getMessage());

    }

    }

    final ImageView fadeView = (ImageView)findViewById(R.id.sync_flash_rectangle);

    fadeView.setBackgroundColor(Color.WHITE);

    fadeIn(fadeView, 1, 0, 1000, true);

    Calendar syncTime = syncModule.getDateAndTime();

    monthDayYear.setText(new SimpleDateFormat("MM/dd/yyyy").format(syncTime.getTime()));

    hourMinuteSecond.setText(new SimpleDateFormat("HH:mm:ss:00").format(syncTime.getTime()));

    try {

    latch.countDown();

    latch.await(50, TimeUnit.SECONDS);

    } catch (InterruptedException ex) {

    Util.appendLog("SyncActivity: InterruptedException while flashing camera " + ex.getMessage());

    }

    counter.set(1000);

    }

    更多相关内容
  • 如果我正确理解您的问题,此测试证明您的所有假设/要求都是真实/满足的. (使用JUnit和Hamcrest运行.)请注意runCodeUnderTest()方法中的代码,尽管它散布着时间记录...import java.util.concurrent.CountDownLatch;impo...

    如果我正确理解您的问题,此测试证明您的所有假设/要求都是真实/满足的. (使用JUnit和Hamcrest运行.)请注意runCodeUnderTest()方法中的代码,尽管它散布着时间记录,并且超时减少了10倍.

    import org.junit.Before;

    import org.junit.Test;

    import java.util.concurrent.CountDownLatch;

    import java.util.concurrent.TimeUnit;

    import static org.hamcrest.Matchers.closeTo;

    import static org.hamcrest.Matchers.lessThan;

    import static org.junit.Assert.assertThat;

    public class CountdownLatchTest {

    static volatile boolean signal;

    CountDownLatch latch = new CountDownLatch(1);

    long elapsedTime;

    long[] wakeupTimes = new long[2];

    @Before

    public void setUp() throws Exception {

    signal = false;

    }

    @Test

    public void successfulCountDownDuringFirstAwait() throws Exception {

    countDownAfter(150);

    runCodeUnderTest();

    assertThat((double) elapsedTime, closeTo(150, 10));

    assertThat(wakeupTimeSeparation(), lessThan(10));

    }

    @Test

    public void successfulCountDownDuringSecondAwait() throws Exception {

    countDownAfter(450);

    runCodeUnderTest();

    assertThat((double) elapsedTime, closeTo(450, 10));

    assertThat((double) wakeupTimeSeparation(), closeTo(150, 10));

    }

    @Test

    public void neverCountDown() throws Exception {

    runCodeUnderTest();

    assertThat((double) elapsedTime, closeTo(650, 10));

    assertThat((double) wakeupTimeSeparation(), closeTo(350, 10));

    }

    @Test

    public void countDownAfterSecondTimeout() throws Exception {

    countDownAfter(1000);

    runCodeUnderTest();

    assertThat((double) elapsedTime, closeTo(650, 10));

    assertThat((double) wakeupTimeSeparation(), closeTo(350, 10));

    }

    @Test

    public void successfulCountDownFromSignalField() throws Exception {

    countDownAfterSignal();

    runCodeUnderTest();

    assertThat((double) elapsedTime, closeTo(300, 10));

    }

    private int wakeupTimeSeparation() {

    return (int) (wakeupTimes[1] - wakeupTimes[0]);

    }

    private void runCodeUnderTest() throws InterruptedException {

    long start = System.currentTimeMillis();

    latch.await(300, TimeUnit.MILLISECONDS);

    wakeupTimes[0] = System.currentTimeMillis();

    signal = true;

    latch.await(350, TimeUnit.MILLISECONDS);

    wakeupTimes[1] = System.currentTimeMillis();

    elapsedTime = wakeupTimes[1] - start;

    }

    private void countDownAfter(final long millis) throws InterruptedException {

    new Thread(new Runnable() {

    @Override

    public void run() {

    sleep(millis);

    latch.countDown();

    }

    }).start();

    }

    private void countDownAfterSignal() {

    new Thread(new Runnable() {

    @Override

    public void run() {

    boolean trying = true;

    while (trying) {

    if (signal) {

    latch.countDown();

    trying = false;

    }

    sleep(5);

    }

    }

    }).start();

    }

    private void sleep(long millis) {

    try {

    Thread.sleep(millis);

    } catch (InterruptedException e) {

    throw new IllegalStateException("Unexpected interrupt", e);

    }

    }

    }

    展开全文
  • @Testpublic void TestAsync() throws InterruptedException {CountDownLatch countDownLatch = new CountDownLatch(10);for (int i=0;i<10;i++){try {testService.asyncTest(i);} catch (Exception e) {e.printS...

    @Test

    public void TestAsync() throws InterruptedException {

    CountDownLatch countDownLatch = new CountDownLatch(10);

    for (int i=0;i<10;i++){

    try {

    testService.asyncTest(i);

    } catch (Exception e) {

    e.printStackTrace();

    } finally {

    countDownLatch.countDown();

    }

    }

    try {

    countDownLatch.await();

    } catch (Exception e) {

    System.out.println("阻塞异常");

    }

    System.out.println("执行了");

    }

    @Async

    public void asyncTest(int i) throws InterruptedException {

    System.out.println("线程" + Thread.currentThread().getName() + " 执行异步任务:" + i);

    //模拟任务执行时间:500ms

    Thread.sleep(500);

    }

    @Configuration

    @EnableAsync

    public class AsyncConfig {

    @Bean

    public TaskExecutor taskExecutor() {

    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

    // 设置核心线程数

    executor.setCorePoolSize(3);

    executor.setMaxPoolSize(5);

    executor.setQueueCapacity(10);

    executor.setKeepAliveSeconds(60);

    executor.setThreadNamePrefix("test-async-");

    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

    executor.setWaitForTasksToCompleteOnShutdown(true);

    return executor;

    }

    }

    bVbIunO

    由于设置了核心线程数为3,所以就只执行了前3个线程,就结束了...,如果做到让他把所有线程都执行完毕再结束?从网上查到资料说用countDownLatch.await()来阻塞,等待所有线程执行完毕,然而使用后无效,求解~

    展开全文
  • countDownLatch.await()与thread.join()区别

    万次阅读 2018-10-26 10:15:28
    CountDownLatch 是能使一组线程等另一组线程都跑完了再继续跑 ,CountDownLatch.await() 方法在倒计数为0之前会阻塞当前线程. 实例2:CountDownLatch实现 public class TestRunnable implements ...

    在编写多线程的工作中,有个常见的问题:主线程(main) 启动好几个子线程(task)来完成并发任务,主线程要等待所有的子线程完成之后才继续执行main的其它任务。

    默认主线程退出时其它子线程不会停,如果想让main退出时其它子线程终止,可以用subThread.setDaemon(true) 设置子线程为“守护线程”。

    如果要在主线程等待所有子线程完成后,还要执行其它操作(比如:结果合并).可以用join()方法来等待所有子线程完成后,才继续执行。如下:

    实例1:Join实现

    复制代码

    public class TestRunnable implements Runnable{
    
        /** 线程名 */
        private String threadName;
    
    
        public TestRunnable(String threadName) {
            this.threadName = threadName;
        }
    
    
        @Override
        public void run() {
            System.out.println( "[" + threadName + "] Running !" );
        }
    
        public static void main(String[] args) throws InterruptedException {
            List<Thread> lists = new ArrayList<Thread>();
            for(int i=0; i<5; i++){
                Thread thread = new Thread(new TestRunnable("子线程" + (i + 100)));
                lists.add(thread);
                thread.start();
            }
            System.out.println("主线程阻塞,等待所有子线程执行完成");
            for(Thread thread : lists){
                // 如果注释掉thread.join(),启动后 main线程 与 所有子线程 thread并发工作,并不会等待子线程完成后再执行
                thread.join();
            }
            System.out.println("所有线程执行完成!");
        }
    }

    复制代码

    此外可以用java.util.concurrent.CountDownLatch类更简洁的实现这种场景.

    CountDownLatch 的作用和 Thread.join() 方法类似,可用于一组线程和另外一组线程的协作。

    例如:主线程在做一项工作之前需要一系列的准备工作,只有这些准备工作都完成,主线程才能继续它的工作,这些准备工作彼此独立,所以可以并发执行以提高速度。在这个场景下就可以使用 CountDownLatch 协调线程之间的调度了。

    在直接创建线程的年代(Java 5.0 之前),我们可以使用 Thread.join().在 JUC 出现后,因为线程池中的线程不能直接被引用,所以就必须使用 CountDownLatch 了。

    CountDownLatch 是能使一组线程等另一组线程都跑完了再继续跑 ,CountDownLatch.await() 方法在倒计数为0之前会阻塞当前线程.

    实例2:CountDownLatch实现

    复制代码

    public class TestRunnable implements Runnable{
    
        /** 处理main线程阻塞(等待所有子线程) */
        private CountDownLatch countDown;
    
        /** 线程名字 */
        private String  threadName;
    
    
        public TestRunnable(CountDownLatch countDownLatch, String threadName) {
            this.countDown = countDownLatch;
            this.threadName = threadName;
        }
    
        @Override
        public void run() {
            System.out.println( "[" + threadName + "] Running ! [countDownLatch.getCount() = " + countDown.getCount() + "]." );
            // 每个独立子线程执行完后,countDownLatch值减1
            countDown.countDown();
        }
    
        public static void main(String [] args) throws InterruptedException {
            int countNum = 5;
            CountDownLatch countDownLatch = new CountDownLatch(countNum);
            for(int i=0; i<countNum; i++){
                new Thread(new TestRunnable(countDownLatch,"子线程" + (i+100))).start();
            }
            System.out.println("主线程阻塞,等待所有子线程执行完成");
            //endLatch.await()使得主线程(main)阻塞直到endLatch.countDown()为零才继续执行
            countDownLatch.await();
            System.out.println("所有线程执行完成!");
        }
    }

    复制代码

    执行结果:

    对于countDownLatch我们需要注意:CountDownLatch.await() 方法在倒计数为0之前会阻塞当前线程.
    a)在不使用await()的时候:

    执行结果如下:

    此时我们看到,主线程和子线程并发执行,主线程执行完后子线程还在执行,没有实现我们需要的场景.

    b)CountDownLatch.await() 方法在倒计数不为0时

    执行结果:

    如图,可以看到,子线程执行完成了,但是countDownLatch的倒记数的值不为0,进入持续等待中,并没有唤醒主线程来执行.所以countDownLatch.await()生效必须保证计数值变为0.

    转载自:[http://www.cnblogs.com/dennisit/p/4340611.html]

     

    展开全文
  • notifier.await(); } catch (InterruptedException e) {} } 相比前面的代码,finally{}代码块中没有再判断是否已经执行过唤醒动作,为什么呢,因为countDown当计数已经归0的时候什么也不做,所以就算多执行...
  • 主要为大家详细解析了CountDownLatch源码之await方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • CountDownLatch是一种java.util.concurrent包下一个同步工具类,它允许一个或多个线程等待直到在其他线程中一组操作执行完成。 CountDownLatch的用法非常简单,下面的例子也是我在网上看到的,十分贴切,这里就贴...
  • 多线程 join和countDownLatch.await()区别

    千次阅读 2018-06-02 11:25:24
    调用thread.join() 方法必须等thread 执行完毕,当前线程才能继续往下执行,而CountDownLatch通过计数器提供了更灵活的控制,只要检测到计数器为0当前线程就可以往下执行而不用管相应的thread是否执行完毕。...
  • await方法(long timeout, TimeUnit unit)的作用使线程在指定的最大时间单位内进入WAITING状态,如果超过这个时间则自动唤醒,程序继续向下运行。 timeout是等待的时间 unit 是参数时间的单位 上代码: package ...
  • CountDownLatch.countDown()的用法

    千次阅读 2020-10-21 16:32:12
    解释:CountDownLatch.countDown()是用来线程计数器-1的,也就是新增线程运行完之后,都调用此方法将计数器变成0,最后调用await()方法,主线程就会被唤醒,继续执行其它代码 应用场景:启动一个服务时,主线程需要...
  • await 调用sync.acquireSharedInterruptibly public void await() throws InterruptedException { sync.acquireSharedInterruptibly(1); } sync.acquireSharedInterruptibly调用tryAc...
  • 1. 需求:主线程需要等待其他三个子线程执行完毕后,才能继续执行 ...import java.util.concurrent.CountDownLatch; /** * @Description * @author 大都督 * @date 2019年5月1日 */ public cl...
  • if(countDownLatch.await(1, TimeUnit.SECONDS)) { // 不超时 return response; } } catch (Exception e) { // ignore exception } // 来到这里表示超时 // throw new TimeoutException(...
  • CountDownLatch

    2021-07-10 14:25:48
    CountDownLatch是在jdk1.5版本引入的,存在于juc包下面。由大佬 Doug Lea(绝对牛逼的大佬,感兴趣的可以自己百度一下) 编写。 跟它一同出现的还有CyclicBarrier、Semaphore、concurrentHashMap和BlockingQueue...
  • 纯记录,记忆越来越差,能力又一般,纯讨论简单细节。线程超时控制的方法有很多也有很多新的方法,CountDownLatch只是其中... 看个例子,例子1很简单,起个线程,用CountDownLatch的带超时的 await方法控制超时 例...
  • CountDownLatch的使用

    2021-06-16 15:07:12
    阻塞方法(带时间参数,代表兜底方案, 最多阻塞多少时间) countDownLatch.await(5,TimeUnit.SECONDS); countDownLatch.await(); 3. 实战 3.1 需求 批处理每日推送消息: 每天某个时间轮训扫表3000万个用户进行推送...
  • Android 并发编程—CountDownLatch★★★

    千次阅读 2022-01-20 14:22:18
    当计数器的值不为0时,调用await()方法的线程会被加入到阻塞队列,一直阻塞到计数器的值为0。 常用方法: public class CountDownLatch { public CountDownLatch(intent count);//构造一个值为count的计数器 public ...
  • import java.util.Random;import java.util.Scanner;import java.util.concurrent.CountDownLatch;/*** @ClassName: Main32* @description:* @author: edison_Kwok* @Date: create in 2020/2/20 ...
  • JUC之CountDownLatch

    2021-05-26 18:57:53
    介绍CountDownLatch
  • CountDownLatch的用法

    2021-03-29 16:40:40
    CountDownLatch的用法CountDownLatch的用法1.CountDownLatch概念2.CountDownLatch的用法3.案例4.CountDownLatch的不足5.CountDownLatch(倒计时计算器)使用说明 CountDownLatch的用法 1.CountDownLatch概念 ...
  • http://www.bubuko.com/infodetail-3337727.html CountDownLatch.await()方法手误写成CountDownLatch.wait() 注意await与wait一字之差
  • CountDownLatch await可能存在的问题

    千次阅读 2019-01-05 23:38:00
    执行countdown的某个子线程可能会因为某些原因无法执行countdown,这样就会导致await线程一直阻塞下去。 在线程池中多次调用await方法,因为await方法会阻塞一段时间,有可能导致线程池可用线程被大量阻塞。 转载于:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,785
精华内容 18,314
关键字:

countdownlatch.await