ConcurrentHashMap

最新推荐文章于 2023-05-19 14:44:12 发布
最新推荐文章于 2023-05-19 14:44:12 发布
阅读量232 收藏
点赞数
分类专栏： Centos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq5132834/article/details/80583600
版权 
package com.paic.hm.openfire.dubbo;

import java.util.concurrent.ConcurrentHashMap;

import org.apache.commons.lang.StringUtils;
import org.jivesoftware.util.JiveGlobals;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.MonitorConfig;
import com.alibaba.dubbo.config.ProtocolConfig;
import com.alibaba.dubbo.config.ReferenceConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.alibaba.dubbo.config.ServiceConfig;
import com.alibaba.dubbo.config.utils.ReferenceConfigCache;
import com.alibaba.dubbo.rpc.service.GenericService;
import com.paic.diamond.common.Config;
import com.paic.hm.openfire.cluster.ClusterConstants;
import com.paic.hm.openfire.cluster.packet.PacketRouter;
import com.paic.hm.openfire.cluster.packet.PacketRouterImpl;
import com.paic.hm.openfire.cluster.session.SessionOperation;
import com.paic.hm.openfire.cluster.session.SessionOperationImpl;
import com.paic.hm.openfire.dubbo.service.CommonPropertyService;
import com.paic.hm.openfire.dubbo.service.ConversationListDubboService;
import com.paic.hm.openfire.dubbo.service.HttpRouteDubboService;
import com.paic.hm.openfire.dubbo.service.IQDubboService;
import com.paic.hm.openfire.dubbo.service.MessageDubboService;
import com.paic.hm.openfire.dubbo.service.OfflineMessageDubboService;
import com.paic.hm.openfire.dubbo.service.OfflineMessageNewDubboService;
import com.paic.hm.openfire.dubbo.service.OnlineUserSessionService;
import com.paic.hm.openfire.dubbo.service.ResourceDubboService;
import com.paic.hm.openfire.dubbo.service.SfpOfflineMessageDubboService;
import com.paic.hm.openfire.dubbo.service.impl.CommonPropertyServiceImpl;
import com.paic.hm.openfire.dubbo.service.impl.ConversationListDubboServiceImpl;
import com.paic.hm.openfire.dubbo.service.impl.HttpRouteDubboServiceImpl;
import com.paic.hm.openfire.dubbo.service.impl.IQDubboServiceImpl;
import com.paic.hm.openfire.dubbo.service.impl.MessageDubboServiceImpl;
import com.paic.hm.openfire.dubbo.service.impl.OfflineMessageDubboServiceImpl;
import com.paic.hm.openfire.dubbo.service.impl.OfflineMessageNewDubboServiceImpl;
import com.paic.hm.openfire.dubbo.service.impl.OnlineUserSessionServiceImpl;
import com.paic.hm.openfire.dubbo.service.impl.ResourceDubboServiceImpl;
import com.paic.hm.openfire.dubbo.service.impl.SfpOfflineMessageDubboServiceImpl;
import com.paic.hm.openfire.dubbo.util.CommonProperyKey;
import com.paic.hm.openfire.util.UserCommonUtils;

public class DubboBeanContainer {
	
	private static final Logger Log = LoggerFactory.getLogger(DubboBeanContainer.class);
	
	private static ApplicationConfig application;
	private static RegistryConfig registry;
	private static ProtocolConfig protocol;
	private static MonitorConfig monitor;
	private static String group;
	

	private static ConcurrentHashMap<String,GenericService> serviceMap = new ConcurrentHashMap<String,GenericService>();
	private static DubboBeanContainer instance = new DubboBeanContainer();
	
	public static DubboBeanContainer getInstance() {
//		if (instance == null) {
//			synchronized (DubboBeanContainer.class) {
//				if (instance == null) {
//					instance = new DubboBeanContainer();					
//				}
//			}
//		}
		return instance;
	}
	
