并发容器

最新推荐文章于 2024-09-29 09:06:58 发布
最新推荐文章于 2024-09-29 09:06:58 发布
阅读量552 收藏 1
点赞数
分类专栏： Java多线程与高并发 文章标签： 并发容器

背景

某些业务中因为使用HashMap这些线程不安全的结合类，如果因为线程不安全的问题导致了得到的结果我们的预期不一致，那么我们可以使用这些集合类对应的同步容器或者并发容器（JUC）包下。

集合类型对应的并容器补充
MapConcurrentHashMap
MapConcurrentSkipListMap
ListCopyOnWriteArrayList
ListConcurrentLinkedQueue
SetCopyOnWriteArraySet
SetConcurrentSkipListSet

Map

demo1

package com.mark.example.concurrent;

import com.mark.annotations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.*;

/**
 *
 * author:Mark
 * date:2018/7/31  11:53
 *
 * HashMap：线程不安全
 * HashTable：线程安全，效率低，锁住整个表
 * ConcurrentHashMap:采用锁分段机制
 *
 */
@Slf4j
@ThreadSafe
public class ConcurrentHashMapTest {
    public static int clientTotal = 5000;//请求总数
    public static int threadTotal = 200;//同时并发执行的线程数
    public static Map<Integer,Integer> map = new ConcurrentHashMap<>();

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();//线程池
        final Semaphore semaphore = new Semaphore(threadTotal);//信号量，控制同时并发的线程数
        CountDownLatch countDownLatch = new CountDownLatch(clientTotal);//计数器，保证线程执行完之后再进行其他的处理
        for (int i = 0; i < clientTotal; i++) {
            final int count = i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();//关闭线程池
        log.info("size:{}",map.size());
    }

    private static void update(int i) {//模拟并发的访问方法
        map.put(i, i);
    }
}

运行结果：线程安全

12:00:18.467 [main] INFO com.mark.example.concurrent.ConcurrentHashMapTest - size:5000

package com.mark.example.concurrent;

import com.mark.annotations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.Map;
import java.util.concurrent.*;

/**
 * author:Mark
 * date:2018/7/31  11:53
 */
@Slf4j
@ThreadSafe
public class ConcurrentSkipListMapTest {
    public static int clientTotal = 5000;//请求总数
    public static int threadTotal = 200;//同时并发执行的线程数
    public static Map<Integer,Integer> map = new ConcurrentSkipListMap<>();

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();//线程池
        final Semaphore semaphore = new Semaphore(threadTotal);//信号量，控制同时并发的线程数
        CountDownLatch countDownLatch = new CountDownLatch(clientTotal);//计数器，保证线程执行完之后再进行其他的处理
        for (int i = 0; i < clientTotal; i++) {
            final int count = i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();//关闭线程池
        log.info("size:{}",map.size());
    }

    private static void update(int i) {//模拟并发的访问方法
        map.put(i, i);
    }
}

运行结果：线程安全

12:01:10.247 [main] INFO com.mark.example.concurrent.ConcurrentSkipListMapTest - size:500

List

CopyOnWriteArrayList
demo3

package com.mark.example.concurrent;

import com.mark.annotations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 * author:Mark
 * date:2018/7/31  11:56
 *
 * 写入并复制：适合并发的时候迭代操作
 * 如果添加操作多时，效率低因为需要拷贝
 */
@Slf4j
@ThreadSafe
public class CopyOnWriteArrayListTest {
    public static int clientTotal = 5000;//请求总数
    public static int threadTotal = 200;//同时并发执行的线程数
    public static List<Integer> list = new CopyOnWriteArrayList<>();

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();//线程池
        final Semaphore semaphore = new Semaphore(threadTotal);//信号量，控制同时并发的线程数
        CountDownLatch countDownLatch = new CountDownLatch(clientTotal);//计数器，保证线程执行完之后再进行其他的处理
        for (int i = 0; i < clientTotal; i++) {
            final int count = i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();//关闭线程池
        log.info("size:{}",list.size());
    }

    private static void update(int i) {//模拟并发的访问方法
        list.add(i);
    }
}

运行结果：线程安全

2:03:10.771 [main] INFO com.mark.example.concurrent.CopyOnWriteArrayListTest - size:5000

Set

CopyOnWriteArraySet

package com.mark.example.concurrent;

import com.mark.annotations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.Set;
import java.util.concurrent.*;

/**
 * author:Mark
 * date:2018/7/31  11:59
 */
@Slf4j
@ThreadSafe
public class CopyOnWriteArraySetTest {
    public static int clientTotal = 5000;//请求总数
    public static int threadTotal = 200;//同时并发执行的线程数
    public static Set<Integer> set = new CopyOnWriteArraySet<>();


    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();//线程池
        final Semaphore semaphore = new Semaphore(threadTotal);//信号量，控制同时并发的线程数
        CountDownLatch countDownLatch = new CountDownLatch(clientTotal);//计数器，保证线程执行完之后再进行其他的处理
        for (int i = 0; i < clientTotal; i++) {
            final int count = i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();//关闭线程池
        log.info("size:{}",set.size());
    }

