Java并发编程-精通篇（工具类）

最新推荐文章于 2023-12-09 11:39:45 发布
最新推荐文章于 2023-12-09 11:39:45 发布
阅读量626 收藏 3
点赞数 1
分类专栏： Java 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012449363/article/details/87444497
版权

常用的Concurrent同步工具类
CountDownLatch
CyclicBarrier
Semaphore
Exchanger
ReentrantLock
ReentrantReadWriteLock

1.CountDownLatch

线程安全计数器。允许一个或多个线程等待一系列的操作完成。
给一个指定数值初始化，然后通过countDown()方法将计数器减一。
通过await()方法，线程可以阻塞等待直到计数器为零。
由于用法比较简单，就不写DEMO了（懒）

2.CyclicBarrier

循环栅栏，允许一组线程相互等待，直到达到某个公共屏障点（common barrier point）。
在涉及固定大小的线程的程序中，这些线程必须不是的相互等待，这时使用CyclicBarrier可以使等待线程达到common barrier point时得到释放。

使用场景：需要所有子任务都完成时，才执行主任务。在使用时，工作线程数一定要大于CyclicBarrier初始化的数值，否则将永远阻塞下去。

package com.jimmy.concurrent.util;

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

public class CyclicBarrierDemo {

    static class Runner implements Runnable {

        private CyclicBarrier barrier;
        private String name;

        public Runner(CyclicBarrier barrier, String name) {
            this.barrier = barrier;
            this.name = name;
        }

        @Override
        public void run() {
            try {
                Thread.sleep((new Random().nextInt(8)) * 1000 );
                System.out.println(name + " is ready.[" + System.currentTimeMillis()  + ']');
                // 所有参与者都在此执行await之前，将一直阻塞
                barrier.await();
                // 所有参与者的await方法都执行后，将同时执行下面动作
                System.out.println(name + " run! [" + System.currentTimeMillis()  + "]");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3);

        ExecutorService executor = Executors.newFixedThreadPool(3);
        executor.submit(new Thread(new Runner(barrier, "No1 Runner")));
        executor.submit(new Thread(new Runner(barrier, "No2 Runner")));
        executor.submit(new Thread(new Runner(barrier, "No3 Runner")));

        executor.shutdown();
    }
}

执行结果：从输出run的执行时间可以看出，当所有的await()方法执行完成之后，后序的动作确实是同时执行的。
在这里插入图片描述

3. Semaphore

计数信号量，信号量维护了一个许可集合。
通过acquire()来获取一个许可，只有成功获取了许可，线程才能继续执行。如果无法获取到许可，线程将阻塞。
通过release()来是放一个许可，只有成功释放了许可，其他线程才能去获取新的许可。

DEMO

package com.jimmy.concurrent.util;

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

public class SemaphoreDemo {

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

        final Semaphore semaphore = new Semaphore(2);

        for (int i = 0 ; i < 5; i ++) {
            Runnable run = () -> {
                try {
                    System.out.println(Thread.currentThread() + "try to require permit");
                    // 获取许可
                    semaphore.acquire();
                    System.out.println(Thread.currentThread() + "require permit.");
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread() + "release permit");
                    // 释放许可，如果不释放，所有未获取到许可的线程将被阻塞
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            executorService.submit(run);
        }
        executorService.shutdown();
    }
}

正常释放许可的结果：每次有两个线程获取到许可并继续执行。
在这里插入图片描述
未正常释放许可的结果：许可耗尽之后，其他线程阻塞
在这里插入图片描述

4. Exchanger

交换器，可以在两个线程之间互换对象的汇合点。
必须是两个线程，且都已达到汇合点，才能进行数据交换

package com.jimmy.concurrent.util;

import java.util.Random;
import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExchangerDemo {

    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();
        ExecutorService executor = Executors.newCachedThreadPool();

        executor.submit(new ExchangerRunner(exchanger, "A"));
        executor.submit(new ExchangerRunner(exchanger, "B"));

        executor.shutdown();
    }
}

class ExchangerRunner implements Runnable {

    private Exchanger<String> exchanger;
    private String data;

