并发编程与高并发解决方案学习(J.U.C之AQS-CountDownLatch、Semaphore)_c高并发解决方案-程序员宅基地

※使用Node实现FIFO队列，可以用于构建锁或者其他同步装置的基础框架

※利用int类型表示状态 state=0表示还没有线程获取锁 state=1表示有现成获取锁，大于1表示可重入锁数量

※使用方法是继承 AQS使用模板方法模式，继承模板方法，复写其中的方法

※子类通过继承并通过实现它的方法管理其状态{acquire和release}的方法操作状态

※可以同时实现排它锁和共享锁模式(
独占、共享)

AQS同步组件（
CountDownLatch、Semaphore、CyclicBarrier、ReentrantLock、Condition、FutureTask）

CountDownLatch(作用类似于join())
 同步辅助类，可以实现阻塞的作用，同一时间只能有一个线程操作该计数器，调用该类的await类会一直处于阻塞状态，直到其他线程调用countDown方法，使当前计数器的值为0（计数器不可以重置）

使用场景：程序执行需要等待某个条件完成之后才能继续执行后续的操作，典型应用例如：并行计算（ 当某个处理的运算量很大的时候，可以将该运算任务拆分为多个子任务，等待所有子任务都执行完之后，父任务再拿到所有子任务运行结果进行汇总）。

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
public class CountDownLatchExample1 {
    private final static int threadCount = 20;
    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newCachedThreadPool();
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    test(threadNum);
                } catch (Exception e) {
                    log.error("exception", e);
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        countDownLatch.await();
        log.info("finish");
        exec.shutdown();
    }

    private static  void test(int threadNum) throws Exception {
        Thread.sleep(100);
        log.info("{}", threadNum);
        Thread.sleep(100);
    }
}

输出结果

15:54:06.904 [pool-1-thread-1] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 0
15:54:06.904 [pool-1-thread-8] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 7
15:54:06.905 [pool-1-thread-19] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 18
15:54:06.904 [pool-1-thread-6] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 5
15:54:06.904 [pool-1-thread-7] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 6
15:54:06.904 [pool-1-thread-4] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 3
15:54:06.904 [pool-1-thread-5] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 4
15:54:06.904 [pool-1-thread-3] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 2
15:54:06.904 [pool-1-thread-2] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 1
15:54:06.904 [pool-1-thread-9] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 8
15:54:06.905 [pool-1-thread-18] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 17
15:54:06.904 [pool-1-thread-10] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 9
15:54:06.905 [pool-1-thread-17] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 16
15:54:06.904 [pool-1-thread-11] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 10
15:54:06.905 [pool-1-thread-20] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 19
15:54:06.905 [pool-1-thread-16] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 15
15:54:06.905 [pool-1-thread-13] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 12
15:54:06.904 [pool-1-thread-12] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 11
15:54:06.905 [pool-1-thread-15] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 14
15:54:06.905 [pool-1-thread-14] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - 13
15:54:07.009 [main] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample1 - finish

案例2（起了很多线程去完成任务，但是这个任务指向给指定的时间，操作这个时间没做完，也不管了）

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;

@Slf4j
public class CountDownLatchExample2 {
    private final static int threadCount = 200;
    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newCachedThreadPool();
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    test(threadNum);
                } catch (Exception e) {
                    log.error("exception", e);
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        countDownLatch.await(10, TimeUnit.MILLISECONDS);
        log.info("finish");
        exec.shutdown();
    }

    private static void test(int threadNum) throws Exception {
        Thread.sleep(1000);
        log.info("{}", threadNum);
    }
}

输出结果

15:57:13.433 [main] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - finish
15:57:14.423 [pool-1-thread-1] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 0
15:57:14.435 [pool-1-thread-4] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 3
15:57:14.436 [pool-1-thread-3] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 2
15:57:14.436 [pool-1-thread-2] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 1
15:57:14.438 [pool-1-thread-5] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 4
15:57:14.441 [pool-1-thread-8] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 7
15:57:14.442 [pool-1-thread-7] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 6
15:57:14.442 [pool-1-thread-6] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 5
15:57:14.442 [pool-1-thread-11] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 10
15:57:14.443 [pool-1-thread-10] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 9
15:57:14.443 [pool-1-thread-9] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 8
15:57:14.443 [pool-1-thread-13] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 12
15:57:14.443 [pool-1-thread-12] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 11
15:57:14.443 [pool-1-thread-15] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 14
15:57:14.444 [pool-1-thread-14] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 13
15:57:14.444 [pool-1-thread-20] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 19
15:57:14.444 [pool-1-thread-19] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 18
15:57:14.447 [pool-1-thread-18] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 17
15:57:14.447 [pool-1-thread-16] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 15
15:57:14.447 [pool-1-thread-17] INFO com.mmall.concurrency.example.aqs.CountDownLatchExample2 - 16

