JAVA并发编程（三）——同步控制(下)

最新推荐文章于 2024-09-21 10:38:43 发布
最新推荐文章于 2024-09-21 10:38:43 发布
阅读量217 收藏
点赞数
分类专栏： JVM 文章标签： java 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37169817/article/details/78219161
版权

要实现并发的同步控制，除了上篇文章中介绍的使用synchronized和ReentrantLock以外，JDK中内部提供了许多使用的API和框架。这里我将介绍其中几种常用的。

  • Semaphore(信号量)
  • ReadWriteLock(读写锁)
  • CountDownLatch(倒计时器)
  • CyclicBarrier(循环栅栏)

Semaphore

我们知道，不论是synchronized还是ReentrantLock，一次都只允许一个线程访问共享的资源。而Semaphore可以指定某个数量的线程同时访问一个资源。就好像一个厕所，有多个坑位，就可以使得多个人同时使用，人数超过了，就需要等待。
Semaphore提供了两个常用的构造函数，以及常用的方法如下：

//创建具有给定的许可数和非公平的公平设置的 Semaphore。
Semaphore(int permits);
// 创建具有给定的许可数和给定的公平设置的 Semaphore。
Semaphore(int permits, boolean fair);
//获得使用资源的许可
void acquire();
//释放获得的许可
void release();

为了更好的学习Semaphore，我写了一个小的demo，模拟多个人同时上多个厕所。

