您当前的位置:首页 > 电脑百科 > 程序开发 > 语言 > JAVA

常用的并发工具类

时间:2021-03-24 14:09:01  来源:  作者:

在 JDK1.5 后,推出了几个并发的工具类,位于 JUC(JAVA.util.concurrent)包下。

CountDownLatch

CountDownLatch 类是使一个线程等待其他线程各自执行完毕后再执行。

类似于现实中某个活动需要等到全部人齐了才可以开始。

实现原理:

  • 基于 AQS 的共享模式。

从ReentrantLock的实现看AQS的原理及应用

  • 这个类是一个同步计数器,主要用于线程间的控制。
  • 当 CountDownLatch 的 count 计数 > 0 时,本线程的 await() 会造成阻塞,直到 count 变为 0,开始执行本线程。
package test;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test1 {
    public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(2);      // 计数器初始化为 2,要等两个线程执行完毕
        System.out.println("主线程开始执行");

        ExecutorService es1 = Executors.newSingleThreadExecutor();
        es1.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                    System.out.println("子线程:" + Thread.currentThread().getName() + "执行");
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                latch.countDown();    // 使计数器减一
            }
        });

        ExecutorService es2 = Executors.newSingleThreadExecutor();
        es2.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println("子线程:" + Thread.currentThread().getName() + "执行");
                latch.countDown();
            }
        });
        System.out.println("等待两个线程执行完毕");
        try {
            latch.await();       // 主线程挂起,等待两个线程执行完
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("两个子线程都执行完毕,继续执行主线程");
    }
}


主线程开始执行                      
等待两个线程执行完毕                
子线程:pool-2-thread-1执行         
子线程:pool-1-thread-1执行      
两个子线程都执行完毕,继续执行主线程

CyclicBarrier

与 CountDownLatch 功能一样,不过它可以重复循环,而 CountDownLatch 只能执行一次。

实现原理:

  • 基于 ReentrantLock 和 Condition
//同步操作锁
private final ReentrantLock lock = new ReentrantLock();
//线程拦截器
private final Condition trip = lock.newCondition();
//每次拦截的线程数
private final int parties;
//换代前执行的任务
private final Runnable barrierCommand;
//表示栅栏的当前代
private Generation generation = new Generation();
//计数器
private int count;

//静态内部类Generation
private static class Generation {
  boolean broken = false;
  • 上面贴出了 CyclicBarrier 所有的成员变量,可以看到 CyclicBarrier 内部使通过条件 trip 来对线程进行阻塞。
  • 并且其内部维护了两个 int 型变量 parites 和 count,parties 表示每次拦截的线程数,该值在构造时进行赋值。count 是内部计数器,他的初始值和 parties 相同,以后随着每次 await 方法的调用而减一,直到减为零将唤醒主线程。
  • CyclicBarrier 有一个静态内部类 Generation,该类的对象代表栅栏的当前代,就像玩游戏时代表的本局游戏,利用它可以实现循环等待。
  • barrierCommand 表示换代前执行的任务,当 count 减为零时表示本局游戏结束,需要转到下一局。在转到下一局游戏之前,利用它可以实现循环等待。
package test;

import java.util.concurrent.CyclicBarrier;

public class Test2 {
    static class TaskThread extends Thread{
        CyclicBarrier barrier;

        public TaskThread(CyclicBarrier barrier){
            this.barrier = barrier;
        }

        @Override
        public void run(){
            try{
                Thread.sleep(100);
                System.out.println(getName() + "到达栅栏 A");
                barrier.await();              // 等待所有线程都执行到这,才执行主线程
                System.out.println(getName() + "冲破栅栏 A");   // 主线程完成后继续执行
                Thread.sleep(2000);
                System.out.println(getName() + "到达栅栏 B");
                barrier.await();
                System.out.println(getName() + "冲破栅栏 B");
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        int threadNum = 5;
        CyclicBarrier barrier = new CyclicBarrier(threadNum, new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "完成任务");
            }
        });
        for (int i = 0; i < threadNum; i++) {
            new TaskThread(barrier).start();
        }
    }
}

Semaphore

该类用于控制信号量的个数,可以控制同时访问资源的线程个数,并提供了同步机制。例如,实现一个文件允许的并发访问数。

Semaphore 的主要方法:

  • acquire():从此信号量中获取一个许可,若已超过许可量,则阻塞此请求线程。
  • release():释放一个许可,将其返回给信号量。
  • availablePermits():返回此信号量中当前可用的许可数。
  • hasQueuedThreads():查询是否有线程正在等待获取。
package test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class Test {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final Semaphore sp = new Semaphore(3);   // 创建 Semaphore 信号量,初始化许可大小为3
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        sp.acquire();  // 请求获取许可,如果有可获取许可,则继续往下指向,许可数减一。
                    } catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println("线程" + Thread.currentThread().getName() +
                            "进入,当前已有" + (3 - sp.availablePermits()) + "个并发") ;
                    try{
                        Thread.sleep((long)(Math.random() * 10000));
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println("线程" + Thread.currentThread().getName() + "即将离开");
                    sp.release();  // 释放许可证,许可数+1
                }
            };
            service.execute(runnable);
        }
    }
}

Exchanger

这个类用于交换数据,只能用于两个线程。当一个线程运行到 exchange() 方法时会阻塞,另一个线程运行到 exchange() 时,两者交换数据,然后执行后面的程序。

package test;

import java.util.concurrent.Exchanger;

public class Test3 {
    static class Producer extends Thread{   // 生产者线程
        private Exchanger<Integer> exchanger;     // 交换标志
        private static int data = 0;
        Producer(String name, Exchanger<Integer> exchanger){
            super("Producer-" + name);
            this.exchanger = exchanger;
        }

