JUC并发工具类

已于 2022-08-10 15:12:47 修改
阅读量156 收藏 1
点赞数
分类专栏： 并发编程 文章标签： 并发编程
于 2020-08-11 10:27:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ke_g3/article/details/107929556
版权

文章目录

CountDownLatch

倒计时，做减法计算，count=0，唤醒阻塞线程。

public class App {

    public static void main(String[] args) throws InterruptedException {
        new App().test();
    }

    public void test() throws InterruptedException {
        long start = System.currentTimeMillis();
        doTask();
        long end = System.currentTimeMillis();
        System.out.println("耗时(s)：" + (end - start) / 1000);
    }

    private void doTask() throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(10);
	// 控制主线程最后执行
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(()->{
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName());
                countDownLatch.countDown();
            });
            thread.start();
        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName() + " finish");
    }

}

Thread-1
Thread-4
Thread-8
Thread-3
Thread-5
Thread-6
Thread-2
Thread-0
Thread-9
Thread-7
main finish
耗时(s)：2

CyclicBarrier

可循环利用的屏障，做加法计算，count=屏障值（parties），唤醒阻塞线程。

相比CountDownLatch的一次性，CyclicBarrier是可循环利用的。

public class App {

    public static void main(String[] args) throws InterruptedException {
        new App().test();
    }

    public void test() {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, ()->{
            System.out.println(Thread.currentThread().getName() + " 等待完成后，优先执行该Runnable");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + " 出发！");
        });
        // 可循环的栅栏，需要等待同伴(parties个)到齐。
        for (int i = 0; i < 4; i++) {
            Thread thread = new Thread(()->{
                try {
                    System.out.println(Thread.currentThread().getName());
                    cyclicBarrier.await();
                    System.out.println(Thread.currentThread().getName() + " finished");
                } catch (InterruptedException | BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }
            });
            thread.start();
        }

        try {
            Thread.sleep(5000);
            cyclicBarrier.await();
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException | BrokenBarrierException e) {
            throw new RuntimeException(e);
        }
    }
}

Thread-0
Thread-3
Thread-2
Thread-1
main 等待完成后，优先执行该Runnable
main 出发！
main
Thread-0 finished
Thread-1 finished
Thread-3 finished
Thread-2 finished

Semaphore

控制最大的线程并发数，用来做流量控制。

好比疫情下，超市最大只允许n人购物，其他人只能在外等待里面的人出来。

public class App {

    public static void main(String[] args) throws InterruptedException {
        new App().test();
    }

    public void test() {
        Semaphore semaphore = new Semaphore(1);
        // 控制执行线程数量
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(()->{
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName());
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    semaphore.release();
                }
            });
            thread.start();
        }

        System.out.println(Thread.currentThread().getName());
    }
}


Thread-0
main
Thread-1
Thread-2
Thread-3
Thread-4
Thread-5
Thread-6
Thread-7
Thread-8
Thread-9

Exchanger

两个线程之间的数据交换，Exchange是 阻塞形式的，两个线程要都到达执行Exchange函数才会交换。

public class App {

    public static void main(String[] args) throws InterruptedException {
        new App().test();
    }

    public void test() {
        Exchanger<String> exchanger = new Exchanger<>();
        // 线程之间的数据交换
        for (int i = 0; i < 4; i++) {
            int finalI = i;
            Thread thread = new Thread(() -> {
                try {
                    String exchange = exchanger.exchange("我是线程" + finalI);
                    System.out.println(Thread.currentThread().getName() + " exchange: " + exchange);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            });
            thread.start();
        }

    }
}


Thread-3 exchange: 我是线程2
Thread-2 exchange: 我是线程3
Thread-0 exchange: 我是线程1
Thread-1 exchange: 我是线程0

附录-简单实现

利用wait和notify也可以自己简单实现上述四个类功能

/**
 * MyCountDownLatch
 * @author admin
 */
public class App {

    public static void main(String[] args) {
        MyCountDownLatch countDownLatch = new MyCountDownLatch(2);

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(1);
                countDownLatch.countDown();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(2);
                countDownLatch.countDown();
            }
        }).start();

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(3);
    }

    static class MyCountDownLatch {

        int count = 0;

        public MyCountDownLatch(int count) {
            this.count = count;
        }

        public void await() throws InterruptedException {
            synchronized (this) {
                if (count > 0) {
                    wait();
                }
            }
        }

        public void countDown() {
            synchronized (this) {
                if (--count == 0) {
                    notifyAll();
                }
            }
        }
    }
}


/**
 * MyCyclicBarrier
 * @author admin
 */
