并发容器与并发工具类的使用

最新推荐文章于 2022-07-29 17:44:12 发布
最新推荐文章于 2022-07-29 17:44:12 发布
阅读量202 收藏
点赞数
分类专栏： 并发编程 文章标签： LinkedBlockingQueue CountDownLatch CyclicBarrier Semaphore Exchanger
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kangswx/article/details/92091141
版权

  1. 同步容器

    Vector，HashTable – jdk提供的同步容器类

    Collections.synchronizedXXX 本质是对响应的容器进行包装

  2. 同步容器类的缺点

    在单独使用里面的方法的时候，可以保证线程安全，但是符合操作需要额外加锁来保证线程安全，使用Interator迭代容器或使用for–each遍历容器，在迭代过程中修改容器会抛出CurrentModificationException异常。要想避免CurrentModificationException，就必须在迭代的过程中持有容器的锁。但是若容器交大的话，迭代的时间会较长，那么需要访问该容器的线程就会进入长时间的等待，从而极大的降低性能。

    若不希望在迭代的过程中对容器加锁，可以使用克隆容器的方式，使用线程封闭，由于其他线程不会对容器进行修改，可以避免CurrentModificationException，但是在创建副本的时候，存在较大性能开销。

  3. 并发容器

    CopyOnWrite、Concurrent、BlockingQueue+

    根据具体的场景进行设计，尽量避免使用锁，提高容器的并发访问性。

    ConcurrentBlockingQueue 基于queue实现的FIFO先进先出的队列，队列为空，取操作会被阻塞

    ConcurrentLinkedQueue 队列为空，取的时候直接返回空

  4. 同步容器Vector的坑：

    import java.util.Iterator;
import java.util.Vector;

public class VectorDemo {

    public static void main(String[] args) {
        Vector<String> strings = new Vector<>();
        for(int i = 0; i < 1000; i++){
            strings.add("demo" + i);
        }

        //错误迭代
        /*strings.forEach(e -> {
            if(e.equals("demo3")){
                strings.remove(e);   //ConcurrentModificationException
            }
            System.out.println(e);
        });*/

        //正确的迭代
        Iterator<String> iterator = strings.iterator();
        /*单线程下正确的迭代方式
        while (iterator.hasNext()){
            String next = iterator.next();
            if("demo3".equals(next)){
                iterator.remove();
            }
        }*/

        for(int i = 0; i < 4; i++){
            new Thread(() -> {
                synchronized (iterator) {
                    while (iterator.hasNext()) {
                        String next = iterator.next();
                        if ("demo3".equals(next)) {
                            iterator.remove();    //不加锁的话，在多线程下回报错NoSuchElementException
                        }
                    }
                }
            }).start();
        }
    }
}

  5. 并发容器使用代码示例：

    import java.util.concurrent.CopyOnWriteArrayList;

public class Demo {

    public static void main(String[] args) {
        CopyOnWriteArrayList<String> stringCopyOnWriteArrayList = new CopyOnWriteArrayList<>();
        for(int i = 0; i < 1000; i++){
            stringCopyOnWriteArrayList.add("demo"+i);
        }

        //可以正常访问
       /* stringCopyOnWriteArrayList.forEach(e -> {
            if("demo2".equals(e)){
                stringCopyOnWriteArrayList.remove(e);
            }
        });*/

      /*  Iterator<String> iterator = stringCopyOnWriteArrayList.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            if("demo2".equals(next)){
                //CopyOnWriteArrayList不支持在迭代器里面移除元素
                iterator.remove();     //UnsupportedOperationException
            }
        }*/

        for (int i = 0; i < 4; i++){
            new Thread(() -> {
                stringCopyOnWriteArrayList.forEach(e -> {
                    if("demo2".equals(e)){
                        stringCopyOnWriteArrayList.remove(e);
                    }
                });
            }).start();
        }
    }
}

  6. LinkedBlockingQueue,在并发编程中使用非常频繁，因其可以作为生产者消费者的中间商，没有元素的时候会阻塞

  7. LinkedBlockingQueue的使用代码示例

    import java.util.concurrent.LinkedBlockingDeque;

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        LinkedBlockingDeque<String> strings = new LinkedBlockingDeque<>();

        //向队列中放入元素
        strings.add("");   //实际调用的是offer，在队列满的时候，会抛出异常
        strings.offer(""); //如果队列满了，会返回如对失败
        strings.put("");   //作为生产者，如果队列满了，会进入阻塞状态

        //从队列中去元素
        String remove = strings.remove(); //返回移除的元素，会抛出异常
        strings.poll();   //在队列为空的时候，返回为null
        strings.take();   //作为消费者,在队列为空的时候会进入等待状态
    }
}

    add 调用的是offer

    offer 队列如果满了直接入队失败

  8. CountDownLatch

    应用场景：启动三个线程计算，需要对结果进行累加

    await();      //进入等待状态
