Java并发包中常用的类及其用法

最新推荐文章于 2023-05-25 10:46:29 发布
最新推荐文章于 2023-05-25 10:46:29 发布
阅读量1k 收藏 5
点赞数 2
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42105936/article/details/110679949
版权

介绍几种Java并发包（juc）中常用的类及其用法。

1.ReentrantLock

ReentrantLock可重入锁，与synchronized的区别：
1.ReentrantLock需要自己手动加锁解锁，synchronized的不需要
2.ReentrantLock可以tryLock尝试获取锁（指定时间内），锁未被占用则获取锁（锁会在tryLock返回true后被调用线程获取），则返回true，否则返回false
3.ReentrantLock可以设定公平锁和非公平锁，synchronized只有非公平锁
代码演示：

public class ReentrantLockDemo {
    private static ReentrantLock lock = new ReentrantLock();

    private void testLock() {
        try {
            lock.lock();
            // todo 原子操作
        } finally {
            lock.unlock();
        }
    }

    private void testTryLock() {
        boolean isLocked = false;
        try {
            // 尝试获取锁，规定时间内获取到锁则返回true，超时未获取锁则返回false
            isLocked = lock.tryLock(5, TimeUnit.SECONDS);
            if (isLocked) {
                for (int i = 0; i < 10; i++) {
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            } else {
                System.out.println(Thread.currentThread().getName() + "获取锁超时");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (isLocked) {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        ReentrantLockDemo reentrantLockDemo = new ReentrantLockDemo();

        // 线程1
        new Thread(reentrantLockDemo::testTryLock).start();
        // 线程2
        new Thread(reentrantLockDemo::testTryLock).start();
    }
}

2.CountDownLatch

CountDownLatch：门闩。在一个线程中设定一个预定值（大于0），然后调用await方法等待。其他线程每调用一次countDown方法，预定值就减一，当预定值为0时，await线程就会被唤醒。就像一扇门，被n个门闩拴住，当门闩被一个个的抽掉，门就打开了
代码演示：

public class CountDownLatchDemo {
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(3);

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "开始");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "结束");
                latch.countDown();
            }).start();
        }

        try {
            latch.await(); // 主线程等待
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("结束");
    }
}

3.CyclicBarrier

CyclicBarrier：栅栏，分界线。例如大家一起坐大巴车，每个人上车以后等待（await，线程等待），等到所有人（CyclicBarrier的初始参数parties）都上车后，车就出发（所有线程唤醒）
代码演示：

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        // param1: 等待线程数；param2：所有线程都到齐后触发行为
        CyclicBarrier barrier = new CyclicBarrier(3, ()-> System.out.println("人满，出发"));

        for (int i = 0; i < 3; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "上车");
                try {
                    barrier.await();
//                    System.out.println(Thread.currentThread().getName() + "dosomething");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
            // 每1s启动一个线程
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4.Semaphore

Semaphore：信号量。这个锁用于控制对某组资源的访问权限，即同时只有指定数量的线程可以获得执行权。例如银行大厅有3个人工窗口，同时只有三个人能在窗口办公，其他人都需要等待
使用场景：限流
代码演示：

public class SemaphoreDemo {

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();// 获取锁
                    System.out.println(Thread.currentThread().getName() + "正在执行...");
                    TimeUnit.SECONDS.sleep(3);
                    semaphore.release();// 释放锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

5.ReadWriteLock

ReadWriteLock: 读写锁。写锁是互斥锁，写的时候其他线程不能写，也不能读；读锁是共享锁，读的时候其他线程也可以读，但是不能写。由于读锁是共享锁，多个线程可以同时读数据，所以效率会比直接加一个synchronized效率高
代码演示：

public class ReadWriteLockDemo {
    static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    static Lock readLock = readWriteLock.readLock();// 读锁
    static Lock writeLock = readWriteLock.writeLock(); // 写锁
    static int value = 0;

    public static void read(Lock lock) {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "开始读...");
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName() + "读结束,value = " + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void write(Lock lock, int v) {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "开始写...");
            TimeUnit.SECONDS.sleep(1);
            value = value + v;
            System.out.println(Thread.currentThread().getName() + "写完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        // 模拟10个线程读
        for (int i = 0; i < 10; i++) {
            new Thread(() -> ReadWriteLockDemo.read(readLock)).start();
        }
        // 模拟3个线程写
        for (int i = 0; i < 3; i++) {
            new Thread(() -> ReadWriteLockDemo.write(writeLock, 1)).start();
        }

    }
}

6.LockSupport

LockSupport用于控制一个线程的停止与唤醒，调用park方法则线程阻塞，调用unpark方法则线程重新运行。与wait/notify的区别：
1.wait/notify必须在同步代码中使用，多个线程竞争一把锁的情况下，线程调用wait让出锁，notify唤醒其他线程来竞争锁
2.unpark可以先于park调用，成对出现则线程不会停止

public class LockSupportDemo {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                if (i == 5) {
                    LockSupport.park(); // 线程停止
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
//        LockSupport.unpark(t);
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        LockSupport.unpark(t); // 解除线程停止状态
        System.out.println("线程继续运行...");
    }
}

7.Condition

Condition：用于线程间通信，其重要方法await/signal/signalAll,作用类似于Object的wait/notify/notifyAll
区别：
1.Condition的使用需要依赖ReentrantLock
2.每个Condition对象都相当于一个队列，线程调用了Condition对象的await方法，就会到相应的队列中等待
例如有两个Condition对象：producer，consumer，线程调用producer.await(),则线程会在producer队列中等待，线程调用consumer.await()，则线程会在consumer队列中等待.此时调用producer.signalAll(),会唤醒producer队列中等待的所有线程去竞争锁，consumer同理
代码演示：

/**
 * demo：
 * 定义一个固定容量的容器，容量为10，能够支持2个生产者put和10个消费者get。
 * 容器元素为最大容量时，生产者停止put，需通知消费者get；容器元素为0时，消费者停止get，需通知生产者put
 * created by it_hushuai
 * 2020/12/5 15:43
 */
public class ConditionDemo {
    public static void main(String[] args) {
        ContainerDemo<String> container = new ContainerDemo<>();

        // 启动消费者线程
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                for (int j = 0; j < 5; j++) {
                    System.out.println(Thread.currentThread().getName() + "正在消费元素：" + container.get());
                }
            }).start();
        }

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 启动生产者线程
        for (int i = 0; i < 2; i++) {
            new Thread(()->{
                for (int j = 0; j < 25; j++) {
                    String item = Thread.currentThread().getName() + "-" + j;
                    System.out.println(Thread.currentThread().getName() + "正在生产：" + item);
                    container.put(item);
                }
            }).start();
        }
    }

}

