Concurrent.util 常用类的介绍和使用

傷城~ 2022-06-07 07:41 159阅读 0赞

# Concurrent.util 常用类的介绍和使用 #

*  Concurrentutil 常用类的介绍和使用
    
     *  CyclicBarrier
     *  CountDownLacth
     *  Callable 和 Future
     *  Samaphore 信号量

## CyclicBarrier ##

> 假设一个场景： 每个线程都代表一个跑步运动员，当运动员都准备好后才一起出发，只要有一个没准备好，大家都等待。

package org.mulity.demo;
    
    import java.util.Random;
    import java.util.concurrent.CyclicBarrier;
    import java.util.concurrent.Executor;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /** * CyclicBarrier 使用示例 * * Created by jun on 2017/10/14. */
    public class UseCyclicBarrier { 
    
        static class Runner implements Runnable {
            private CyclicBarrier barrier;
            private String name;
    
            public Runner(CyclicBarrier barrier, String name) {
                this.barrier = barrier;
                this.name = name;
            }
    
            @Override
            public void run() {
                try {
                    Thread.sleep(1000 * (new Random()).nextInt(5));
                    System.out.println(name + ", ready");
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println(name + "GO!");
            }
        }
    
        public static void main(String[] args) {
            // new CyclicBarrier(3); 必须有 3 个barrier.await(); 才能继续往下执行
            CyclicBarrier barrier = new CyclicBarrier(3);
            // 返回一个固定数量的线程池
            ExecutorService executor = Executors.newFixedThreadPool(3);
    
            executor.submit(new Thread(new Runner(barrier, "运动员1")));
            executor.submit(new Thread(new Runner(barrier, "运动员2")));
            executor.submit(new Thread(new Runner(barrier, "运动员3")));
        }
    }

// 输出：
    运动员2, ready
    运动员3, ready
    运动员1, ready
    运动员1GO!
    运动员2GO!
    运动员3GO!

## CountDownLacth ##

> 它常用于监听某些初始化操作，等初始化操作执行完毕后，通知主线程继续工作

package org.mulity.demo;
    
    import java.util.concurrent.CountDownLatch;
    
    /** * CountDownLatch 使用示例 * <p> * Created by jun on 2017/10/14. */
    public class UserCountDownLatch { 
    
        public static void main(String[] args) {
    
            final CountDownLatch countDown = new CountDownLatch(2);
            // CountDownLatch(2) 代表一个 countDown.await(); 需要两个countDown.countDown();来唤醒
    
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("进入线程1：等待其他线程处理完成");
                        countDown.await();
                        System.out.println("t1 线程继续执行");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "t1");
    
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("进入线程2：线程开始初始化");
                        Thread.sleep(3000);
                        countDown.countDown();
                        System.out.println("t2 线程初始化完毕");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "t2");
    
            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("进入线程3：线程开始初始化");
                        Thread.sleep(3000);
                        countDown.countDown();
                        System.out.println("t3 线程初始化完毕");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "t3");
    
            t1.start();
            t2.start();
            t3.start();
        }
    }

// 输出：
    进入线程2：线程开始初始化
    进入线程3：线程开始初始化
    进入线程1：等待其他线程处理完成
    t2 线程初始化完毕
    t3 线程初始化完毕
    t1 线程继续执行

## Callable 和 Future ##

> Future 模式 有点类似于 ajax 异步的调用，非常适合在处理耗时很长的业务逻辑的时候使用，可以有效的减小系统的响应时间，提高系统的吞吐量

package org.mulity.demo;
    
    import java.util.concurrent.*;
    
    /** * Future 使用示例 * * Created by jun on 2017/10/14. */
    public class UseFuture implements Callable<String>{ 
    
        private String para;
    
        public UseFuture(String para) {
            this.para = para;
        }
    
        /** * 这里是真实的业务逻辑，执行起来可能比较慢 */
        @Override
        public String call() throws Exception {
            // 模拟执行耗时
            Thread.sleep(3000);
            return this.para + "处理完成";
        }
    
        public static void main(String[] args) throws InterruptedException, ExecutionException {
            String queryStr = "query";
            FutureTask future = new FutureTask<String>(new UseFuture(queryStr));
            // 该方法会创建一个线程的线程池，若空闲则执行，若没有空闲线程，则缓存在任务队列中
            ExecutorService executor = Executors.newSingleThreadExecutor();
            Future f = executor.submit(future);
            System.out.println("请求完毕");
    
            // 主程序可以执行其他业务逻辑
            Thread.sleep(1000);
    
            // future.get() 没得到数据前会阻塞
            System.out.println("数据：" + future.get());
            executor.shutdown();
        }
    }

// 输出
    请求完毕
    数据：query处理完成

## Samaphore 信号量 ##

> 常用于高并发下，Java 层面，系统的限流。

package org.mulity.demo;
    
    import java.util.Random;
    import java.util.concurrent.Executor;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Semaphore;
    
    /** * Semaphore 示例 * * Created by jun on 2017/10/14. */
    public class UseSemaphore { 
    
        public static void main(String[] args) {
            // 返回一个可以根据实际情况调整线程个数的线程池，不限制最大的线程数量，若有空闲的线程，则执行任务，若无任务则不创建线程，并且每一个空闲线程会在60秒后自动回收
            ExecutorService executor = Executors.newCachedThreadPool();
            // 同时只能有 5 个线程同时访问
            final Semaphore semp = new Semaphore(5);
            // 模拟 20个线程同时访问
            for (int index = 0; index < 20; index++) {
                final int NO = index;
                Runnable run = new Runnable() {
                    @Override
                    public void run() {
                        try {
                            // 获取许可
                            semp.acquire();
                            System.out.println(NO + "已经获取许可");
                            // 模拟实际业务逻辑
                            Thread.sleep(1000 * (new Random()).nextInt(10));
                            // 释放许可
                            semp.release();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                };
                executor.submit(run);
            }
        }
    }

// 输出:
    0已经获取许可
    1已经获取许可
    2已经获取许可
    3已经获取许可
    4已经获取许可
    5已经获取许可
    6已经获取许可
    7已经获取许可
    ...