	/**
	 * 初始化配置
	 */
	private void initConfig() {
		// 当前应用配置
		application = new ApplicationConfig();
		application.setName(JiveGlobals.getProperty("dubbo.config.application_name", "hm-core"));

		String zk_address = JiveGlobals.getProperty(UserCommonUtils.HM_ZK_ADDRESS,UserCommonUtils.DEFAULT_ZK_ADDRESS);
		String zk_port = JiveGlobals.getProperty(UserCommonUtils.HM_ZK_PORT,UserCommonUtils.DEFAULT_ZK_PORT);
		Log.info("*************** hm_core zookeeper服务 address： " + zk_address + ", port: " + zk_port);
		
		registry = new RegistryConfig();
		registry.setAddress(zk_address);

		// 服务提供者协议配置
		protocol = new ProtocolConfig();
		protocol.setName("dubbo");
		protocol.setThreads(JiveGlobals.getIntProperty("dubbo.config.threads.cnt", 200));
		protocol.setPort(Integer.valueOf(zk_port));

		monitor = new MonitorConfig();
		monitor.setProtocol("registry");
		
		// wangqiang406 2014-08-07 
		// 为了支持灰度和vip环境, 改为先从配置文件读
		group = getDubboConfigGroup();
		Log.info("dubbo.config.group:" + group);
	}
	
	/**
	 * 读dubbo group配置
	 * 优先从配置文件读, 读不到再按以前的逻辑读数据库配置
	 * 
	 * @return dubbo group
	 */
	private String getDubboConfigGroup(){
		String group = Config.getInstance().getProperty("dubbo.config.group", "");;
		if(StringUtils.isNotEmpty(group)){
			return group;
		}
		return getDubboConfigGroupFromDB();
	}
	
	/**
	 * 从数据库读配置文件	 * 
	 * @return
	 */
	private String getDubboConfigGroupFromDB(){
		//现在有多个组，txt,pay,pasc
		return JiveGlobals.getProperty(CommonProperyKey.HM_ENV, CommonProperyKey.DEFAULT_HM_ENV);
	}
	