调用shutdown并不是第一时间将线程都全部销毁掉，而是让当前已有的线程全部执行完，之后再把这个线程池销毁掉。

Semaphore 信号量(控制并发访问的线程个数，类似于有限的链表，常用语仅能提供有限个访问的资源,比如 控制数据库连接数)

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
public class SemaphoreExample1 {
    private final static int threadCount = 20;
    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    semaphore.acquire(); // 每次获取一个许可
                    test(threadNum);
                    semaphore.release(); // 每次释放一个许可
                } catch (Exception e) {
                    log.error("exception", e);
                }
            });
        }
        exec.shutdown();
    }

    private static void test(int threadNum) throws Exception {
        log.info("{}", threadNum);
        Thread.sleep(1000);
    }
}

输出结果(一次3条输出)

15:59:19.291 [pool-1-thread-2] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 1
15:59:19.291 [pool-1-thread-1] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 0
15:59:19.291 [pool-1-thread-3] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 2
15:59:20.309 [pool-1-thread-4] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 3
15:59:20.310 [pool-1-thread-5] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 4
15:59:20.310 [pool-1-thread-6] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 5
15:59:21.310 [pool-1-thread-7] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 6
15:59:21.310 [pool-1-thread-8] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 7
15:59:21.311 [pool-1-thread-9] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 8
15:59:22.310 [pool-1-thread-10] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 9
15:59:22.310 [pool-1-thread-11] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 10
15:59:22.311 [pool-1-thread-12] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 11
15:59:23.311 [pool-1-thread-13] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 12
15:59:23.311 [pool-1-thread-14] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 13
15:59:23.312 [pool-1-thread-15] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 14
15:59:24.311 [pool-1-thread-16] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 15
15:59:24.311 [pool-1-thread-17] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 16
15:59:24.312 [pool-1-thread-18] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 17
15:59:25.312 [pool-1-thread-20] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 19
15:59:25.312 [pool-1-thread-19] INFO com.mmall.concurrency.example.aqs.SemaphoreExample1 - 18

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
public class SemaphoreExample2 {
    private final static int threadCount = 20;
    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    semaphore.acquire(3); // 每次获取多个许可
                    test(threadNum);
                    semaphore.release(3); // 每次释放多个许可
                } catch (Exception e) {
                    log.error("exception", e);
                }
            });
        }
        exec.shutdown();
    }

    private static void test(int threadNum) throws Exception {
        log.info("{}", threadNum);
        Thread.sleep(1000);
    }
}

输出结果（一次一条输出）

16:00:37.474 [pool-1-thread-1] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 0
16:00:38.480 [pool-1-thread-2] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 1
16:00:39.480 [pool-1-thread-3] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 2
16:00:40.481 [pool-1-thread-4] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 3
16:00:41.482 [pool-1-thread-5] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 4
16:00:42.482 [pool-1-thread-6] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 5
16:00:43.483 [pool-1-thread-7] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 6
16:00:44.483 [pool-1-thread-8] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 7
16:00:45.484 [pool-1-thread-9] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 8
16:00:46.484 [pool-1-thread-10] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 9
16:00:47.484 [pool-1-thread-11] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 10
16:00:48.485 [pool-1-thread-12] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 11
16:00:49.485 [pool-1-thread-13] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 12
16:00:50.485 [pool-1-thread-14] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 13
16:00:51.486 [pool-1-thread-15] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 14
16:00:52.486 [pool-1-thread-17] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 16
16:00:53.486 [pool-1-thread-16] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 15
16:00:54.486 [pool-1-thread-18] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 17
16:00:55.487 [pool-1-thread-19] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 18
16:00:56.488 [pool-1-thread-20] INFO com.mmall.concurrency.example.aqs.SemaphoreExample2 - 19

案例（假如当前并发数是3，超过3个就丢弃）

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;

@Slf4j
public class SemaphoreExample3 {
    private final static int threadCount = 20;
    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    if (semaphore.tryAcquire()) { // 尝试获取一个许可
                        test(threadNum);
                        semaphore.release(); // 释放一个许可
                    }
                } catch (Exception e) {
                    log.error("exception", e);
                }
            });
        }
        exec.shutdown();
    }

    private static void test(int threadNum) throws Exception {
        log.info("{}", threadNum);
        Thread.sleep(1000);
    }
}

输出结果

16:01:45.406 [pool-1-thread-2] INFO com.mmall.concurrency.example.aqs.SemaphoreExample3 - 1
16:01:45.405 [pool-1-thread-1] INFO com.mmall.concurrency.example.aqs.SemaphoreExample3 - 0
16:01:45.413 [pool-1-thread-3] INFO com.mmall.concurrency.example.aqs.SemaphoreExample3 - 2

尝试获得许可，只让执行5秒

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;