countDown();  //计数器减一

  9. CountDownLatch使用代码示例

    import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {

    public static void main(String[] args) {

        CountDownLatch countDownLatch = new CountDownLatch(8);

        new Thread(() -> {
            try {
                //进入等待状态，等countDownLatch减为0时才执行下面的操作
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("800密比赛结束，准备清空跑道并进行跨栏比赛");
        }).start();

        for (int i = 0; i < 8; i++){
            int finalI = i;
            new Thread(() -> {
                try {
                    Thread.sleep(finalI * 1000L);
                    System.out.println(Thread.currentThread().getName()+"----比赛结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //在线程执行结束后，减1
                    countDownLatch.countDown();
                }
            }).start();
        }
    }
}
/*
    执行结果：
    Thread-1----比赛结束
    Thread-2----比赛结束
    Thread-3----比赛结束
    Thread-4----比赛结束
    Thread-5----比赛结束
    Thread-6----比赛结束
    Thread-7----比赛结束
    Thread-8----比赛结束
    800密比赛结束，准备清空跑道并进行跨栏比赛
*/

  10. CyclicBarrier–栅栏

    允许一组线程达到一个公共的障碍点，之后再继续执行

  11. CyclicBarrier与CountDownLatch的区别

    • CountDownLatch一般用于一个线程等待若干个其他线程执行完成任务后，它才执行，不可重复使用
    • CyclicBarrier一般用于一组线程相互等待至某个状态，然后这一组线程再同时执行，可重用的

  12. CyclicBarrier代码示例

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

public class CyclicBarrierDemo {

    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(8);

        for (int i = 0; i < 8; i++) {
            int finalI = i;
            new Thread(() -> {
                try {
                    Thread.sleep(finalI * 1000L);
                    System.out.println(Thread.currentThread().getName() + "----准备就绪");
                    //执行到就绪状态的时候，进入等待状态
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }

                //等所有的线程都进入到就绪状态，再同时执行下面的操作
                System.out.println(Thread.currentThread().getName() + "----开始比赛");
            }).start();
        }
    }

}

  13. Semaphore – 信号量

    控制线程的并发数量

  14. Semaphore 的使用场景： 接口限流

  15. 代码示例

    import java.util.concurrent.Semaphore;

public class SemaphoreDemo {

    public static void main(String[] args) {

        Semaphore semaphore = new Semaphore(8);
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();  //获得信号,当信号量不足时进入等待状态
                    System.out.println(Thread.currentThread().getName() + "----开始执行");
                    Thread.sleep(5 * 1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); //释放信号
                }
            }).start();
        }
    }
}

  16. Exchanger： 用来两个线程之间交换数据

    它提供了一个同步点，在这个同步点两个线程可以交换数据。这两个线程通过exchanger交换数据，如果第一个线程先执行exchange方法，它会一直等待第二个线程执行exchange，当两个线程都达到同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。所以使用exchanger的重点是成对的线程使用exchange()方法，当有一堆线程达到了同步点，就会进行交换数据，因此该工具类的线程对象时"成对"的。

  17. Exchanger使用代码示例

    import java.util.concurrent.Exchanger;

public class ExchangerDemo {

    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();
        String str1 = "str1";
        String str2 = "str2";

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "===初始值1===" + str1);
            try {
                String exchange = exchanger.exchange(str1);
                System.out.println(Thread.currentThread().getName() + "===交换值1===" + exchange);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "线程1").start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "===初始值2===" + str2);
            try {
                String exchange = exchanger.exchange(str2);
                System.out.println(Thread.currentThread().getName() + "===交换值2===" + exchange);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "线程2").start();

    }

}