	private DubboBeanContainer(){
		//dubbo的治理中心，使用前访问一下  http://10.25.22.222:8180/dubbo/governance/services
		// 用户名密码  root/root
		

		//========================== openfire 调用第三方服务======================
		//
		
		// 当前应用配置
//		ApplicationConfig application = new ApplicationConfig();
//		application.setName("hm_core"); // 连接注册中心配置
//		
//		RegistryConfig registry = new RegistryConfig();
//		registry.setAddress("zookeeper://10.13.48.77:2181");
		registry.setRegister(false);
//		registry.setPort(20880);
//		
//		MonitorConfig monitor = new MonitorConfig();
//		monitor.setProtocol("registry");
//		
//		
//		ReferenceConfig<GenericService> reference = new ReferenceConfig<GenericService>(); // 该实例很重量，里面封装了所有与注册中心及服务提供方连接，请缓存
//		
//		reference.setApplication(application);
//		reference.setRegistry(registry);
//		reference.setMonitor(monitor);
//		reference.setInterface("com.paic.hm.friends.facade.CommonAccountPlatFacade"); // 弱类型接口名 
//		reference.setGroup("txt");
//		reference.setVersion("1.0.0"); 
//		reference.setGeneric(true); // 声明为泛化接口
//		reference.setCheck(false);
//		
//		
//		GenericService genericService = reference.get(); // 用com.alibaba.dubbo.rpc.service.GenericService可以替代所有接口引用
//		
//		// 基本类型以及Date,List,Map等不需要转换，直接调用 
//		Object result = genericService.$invoke("sayHello", new String[] {"java.lang.String"}, new Object[] {"world"});
//		System.out.println("invoke simple result============" + (String)result);
//		
//		
//		
//		
//		// 用Map表示POJO参数，如果返回值为POJO也将自动转成Map 
//		Map<String, Object> article = new HashMap<String, Object>(); 
//		article.put("username", "zy"); 
//		article.put("article", "who am i？"); 
//		
//		Object result2 = genericService.$invoke("sayHello2", 
//												new String[] {"com.paic.hm.friends.facade.dto.ArticleDtoTest"}, 
//												new Object[] {article});
//		
//		
//		List<Map<String,Object>> rest = (List<Map<String,Object>>)result2;
//		
//		for(Map<String,Object> map : rest){
//			for(String key : map.keySet()){
//				System.out.println("=====================" + map.get(key));
//				
//			}
//		}
//		
		
		try {
			initConfig();

			// ===========================openfire 暴露服务给第三方调用
			// ================================
			/*
			 * 公共配置查询接口配置
			 */
			CommonPropertyService commonPropertyService = new CommonPropertyServiceImpl();
			dubboServiceConfig(new ServiceConfig<CommonPropertyService>(),
					CommonPropertyService.class, commonPropertyService);

			/*
			 * 消息通知接口配置
			 */
			MessageDubboService messageDubboService = new MessageDubboServiceImpl();
			dubboServiceConfig(new ServiceConfig<MessageDubboService>(),MessageDubboService.class, messageDubboService);
			
			/**
			 * 离线消息Duboo接口
			 */
			OfflineMessageDubboService offlineMessageDubboService = new OfflineMessageDubboServiceImpl();
			dubboServiceConfig(new ServiceConfig<OfflineMessageDubboService>(), OfflineMessageDubboService.class, offlineMessageDubboService);
			
			/**
			 * 离线消息新Duboo接口
			 */
			OfflineMessageNewDubboService offlineMessageNewDubboService = new OfflineMessageNewDubboServiceImpl();
			dubboServiceConfig(new ServiceConfig<OfflineMessageNewDubboService>(), OfflineMessageNewDubboService.class, offlineMessageNewDubboService);
			
			/**
			 * 登陆token相关接口
			 * 
			 */
			ResourceDubboService resourceDubboService = new ResourceDubboServiceImpl();
			dubboServiceConfig(new ServiceConfig<ResourceDubboService>(), ResourceDubboService.class, resourceDubboService);
			
			/**
			 * 在线用户session管理接口
			 * 
			 */
			OnlineUserSessionService onlineUserSessionService = OnlineUserSessionServiceImpl.getInstance();
			dubboServiceConfig(new ServiceConfig<OnlineUserSessionService>(), OnlineUserSessionService.class,onlineUserSessionService);

			//IQ 对外接口
			IQDubboService iqService = new IQDubboServiceImpl();
			dubboServiceConfig(new ServiceConfig<IQDubboService>(), IQDubboService.class, iqService);
			
			
			SessionOperation sessionOpration = new SessionOperationImpl();
			dubboLogicServiceConfig(new ServiceConfig<SessionOperation>(), SessionOperation.class, sessionOpration, ClusterConstants.DUBBO_LOGIC_GROUP);
			
			PacketRouter packetRouter = new PacketRouterImpl();
			dubboLogicServiceConfig(new ServiceConfig<PacketRouter>(), PacketRouter.class, packetRouter, ClusterConstants.DUBBO_LOGIC_GROUP);
		
			SfpOfflineMessageDubboService sfpOfflineMessageDubboService = new SfpOfflineMessageDubboServiceImpl();
			dubboServiceConfig(new ServiceConfig<SfpOfflineMessageDubboService>(), SfpOfflineMessageDubboService.class, sfpOfflineMessageDubboService);
			
			// 新版http路由消息接口
			HttpRouteDubboService httpRouteDubboService = new HttpRouteDubboServiceImpl();
			dubboServiceConfig(new ServiceConfig<HttpRouteDubboService>(), HttpRouteDubboService.class, httpRouteDubboService);
			
			// 会话列表接口
			ConversationListDubboService conversationService = new ConversationListDubboServiceImpl();
			dubboServiceConfig(new ServiceConfig<ConversationListDubboService>(), ConversationListDubboService.class, conversationService);
			Log.info("succeed in dispose dubbo service");
		} catch (Exception e) {
			Log.error("初始化dubbo接口配置失败", e);
		}

	}
	
	private <T> void groupDubboServiceConfig(ServiceConfig<T> service, Class<T> interfaceClass, T serviceBean) {
		service.setApplication(application);
		service.setRegistry(registry);
		service.setProtocol(protocol);
		service.setMonitor(monitor);
		service.setInterface(interfaceClass);
		service.setVersion("1.0.0");
		service.setGroup(group);
		service.setTimeout(6000);
		//设置接口实现类bean
		service.setRef(serviceBean);
		// 暴露及注册服务
		service.export();
		
	}
	
	
	/**
	 * 提供给外部调用的dubbo接口bean配置
	 * @param service
	 * @param clazz
	 */
	private <T> void dubboServiceConfig(ServiceConfig<T> service, Class<T> interfaceClass, T serviceBean) {
		service.setApplication(application);
		service.setRegistry(registry);
		service.setProtocol(protocol);
		service.setMonitor(monitor);
		service.setInterface(interfaceClass);
		service.setVersion("1.0.0");
		service.setGroup(group);
		
		//设置接口实现类bean
		service.setRef(serviceBean);
		// 暴露及注册服务
		service.export();
		
	}

