java并发容器代码讲解（ConcurrentHashMap和ConcurrentSkipListMap）

偏执的太偏执、 2023-06-27 04:27 13阅读 0赞

## 1.ConcurrentHashMap ##

**ConcurrentHashMap是Java中的一个线程安全且高效的HashMap实现，处理高并发**  
**与ConcurrentSkipListMap相比：  
ConcurrentHashMap底层使用的是哈希表，ConcurrentSkipListMap使用的是红黑树**  
**优点：ConcurrentHashMap性能和存储空间优于ConcurrentSkipListMap  
缺点：无法对数据排序**

package com.zr.concurrency.test.safe.concurrentcontainer;
    
    import com.zr.concurrency.annotation.ThreadSafe;
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.Map;
    import java.util.concurrent.*;
    
    /** * @description: 使用并发容器ConcurrentHashMap实现线程安全 * ConcurrentHashMap是Java中的一个线程安全且高效的HashMap实现，处理高并发 * 与ConcurrentSkipListMap相比，ConcurrentHashMap底层使用的是哈希表，ConcurrentSkipListMap使用的是红黑树 * 优点：ConcurrentHashMap性能和存储空间优于ConcurrentSkipListMap * 缺点：无法对数据排序， * @author: liangrui * @create: 2020-01-03 12:20 **/
    @Slf4j
    @ThreadSafe
    public class ConcurrentHashMapExample { 
        //请求总数
        private static int clientTotal=5000;
        //并发线程总数
        private static int threadTotal=200;
        //创建ConcurrentHashMap并发容器
        private static Map<Integer,Integer> map=new ConcurrentHashMap<>();
    
        /** * 每个线程执行的任务 * @param i */
        private static void update(int i){ 
            map.put(i,i);
        }
    
        public static void main(String[] args) throws InterruptedException { 
            //创建线程池
            ExecutorService executorService= Executors.newCachedThreadPool();
            //控制并发执行线程数
            Semaphore semaphore=new Semaphore(threadTotal);
            //创建CountDownLatch类计数线程执行次数，执行clientTotal.countDown()方法，从clientTotal开始计数每次-1，当执行到0，调用clientTotal.await()方法放行
            CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
            for (int i = 0; i < clientTotal; i++) { 
                //因为lambda表达式中的变量必须为final
                final Integer num=i;
                executorService.execute(
                        ()->{ 
                            try{ 
                                //200个并发线程许可1个线程执行
                                semaphore.acquire();
                                //执行任务
                                update(num);
                                //释放线程
                                semaphore.release();
                            }catch (Exception e){ 
                                log.error("exception",e);
                            }
                            //总线程数-1
                            countDownLatch.countDown();;
                        }
                );
            }
            //当线程计数到0，此方法才执行，线程不再封闭
            countDownLatch.await();
            //关闭线程池
            executorService.shutdown();
            //输出map的元素个数
            log.info("size:{}",map.size());
        }
    }

输出结果：

14:14:47.553 [main] INFO com.zr.concurrency.test.safe.concurrentcontainer.ConcurrentHashMapExample - size:5000

## 2.ConcurrentSkipListMap ##

**ConcurrentSkipListMap是Java中的一个线程安全且高效的TreeMap实现，处理高并发  
与ConcurrentHashMap相比，ConcurrentSkipListMap底层使用的是红黑树，ConcurrentHashMap使用的是哈希表  
优点：可以对数据排序  
缺点：无明显缺点**

package com.zr.concurrency.test.safe.concurrentcontainer;
    
    import com.zr.concurrency.annotation.ThreadSafe;
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.Map;
    import java.util.concurrent.*;
    
    /** * @description: 使用并发容器ConcurrentSkipListMap实现线程安全 * ConcurrentSkipListMap是Java中的一个线程安全且高效的TreeMap实现，处理高并发 * 与ConcurrentHashMap相比，ConcurrentSkipListMap底层使用的是红黑树，ConcurrentHashMap使用的是哈希表 * 优点：可以对数据排序 * 缺点：无明显缺点 * @author: liangrui * @create: 2020-01-03 12:20 **/
    @Slf4j
    @ThreadSafe
    public class ConcurrentSkipListMapExample { 
        //请求总数
        private static int clientTotal=5000;
        //并发线程总数
        private static int threadTotal=200;
        //创建ConcurrentSkipListMap并发容器
        private static Map<Integer,Integer> map=new ConcurrentSkipListMap<>();
    
        /** * 每个线程执行的任务 * @param i */
        private static void update(int i){ 
            map.put(i,i);
        }
    
        public static void main(String[] args) throws InterruptedException { 
            //创建线程池
            ExecutorService executorService= Executors.newCachedThreadPool();
            //控制并发执行线程数
            Semaphore semaphore=new Semaphore(threadTotal);
            //创建CountDownLatch类计数线程执行次数，执行clientTotal.countDown()方法，从clientTotal开始计数每次-1，当执行到0，调用clientTotal.await()方法放行
            CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
            for (int i = 0; i < clientTotal; i++) { 
                //因为lambda表达式中的变量必须为final
                final Integer num=i;
                executorService.execute(
                        ()->{ 
                            try{ 
                                //200个并发线程许可1个线程执行
                                semaphore.acquire();
                                //执行任务
                                update(num);
                                //释放线程
                                semaphore.release();
                            }catch (Exception e){ 
                                log.error("exception",e);
                            }
                            //总线程数-1
                            countDownLatch.countDown();;
                        }
                );
            }
            //当线程计数到0，此方法才执行，线程不再封闭
            countDownLatch.await();
            //关闭线程池
            executorService.shutdown();
            //输出map的元素个数
            log.info("size:{}",map.size());
        }
    }

运行结果：

14:16:23.298 [main] INFO com.zr.concurrency.test.safe.concurrentcontainer.ConcurrentSkipListMapExample - size:5000