    private static void update(int i) {//模拟并发的访问方法
        set.add(i);
    }
}

12:04:12.005 [main] INFO com.mark.example.concurrent.CopyOnWriteArraySetTest - size:5000

ConcurrentSkipListSet

package com.mark.example.concurrent;

import com.mark.annotations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.*;

/**
 * author:Mark
 * date:2018/7/31  11:57
 */
@Slf4j
@ThreadSafe
public class ConcurrentSkipListSetTest {
    public static int clientTotal = 5000;//请求总数
    public static int threadTotal = 200;//同时并发执行的线程数
    public static Set<Integer> set = new ConcurrentSkipListSet<>();


    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();//线程池
        final Semaphore semaphore = new Semaphore(threadTotal);//信号量，控制同时并发的线程数
        CountDownLatch countDownLatch = new CountDownLatch(clientTotal);//计数器，保证线程执行完之后再进行其他的处理
        for (int i = 0; i < clientTotal; i++) {
            final int count = i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();//关闭线程池
        log.info("size:{}",set.size());
    }

    private static void update(int i) {//模拟并发的访问方法
        set.add(i);
    }
}

运行结果：线程安全

12:04:57.362 [main] INFO com.mark.example.concurrent.ConcurrentSkipListSetTest - size:5000

GZ-豆浆油条
关注
专栏目录
并发容器介绍
weixin_38738049的博客
02-22 449
并发容器
Java并发编程：同步容器
weixin_30763397的博客
08-24 155
Java并发编程：同步容器 　　为了方便编写出线程安全的程序，Java里面提供了一些线程安全类和并发工具，比如：同步容器、并发容器、阻塞队列、Synchronizer（比如CountDownLatch）。今天我们就来讨论下同步容器。 　　以下是本文的目录大纲： 　　一.为什么会出现同步容器？ 　　二.Java中的同步容器类 　　三.同步容器的缺陷 　　若有不正之处请多多谅解...
java并发之并发容器
最新发布
通往IT大道的专栏
09-29 1054
当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态， 如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈。JDK1.7的ConcurrentHashMap（分段锁）对整个桶数组进行了分割分段(Segment)， 每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问度。实现， JDK1.8 的ConcurrentHashMap底层采用的数据结构与JDK1.8 的HashMap的结构一样，
Java同步容器和并发容器详解
08-25
Java同步容器和并发容器详解 Java同步容器和并发容器是Java基础类库中使用频率最高的一部分，Java集合包中提供了大量的容器类来帮组我们简化开发。下面我们来一起学习Java同步容器和并发容器的知识点。 一、同步...
并发容器的原理，7大并发容器详解、及使用场景
11-15
并发容器的出现解决了传统同步容器在性能上的不足，通过引入更先进的并发控制策略，如锁分段、CAS算法等，提升了程序的并发性和吞吐量。 首先，我们要理解什么是同步容器。Java 集合框架中的非线程安全容器，如 ...
基于CopyOnWriteArrayList并发容器(实例讲解)
08-28
CopyOnWriteArrayList并发容器 CopyOnWriteArrayList是一种基于Copy-On-Write机制的并发容器，自JDK 1.5开始提供。它的基本思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把...
Java多线程编程中的两种常用并发容器讲解
09-03
Java并发编程中，ConcurrentHashMap和CopyOnWriteArrayList是两种常用的并发容器，它们设计的目标是在多线程环境下提供高效且安全的数据访问。这里主要聚焦于ConcurrentHashMap的讲解。 **ConcurrentHashMap概述** ...
并发容器概述
持之以恒！
07-22 235
同步类容器都是线程安全的，但在某些场景下可能需要加锁来保护复合操作。复合类操作如：迭代（反复访问元素，遍历完容器中所有的元素）、跳转（根据指定的顺序找到当前元素的下一个元素）、以及条件运算。这些复合操作在多线程并发地修改容器时，可能会表现出意外的行为，最经典的便是ConcurrentModificationException，原因是当容器迭代的过程中，被并发的修改了内容，这是由于早期迭代器设计的时...
java并发——并发容器
ly908979139的专栏
04-08 757
java并发——并发容器，大概介绍了java.util.concurrent下的并发容器，LinkedBlockingQueue，ConcurrentHashMap等
ConcurrentHashMap原理
weixin_30532987的博客
07-06 109
　　ConcurrentHashMap从JDK1.5开始随java.util.concurrent包一起引入JDK中，主要为了解决HashMap线程不安全和Hashtable效率不高的问题。众所周知，HashMap在多线程编程中是线程不安全的，而Hashtable由于使用了synchronized修饰方法而导致执行效率不高；因此，在concurrent包中，实现了ConcurrentHashMap...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值