	private <T> void dubboLogicServiceConfig(ServiceConfig<T> service, Class<T> interfaceClass, T serviceBean,String group) {
		service.setApplication(application);
		service.setRegistry(registry);
		service.setProtocol(protocol);
		service.setMonitor(monitor);
		service.setInterface(interfaceClass);
		service.setVersion("1.0.0");
		service.setGroup(group);
		
		//设置接口实现类bean
		service.setRef(serviceBean);
		// 暴露及注册服务
		service.export();
	}
	
	
	/**
	 * 获取要调用的dubbo接口
	 * 除调用UM以外的dubbo接口都使用这个方法
	 * 因为只有openfire和um区分多套环境
	 * 
	 * @param interfaceName 接口名路径
	 * @return
	 */
	public GenericService getServiceNotUM(String interfaceName){
		// 从db读group, 忽略配置文件
		String _group = getDubboConfigGroupFromDB();
		return getService(interfaceName,_group);
	}
	
	/**
	 * 获取要调用的dubbo接口
     * 只有调用UM的dubbo接口才使用这个方法
     * 因为只有openfire和um区分多套环境
     * 
	 * @param interfaceName 接口名路径
	 * @return
	 */
	public GenericService getService(String interfaceName){	
			return getService(interfaceName, group, null);
	}
	
	/**
	 * 获取要调用的dubbo接口
	 * 
	 * @param interfaceName 接口名路径
	 * @param group
	 * @return
	 */
	public GenericService getService(String interfaceName, String _group){
		return getService(interfaceName, _group, null);
	}
	
	public GenericService getServiceWirhCluster(String interfaceName, String cluster){
		return getService(interfaceName, group, cluster);
	}
	
	public SessionOperation getSessionOperation(){

		if(application == null){
			new DubboBeanContainer();
		}
		
		// 该实例很重量，里面封装了所有与注册中心及服务提供方连接，请缓存
		ReferenceConfig<SessionOperation> reference = new ReferenceConfig<SessionOperation>(); 
		
		reference.setApplication(application);
		reference.setRegistry(registry);
		reference.setMonitor(monitor);
		reference.setInterface(SessionOperation.class);  
		reference.setGroup(ClusterConstants.DUBBO_LOGIC_GROUP);
		reference.setVersion("1.0.0"); 
		reference.setTimeout(500);
		reference.setCheck(false);
		reference.setScope(ClusterConstants.DUBBO_REMOTE);
		reference.setCluster(ClusterConstants.DUBBO_CLUSTER);	//新的路由Cluster

		ReferenceConfigCache cache = ReferenceConfigCache.getCache();
		SessionOperation sessionOperation = cache.get(reference);  
		return sessionOperation;
	}
	
