【高并发】11 AQS代码案例

最新推荐文章于 2023-08-18 12:15:00 发布
最新推荐文章于 2023-08-18 12:15:00 发布
阅读量145 收藏
点赞数
分类专栏： 0704【高并发】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40996741/article/details/107076267
版权

一、CountDownLatch

1、代码一

package com.current.flame.aqs;

import lombok.extern.slf4j.Slf4j;

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

/**
 * @author haoxiansheng
 */
@Slf4j
public class CountDownLatchExample1 {
    private final static int threadCount = 200;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newCachedThreadPool();
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            service.execute(()-> {
                try {
                    testCountDownLatch(threadNum);
                } catch (InterruptedException e) {
                    log.error("Exception=>{}", e.getMessage());
                } finally {
                    countDownLatch.countDown(); // -1
                }
            });
        }
        countDownLatch.await();
        log.info("=========finish");
        service.shutdown();
    }

    private static void testCountDownLatch(int threadNum) throws InterruptedException {
        Thread.sleep(100);
        log.info("threadNum=====>{}", threadNum);
        Thread.sleep(100);
    }
}

2、代码二

package com.current.flame.aqs;

import lombok.extern.slf4j.Slf4j;

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

/**
 * @author haoxiansheng
 */
@Slf4j
public class CountDownLatchExample2 {
    private final static int threadCount = 200;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newCachedThreadPool();
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            service.execute(()-> {
                try {
                    testCountDownLatchTimeOut(threadNum);
                } catch (InterruptedException e) {
                    log.error("Exception=>{}", e.getMessage());
                } finally {
                    countDownLatch.countDown(); // -1
                }
            });
        }
        countDownLatch.await(10, TimeUnit.MICROSECONDS);
        log.info("=========finish");
        service.shutdown();
    }

    private static void testCountDownLatchTimeOut(int threadNum) throws InterruptedException {
        Thread.sleep(100);
        log.info("threadNum=====>{}", threadNum);
        Thread.sleep(100);
    }
}

二、CyclicBarrier

1、代码一

package com.current.flame.aqs;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author haoxiansheng
 */
@Slf4j
public class CyclicBarrierExample1 {

    private static CyclicBarrier barrier = new CyclicBarrier(5, ()->{
        log.info("优先执行我 callback is running");
    });
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
            final int threadNum = i;
            Thread.sleep(1000);
            executor.execute(() -> {
                try {
                    testCyclicBarrier(threadNum);
                } catch (Exception e) {
                    log.error("exception=>{}", e);
                }
            });
        }
        executor.shutdown();
    }

    private static void testCyclicBarrier(int threadNum) throws InterruptedException, BrokenBarrierException {
        Thread.sleep(1000);
        log.info("thread-{} say: I am is ready", threadNum);
        barrier.await();
        log.info("thread-{} say: continue", threadNum);
    }
}

2、代码二

package com.current.flame.aqs;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;

/**
 * @author haoxiansheng
 */
@Slf4j
public class CyclicBarrierExample2 {

    private static CyclicBarrier barrier = new CyclicBarrier(5);
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
            final int threadNum = i;
            Thread.sleep(1000);
            executor.execute(() -> {
                try {
                    testCyclicBarrierAwait(threadNum);
                } catch (Exception e) {
                    log.error("exception", e);
                }
            });
        }
        executor.shutdown();
    }

    private static void testCyclicBarrierAwait(int threadNum) throws InterruptedException, BrokenBarrierException, TimeoutException {
        Thread.sleep(1000);
        log.info("thread-{} say: I am is ready", threadNum);
        try{
            barrier.await(2000, TimeUnit.MILLISECONDS);
        } catch (BrokenBarrierException | TimeoutException e) {
            log.warn("e", e);
        }
        log.info("thread-{} say: continue", threadNum);
    }
}

三、Semaphore

1、代码一

package com.current.flame.aqs;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;

/**
 * @author haoxiansheng
 * 单个许可
 */
@Slf4j
public class SemaphoreExample1 {
    private final static int threadCount = 200;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newCachedThreadPool();

        final Semaphore semaphore = new Semaphore(5); // 一共有多少线程同步等待
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            service.execute(()-> {
                try {
                    semaphore.acquire();  // 拿到许可
                    testSemaphore(threadNum);
                    semaphore.release();  // 释放许可
                } catch (InterruptedException e) {
                    log.error("Exception=>{}", e.getMessage());
                } finally {
                }
            });
        }
        log.info("=========finish");
        service.shutdown();
    }

    private static void testSemaphore(int threadNum) throws InterruptedException {
        log.info("threadNum=====>{}", threadNum);
        Thread.sleep(1000);
    }
}