        @Override
        public void run(){
            for (int i = 1; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                    data = i;
                    System.out.println(getName() + "交换前:" + data);
                    data = exchanger.exchange(data);        // 将此 data 与 消费者的 data 进行交换
                    System.out.println(getName() + "交换后:" + data);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }

    static class Consumer extends Thread{   // 消费者线程
        private Exchanger<Integer> exchanger;   // 交换标志
        private static int data = 0;
        Consumer(String name, Exchanger<Integer> exchanger){
            super("Consumer-" + name);
            this.exchanger = exchanger;
        }

        @Override
        public void run(){
            while(true){
                data = 0;
                System.out.println(getName() + "交换前:" + data);
                try{
                    data = exchanger.exchange(data);   // 将此 data 与生产者的 data 进行交换,因为先执行到这,会阻塞知道生产者执行到交换
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(getName() + "交换后:" + data);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Exchanger<Integer> exchanger = new Exchanger<>();
        new Producer("", exchanger).start();
        new Consumer("", exchanger).start();
        Thread.sleep(7000);
    }
}


Tags:并发工具类   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,如有任何标注错误或版权侵犯请与我们联系(Email:2595517585@qq.com),我们将及时更正、删除,谢谢。
▌相关推荐
Java为我们提供了一些效果非常不错的并发工具类,这里主要介绍一下如下几个工具类的使用,并不会去深究实现原理(其实原理都是通过自旋CAS,CAS对应的处理器原子操作指令是CMPXCHG...【详细内容】
2021-04-27  Tags: 并发工具类  点击:(260)  评论:(0)  加入收藏
在 JDK1.5 后,推出了几个并发的工具类,位于 JUC(java.util.concurrent)包下。CountDownLatchCountDownLatch 类是使一个线程等待其他线程各自执行完毕后再执行。类似于现实中某...【详细内容】
2021-03-24  Tags: 并发工具类  点击:(350)  评论:(0)  加入收藏
▌简易百科推荐
一、Redis使用过程中一些小的注意点1、不要把Redis当成数据库来使用二、Arrays.asList常见失误需求:把数组转成list集合去处理。方法:Arrays.asList 或者 Java8的stream流式处...【详细内容】
2021-12-27  CF07    Tags:Java   点击:(3)  评论:(0)  加入收藏
文章目录 如何理解面向对象编程? JDK 和 JRE 有什么区别? 如何理解Java中封装,继承、多态特性? 如何理解Java中的字节码对象? 你是如何理解Java中的泛型的? 说说泛型应用...【详细内容】
2021-12-24  Java架构师之路    Tags:JAVA   点击:(5)  评论:(0)  加入收藏
大家好!我是老码农,一个喜欢技术、爱分享的同学,从今天开始和大家持续分享JVM调优方面的经验。JVM调优是个大话题,涉及的知识点很庞大 Java内存模型 垃圾回收机制 各种工具使用 ...【详细内容】
2021-12-23  小码匠和老码农    Tags:JVM调优   点击:(11)  评论:(0)  加入收藏
前言JDBC访问Postgresql的jsonb类型字段当然可以使用Postgresql jdbc驱动中提供的PGobject,但是这样在需要兼容多种数据库的系统开发中显得不那么通用,需要特殊处理。本文介绍...【详细内容】
2021-12-23  dingle    Tags:JDBC   点击:(12)  评论:(0)  加入收藏
Java与Lua相互调用案例比较少,因此项目使用需要做详细的性能测试,本内容只做粗略测试。目前已完成初版Lua-Java调用框架开发,后期有时间准备把框架进行抽象,并开源出来,感兴趣的...【详细内容】
2021-12-23  JAVA小白    Tags:Java   点击:(10)  评论:(0)  加入收藏
Java从版本5开始,在 java.util.concurrent.locks包内给我们提供了除了synchronized关键字以外的几个新的锁功能的实现,ReentrantLock就是其中的一个。但是这并不意味着我们可...【详细内容】
2021-12-17  小西学JAVA    Tags:JAVA并发   点击:(10)  评论:(0)  加入收藏
一、概述final是Java关键字中最常见之一,表示“最终的,不可更改”之意,在Java中也正是这个意思。有final修饰的内容,就会变得与众不同,它们会变成终极存在,其内容成为固定的存在。...【详细内容】
2021-12-15  唯一浩哥    Tags:Java基础   点击:(14)  评论:(0)  加入收藏
1、问题描述关于java中的日志管理logback,去年写过关于logback介绍的文章,这次项目中又优化了下,记录下,希望能帮到需要的朋友。2、解决方案这次其实是碰到了一个问题,一般的情况...【详细内容】
2021-12-15  软件老王    Tags:logback   点击:(17)  评论:(0)  加入收藏
本篇文章我们以AtomicInteger为例子,主要讲解下CAS(Compare And Swap)功能是如何在AtomicInteger中使用的,以及提供CAS功能的Unsafe对象。我们先从一个例子开始吧。假设现在我们...【详细内容】
2021-12-14  小西学JAVA    Tags:JAVA   点击:(21)  评论:(0)  加入收藏
一、概述观察者模式,又可以称之为发布-订阅模式,观察者,顾名思义,就是一个监听者,类似监听器的存在,一旦被观察/监听的目标发生的情况,就会被监听者发现,这么想来目标发生情况到观察...【详细内容】
2021-12-13  唯一浩哥    Tags:Java   点击:(16)  评论:(0)  加入收藏
相关文章
    无相关信息
最新更新
栏目热门
栏目头条