	public PacketRouter getPacketRouter(){
		if(application == null){
			new DubboBeanContainer();
		}
		// 该实例很重量，里面封装了所有与注册中心及服务提供方连接，请缓存
		ReferenceConfig<PacketRouter> reference = new ReferenceConfig<PacketRouter>(); 
		
		reference.setApplication(application);
		reference.setRegistry(registry);
		reference.setMonitor(monitor);
		reference.setInterface(PacketRouter.class);  
		reference.setGroup(ClusterConstants.DUBBO_LOGIC_GROUP);
		reference.setVersion("1.0.0"); 
		reference.setTimeout(500);
		reference.setCheck(false);
		reference.setScope(ClusterConstants.DUBBO_REMOTE);
		reference.setCluster(ClusterConstants.DUBBO_CLUSTER);	//新的路由Cluster

		ReferenceConfigCache cache = ReferenceConfigCache.getCache();
		PacketRouter packetRouter = cache.get(reference); 
		
		return packetRouter;
	}
	
	
	/**
	 * 获取要调用的dubbo接口
	 * 
	 * @param interfaceName 接口名路径
	 * @param group
	 * @return
	 */
	private GenericService getService(String interfaceName, String _group, String cluster){

		if(application == null){
			new DubboBeanContainer();
		}

		if(serviceMap.containsKey(interfaceName)){
			return serviceMap.get(interfaceName);
		}else{
			// 该实例很重量，里面封装了所有与注册中心及服务提供方连接，请缓存
			ReferenceConfig<GenericService> reference = new ReferenceConfig<GenericService>(); 
			
			reference.setApplication(application);
			reference.setRegistry(registry);
			reference.setMonitor(monitor);
			reference.setInterface(interfaceName); // 弱类型接口名 
			reference.setGroup(_group);
			reference.setVersion("1.0.0"); 
			reference.setTimeout(30000);
			reference.setGeneric(true); // 声明为泛化接口
			reference.setCheck(false);
			if(cluster!=null && (!"".equals(cluster)))
				reference.setCluster(cluster);
			
			// 用com.alibaba.dubbo.rpc.service.GenericService可以替代所有接口引用
			GenericService genericService = reference.get();
			
			Log.info("interfaceName=" + interfaceName + ",group=" + _group);
			
			serviceMap.putIfAbsent(interfaceName, genericService);
			
			return genericService;
		}

	}
	
	public GenericService getServiceWithoutGroup(String interfaceName){
		if(application == null){
			new DubboBeanContainer();
		}

		if(serviceMap.containsKey(interfaceName)){
			return serviceMap.get(interfaceName);
		}else{
			// 该实例很重量，里面封装了所有与注册中心及服务提供方连接，请缓存
			ReferenceConfig<GenericService> reference = new ReferenceConfig<GenericService>(); 
			
			reference.setApplication(application);
			reference.setRegistry(registry);
			reference.setMonitor(monitor);
			reference.setInterface(interfaceName); // 弱类型接口名 
//			reference.setGroup(group);
			reference.setVersion("1.0.0"); 
			reference.setGeneric(true); // 声明为泛化接口
			reference.setCheck(false);
			
			// 用com.alibaba.dubbo.rpc.service.GenericService可以替代所有接口引用
			GenericService genericService = reference.get();
			
			Log.info("interfaceName=" + interfaceName);
			
			serviceMap.putIfAbsent(interfaceName, genericService);
			
			return genericService;	
		}
	}

}

