Java：线程并发工具类

最新推荐文章于 2024-07-09 22:12:05 发布

1024工场

最新推荐文章于 2024-07-09 22:12:05 发布

阅读量7.4k

点赞数 1

分类专栏： Java Java必备文章标签： CountDownLatch CyclicBarrier Semaphore Exchanger Thread

本文链接：https://blog.csdn.net/p106786860/article/details/52686245

版权

Java 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

Java必备

11 篇文章 7 订阅

订阅专栏

一、CountDownLatch
1.应用场景
在实际多线程并发开发过程中，我们会碰见很多等待子线程完毕后在继续执行的情况，（如多个子线程下载文件，所有子线程执行完毕后再重命名为文件名）。
2.使用方式
CountDownLatch的构造函数接受一个int类型的参数作为计数器，调用countDwon()方法，计数器减1，await()方法阻塞当前线程，直到计数器变为0；、
补充：
计数器为0的时候，调用awaite()方法不会阻塞主线程；
初始化后，不能修改计数器的值；
可以使用await(long time,TimeUnit unit)等待特定时间后，就不阻塞主线程；

3.实例代码

public class Main {   
    //等待2个子线程执行完毕，计数器为2   
    static CountDownLatch countDownLatch = new CountDownLatch(2);   
   
    public static void main(String[] args) {   
        System.out.println("start subThread doing...");   
        //创建并开启2个子线程   
        SubThread subThread1 = new SubThread();   
        SubThread subThread2 = new SubThread();   
        subThread1.start();   
        subThread2.start();   
   
        try {   
            //阻塞主线程，等待子线程结束   
            countDownLatch.await();   
        } catch (InterruptedException e) {   
            e.printStackTrace();   
        }   
   
        System.out.println("subThread are finish...");   
    }   
   
    static class SubThread extends Thread {   
        @Override   
        public void run() {   
            //模拟执行任务   
            try {   
                sleep(3000);   
            } catch (InterruptedException e) {   
                e.printStackTrace();   
            }   
            //子线程执行完毕，减少计数器   
            System.out.println(getName() + " done...");   
            countDownLatch.countDown();   
        }   
    }   
}

运行结果：当Thread-1、Thread-0两个子线程执行完毕后，在运行main线程后续的逻辑

start subThread doing... 
Thread-1 done... 
Thread-0 done... 
subThread are finish...