class Toilet implements Runnable{
    private Semaphore semaphore;
    private int id;
    public Toilet(Semaphore semaphore,int id){this.semaphore = semaphore;this.id=id;}
    @Override
    public void run() {
        try {
            semaphore.acquire();
            System.out.println("编号："+id+"在上厕所时间为："+System.currentTimeMillis()/1000);
            //模拟上厕所
            TimeUnit.MILLISECONDS.sleep((long) (Math.random() * 10000));
            System.out.println("编号："+id+"厕所上完了");
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class TestSemaphore {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(2);
        for (int i = 1; i <= 10; i++) {
            exec.execute(new Toilet(semaphore, i));
        }
        TimeUnit.SECONDS.sleep(30);
        exec.shutdown();
        System.out.println("厕所都上完了");
    }
}
//output:
/*
编号：2在上厕所时间为：1507810796
编号：1在上厕所时间为：1507810796
编号：1厕所上完了
编号：4在上厕所时间为：1507810797
编号：4厕所上完了
编号：3在上厕所时间为：1507810798
编号：2厕所上完了
编号：6在上厕所时间为：1507810799
编号：3厕所上完了
编号：7在上厕所时间为：1507810804
编号：6厕所上完了
编号：5在上厕所时间为：1507810808
编号：5厕所上完了
编号：8在上厕所时间为：1507810810
编号：7厕所上完了
编号：9在上厕所时间为：1507810812
编号：9厕所上完了
编号：10在上厕所时间为：1507810814
编号：10厕所上完了
编号：8厕所上完了
厕所都上完了
*/

这里我模拟了10个人上两个厕所的过程。只要在需要同步的业务逻辑上加上semaphore.acquire();和semaphore.release();即可。非常简单实用。

ReadWriteLock(读写锁)

我们知道，在程序中使用锁是非常消耗性能的，所以为了提高性能，需要减少锁的使用。要知道，我们对一个资源访问，但是不去修改而是简单的读取数据，在这种情况下如果加锁，是完全没有必要的。所以对于一些经常用来读取但是几乎不修改的变量，我们需要重新考虑，使得多个线程读取的时候不需要锁，仅仅在写入的时候加锁。这时候，就需要用到ReadWriteLock。具体用法如下：

public class ReadWriteLockDemo {

    private static Lock lock = new ReentrantLock();
    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private static Lock readLock = readWriteLock.readLock();
    private static Lock writeLock = readWriteLock.writeLock();
    private int value;

    public Object handleRead(Lock lock) throws InterruptedException{
        try{
            lock.lock();
            TimeUnit.SECONDS.sleep(3);
            System.out.println("reading"+"读取时间为："+System.currentTimeMillis()/1000);
            TimeUnit.SECONDS.sleep(1);
            return value;
        }finally{
            lock.unlock();
        }
    }
    public void handleWrite(Lock lock,int index) throws InterruptedException{
        try{
            lock.lock();
        System.out.println("write 数据为:"+index+"写入时间为："+System.currentTimeMillis()/1000);
            TimeUnit.SECONDS.sleep(3);
            value = index;
        }finally{
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        long currentTimeMillis = System.currentTimeMillis();
        final ReadWriteLockDemo demo = new ReadWriteLockDemo();
        Runnable readRunnable = new Runnable() {
            @Override
            public void run() {
                try {
                    demo.handleRead(readLock);
                    //demo.handleRead(lock);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Runnable writeRunnable = new Runnable() {
            @Override
            public void run() {
                try {
                    demo.handleWrite(writeLock, new Random().nextInt());
                    //demo.handleWrite(lock, new Random().nextInt());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 8; i++) {
            new Thread(readRunnable).start();
        }
        for (int i = 0; i < 2; i++) {
            new Thread(writeRunnable).start();
        }
    }
}
/*
使用readWriteLock输出：
reading读取时间为：1507811783
reading读取时间为：1507811783
reading读取时间为：1507811783
reading读取时间为：1507811783
reading读取时间为：1507811783
reading读取时间为：1507811783
reading读取时间为：1507811783
reading读取时间为：1507811783
write 数据为:-1205341170写入时间为：1507811784
write 数据为:2021909351写入时间为：1507811787
*/
/*
使用ReentrantLock输出如下：
reading读取时间为：1507811880
reading读取时间为：1507811884
reading读取时间为：1507811888
reading读取时间为：1507811892
reading读取时间为：1507811896
reading读取时间为：1507811900
reading读取时间为：1507811904
reading读取时间为：1507811908
write 数据为:273063536写入时间为：1507811909
write 数据为:-708027034写入时间为：1507811912
*/

可以看到，使用readWriteLock在读取的时候不阻塞，在写入数据的时候需要同步。性能相比较ReentrantLock高了许多。

CountDownLatch(倒计时器)

CountDownLatch翻译为倒计时插销，其实就是一个倒计时工具，就像火箭发射前指挥员喊得：“5,4,3,2,1，发射！”。(我还记得2003年读小学时，电视上看着神州5号飞船发射，那一个激动啊。。。扯远了)。在并发中，他的作用就是计算还有多少剩下的线程需要执行，执行一个线程，计数器减一，直到为零，然后通知目标线程开始执行。
CountDownLatch的构造器接收一个整数位参数：

public CountDownLatch(int count);//count为执行的个数

老样子，给一个例子能更好的学习：

class Work extends Thread{
    private int thredId;
    private CountDownLatch latch;
    public Work(int id,CountDownLatch latch){
        this.latch = latch;
        this.thredId = id;
    }
    public void run(){
        dowork();
        //执行完一个任务，count减一
        latch.countDown();
    }
    public void dowork(){
        System.out.println(this+" is doing");
    }
    public String toString(){return "Thread:"+thredId ;}
}

class MainWork extends Thread{
    private CountDownLatch latch;
    public MainWork(CountDownLatch latch){this.latch = latch;}
    public void run(){
        try {
            System.out.println("准备主任务中");
            //主任务在这里等待小任务完成
            latch.await();
            System.out.println("开始执行主要任务");
        } catch (InterruptedException e) {          
            e.printStackTrace();
        }
    }
}
public class CountDownLatchDemo {
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(10);
        ExecutorService executorService = Executors.newCachedThreadPool();
        //开始主任务线程
        executorService.execute(new MainWork(latch));
        //开始10个小任务线程
        for (int i = 1; i <= 10; i++) {
            executorService.execute(new Work(i, latch));
        }
        executorService.shutdown();
    }
}
/*
output:
准备主任务中
Thread:2 is doing
Thread:6 is doing
Thread:10 is doing
Thread:4 is doing
Thread:8 is doing
Thread:3 is doing
Thread:7 is doing
Thread:1 is doing
Thread:5 is doing
Thread:9 is doing
开始执行主要任务
*/

可以看到，我们构造了一个计数器数量为10的CountDownLatch当10个小任务执行完成后，MainWork继续执行。

CyclicBarrier(循环栅栏)

CyclicBarrier和CountDownLatch非常类似，也实现线程之间的计数等待的功能，但是他的功能更加复杂且强大。用学生集合去做操形容CyclicBarrier是比较好的：学生们在教室前集合，先到的同学需要等待，直到所有的同学都到期，这是，大家一起执行出操的任务。如果熟悉赛车比赛的同学也可以理解为比赛前的发车。
CyclicBarrier的构造函数接收一个count和一个task任务，当计数器计数完成以后，执行task任务，task执行完成以后，计数器中的任务线程还可以再次执行的。

CyclicBarrier(int count, Runnable task);

这里我就用我喜爱的F1(赛车)发车用来模拟（对了我是从04年中国赛开始看F1的，F1是属于比较小众的运动吧，关注也不高，但不知道为什么就这么坚持下来了）：

public class F1 {

    public static class Car implements Runnable {
        private int carId;
        private final CyclicBarrier barrier;

        public Car(int carId, CyclicBarrier barrier) {
            this.barrier = barrier;
            this.carId = carId;
        }

        @Override
        public void run() {
            try {
                System.out.println(carId+"号车准备发车");
                TimeUnit.MILLISECONDS.sleep(2000);
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println(carId+"号车起步了");
        }
    }
    //控制台，发出同步指令的，相当于信号灯
    //当22个小车线程执行到wait时，执行Controll的task
    public static class Controll implements Runnable{
        @Override
        public void run() {
            System.out.println("所有车都准备好了，信号灯倒计时");
            for(int i=3;i>=0;i--){
                try {
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println((i==0? "发车":i));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        CyclicBarrier barrier = new CyclicBarrier(22, new Controll());
        System.out.println("马来西亚大奖赛正赛开始了");
        TimeUnit.SECONDS.sleep(3);
        //F1一共有22辆赛车
        for(int i =1;i<23;i++){
            new Thread(new Car(i, barrier)).start();;
        }
    }
}
/*
output：
马来西亚大奖赛正赛开始了
1号车准备发车
2号车准备发车
。。。。。。
。。。。。。
21号车准备发车
22号车准备发车
所有车都准备好了，信号灯倒计时
3
2
1
发车
22号车起步了
1号车起步了
。。。。。。
。。。。。。
9号车起步了
21号车起步了
*/

从输出可以知道，当22个赛车线程都执行到wait()时候(准备发车)，一个目标控制台线程开始执行(倒计时3,2,1)，目标线程执行完成以后，22个赛车线程继续执行接下未完成的任务(发车，启动车)，这和CountDownLatch是不同的。

JDK中的java.util.concurrent包还有很多的同步控制工具，由于篇幅有限，需要大家自己去学习了。

早就戒了
关注
专栏目录
Java并发编程进阶——并发锁
行者无疆的博客
03-14 4226
1 JAVA 多线程锁介绍 1.1 悲观锁 定义：悲观锁指对数据被外界修改持保守态度，认为数据很容易就会被其他线程修改（很悲观），所以在数据被处理前先对数据进行加锁，并在整个数据处理过程中，使数据处于锁定状态。 悲观锁的实现：开发中常见的悲观锁实现往往依靠数据库提供的锁机制，即在数据库中，在对数据记录操作前给记录加排它锁。如果获取锁失败，则说明数据正在被其他线程修改，当前线程则等待或者抛出异常。如果获取锁成功，则对记录进行操作，然后提交事务后释放排它锁。 实例：Java 中的 synchronized 关键
Java并发编程——同步队列(SynchronousQueue)
qq_43576814的博客
08-17 744
SynchronousQueue是无界的，是一种无缓冲的等待队列，但是由于该Queue本身的特性，在某次添加元素后必须等待其他线程取走后才能继续添加；可以认为SynchronousQueue是一个缓存值为1的阻塞队列。 public class SynchronousQueueDemo { public static void main(String[] args) { BlockingQueue<String> blockingQueue=new Synchronous
Java并发编程(8) —— AQS抽象同步队列详解
m0_56602092的博客
04-12 1775
AbstractQueuedSynchronizer抽象同步队列简称AQS，它是实现锁和同步器的基础组件，并发包中锁的底层就是使用AQS实现的。AQS 为构建锁和同步器提供了一些通用功能的实现，因此使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，比如ReentrantLock，Semaphore，ReentrantReadWriteLock，SynchronousQueue等等皆是基于 AQS 的
Java并发编程——CompletableFuture详解
Java是世界上最好的语言
11-15 2432
Future/Callable Java 1.5开始，提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。 Future接口可以构建异步应用，是多线程开发中常见的设计模式。 当我们需要调用一个函数方法时。如果这个函数执行很慢,那么我们就要进行等待。但有时候,我们可能并不急着要结果。 因此,我们可以让被调用者立即返回,让他在后台慢慢处理这个请求。对于调用者来说,则可以先处理一些其他任务,在真正需要数据的场合再去尝试获取需要的数据。 简单实现 public class Fut
Java并发编程——ForkJoin详解
热门推荐
Java是世界上最好的语言
11-13 1万+
概念 Fork/Join 框架是 Java7 提供了的一个用于并行执行任务的框架， 是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。类似于Java 8中的parallel Stream。 【只能将任务1个切分为两个，不能切分为3个或其他数量】 简单使用 public class ForkJoinExample { //针对一个数字，做计算。 private static final Integer MAX = 200; static class
Java并发编程——线程创建的4种常见方式
weixin_44814196的博客
08-07 2232
介绍常见的 4 种Java线程创建方式，并给出相应的源码解析。
Java并发编程——ConcurrentHashMap详解
Java是世界上最好的语言
11-14 1万+
引出 场景：针对用户来做一个访问次数的记录。 通过HashMap进行记录，key为用户名，value为访问次数。 public class ConcurrentHashMapDemo { private static final HashMap<String, Integer> USER_ACCESS_COUNT = new HashMap<>(); public static void main(String[] args) { //针对用户来做
Java并发编程3——线程状态转换
m0_43424329的博客
09-17 290
Java线程的状态转换
Java并发编程——synchronized解决线程同步问题
HiXinJ的博客
01-28 238
线程安全问题的例子 下面示例没有线程同步，出现了脏读现象。线程A调用setValue取得了publicVarRef对象锁，但是线程A仍然可以调用publicVarRef对象的非synchronized方法getValue()。 public class Runner { public static void main(String[] args) { try { ...
Java 入门指南：Java 并发编程 —— 同步工具类 CountDownLatch（倒计时门闩）
Zachyy的博客
09-10 1208
CountDownLatch（倒计时门闩）是 Java 中的一种同步辅助类，用于控制多个线程之间的协调，允许一个或多个线程等待其他线程完成一组操作。 CountDownLatch 通过维护一个计数器来实现，计数器初始值可以设定为一个正整数（通常为需要等待的线程数量或任务数量）。每当一个线程完成任务后，计数器的值就会减1。当计数器的值减到 0 时，所有等待的线程都会被释放，此时所有因调用 await() 方法而阻塞的线程都会被唤醒，继续执行后续的操作。
Java并发编程总结——慎用CAS详解
09-02
Java并发编程中，CAS（Compare and Swap，比较并交换）是一种无锁算法，常用于实现原子操作，它在多线程环境下提供了数据的一致性。然而，CAS并不是万能的，过度依赖或不当使用可能会导致问题。下面我们将深入探讨...
java并发编程——内存模型
02-24
且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行——源自百度百科在并发编程中，我们需要处理两个关键问题：线程之间如何通信和线程之间如何同步，后续篇章将围绕这两个问题进行...
Java并发编程之——Amino框架
08-10
Java并发编程是一个复杂而重要的主题，它涉及到多线程、同步机制、线程池和并发容器等关键概念。Amino框架是Java并发编程领域的一个工具，它旨在简化并发编程，提高程序的性能和可维护性。这篇博客文章可能详细探讨...
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 363
Arthas sysenv（查看JVM的环境变量）
JDK17新增语法特性
2201_76124988的博客
09-20 738
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 246
faiss版本 faiss-v1.7.4。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 1065
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
面试突击-多线程和IO专题(至尊典藏版)
人生若只初相见@的博客
09-18 1822
金九银十多线程和IO大厂面试专题
Mybatis-plus进阶篇(四)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
09-19 1403
nested 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于创建一个独立的查询条件块，不带默认的 AND 或 OR 逻辑。last 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它允许你直接在查询的最后添加一个 SQL 片段，而不受 MyBatis-Plus 的查询优化规则影响。exists 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于在查询中添加一个 EXISTS 子查询。这个方法特别适用于需要对数值字段进行减量操作的场景。
《Java并发实践》——掌握并发编程的艺术
"《Java并发实践》是一本权威的讲解Java并发编程的书籍，对于提升到高级程序员水平至关重要。" 本书《Java并发实践》由Brian Göetz、Tim Peierls、Joshua Bloch、Joseph Bowbeer、David Holmes和Doug Lea等多位...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值