JDK8中ConCurrentHashMap源码详解，以及原理
保暖透气大裤衩LeoLee的博客
03-13 428
初始化 ConcurrentHashMap<String, Object> cMap = new ConcurrentHashMap<>(); 默认的构造方法中是空方法，数组的长度默认是16，在第一次put操作的时候进行数组的初始化。 /** * Creates a new, empty map with the default initial table size (16). */ public ConcurrentHashMap() { } 但是在实际的使用中，如
第二章 ConcurrentHashMap源码解析
weixin_34363171的博客
01-08 111
注：在看这篇文章之前，如果对HashMap的层不清楚的话，建议先去看看HashMap源码解析。 http://www.cnblogs.com/java-zhao/p/5106189.html 1、对于ConcurrentHashMap需要掌握以下几点 Map的创建：ConcurrentHashMap() 往Map中添加键值对：即put(Object key, Object value)...
ConcurrentHashMap源码阅读03
js_tengzi的博客
11-26 485
为了更快速方便地理解ConcurrentHashMap的设计原理，这篇文章我们主要从以下几个视角来探讨ConcurrentHashMap的内部实现：内部结构、初始化、put操作的不同情况、扩容流程、线程安全及红黑树的转化等。
hashmap put 过程
雪雪
05-19 554
而红黑树在插入新数据后可能需要通过左旋，右旋、变色这些操作来保持平衡，引入红黑树就是为了查找数据快，解决链表查询深度的问题，我们知道红黑树属于自平衡二叉树，但是为了保持“平衡”是需要付出代价的，但是该代价所损耗的资源要比遍历线性链表要少，之所以选择红黑树是为了解决二叉查找树的缺陷，二叉查找树在特殊情况下会变成一条线性结构（这就跟原来使用链表结构一样了，造成很深的问题），遍历查找会非常慢。所以当长度大于8的时候，会使用红黑树，如果链表长度很短的话，根本不需要引入红黑树，引入反而会慢。
Map--06 ---Map中常用方法
时光里的博客
11-09 258
Map中常用方法 添加、删除、修改操作： Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中 void putAll(Map m):将m中的所有key-value对存放到当前map中 Object remove(Object key)：移除指定key的key-value对，并返回value void clear()：清空当前map中的所有数据 元素查询的操作： Object get(Object key)：获取指定key对
Java中遍历ConcurrentHashMap的四种方式详解
08-25
Java中遍历ConcurrentHashMap的四种方式详解 Java中遍历ConcurrentHashMap的四种方式详解是Java开发中一个非常重要的知识点。ConcurrentHashMap是Java中一种高效且线程安全的HashMap实现，它提供了高效的读写操作...
Java并发系列之ConcurrentHashMap源码分析
08-27
Java并发系列之ConcurrentHashMap源码分析 ConcurrentHashMap是Java中一个高性能的哈希表实现，它解决了HashTable的同步问题，允许多线程同时操作哈希表，从而提高性能。 1. ConcurrentHashMap的成员变量： ...
JDK1.8中ConcurrentHashMap中computeIfAbsent死循环bug问题
08-24
JDK1.8中ConcurrentHashMap中computeIfAbsent死循环bug问题 JDK1.8中ConcurrentHashMap中computeIfAbsent方法是一个非常重要的方法，它可以让开发者在键不存在时，提供一个默认值作为回应。但是，在JDK1.8中，这个...
Java利用ConcurrentHashMap实现本地缓存demo
05-25
Java利用ConcurrentHashMap实现本地缓存demo； 基本功能有缓存有效期、缓存最大数、缓存存入记录、清理线程、过期算法删除缓存、LRU算法删除、获取缓存值等功能。 复制到本地项目的时候，记得改包路径哦~
hashmap put过程_HashMap
weixin_39949894的博客
11-29 177
前言：容器是java中尤为重要的章节，都是实现一个map的接口，key-value这样的数据结构常用于内存存放数据，接下来我就跟着源码讲解hashmap！1.首先们先打开Hashmap的源码java版本的更新首先我们先讲讲jdk1.7的hashmap在jdk1.7中hashmap底层是数组+链表的结构：上面源码中比较核心的几个源码代表的含义： （1）static final int ...
Jdk1.8下ConcurrentHashMap常用方法的源码分析
放牛娃的博客
07-13 260
1.首先从下面这段代码开始分析 ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>(); map.put("123", "1"); map.put("234", "2"); System.out.println(map.get("123")); System.out.println(map.size()); 2.我们先从put方法看起 public V put(K key, V value) {
HashMap的put过程
qq_51405587的博客
06-01 1466
1.put方法会判断当前HasHMap是否为null或长度是否为0。 2.根据key计算哈希码得到数组位置。 3.判断key是否为null、不为null说明数据存在将vAmalie覆盖、为null说明数据不存在。 4.判断数组后的链是否为红黑树、为红黑树就已k-v格式存储。 4.不为红黑树那就是链表、put方法遍历链表。 5.在遍历链表过程中判断数组长度是否大于8如果大于则使用红黑树k-v格式存储。 6.小于则判断链表中的key是否为null、为null直接插入、不为null则覆盖。 7.判断数组长度是否大
阿里面试官：HashMap数据结构之道
06-28 240
问题1：HashMap的数据结构是什么样的？ 同学1：嗯...数组+链表 同学2：数组+链表... 同学3：数组+链表... 同学4：数组+链表+红黑树... 同学n：..... 为什么答案会有两种？难道大家学习的HashMap有两个版本？我突然想起马克思哲学里面的...
HashMap put过程
青耕
12-16 1166
put方法 JDK8 /** * Associates the specified value with the specified key in this map. * If the map previously contained a mapping for the key, the old * value is replaced. * * @param key key with w...
ConcurrentHashmap
最新发布
01-15
### Java `ConcurrentHashMap` 使用与特性 #### 特性概述 `ConcurrentHashMap` 是线程安全的哈希表实现，在高并发环境下提供了高效的读写性能。不同于传统的同步集合类通过锁定整个容器来保证线程安全性，`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值