public class App2 {

    public static void main(String[] args) {
        MyCyclicBarrier cyclicBarrier = new MyCyclicBarrier(3);

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("1---1");
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("1---2");
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("2---1");
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("2---2");
            }
        }).start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("3---1");
        try {
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("3---2");
    }

    static class MyCyclicBarrier {

        int count = 0;

        int threadWaitNum;

        public MyCyclicBarrier(int threadWaitNum) {
            this.threadWaitNum = threadWaitNum;
        }

        public void await() throws InterruptedException {
            synchronized (this) {
                count++;
                if (count == threadWaitNum) {
                    notifyAll();
                } else {
                    wait();
                }
            }
        }
    }
}


import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * MySemaphore
 * @author admin
 */
public class App3 {

    public static void main(String[] args) {
        MySemaphore semaphore = new MySemaphore(2);

        for (int i = 0; i < 6; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        semaphore.acquire();
                        System.out.println(Thread.currentThread().getName() + " " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                        Thread.sleep(1000);
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "线程-" + i);
            thread.start();
        }
    }

    static class MySemaphore {

        int count = 0;

        int permits;

        public MySemaphore(int permits) {
            this.permits = permits;
        }

        public void acquire() throws InterruptedException {
            synchronized (this) {
                if (count < permits) {
                    count++;
                } else {
                    wait();
                    acquire();
                }
            }
        }
        public void release() throws InterruptedException {
            synchronized (this) {
                count--;
                notify();
            }
        }
    }
}


/**
 * MyExchanger
 *
 * @author admin
 */
public class App4 {