/*
	执行结果：
        线程1===初始值1===str1
        线程2===初始值2===str2
        线程2===交换值2===str1
        线程1===交换值1===str2
*/
kangswx
关注
专栏目录
同步类容器和并发类容器
yjclsx的博客
07-31 41万+
一.为什么会出现同步容器？ 在Java的集合容器框架中，主要有四大类别：List、Set、Queue、Map。 注意Collection和Map是顶层接口，而List、Set、Queue接口则分别继承了Collection接口，分别代表数组、集合和队列这三大类容器。 像ArrayList、LinkedList都是实现了List接口，HashSet实现了Set接口，而Deque（双向队列，允许...
并发容器的原理，七大并发容器详解、及使用场景
weixin_43649691的博客
11-30 703
并发容器的由来 在Java并发编程中，经常听到Java集合类，同步容器、并发容器，那么他们有哪些具体分类，以及各自之间的区别和优劣呢？ 只有把这些梳理清楚了，你才能真正掌握在高并发的环境下，正确使用好并发容器，我们先从Java集合类，同步容器谈起。 1.什么是同步容器 Java的集合容器框架中，主要有四大类别：List、Set、Queue、Map，大家熟知的这些集合类ArrayList、Link...
并发容器的原理，7大并发容器详解、及使用场景
11-15
并发容器的原理，7大并发容器详解、及使用场景。有兴趣的可以看下。
多线程系列五：并发工具类和并发容器
weixin_33849215的博客
02-10 103
一、并发容器 1.ConcurrentHashMap 为什么要使用ConcurrentHashMap 在多线程环境下，使用HashMap进行put操作会引起死循环，导致CPU利用率接近100%，HashMap在并发执行put操作时会引起死循环，是因为多线程会导致HashMap的Entry链表 形成环形数据结构，一旦形成环形数据结构，Entry的next节点永远不为空，就会产生死循环获取En...
学习互联网架构第十课（并发类容器）
u012453843的专栏
06-27 1009
并发类容器是专门针对并发设计的，使用ConcurrentHashMap来代替给予散列的传统的HashTable，而且在ConcurrentHashMap中，添加了一些常见复合操作的支持。以及使用了CopyOnWriteArrayList代替Vector,并发的CopyOnWriteArraySet，以及并发的Queue,ConcurrentLinkedQueue和LinkedBlockingQue
并发容器使用
qq_36955645的博客
05-21 152
CopyOnWriteArrayList、ConcurrentSkipListMap、ConcurrentSkipListSet、ConcurrentHashMap、BlockingQuence等并发容器使用：
多线程---并发容器的使用
热门推荐
意田天的博客
08-13 1万+
多线程---并发容器的使用1. 容器概览2. 容器的使用1. Map1. HashTable2. HashMap3. SynchronizedHashMap4. ConcurrentHashMap2. Collection1. ArrayList2. Vector3. LinkedList4. ConcurrentLinkedQueue3. 并发容器的使用1. ConcurrentHashMap2. CopyOnWriteArrayList3. ConcurrentLinkedQueue4. LinkedB
Java从同步容器到并发容器的操作过程
08-26
Java中的同步容器与并发容器是处理多线程环境下数据安全的重要工具。同步容器，如`Vector`和`HashTable`，通过在每个方法上添加`synchronized`关键字实现了线程安全，但这种方式存在性能瓶颈，因为每次操作都需要...
CountDownLatch、Semaphore等4大并发工具类详解
11-15
Java 并发工具类是 Java 并发编程的核心组件之一，提供了多种同步结构和并发容器，帮助开发者创建高效、可靠的并发程序。本文将详细介绍 Java 并发工具类的四大类：CountDownLatch、Semaphore、CyclicBarrier 和 ...
并发容器——BlockingQueue相关类
03-22
在Java编程中，`BlockingQueue`是一个非常重要的并发容器，它是Java并发包`java.util.concurrent`中的核心组件。`BlockingQueue`实现了一种线程安全的数据结构，它能够有效地协调生产者和消费者的动作，实现高效的...
JAVA并发容器与并发工具类
追梦的疯子
08-31 189
JAVA并发容器与工具笔记1、JAVA并发容器2、JAVA并发容器2.1、CountDownLatch2.2、CyclicBarrier2.3、CyclicBarrier和CountDownLatch的区别2.4、Semaphore2.5、Exchanger 1、JAVA并发容器 ConcurrentHashMap :线程安全的Map。 ConcurrentLinkedQueue：线程安全非阻塞队列。采用先进先出的规 则对节点进行排序，当我们添加一个元素的时候，它会添加到队列的尾部；当我们获取一个元素时，
并发容器、同步容器、同步工具类
yangnan0110的专栏
04-13 613
一、同步容器类 1.同步容器类包括Vector和Hashtable。这些类实现线程安全的方式是：将它们的状态封装起来，并对每个公有方法都进行同步，使得每次只有一个线程能够访问容器的状态。 2.同步容器类都是线程安全的，但在某些情况下可能需要额外的客户端加锁来保护符合操作。 3.
java并发容器类
qq_35151346的博客
08-19 247
一、概述 在Java中,普通常用集合 1.这些集合在我们编程中经常用到，但是在这些集合中除HashTale外，其他的都是属于线程不安全的，意味着我们在多线程情况下使用这些集合，我们的数据不能得到保障。单是HashTable的底层实现是给整个数组加了一把锁，意味着在多线程下，势必会出现线程竞争资源的情况，轻量级锁不停自旋后会升级为重量级锁，性能较差。 2.为了能够在多线程情况下操作数...
java 模拟并发访问_Java中如何模拟真正的同时并发请求？
weixin_28711397的博客
02-13 188
​有时需要测试一下某个功能的并发性能，又不要想借助于其他工具，索性就自己的开发语言，来一个并发请求就最方便了。java中模拟并发请求，自然是很方便的，只要多开几个线程，发起请求就好了。但是，这种请求，一般会存在启动的先后顺序了，算不得真正的同时并发！怎么样才能做到真正的同时并发呢？是本文想说的点，java中提供了闭锁 CountDownLatch, 刚好就用来做这种事就最合适了。只需要：开启n个线...
并发编程学习笔记 之 常用并发容器的概念及使用方法
向心行者
07-29 508
所有线程对该容器的读取操作将不会对数据集合产生加锁的动作，从而使得高并发高吞吐量的读取操作变得高效，但是当有线程对该容器中的数据集合进行删除或增加等写操作时才会对整个数据集合进行加锁操作，然后将容器中的数据集合复制一份，并且基于最新的复制进行删除或增加等写操作，当写操作执行结束以后，将最新复制的数据集合引用指向原有的数据集合，进而达到读写分离最终一致性的目的。并发容器是指在高并发应用程序的使用过程中，这些容器（数据结构）是线程安全的，而且在高并发的程序中运行它们会有高效的性能表现。...
并发容器类
DLC990319的博客
06-10 266
一、并发容器概览 ConcurrentHashMap： 线程安全的HashMap CopyOnWriteArrayList：线程安全的ArrayList BlockingQueue：是一个接口，表示阻塞队列，非常适合用于作为数据共享的通道。 ConcurrentLinkedQueue：高效的非阻塞并发队列，使用链表实现。可看作一个线程安全的LinkedList。 ConcurrentSkipListMap：是一个Map，使用跳表的数据结构进行快速查找。 二、ConcurrentHashMap 1.Map简介
并发容器 & 并发工具
一名努力的大学生，希望可以帮到更多人
02-23 950
一、并发容器 CopyOnWriteArrayList 1.读写分离 写操作在一个复制的数组上进行，读操作还是在原数组中进行，读写分离，互不影响。 写操作需要加锁，防止并发写入时导致写入数据丢失。 写操作结束之后需要把原数组指向新的复制数组。 //写操作: //通过过创建底层数组的新副本来实现的。 //当 List 需要被修改的时候，并不修改原有内容，而是对原有数据进行一次复制，将修改的内容写入副本。 //写完之后，把原数组指向新的复制数组。 //这样可以保证写操作实在一个复制的数组上进行，而
并发编程艺术：工具与框架详解
6. **并发控制机制**：涵盖了Lock同步器（如ReentrantLock）、阻塞队列、执行器（Executor）和并发容器（如AQS抽象同步器），以及非阻塞数据结构（如Atomic变量类）的使用，重点提及了Volatile变量的读写和CAS算法。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值