    public ExchangerRunner(Exchanger<String> exchanger, String data) {
        this.exchanger = exchanger;
        this.data = data;
    }

    @Override
    public void run() {
        try {
            System.out.println(Thread.currentThread() + " data before exchange " + this.data);
            Thread.sleep(new Random().nextInt(5) * 1000);
            // 记录达到汇合点的时间
            System.out.println(Thread.currentThread() + " is wait for exchange [" + System.currentTimeMillis() + "]");
            // 当两个线程都达到该汇合点时，执行交换。
            this.data = this.exchanger.exchange(this.data);
            // 从这条记录的时间戳可以看出，达到汇合点的交换是同时执行的。
            System.out.println(Thread.currentThread() + " data after exchange " + this.data + "[" + System.currentTimeMillis() + "]");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

可以从时间戳看出，当两个线程都达到汇合点之后，才会执行交换。
在这里插入图片描述

5. ReentrantLock

重入锁，可以替代Synchronized关键字，对同步代码块加锁。
与Condition一起使用，实现线程之间的通信。

一个Condition对应一个ReentrantLock
一个ReentrantLock可以创建多个Condition, 不同condition之前的通信不互相影响。

DEMO：一个ReentrantLock对应一个Condition

package com.jimmy.concurrent.util;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void runAwaitTest() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " waiting.");
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " condition await.");
            // 释放锁并阻塞，直到重新获取到锁
            condition.await();
            System.out.println(Thread.currentThread().getName() + " continue...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + " finish.");
            lock.unlock();
        }
    }

    public void runSignalTest() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " start.");
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " condition signal.");
            // 通知其他线程可以竞争锁
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + " finish.");
            lock.unlock();
        }
    }


    public static void main(String[] args) {
        ReentrantLockDemo demo = new ReentrantLockDemo();
        Thread t1 = new Thread(() -> {
            demo.runAwaitTest();
        }, "t1");

        Thread t2 = new Thread(() -> {
            demo.runSignalTest();
        }, "t2");

        t1.start();
        t2.start();
    }
}

执行结果：
在这里插入图片描述

DEMO：一个ReentrantLock对应多个Condition

package com.jimmy.concurrent.util;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockWithMultiConditionDemo {
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();


    public void runAwait1Test() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " waiting." + "[" + System.currentTimeMillis() + "]");
            System.out.println(Thread.currentThread().getName() + " condition-1 await." + "[" + System.currentTimeMillis() + "]");
            // 释放锁并阻塞，直到重新获取到锁
            condition1.await();
            System.out.println(Thread.currentThread().getName() + " continue..." + "[" + System.currentTimeMillis() + "]");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + " finish." + "[" + System.currentTimeMillis() + "]");
            lock.unlock();
        }
    }

    public void runAwait2Test() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " waiting." + "[" + System.currentTimeMillis() + "]");
            System.out.println(Thread.currentThread().getName() + " condition-1 await." + "[" + System.currentTimeMillis() + "]");
            // 释放锁并阻塞，直到重新获取到锁
            condition1.await();
            System.out.println(Thread.currentThread().getName() + " continue..." + "[" + System.currentTimeMillis() + "]");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + " finish." + "[" + System.currentTimeMillis() + "]");
            lock.unlock();
        }
    }

    public void runAwait3Test() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " waiting." + "[" + System.currentTimeMillis() + "]");
            System.out.println(Thread.currentThread().getName() + " condition-2 await." + "[" + System.currentTimeMillis() + "]");
            // 释放锁并阻塞，直到重新获取到锁
            condition2.await();
            System.out.println(Thread.currentThread().getName() + " continue..." + "[" + System.currentTimeMillis() + "]");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + " finish." + "[" + System.currentTimeMillis() + "]");
            lock.unlock();
        }
    }

    public void runSignalAllTest() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " start." + "[" + System.currentTimeMillis() + "]");
            System.out.println(Thread.currentThread().getName() + " condition-1 signalAll." + "[" + System.currentTimeMillis() + "]");
            // 通知其他线程可以竞争锁
            condition1.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + " finish." + "[" + System.currentTimeMillis() + "]");
            lock.unlock();
        }
    }

    public void runSignalTest() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " start." + "[" + System.currentTimeMillis() + "]");
            System.out.println(Thread.currentThread().getName() + " condition-2 signal." + "[" + System.currentTimeMillis() + "]");
            // 通知其他线程可以竞争锁
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + " finish." + "[" + System.currentTimeMillis() + "]");
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockWithMultiConditionDemo demo = new ReentrantLockWithMultiConditionDemo();
        Thread t1 = new Thread(() -> {
            demo.runAwait1Test();
        }, "t1");

        Thread t2 = new Thread(() -> {
            demo.runAwait2Test();
        }, "t2");

        Thread t3 = new Thread(() -> {
            demo.runAwait3Test();
        }, "t3");

        t1.start();  //c1
        t2.start();  //c1
        t3.start();  //c2

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

        Thread t4 = new Thread(() -> {
            demo.runSignalAllTest();
        }, "t4");
        t4.start(); // c1 all

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

        Thread t5 = new Thread(() -> {
            demo.runSignalTest();
        }, "t5");
        t5.start(); // c2
    }
}