2、代码二

package com.current.flame.aqs;

import lombok.extern.slf4j.Slf4j;

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

/**
 * @author haoxiansheng
 * 多个许可
 */
@Slf4j
public class SemaphoreExample2 {
    private final static int threadCount = 20;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newCachedThreadPool();

        final Semaphore semaphore = new Semaphore(5);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            service.execute(()-> {
                try {
                    semaphore.acquire(3);  // 拿到许可
                    testSemaphore(threadNum);
                    semaphore.release(1);  // 释放许可
                    log.info("release=====2");
                    semaphore.release(2);
                } catch (InterruptedException e) {
                    log.error("Exception=>{}", e.getMessage());
                } finally {
                }
            });
        }
        log.info("=========finish");
        service.shutdown();
    }

    private static void testSemaphore(int threadNum) throws InterruptedException {
        log.info("threadNum=====>{}", threadNum);
        Thread.sleep(1000);
    }
}

3、代码三

package com.current.flame.aqs;

import lombok.extern.slf4j.Slf4j;

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

/**
 * @author haoxiansheng
 * 单个许可
 */
@Slf4j
public class SemaphoreExample3 {
    private final static int threadCount = 30;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newCachedThreadPool();

        final Semaphore semaphore = new Semaphore(5);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            service.execute(() -> {
                try {
                    //if (semaphore.tryAcquire()) { // 尝试拿到许可
                    if (semaphore.tryAcquire(2000, TimeUnit.MILLISECONDS)) { // 尝试拿到许可
                        testSemaphore(threadNum);
                        semaphore.release();  // 释放许可
                    }
                } catch (InterruptedException e) {
                    log.error("Exception=>{}", e.getMessage());
                } finally {
                }
            });
        }
        log.info("=========finish");
        service.shutdown();
    }

    private static void testSemaphore(int threadNum) throws InterruptedException {
        log.info("threadNum=====>{}", threadNum);
        Thread.sleep(1000);
    }
}

四、future

package com.current.flame.aqs;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;

/**
 * @author haoxiansheng
 */
@Slf4j
public class FutureExample {
    static class MyCallable implements Callable<String>{
        @Override
        public String call() throws Exception {
            log.info("do something......");
            Thread.sleep(5000);
            return "ok";
        }
    }
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newCachedThreadPool();
        Future<String> future = executor.submit(new MyCallable());
        log.info("do other something......");
        Thread.sleep(10000);
        String result = future.get();
        log.info("future=>{}", result);
        executor.shutdown();
    }
}
五、FutureTask
package com.current.flame.aqs;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author haoxiansheng
 */
@Slf4j
public class FutureTaskExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {

//        FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() {
//            @Override
//            public String call() throws Exception {
//                log.info("do something......");
//                Thread.sleep(5000);
//                return "ok";
//            }
//        });
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            log.info("do something......");
            Thread.sleep(5000);
            return "ok";
        });

        new Thread(futureTask).start();
        log.info("do other something");
        Thread.sleep(1000);

        String result = futureTask.get();
        log.info("future=>{}", result);
    }
}

六、ForkJoinTask

package com.current.flame.aqs;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

/**
 * @author haoxiansheng
 * 递归拆分任务
 */
@Slf4j
public class ForkJoinTaskExample extends RecursiveTask<Integer> {
    public static final int threshhold = 2;

    private int start;

    private int end;

