多线程编程_CountDownLatch

CountDownLatch是JAVA提供在java.util.concurrent包下的一个辅助类，可以把它看成是一个计数器，其内部维护着一个count计数，只不过对这个计数器的操作都是原子操作，同时只能有一个线程去操作这个计数器，CountDownLatch通过构造函数传入一个初始计数值，调用者可以通过调用CounDownLatch对象的cutDown()方法，来使计数减1；如果调用对象上的await()方法，那么调用者就会一直阻塞在这里，直到别人通过cutDown方法，将计数减到0，才可以继续执行。

利用这种性质可以做一些事情
简单举几种简单的例子
1.需要开多线程执行，等所有的执行完成之后。在做其他的事情。
2.某个线程执行的时间不确定，我想等5秒之后如果，如果线程还没执行完，处理其他的逻辑

1.需要开多线程执行，等所有的执行完成之后。在做其他的事情。

第一种可以模拟，赛跑比赛，每个运动员是一个线程。所有的线程到达终点比赛结束。

import java.util.concurrent.CountDownLatch;

public class Sample {
    /**
     * 计数器，用来控制线程
     * 传入参数2，表示计数器计数为2
     */
    private final static CountDownLatch mCountDownLatch = new CountDownLatch(2);

    /**
     * 示例工作线程类
     */
    private static class WorkingThread extends Thread {
        private final String mThreadName;
        private final int mSleepTime;
        public WorkingThread(String name, int sleepTime) {
            mThreadName = name;
            mSleepTime = sleepTime;
        }
        
        @Override
        public void run() {
            System.out.println("[" + mThreadName + "] started!");
            try {  
                    Thread.sleep(mSleepTime);  
            } catch (InterruptedException e) {  
                    e.printStackTrace();  
            }
            mCountDownLatch.countDown();
            System.out.println("[" + mThreadName + "] end!"); 
        }
    }
    
    /**
     * 示例线程类
     */
    private static class SampleThread extends Thread {
        
        @Override
        public void run() {
            System.out.println("[SampleThread] started!");
            try {
                // 会阻塞在这里等待 mCountDownLatch 里的count变为0；
                // 也就是等待另外的WorkingThread调用countDown()
                mCountDownLatch.await();
            } catch (InterruptedException e) {
                
            }
            System.out.println("[SampleThread] end!");
        }
    }
    
    public static void main(String[] args) throws Exception {
        // 最先run SampleThread
        new SampleThread().start();
        // 运行两个工作线程
        // 工作线程1运行5秒
        new WorkingThread("WorkingThread1", 5000).start();
        // 工作线程2运行2秒
        new WorkingThread("WorkingThread2", 2000).start();
    }
}

结果如下

[SampleThread] started!
[WorkingThread1] started!
[WorkingThread2] started!
[WorkingThread2] end!
[WorkingThread1] end!
[SampleThread] end!

 

2.某个线程执行的时间不确定，我想等2秒之后如果，如果线程还没执行完，处理其他的逻辑

               final CountDownLatch latch = new CountDownLatch(1);
                final File outFile = new File(dir, imageName);
                reuslt.path=outFile.getAbsolutePath();
                reuslt.bitmap=bitmap;
                Thread sleepThread = new Thread() {
                    @Override
                    public void run() {
                        super.run();
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        reuslt.result=false;
                        reuslt.type=Reuslt.THREAD_SLEEP;
                        latch.countDown();
                    }
                };
                Thread saveThread = new Thread() {
                    @Override
                    public void run() {
                        super.run();
                       boolean result=BitmapUtils.saveBitmapWithQuality(bitmap, outFile.getPath(), picQuality);
                        reuslt.result=result;
                        reuslt.type=Reuslt.THREAD_SAVE;
                        latch.countDown();
                    }
                };

                sleepThread.start();
                saveThread.start();

                try {
                    latch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
　　　　　　　　　　//TODO samethings

 

转载于:https://www.cnblogs.com/mingfeng002/p/6770119.html