二、CyclicBarrier
1.应用场景
如果当你遇见需要让一组线程达到同一个屏障（同步点）时被阻塞，直到最后一个线程达到屏障时，屏障才会打开的情况。
2.使用方式
CycliBarrier默认的构造方法CyclicBarrier(int parties)，参数标识屏障拦截的线程个数，每个线程调用await()方法告诉SyclicBarrier我们已经达到屏障了，然后当前线程被阻塞。当所有子线程都达到屏障后，则继续执行子线程的后续逻辑。
补充：
CyclicBarrier还提供了一个更高级的函数CyclicBarrier(int parties,Runnable barrierAction），用于在线程达到屏障时，优先执行barrierAction。
3.实例代码

public class Main { 
    //拦截2个子线程屏障 
    static CyclicBarrier cyclicBarrier = new CyclicBarrier(2); 
 
    public static void main(String[] args) { 
        System.out.println("start subThread doing..."); 
        SubThread subThread1 = new SubThread(); 
        SubThread subThread2 = new SubThread(); 
        subThread1.start(); 
        subThread2.start(); 
    } 
 
    static class SubThread extends Thread { 
        @Override 
        public void run() { 
            try { 
                System.out.println(getName() + " doing first things."); 
                //模拟子线程执行第一个任务 
                sleep(3000); 
                System.out.println(getName() + " done first things."); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
             
            try { 
                //完成第一个任务，告知达到屏障 
                cyclicBarrier.await(); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } catch (BrokenBarrierException e) { 
                e.printStackTrace(); 
            } 
 
 
            //所有子线程都完成第一个任务后，继续运行每个子线程的下一个任务 
            System.out.println(getName() + " doing other things."); 
        } 
    } 
}

运行结果：当子线程都执行完第一个任务到达屏障后，执行下一个任务

start subThread doing... 
Thread-0 doing first things. 
Thread-1 doing first things. 
Thread-1 done first things. 
Thread-0 done first things. 
Thread-0 doing other things. 
Thread-1 doing other things.

三、Semaphore
1.应用场景
多线程访问公共资源的情况在开发过程中经常遇见，如数据库连接，可能开启几十个线程进行并发读取，但是考虑到数据库连接性能和消耗，我们必须控制10个线程哪个是连接数据库。Semaphore就是用来控制同时访问特定资源的线程数量。
2.使用方式
Semaphore的构造方法Semaphore(int permits)，permits标识许可证数量。执行任务前，acquire()方法获取一个许可证；任务执行完成后调用relese()方法归还许可证。没有获得许可证的子线程就阻塞等待。
补充：
tryAcquire()：尝试获取许可证；
intavaliablePermits()：返回信号量中当前许可证的个数；
intgetQueueLength()：返回正在等待获取许可证的线程个数；
booleanhasQueueThreads()：是否有线程正在等待许可证；
reducePermits(int reduction)：减少reduction个许可证；
getQueuedThreads()：返回所有等待获取许可证的线程集合；
3.实例代码

public class Main { 
    //创建2个许可证 
    static Semaphore semaphore = new Semaphore(2); 
 
    public static void main(String[] args) { 
        System.out.println("start subThread doing..."); 
        //同时开启4个子线程运行 
        for (int i = 0; i < 4; i++) { 
            SubThread subThread = new SubThread(); 
            subThread.start(); 
        } 
    } 
 
    static class SubThread extends Thread { 
        @Override 
        public void run() { 
            try { 
                //执行任务前获取许可证 
                semaphore.acquire(); 
                System.out.println(getName() + "doing things."); 
                sleep(3000); 
                //执行完任务释放许可证 
                semaphore.release(); 
                System.out.println(getName() + "finish things."); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
}

运行结果：同时只有2个线程运行，当某个线程运行完毕释放许可后，下一个线程才获取许可运行；

start subThread doing... 
Thread-0doing things. 
Thread-1doing things. 
Thread-1finish things. 
Thread-2doing things. 
Thread-0finish things. 
Thread-3doing things. 
Thread-2finish things. 
Thread-3finish things.

四、Exchanger
1.应用场景
在某些实际业务如流水录入中，为了避免错误。采用两个人同时录入，并对比录入的结果是否一致。Exchanger用于进行线程之间的数据交换，它提供了一个同步点，两个线程可以交换彼此的数据。
2.使用方式
两个线程通过exchange()方法交换数据，如果一个线程执行exchange()方法，它会一直等待第二个线程也执行exchange()方法。当两个线程都达到同步点时，就可以交换数据，将本线程产生的数据传递给对方。
3.实例代码

public class Main { 
    //用户线程间交换数据(String)对象exchanger 
    static Exchanger<String> exchanger = new Exchanger<>(); 
 
    public static void main(String[] args) { 
        //创建2个子线程分别执行 
        SubThread1 subThread1 = new SubThread1(); 
        SubThread2 subThread2 = new SubThread2(); 
        subThread1.start(); 
        subThread2.start();  
    } 
 
    static class SubThread1 extends Thread { 
        @Override 
        public void run() { 
            try { 
                System.out.println(getName() + "start doing..."); 
                //模拟执行完成后，获取结果result1，并将result1交换给对方线程 
                sleep(3000); 
                String result1 = "3000"; 
                String result2 = exchanger.exchange(result1); 
                //待两个线程都执行完毕后，交换数据进行比较 
                System.out.println(getName() + " thread1 result:" + result1 + " is equals thread2 result:" + result2 + 
                        "," + result1.equals(result2)); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
 
    static class SubThread2 extends Thread { 
        @Override 
        public void run() { 
            try { 
                System.out.println(getName() + "start doing..."); 
                //模拟执行完成后，获取结果result2，并将result2交换给对方线程 
                sleep(2000); 
                String result2 = "2000"; 
                String result1 = exchanger.exchange(result2); 
                //待两个线程都执行完毕后，交换数据进行比较 
                System.out.println(getName() + " thread1 result:" + result1 + " is equals thread2 result:" + result2 + 
                        "," + result1.equals(result2)); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
}

运行结果：线程1优先执行完毕，等待线程0执行完毕后，交换数据分别进行结果比较

Thread-1start doing... 
Thread-0start doing... 
Thread-1finish doing... 
Thread-0finish doing... 
Thread-0 thread1 result:3000 is equals thread2 result:2000,false 
Thread-1 thread1 result:3000 is equals thread2 result:2000,false

新技术，新未来！欢迎大家关注 “1024工场”微信服务号 ，时刻关注我们的最新的技术讯息！ （甭客气！尽情的扫描或者长按！）

1024工场

关注

1
点赞
踩
24

收藏

觉得还不错? 一键收藏
3
评论
Java：线程并发工具类

一、CountDownLatch 1.应用场景在实际多线程并发开发过程中，我们会碰见很多等待子线程完毕后在继续执行的情况，（如多个子线程下载文件，所有子线程执行完毕后再重命名为文件名）。 2.使用方式 CountDownLatch的构造函数接受一个int类型的参数作为计数器，调用countDwon()方法，计数器减1，await()方法阻塞当前线程，直到计数器变为0；、补充：计数器为0的时候，调用awaite()方法不会阻塞主线程；初始化后，不能修改计数器的值；
复制链接

扫一扫

专栏目录