    public static void main(String[] args) {
        MyExchanger<String> exchanger = new MyExchanger();

        Thread thread = new Thread(() -> {
            try {
                String a = "AAAAA";
                String b = exchanger.exchange(a);
                System.out.println(Thread.currentThread().getName() + " " + a + ", 交换后：" + b);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "线程-A");
        thread.start();

        Thread thread2 = new Thread(() -> {
            try {
                String b = "BBBBB";
                String a = exchanger.exchange(b);
                System.out.println(Thread.currentThread().getName() + " " + b + ", 交换后：" + a);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "线程-B");
        thread2.start();
    }

    static class MyExchanger<T> {

        T value;

        public T exchange(T exchangeValue) throws InterruptedException {
            synchronized (this) {
                if (value != null) {
                    T v = value;
                    value = exchangeValue;
                    notify();
                    return v;
                } else {
                    value = exchangeValue;
                    wait();
                    return exchange(null);
                }
            }
        }
    }
}
jack_zhou.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
06、JUC并发工具类在大厂的应用场景详解-ev
03-07
06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev...
JUC常用4大并发工具类详解
sinat_31583645的博客
07-19 548
首先这个第一个参数也是 Int 类型的,传入的是执行线程的个数,这个数量和 CountDownLatch 不一样,这个数量是需要和线程数量吻合的,CountDownLatch 则不一样,CountDownLatch 可以大于等于,而 CyclicBarrier 只能等于,然后是第二个参数,第二个参数是 barrierAction,这个参数是当屏障开放后,执行的任务线程,如果当屏障开放后需要执行什么任务,可以写在这个线程中。通过返回结果就可以很直接的看到业务线程是在初始化线程完全跑完之后,才开始执行的。
JUC 常用 4 大并发工具类详解
天行健，君子以自强不息；地势坤，君子以厚德载物。
06-28 807
什么是 JUC?JUC 就是 java.util.concurrent 包,这个包俗称 JUC,里面都是解决并发问题的一些东西,该包的位置位于 java 下面的 rt.jar 包下面JUC 中 4 大常用并发工具类CountDownLatchCyclicBarrierSemaphoreExChangerCountDownLatchCountDownLatch,俗称闭锁,作用是类似加强版的 Join...
常用的JUC（Java Util Concurrent）工具类
weixin_44440231的博客
04-14 1162
包下的原子类为Java并发编程提供了一组高效的、线程安全的原子操作类，它们主要用于在高并发环境下确保对共享变量的操作具有原子性，即在同一时刻只有一个线程能够修改这些变量的值，而不会出现因多线程并发导致的中间状态或数据竞争问题。当两个线程都到达交换点时，它们各自携带的数据会被互换，确保线程间的通信和协作。，等待其他线程也到达屏障。当所有线程都到达后，屏障动作执行，然后屏障重置，线程们继续进行下一次迭代，如此反复三次。的特性，它们各自操作的是独立的本地副本，因此输出结果互不影响，展示了线程间数据的隔离。
JUC常用并发工具类
YIYIYI
12-29 1462
JUC常用并发工具类
【Java EE 初阶】JUC常见工具类介绍
m0_57248981的博客
05-17 1029
个选手依次就位，哨声响才同时出发；所有选手都通过终点，才能颁奖。操作中的加减计数器操作都是原子的。可以在多线程环境下直接使用。阻塞等待所有任务执行完毕。内部的计数器同时自减。
6、JUC并发工具类在大厂的应用场景详解(1).pdf
02-28
6.JUC并发工具类在大厂的应用场景详解 (1).pdf 7、深入理解 AQS 独占锁之 Reentrantlock 源码分析 (1).pdf 8、读写锁ReentrantReadWriteLock&StampLock详解.pdf 9、并发容器 (Map、List、Set） 实战及其原理.pdf 10...
JUC并发编程.rar
12-14
在Java世界中，Java Util Concurrency (JUC) 是一个至关重要的模块，它为开发者提供了丰富的并发工具和机制，使得在多线程环境下编写高效、安全的代码变得可能。"JUC并发编程.rar"这个压缩包文件包含了关于并发编程...
JUC并发工具包实例.zip
01-28
Java并发工具包（Java Concurrency Utility，简称JUC）是Java平台中用于高效并发编程的重要模块，它在`java.util.concurrent`包下提供了一系列高级并发工具。这些工具可以帮助开发者更好地管理和控制多线程环境，...
并发编程、juc工具包源码分析笔记
11-03
Java 并发库（Java Util Concurrency, JUC）是 Java 平台中用于处理并发问题的核心工具包，提供了丰富的类和接口来简化并发编程。 在计算机系统中，进程是操作系统资源分配的基本单位，它拥有独立的内存空间，而...
JUC 常用并发工具类教程（包括可重入锁ReentrantLock、CountDownLatch、读写锁ReadWriteLock、信号量Semaphore、常见队列等）
tttalk的博客
09-28 951
juc 多线程 重入锁ReentrantLock、CountDownLatch、读写锁ReadWriteLock、信号量Semaphore、常见队列
JUC工具类
复制乔布斯
04-11 810
​Exchanger​ 是 Java 中的一个同步工具类，用于在两个线程之间进行数据交换。Exchanger​ 提供了一个同步点，当两个线程都到达这个同步点时，它们可以交换数据。​ExchangerExchanger​ 允许两个线程之间进行数据的交换，其中一个线程将数据放入Exchanger​，而另一个线程从Exchanger​ 中取出数据，从而实现线程间的数据传递。Exchanger​ 提供了一个同步点，当两个线程都到达这个同步点时，它们可以交换数据。
七、JUC并发工具
耀耀zz的博客
02-28 417
JUC并发工具，CountDownLatch、CyclicBarrier、Semaphone应用&源码分析。
JUC类和接口的分类与简介
晨港飞燕的专栏
12-17 1077
与普通的ReentrantLock相比，ReentrantReadWriteLock分为读锁和写锁，提供了更高的并发性。需要注意的是，StampedLock 的使用要求开发者具有更高的注意力，以确保正确地释放锁，并避免死锁等问题。这样可以实现在读操作时允许多个线程并发访问，但在写操作时只允许一个线程访问，确保数据的一致性和线程安全性。： 与传统的 ReentrantReadWriteLock 类似，StampedLock 提供了写锁，只允许一个线程独占地获取锁。在公平锁中，线程按照请求锁的顺序获取锁；
【多线程进阶】JUC下的常用类
书生-w的博客
06-13 7950
"JUC"是"Java Util Concurrent"的缩写，代表Java提供的一套并发工具类。这些工具类大大简化了编程并发和多线程应用的复杂性，提供了更高级、更强大、更安全的并发操作功能。以下是一些常见的JUC类：
JUC 常用4大并发工具类详解
路人甲Java
05-21 308
您好，我是路人，更多优质文章见个人博客：http://itsoku.com什么是 JUC?JUC 就是 java.util.concurrent 包,这个包俗称 JUC,里面都是解决并发问题的一些东西,该包的位置位于 java 下面的 rt.jar 包下面JUC 中 4 大常用并发工具类CountDownLatchCyclicBarrierSemaphoreExChangerCountDownLa...
juc并发编程线程池
最新发布
06-18
Java并发工具包（Java Util Concurrency, JUC）提供了一个强大的线程池实现，即`java.util.concurrent.Executors`和`java.util.concurrent.ThreadPoolExecutor`。线程池是并发编程中常用的一种机制，它允许您预先...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值