    public ForkJoinTaskExample(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum = 0;
        // 如果任务足够小就计算任务
        boolean canCompute = (end - start) <= threshhold;
        if (canCompute) {
            for (int i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            // 如果任务大于阀值,就分裂成两个自任务计算
            int middle = (start + end)/2;
            ForkJoinTaskExample leftTask = new ForkJoinTaskExample(start, middle);
            ForkJoinTaskExample rightTask = new ForkJoinTaskExample(middle+1, end);
            leftTask.fork();
            rightTask.fork();

            // 等待任务结束合并结果
            int leftResult = leftTask.join();
            int rightResult = rightTask.join();
            // 合并子任务
            sum = leftResult + rightResult;
        }
        return sum;
    }

    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        // 生成一个计算任务 计算 1+2+3+4
        ForkJoinTaskExample taskExample = new ForkJoinTaskExample(1, 100);

        // 执行一个任务
        Future<Integer> result = forkJoinPool.submit(taskExample);
        try{
            log.info("result:{}",result.get());
        } catch (Exception e) {
            log.error("exception", e);
        }
    }
}
努力的阳光蓝孩
关注
专栏目录
Java并发编程-AQS详解及案例实战（上篇）
program哲学
07-06 157
详细介绍AQS底层机制及相关应用案例实战
Java并发编程-AQS详解及案例实战（下篇）
最新发布
program哲学
07-07 81
详细介绍AQS底层机制及相关应用案例实战
7-ReentrantLock底层原理分析
weixin_45596022的博客
02-15 7084
一，Lock Lock 在 J.U.C 中是最核心的组件。 1，Lock实现 Lock 本质上是一个接口，它定义了释放锁和获得锁的抽象方法，定义成接口就意味着它定义了锁的一个标准规范，也同时意味着锁的不同实现。实现 Lock 接口的类有很多，以下为几个常见的锁实现。 ReentrantLock：表示重入锁，它是唯一一个实现了 Lock 接口的类。重入锁指的是线程在获得锁之后，再次获取该锁不需要阻塞，而是直接关联一次计数器增加重入次数。 ReentrantReadWriteLock：重入读写锁，它实现了 Re
AQS的例子分析
AAA821的专栏
03-28 750
https://blog.csdn.net/AAA821/article/details/79712522这篇博客介绍了一下AQS然后看了下阿里Druid的源码,举其中一个方法来解释AQS的作用,通过例子可以更好的理解AQS的作用这个是SimpleCanalConnector的connect方法,public void connect() throws CanalClientException {...
Java并发笔记 （9）---- AQS示例
谷家舟
05-03 436
文章目录队列同步器的接口与示例 队列同步器 AbstractQueuedSynchronizer（以下简称A.Q.S）,是用来构建锁或者其他同步组 件的基础框架。 同步器是实现锁（也可以是任意同步组件）的关键 锁是面向使用者的，它定义了使用者与锁交互的接口 同步器面向的是锁的实现者，它简化了锁的实现方式 队列同步器的接口与示例 同步器的设计是基于模板方法模式的 重写同步器指定的方法时，需要使用...
AQS简介和AQS案例
trigger的博客
06-04 489
目录AQS是什么？有什么用特点：和synchronized有什么不同？ReenTrantLock和synchronized有什么区别怎么利用AQS设计自己的锁？关于Java并发编程 ，可参见gitee项目：锁和释放锁 首先你可以根据 aqs去设计自己的锁，设计出的锁可以是公平锁，而synchronized只能是非公平锁。而且当线程抢不到锁阻塞等待时可以被打断。1.使用区别  Lock是一个接口，而synchronized是关键字，是内置的语言实现。2.功能区别(1)可中断锁：体现在lockInterrupt
AQS的例子分析二
AAA821的专栏
03-31 397
这个例子不单是让我们更了解AQS的具体使用,还明白了AQS类中state字段的作用因为tryAcquire这个方法是我们自己实现的,方法作用是尝试获取资源,根据我们自己的逻辑来决定是否获取成功.像下面这个例子,我的逻辑就是当资源小于0时，线程就获取失败,所以我先调用setState方法设初始值放到state字段,值为N,然后每来一个线程就将Ｎ-1,然后判断是否N-1小于0，从而实现线程资源的控制工...
【并发编程】简单化理解AQS和ReentrantLock.pdf
05-03
AQS和`ReentrantLock`是Java并发编程中重要的组成部分，通过对它们的理解和掌握，可以更好地设计和实现高性能的并发程序。通过本文的学习，读者可以了解到这些核心概念和技术的实际应用，并能够根据具体的业务需求...
AQS扩展与应用：Semaphore的高并发场景下的有效实践
在Java的并发框架中，AbstractQueuedSynchronizer（AQS）是一个强大且灵活的同步器的基础类。它通过一个等待队列（等待线程以FIFO的顺序排队）和一个状态变量（表示共享资源的数量或状态）来实现同步。 AQS提供了多...
AQS的并发原理
AQS是一个用于构建锁和其他同步器的强大框架，在Java并发编程中扮演着至关重要的角色。它采用了一种基于状态的机制来管理线程的获取和释放资源。 ## AQS的作用 AQS提供了一种便捷的方式来实现同步器，通过有效地...
AQS源码详解与实践
Mystic
02-03 202
AQS源码详解 1. 概述 ​ AQS（AbstractQueuedSynchronizer ）字面意思是抽象队列同步器，是用来构建锁或者其它同步器组件的重量级基础框架及整个JUC体系的基石。通过内置的FIFO队列来完成资源获取线程的排队工作，并通过一个int类变量表示持有锁的状态。 ​ AQS解决的问题主要是，在加锁的时候会产生阻塞，此时就需要排队。而实现排队就需要某种类型的队列去进行管理。并且排队的线程也需要被唤醒以保证锁的分配。这些都由AQS来进行解决。总结一下可以分为两点： （1）对排队的线程进行管
AQS解析与实战
pengjianglilive的专栏
11-15 447
前段时间在面试，发现面试官都有问到同步器AQS的相关问题。AQS为Java中几乎所有的锁和同步器提供一个基础框架，派生出如ReentrantLock、Semaphore、CountDownLatch等AQS全家桶。本文基于AQS原理的几个核心点，谈谈对AbstractQueuedSynchronizer的理解，并实现一个自定义同步器。 AQS原理面试题的核心回答要点 state 状态的维护。 CLH队列 ConditionObject通知 模板方法设计模式 独占与共享模式。 自定义同步器。
AQS的使用场景和示例
qq_36140801的博客
09-05 1276
文章目录前言一、Semaphore的原理和使用场景1.Semaphore是什么？2.如何通过AQS实现Semaphore二、CountDownLatch的原理和使用场景1.CountDownLatch是什么？2.如何通过AQS实现CountDownLatch三、CyclicBarrier的原理和使用场景1.CyclicBarrier是什么？2.如何实现CyclicBarrier总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：学习AQS的使用场景以及自己通过AQS实现Semaphore。 ..
AQS
代码学习之路的博客
06-28 3297
1.1.AQS 介绍 AQS 的全称为（AbstractQueuedSynchronizer），类如其名，抽象的队列式的同步器，AQS定义了一套多线程访问共享资源的同步器框架，这个类在 java.util.concurrent.locks 包下面。 参考资料：https://www.cnblogs.com/waterystone/p/4920797.html ...
AQS深入理解与实战----基于JDK1.8
weixin_30443075的博客
08-21 179
要介绍AQS，首先要介绍“同步器”的概念。 同步器是一种抽象数据类型，在该类型的内部，维护了以下内容： 1.一个状态变量，该变量的不同取值可以表征不同的同步状态语义（例如表示一个锁已经被线程持有了还是没有任何线程持有）； 2.能够更新和检查该状态变量值的操作（方法）集合； 3.至少有一个方法——当同步状态的值需要时可调用该方法...
AQS的原理及应用
Java程序员廖志伟
08-18 146
Semaphore 顾名思义为信号量，它可以控制对共享资源的访问线程数目，通过 acquire() 方法来阻塞获取资源线程，release() 方法来释放共享资源，来实现对资源的同步控制。AQS 机制的核心就是通过一个 FIFO 的队列来对等待获取资源的线程进行排序，每次资源的释放都会导致头节点的唤醒，而唤醒后的线程将会尝试再次抢占资源。否则，会尝试获取支付锁。同时，由于网络条件的不稳定，支付操作可能会失败，需要进行多次重试，直到支付成功。同时，如果支付失败，还需要记录该次支付的操作，以便后续进行重试。
Java多线程（七）之同步器基础：AQS框架深入分析
热门推荐
Vern的专栏
12-09 3万+
一、什么是同步器 多线程并发的执行，之间通过某种 共享 状态来同步，只有当状态满足 xxxx 条件，才能触发线程执行 xxxx 。 这个共同的语义可以称之为同步器。可以认为以上所有的锁机制都可以基于同步器定制来实现的。 而juc(java.util.concurrent)里的思想是 将这些场景抽象出来的语义通过统一的同步框架来支持。 juc 里所有的这些锁机制都是基
AQS简单介绍与使用
charming的专栏
04-29 1万+
AQS，全称是 AbstractQueuedSynchronizer，中文译为抽象队列式同步器。这个抽象类对于JUC并发包非常重要，JUC包中的ReentrantLock，，Semaphore，ReentrantReadWriteLock，CountDownLatch 等等几乎所有的类都是基于AQS实现的。 AQS 中有两个重要的东西，一个等待队列，还有一个STATE标志，并且通过CAS来改变它的...
java并发编程——九 AbstractQueuedSynchronizer AQS详解
张硕的博客
03-27 6570
AbstractQueuedSynchronizer概述AQS用来实现锁或其他同步组件的基础框架（注意区别synchronized是在字节码上加指令方式，通过底层机器语言保证同步），AQS使用int类型的volatile变量维护同步状态(state)，使用Node实现FIFO队列来完成线程的排队执行。在锁的实现中通过组合AQS对象的方式使用，利用AQS实现锁的语义。 AQS与锁(如Lock)的对比:
高并发场景下的CountDownLatch与AQS同步队列模拟测试
总结来说，这段代码演示了如何在高并发场景下利用CountDownLatch进行任务调度和同步，确保了线程的执行顺序和任务的正确完成。通过这种方式，可以有效管理并发请求，避免了资源争抢和潜在的死锁问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值