@Slf4j
public class SemaphoreExample4 {
    private final static int threadCount = 20;
    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    if (semaphore.tryAcquire(5000, TimeUnit.MILLISECONDS)) { // 尝试获取一个许可
                        test(threadNum);
                        semaphore.release(); // 释放一个许可
                    }
                } catch (Exception e) {
                    log.error("exception", e);
                }
            });
        }
        exec.shutdown();
    }

    private static void test(int threadNum) throws Exception {
        log.info("{}", threadNum);
        Thread.sleep(1000);
    }
}

输出结果(一次三条输出)

16:02:31.454 [pool-1-thread-3] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 2
16:02:31.454 [pool-1-thread-1] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 0
16:02:31.454 [pool-1-thread-2] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 1
16:02:32.463 [pool-1-thread-4] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 3
16:02:32.464 [pool-1-thread-5] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 4
16:02:32.464 [pool-1-thread-6] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 5
16:02:33.464 [pool-1-thread-8] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 7
16:02:33.464 [pool-1-thread-7] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 6
16:02:33.465 [pool-1-thread-9] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 8
16:02:34.465 [pool-1-thread-10] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 9
16:02:34.465 [pool-1-thread-11] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 10
16:02:34.466 [pool-1-thread-12] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 11
16:02:35.465 [pool-1-thread-13] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 12
16:02:35.466 [pool-1-thread-14] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 13
16:02:35.466 [pool-1-thread-15] INFO com.mmall.concurrency.example.aqs.SemaphoreExample4 - 14

本文链接：https://blog.csdn.net/Andy2019/article/details/79784000

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

python简易爬虫v1.0-程序员宅基地

文章浏览阅读1.8k次，点赞4次，收藏6次。python简易爬虫v1.0作者：William Ma (the_CoderWM)进阶python的首秀，大部分童鞋肯定是做个简单的爬虫吧，众所周知，爬虫需要各种各样的第三方库，例如scrapy, bs4, requests, urllib3等等。此处，我们先从最简单的爬虫开始。首先，我们需要安装两个第三方库：requests和bs4。在cmd中输入以下代码：pip install requestspip install bs4等安装成功后，就可以进入pycharm来写爬虫了。爬

安装flask后vim出现：error detected while processing /home/zww/.vim/ftplugin/python/pyflakes.vim:line 28_freetorn.vim-程序员宅基地

文章浏览阅读2.6k次。解决方法：解决方法可以去github重新下载一个pyflakes.vim。执行如下命令git clone --recursive git://github.com/kevinw/pyflakes-vim.git然后进入git克降目录，./pyflakes-vim/ftplugin,通过如下命令将python目录下的所有文件复制到~/.vim/ftplugin目录下即可。cp -R ...._freetorn.vim

HIT CSAPP大作业：程序人生—Hello‘s P2P-程序员宅基地

文章浏览阅读210次，点赞7次，收藏3次。本文简述了hello.c源程序的预处理、编译、汇编、链接和运行的主要过程，以及hello程序的进程管理、存储管理与I/O管理，通过hello.c这一程序周期的描述，对程序的编译、加载、运行有了初步的了解。_hit csapp

18个顶级人工智能平台-程序员宅基地

文章浏览阅读1w次，点赞2次，收藏27次。来源：机器人小妹　　很多时候企业拥有重复，乏味且困难的工作流程，这些流程往往会减慢生产速度并增加运营成本。为了降低生产成本，企业别无选择，只能自动化某些功能以降低生产成本。　　通过数字化..._人工智能平台

electron热加载_electron-reloader-程序员宅基地

文章浏览阅读2.2k次。热加载能够在每次保存修改的代码后自动刷新 electron 应用界面，而不必每次去手动操作重新运行，这极大的提升了开发效率。安装 electron 热加载插件热加载虽然很方便，但是不是每个 electron 项目必须的，所以想要舒服的开发 electron 就只能给 electron 项目单独的安装热加载插件[electron-reloader]:// 在项目的根目录下安装 electron-reloader，国内建议使用 cnpm 代替 npmnpm install electron-relo._electron-reloader

android 11.0 去掉recovery模式UI页面的选项_android recovery 删除部分菜单-程序员宅基地

文章浏览阅读942次。在11.0 进行定制化开发，会根据需要去掉recovery模式的一些选项就是在device.cpp去掉一些选项就可以了。_android recovery 删除部分菜单

随便推点

echart省会流向图（物流运输、地图）_java+echart地图+物流跟踪-程序员宅基地

文章浏览阅读2.2k次，点赞2次，收藏6次。继续上次的echart博客，由于省会流向图是从echart画廊中直接取来的。所以直接上代码<!DOCTYPE html><html><head> <meta charset="utf-8" /> <meta name="viewport" content="width=device-width,initial-scale=1,minimum-scale=1,maximum-scale=1,user-scalable=no" /&_java+echart地图+物流跟踪