执行结果：
可以看出，程序执行过程中，不同condition是不会相互影响的。condition-1 signalAll()只对t1、t2线程生效，使其获得锁可以继续执行。t3由于没有获取condition的signal()所以在继续阻塞。
在这里插入图片描述

6. ReentrantReadWriteLock

读写锁， 读写分离机制，读读共享，读写互斥、写写互斥。
在读多写少的场景下，效率高于ReentrantLock

公平性问题
所为公平，就是多个线程竞争锁的时候，以先到先得的方式来获得锁。
但是公平性的保证需要额外维护一套竞争锁的线程的顺序，因此效率会比非公平的情况下更低。
Semaphore和ReentrantLock都存在保证公平性的机制

JimmyU1
关注
专栏目录
Java 并发编程
sybh的博客
10-22 361
理论+实战，带你深入浅出Java并发编程
Java并发工具类
weixin_46488959的博客
10-07 563
Lock Condition Semaphore ReadWriteLock StampedLock CountDownLatch、CyclicBarrier 并发容器 原子类 Executor与线程池 Future(获取任务执行结果) CompletableFuture(异步编程) CompletionService Fork/Join(并行计算框架)
Java中的并发工具类
weixin_45502048的博客
02-14 283
JUC并发工具包中提供了CountDownLatch, CyclicBarier, Semaphore作为并发流程控制的手段。 CountDownLatch CountDownLatch允许一个或多个线程等待其他线程完成操作。 在CountDownLatch之前，通常使用join()方法实现等待其他线程的操作。 t1.join(); t1.join()中实现等待的逻辑为 while (isAlive()) { wait(0);
面试：你说你精通Java并发，给我讲讲Java并发之J.U.C
茅坤宝骏氹的博客
05-10 678
转载自面试：你说你精通Java并发，给我讲讲Java并发之J.U.C J.U.C J.U.C即java.util.concurrent包，为我们提供了很多高性能的并发类，可以说是java并发的核心。 J.U.C和CAS和Unsafe和AQS Concurrent包下所有类底层都是依靠CAS操作来实现，而sun.misc.Unsafe为我们提供了一系列的CAS操作。 AQS框架是J.U.C中实现锁及同步机制的基础，其底层是通过调用 LockSupport .unpark()和 LockSuppor.
Java并发编程-常用的辅助类
Java硬件工程师的博客
01-28 3419
常用的辅助类1.CountDownLatch1.2.示例：班长锁门问题1.2.CountDownLatch类简介：1.2.1 CountDownLatch概念1.2.3 CountDownLatch的用法1.3.CountDownLatch案例：1.4.原理总结2.CyclicBarrier2.1.CyclicBarrier简介2.2.案例：集齐7颗龙珠召唤神龙3.Semophore3.1.Semophore简介3.2.抢车位问题3.3.原理总结 1.CountDownLatch 1.2.示例：班长锁门问题
java并发编程-从入门到精通
02-02
本教程“java并发编程-从入门到精通”旨在帮助你深入理解这个领域，并逐步提升你的编程能力。 首先，我们要理解Java并发的基础概念。并发是指一个程序中同时执行的多个线程，这在多核或多处理器系统中尤为常见。...
Java并发编程从入门到精通(pdf)(附源码)
01-16
《Java并发编程从入门到精通》是一本专为Java开发者设计的深度学习并发编程的书籍。作者韩剑锋，凭借其12年的IT行业经验，曾担任多家IT公司的研发总监和技术总监，以其丰富的实战经验和深厚的理论知识，为读者提供了...
java并发编程2
02-15
Java并发编程是Java开发中的重要领域，特别是在多核处理器和分布式系统中，高效地利用并发可以极大地提升程序的性能和响应速度。以下是对标题和描述中所提及的几个知识点的详细解释： 1. **线程与并发** - **线程*...
Java并发编程从入门到精通源码.rar
07-09
这个资源包“Java并发编程从入门到精通源码.rar”显然是为了帮助开发者深入理解并掌握这一关键技能。它包含了从基础概念到高级技术的详细讲解，并提供了源码供学习者实践和探索。 在Java并发编程中，首先要了解的...
java并发编程
01-20
Java并发编程是Java开发者必须掌握的关键技能之一，它涉及到如何在多线程环境中高效、安全地执行程序。并发编程能够充分利用多核处理器的...总的来说，Java并发编程是一门深奥的学问，需要不断学习和实践才能真正精通。
精通java并发
shalistone的博客
05-16 254
目录 10_多线程同步关系实例剖析与讲解.mp4 11_synchronized关键字原理详解.mp4 12_透过字节码理解synchronized关键字.mp4 13_同步方法访问标志与synchronized关键字之间的关系.mp4 14_自旋对于synchronized关键字的底层意义与价值分析.mp4 15_互斥锁属性详解与Monitor对象特性解说.mp4 16_通过openjdk源码分析ObjectMonitor底层实现.mp4 17_透过openjdk源码分析wait与notify方法的本地
java 并发编程的几个工具类
Brook
06-15 516
1.CountDownLatch(倒计时器)适用于一个主线程在等待其他几个线程执行结果的应用场景。(比如一主多重)当CountDownLatch维护的计数器为零的时候，调用await方法的线程才会执行，否则一直阻塞2.CyclicBarrier（CyclicBarrier）3.CountDownLatch和CyclicBarrier的异同...
Java并发工具类介绍
程序猿踩坑集锦
02-25 471
概述 在JDK的并发包（java.util.concurrent）中，为我们提供了几个非常重要的并发工具类，分别为CountDownLatch、CyclicBarrier、Semaphore和Exchanger。 先上总结 1、CountDownLatch，它是一种计数器的方式保证线程同步；它不去控制多个子线程之间的前后关系，只保证某一线程能够在这些子线程执行完成后再执行。 2、CyclicBarrier，通过设置屏障的方式使得多线程同步，能够控制多个线程在屏障处等等其他线程也执行到屏障点，可以实现
Java并发编程知识点总结（二十二）——各种并发工具类详解
XHHP
09-18 480
假设学校规定必须全部的学生到齐，老师才能上课。老师首先来到教室，这时班上的同学都还没有来，老师设置计数器为50，进行逐一倒数，并执行等待方法await()。然后同学们相继到达教室，计数器的值也就一直在递减。最后，全班同学都到达了，那么计数器也就减为0了，这时老师就无需等待了，可以继续执行任务。
精通Java并发——张龙
weixin_63249219的博客
06-02 327
并发
JAVA并发编程
最新发布
weixin_62609672的博客
12-09 354
JAVA并发编程笔记
Java并发编程：问题与解决方案
Java并发编程中，理解并熟练运用并发API如`ExecutorService`、`Future`、`Callable`、`CyclicBarrier`、`Semaphore`、`CountDownLatch`等是至关重要的。同时，掌握并发设计模式，如生产者消费者模型、双端队列、线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值