class ContainerDemo<T> {
    final private LinkedList<T> list = new LinkedList<>();
    final private int MAX = 10; // 容器容量
    private int count = 0;

    private ReentrantLock lock = new ReentrantLock();
    private Condition producer = lock.newCondition();
    private Condition consumer = lock.newCondition();

    public /*synchronized*/ void put(T t) {
        try {
            lock.lock();
            // 这里使用while而不使用if：当线程被唤醒后，仍需判断当前元素个数是否达到最大值
            while (list.size() == MAX) { // 只要当前list的大小为容量值10，则不能添加元素，添加元素线程阻塞
                try {
                    producer.await(); // 生产者线程等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 未到达容器容量
            list.add(t);
            ++count;
            // 通知消费线程
            consumer.signalAll();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 每次只能由一个线程取出一个元素
     *
     * @return
     */
    public /*synchronized*/ Object get() {
        T t = null;
        try {
            lock.lock();
            while (list.size() == 0) { // 当容器元素为0时，停止消费
                try {
                    consumer.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            t = list.removeFirst();
            count--;
            producer.signalAll(); // 通知生产线程
        } finally {
            lock.unlock();
        }
        return t;
    }
}
旧时明月丶
关注
专栏目录
Java 并发包提供了哪些并发工具类
王小明的专栏
05-04 437
Java 并发包提供了哪些并发工具类 Java 基础并发工具类 提供了比 synchronized更加高级的各种同步结构，包括 CountDownLatch, CyclicBarrier、 Semaphore等，可以实现更加丰富的多线程操作，比如利用 Semaphore作为资源 各种线程安全的容器，比如最常见的 ConcurrentHashMap、有序的 ConcunrrentskipListM...
Java 高并发五：JDK并发包1详细介绍
09-01
} } 在这个例子中，如果使用synchronized，子类调用父类的synchronized方法不会产生死锁，因为synchronized是可重入的。同样，ReentrantLock也具备这一特性。1.1.2 可中断当线程尝试获取锁时，如果锁被其他线程持有...
第一章 Java常用的并发类
weixin_34301307的博客
01-08 213
注：本系列博客主要参考于《分布式Java应用：基础与实践》，林昊 著 1、常用的并发集合类 ConcurrentHashMap：线程安全的HashMap的实现 CopyOnWriteArrayList：线程安全且在读操作时无锁的ArrayList CopyOnWriteArraySet：基于CopyOnWriteArrayList，不添加重复元素 ArrayBlockingQueue...
Java并发包下常用类介绍
最新发布
weixin_43740011的博客
05-25 1441
在Java中，有许多常用的并发包类。
Java并发包中常用类
别抢我蓝buff
03-16 313
Java并发包中常用类小结(一) 从JDK1.5以后，Java为我们引入了一个并发包，用于解决实际开发中经常用到的并发问题，那我们今天就来简单看一下相关的一些常见类的使用情况。 1、ConcurrentHashMap ConcurrentHashMap其实就是线程安全版本的hashMap。前面我们知道HashMap是以链表的形式存放hash冲突的数据，以数组形式存放HashEnt...
java并发包的类_java并发包下的类一般都有哪些？java并发包常用类
weixin_42502363的博客
02-16 1570
在java并发包下经常会有很多类供我们使用，今天我们就来看看一般常用的并发包类都有哪些吧。一、ThredPoolExecutorThredPoolExecutor这个类是基于命令模式下的一个典型线程池实现，它主要通过一些策略实现一个典型的线程池，目前我们已经知道的策略如：ThreadPoolExecutor.AbortPolicy,ThreadPoolExecutor.CallerRunsPoli...
Java并发包（java.util.concurrent）常用类及使用实例
# 1. Java并发包介绍 ### 1.1 什么是Java并发包 Java并发包是Java标准库提供的一个用于处理多...Java并发包的发展历程可以追溯到Java 1.5版本，当时引入了`java.util.concurrent`包，其中包含了一些基本的并发类，
探秘Java并发包：常用的并发类和接口
# 1. 介绍 ## 1.1 并发编程概述 在计算机领域，随着多核处理器的普及和互联网应用的发展，并发编程变得越来越重要。并发编程是指程序中包含多个...Java并发包为开发者提供了丰富的并发编程工具和框架，通过这些工具
Java并发编程中使用Executors类创建和管理线程的
10-30
本篇将深入探讨`Executors`类的使用方法及其背后的并发原理。 `Executors`类是Java并发包`java.util.concurrent`中的一个静态工厂类，它提供了多种方法用于创建不同类型的线程池。下面我们将逐一介绍这些方法以及...
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并发包提供了哪些并发工具类？
u011277123的博客
05-28 7491
蓝苍星2019-05-27 12:33:01 我们通常所说的并发包也就是 java.util.concurrent 及其子包，集中了 Java 并发的各种基础工具类，具体主要包括几个方面： 1） 提供了比 synchronized 更加高级的各种同步结构，包括 CountDownLatch、CyclicBarrier、Sempahore 等，可以实现更加丰富的多线程操作，比如利用 Semap...
Java - 多线程并发包下常用类 Future CountDownLatch CyclicBarrier Semaphore
Demon-HY的博客
06-04 338
文章目录Future、FutureTask和CompletableFutureFutureFutureTaskCompletableFutureCountDownLatchCyclicBarrierSemaphore Future、FutureTask和CompletableFuture Future 平时在使用多线程的时候, 是拿不到线程返回值的, 当需要拿到返回值时,需要实现Callable来获取 Callable接口定义 public interface Callable<V> {
juc java_详解JUC 常用4大并发工具类
weixin_26831583的博客
02-17 427
什么是JUC?JUC就是java.util.concurrent包,这个包俗称JUC,里面都是解决并发问题的一些东西该包的位置位于java下面的rt.jar包下面4大常用并发工具类:CountDownLatchCyclicBarrierSemaphoreExChangerCountDownLatch:CountDownLatch,俗称闭锁,作用是类似加强版的Join,是让一组线程等待其他的线程完成...
Java并发包常用类用法及原理
沉下心来，戒骄戒躁
08-18 2018
com.java.util.concurrent包是java5时添加的，专门处理多线程提供的工具类 一、Atomic二、Lock三、BlockingQueue四、BlockDeque五、ConcurrnetMap六、CountDownLatch七、CyclicBarrier八、ExecutorService九、CopyOnWriteList十、ThreadLoca...
JAVA 并发类（一） 常用的并发类
Heqianqian的博客
09-18 2784
1. 集合类 ConcurrentHashMap:线程安全的HashMap的实现 CopyOnWriteArrayList:线程安全且在读操作时无锁的ArrayList CopyOnWriteArraySet:基于CopyOnWriteArrayList 不添加重复元素 ArrayBlockingQueue:基于数组 先进先出 线程安全 可实现指定时间的拥塞读写 LinkedBlockingQueu
Java并发包中的所有类目录
吟啸徐行
07-06 3222
Java并发包中的所有类目录如下，希望逐个击破每一个并发工具！ concurrent: AbstractExecutorService ArrayBlockingQueue BlockingDeque BlockingQueue Callable CompletionService ConcurrentHashMap ConcurrentLinkedDeque Concur
java并发包的类_Java并发包中常用类小结(二) （转载）
weixin_34052529的博客
02-25 87
转载地址：http://yhjhappy234.blog.163.com/blog/static/316328322012324104837102/6、ThredPoolExecutorThredPoolExecutor是基于命令模式下的一个典型的线程池的实现，主要通过一些策略实现一个典型的线程池，目前已知的策略有ThreadPoolExecutor.AbortPolicy, ThreadPool...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值