Java并发包相关组件(1)

1. CountDownLatch

用于线程计时，完成操作后通过countDownLatch.countDown() 就能让计时减一，直到计时为零之后，执行countDownLatch.await() 后的代码，否则阻塞。

class MainThread implements Runnable{
    private CountDownLatch countDownLatch = new CountDownLatch(3);

    @Override
    public void run() {
        ReentrantLock reentrantLock = new ReentrantLock();

        new Thread(()->{
            try {
                reentrantLock.lock();
                Thread.sleep(1000);
                System.out.println("打开冰箱");
                countDownLatch.countDown();
                reentrantLock.unlock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{
            try {
                reentrantLock.lock();
                Thread.sleep(1000);
                System.out.println("把大象装入冰箱");
                countDownLatch.countDown();
                reentrantLock.unlock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }).start();
        new Thread(()->{
            try {
                reentrantLock.lock();
                Thread.sleep(1000);
                System.out.println("关上冰箱");
                countDownLatch.countDown();
                reentrantLock.unlock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{
            try {
                countDownLatch.await();
                System.out.println("步骤完成");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

执行结果

 

 

 

2. CyclicBarrier 

只有当规定数量的线程都完成了对应的操作并通过cyclicBarrier.await() 进入的阻塞状态，cyclicBarrier实现的Runable的内容才会执行。

//运动员线程
class Runner implements Runnable{
    private CyclicBarrier cyclicBarrier;
    private int id;
    private static int allId = 0;

    public Runner(CyclicBarrier cyclicBarrier) {
        this.cyclicBarrier = cyclicBarrier;
        this.id = allId++;
    }

    @Override
    public void run() {
        try {
            System.out.println("运动员" + this.id + "号准备中");
            TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000) + 500);
            System.out.println("运动员" + this.id + "号准备完毕");
            cyclicBarrier.await();
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }
}

//main
class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("所有运动员准备完毕，比赛开始");
            }
        });

        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for(int i = 0;i < 5;i++){
            executorService.submit(new Runner(cyclicBarrier));
        }

    }
}

 

3. DelayQueue 

延时队列，里面的元素需要实现Delayed接口，只有当元素到达延时时间后才会弹出，否则进行阻塞。

class DelayItem implements Delayed{
    //必要字段，表示延时的时长
    private long duration;
    private String msg;

    public DelayItem(long duration, String msg) {
        this.duration = duration + System.currentTimeMillis();
        this.msg = msg;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(this.duration - System.currentTimeMillis(),TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        DelayItem delayItem = (DelayItem) o;

        return this.duration > delayItem.duration ? 1 : -1;
    }

    public String getMsg(){
        return msg;
    }
}

//main
class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        DelayQueue delayQueue = new DelayQueue();

        delayQueue.offer(new DelayItem(3000,"第二紧急事件"));
        delayQueue.offer(new DelayItem(1000,"第一紧急事件"));
        delayQueue.offer(new DelayItem(5000,"第三紧急事件"));

        System.out.println(((DelayItem) delayQueue.take()).getMsg());
        System.out.println(((DelayItem) delayQueue.take()).getMsg());
        System.out.println(((DelayItem) delayQueue.take()).getMsg());


    }
}

 

4. PriorityBlockingQueue

优先级队列，当队列中没有元素时执行取出将会阻塞

class PriorityItem implements Comparable{
    private long priority;
    private String msg;

    public PriorityItem(long priority,String msg) {
        this.priority = priority;
        this.msg = msg;
    }

    @Override
    public int compareTo(Object o) {
        PriorityItem priorityItem = (PriorityItem) o;

　　　　//返回1时会放在尾部，返回-1则放在头部
        return this.priority < priorityItem.priority ? 1 : -1;
    }

    public String getMsg() {
        return msg;
    }
}

//main
class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        PriorityBlockingQueue<PriorityItem> priorityBlockingQueue = new PriorityBlockingQueue();

        priorityBlockingQueue.add(new PriorityItem(10,"第二紧急事件"));
        priorityBlockingQueue.add(new PriorityItem(30,"第一紧急事件"));
        priorityBlockingQueue.add(new PriorityItem(5,"第三紧急事件"));

        System.out.println(((PriorityItem) priorityBlockingQueue.take()).getMsg());
        System.out.println(((PriorityItem) priorityBlockingQueue.take()).getMsg());
        System.out.println(((PriorityItem) priorityBlockingQueue.take()).getMsg());
    }
}

 

5. Semaphore 

信号量，用于实现同步和互斥，分为公平与非公平信号量。公平信号量根据获取锁的时间长短来进行执行，非公平信号量则根据CPU时间片轮转来随机分配执行。

//信号量解决哲学家吃饭问题
class Reader implements Runnable{
    private Semaphore[] semaphore;
    //哲学家编号
    private int id;
    //筷子个数
    private int num;
    private static int allId = 0;

    public Reader(Semaphore[] semaphore) {
        this.semaphore = semaphore;
        num = semaphore.length;
        id = allId++;
    }

    @Override
    public void run() {
        try {
            while (true){
                semaphore[id % num].acquire();
                semaphore[(id + 1) % num].acquire();
                System.out.println("哲学家" + this.id + "号拿起筷子");
                TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000) + 500);
                System.out.println("哲学家" + this.id + "号结束吃饭");
                semaphore[id % num].release();
                semaphore[(id + 1) % num].release();
            }
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }
}

//main
class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Semaphore[] semaphores = new Semaphore[5];

        for(int i = 0;i < semaphores.length;i++){
　　　　　　　　//将信号量设置为公平信号量
            semaphores[i] = new Semaphore(1,true);
        }

        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for(int i = 0;i < 5;i++){
            executorService.submit(new Reader(semaphores));
        }

        executorService.shutdown();
    }
}