Java Code Examples for java.util.concurrent.ConcurrentHashMap

@Override
public Object writeTransform(Field f, Class<?> clazz, Object originalValue) {
  if (f.getType().equals(ConcurrentHashMap.class)) {
    Object[] result = null;
    if (originalValue != null) {
      ConcurrentHashMap<?, ?> m = (ConcurrentHashMap<?, ?>) originalValue;
      result = new Object[m.size() * 2];
      int i = 0;
      for (Map.Entry<?, ?> e : m.entrySet()) {
        result[i++] = e.getKey();
        result[i++] = e.getValue();
      }
    }
    return result;
  } else {
    return super.writeTransform(f, clazz, originalValue);
  }
}
 

OKEventBus(EventBusBuilder builder) {
    logger = builder.getLogger();
    subscriptionsByEventType = new HashMap<>();
    typesBySubscriber = new HashMap<>();
    stickyEvents = new ConcurrentHashMap<>();
    mainThreadSupport = builder.getMainThreadSupport();
    mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
    backgroundPoster = new BackgroundPoster(this);
    asyncPoster = new AsyncPoster(this);
    indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
    subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
            builder.strictMethodVerification, builder.ignoreGeneratedIndex);
    logSubscriberExceptions = builder.logSubscriberExceptions;
    logNoSubscriberMessages = builder.logNoSubscriberMessages;
    sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
    sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
    throwSubscriberException = builder.throwSubscriberException;
    eventInheritance = builder.eventInheritance;
    executorService = builder.executorService;
}
 

@Override
public boolean clearExpired(Date date) {
    boolean clearedAny = false;
    SharedPreferences.Editor prefsWriter = cookiePrefs.edit();

    for (ConcurrentHashMap.Entry<String, Cookie> entry : cookies.entrySet()) {
        String name = entry.getKey();
        Cookie cookie = entry.getValue();
        if (cookie.isExpired(date)) {
            // Clear cookies from local store
            cookies.remove(name);

            // Clear cookies from persistent store
            prefsWriter.remove(COOKIE_NAME_PREFIX + name);

            // We've cleared at least one
            clearedAny = true;
        }
    }

    // Update names in persistent store
    if (clearedAny) {
        prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));
    }
    prefsWriter.apply();

    return clearedAny;
}
 

public static final String getPojoSetter(ProtobufAttribute protobufAttribute, Field field) {
  final String fieldName = field.getName();
  final String upperClassName = field.getDeclaringClass().getCanonicalName();
  // Look at the cache first
  Map<String, String> map = CLASS_TO_FIELD_SETTERS_MAP_CACHE.get(upperClassName);
  if (map != null) {
    if (!map.isEmpty() && map.containsKey(fieldName)) {
      return map.get(fieldName);
    }
  } else {
    map = new ConcurrentHashMap<>();
  }
  final String upperCaseFirstFieldName = JStringUtils.upperCaseFirst(field.getName());
  String setter = "set" + upperCaseFirstFieldName;
  if (!protobufAttribute.pojoSetter().isEmpty()) {
    return protobufAttribute.pojoSetter();
  }
  CLASS_TO_FIELD_SETTERS_MAP_CACHE.put(upperClassName, map);
  return setter;
}
 

/**
 * Mapped forEachEntrySequentially traverses the given
 * transformations of all entries
 */
public void testMappedForEachEntrySequentially() {
    LongAdder adder = new LongAdder();
    ConcurrentHashMap<Long, Long> m = longMap();
    m.forEachEntry(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
                               (Long x) -> adder.add(x.longValue()));
    assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
}
 

public void initialize() {
  receivedAcks = new ConcurrentHashSet<>();

  pingPonger = new GMSPingPonger();
  // UUID logicalAddress = (UUID) channel.getAddress();
  // IpAddress ipaddr = (IpAddress) channel.down(new Event(Event.GET_PHYSICAL_ADDRESS));
  //
  // myAddress = new JGAddress(logicalAddress, ipaddr);
  myAddress = (JGAddress) channel.down(new Event(Event.GET_LOCAL_ADDRESS));

  addressConversionMap = new ConcurrentHashMap<>(this.lastView.size());
  List<InternalDistributedMember> members = this.lastView.getMembers();
  for (InternalDistributedMember addr : members) {
    SocketAddress sockaddr =
        new InetSocketAddress(addr.getNetMember().getInetAddress(), addr.getPort());
    addressConversionMap.put(sockaddr, addr);
  }

  isDebugEnabled = logger.isDebugEnabled();
  resume();
}
 

public boolean cacheStatement(CachedStatement proxy) {
    @SuppressWarnings("unchecked")
    ConcurrentHashMap<CacheKey,CachedStatement> cache =
        (ConcurrentHashMap<CacheKey,CachedStatement>)pcon.getAttributes().get(STATEMENT_CACHE_ATTR);
    if (proxy.getCacheKey()==null) {
        return false;
    } else if (cache.containsKey(proxy.getCacheKey())) {
        return false;
    } else if (cacheSize.get()>=maxCacheSize) {
        return false;
    } else if (cacheSize.incrementAndGet()>maxCacheSize) {
        cacheSize.decrementAndGet();
        return false;
    } else {
        //cache the statement
        cache.put(proxy.getCacheKey(), proxy);
        return true;
    }
}
 

/**
 * Remove the target.
 *
 * @param subscribedMethods the subscribed methods.
 * @param mTargetMap        the target map.
 * @param targetObject      the target object.
 */
private void removeTargetIfRequired(ConcurrentHashMap<String, SubscriberHolder> subscribedMethods,
                                    ConcurrentHashMap<Object,
                                            ConcurrentHashMap<String, SubscriberHolder>> mTargetMap,
                                    Object targetObject) {
    if (subscribedMethods.size() == 0) {
        mTargetMap.remove(targetObject);
    }
}
 

@Override
protected void notify(URL url, NotifyListener listener, List<URL> urls) {
    if (url == null) {
        throw new IllegalArgumentException("notify url == null");
    }
    if (listener == null) {
        throw new IllegalArgumentException("notify listener == null");
    }
    try {
    	doNotify(url, listener, urls);
    } catch (Exception t) {
        // 将失败的通知请求记录到失败列表，定时重试
        Map<NotifyListener, List<URL>> listeners = failedNotified.get(url);
        if (listeners == null) {
            failedNotified.putIfAbsent(url, new ConcurrentHashMap<NotifyListener, List<URL>>());
            listeners = failedNotified.get(url);
        }
        listeners.put(listener, urls);
        logger.error("Failed to notify for subscribe " + url + ", waiting for retry, cause: " + t.getMessage(), t);
    }
}
 

private ConcurrentHashMap<String, Integer> buildVocabulary(InputStream input) throws IOException {

		ConcurrentHashMap<String, Integer> vocabulary = new ConcurrentHashMap<>();

		try (BufferedReader buffer = new BufferedReader(new InputStreamReader(input))) {
			String l = buffer.readLine();
			while (l != null ) {
				String p[] = l.split(",");
				if (p[1].length() > 1) {
					vocabulary.put(p[0], Integer.valueOf(p[1]));
				}
				l = buffer.readLine();
			}
		}
		return vocabulary;
	}
 

public synchronized void preferProportionalFonts() {
    if (FontUtilities.isLogging()) {
        FontUtilities.getLogger()
            .info("Entered preferProportionalFonts().");
    }
    /* If no proportional fonts are configured, there's no need
     * to take any action.
     */
    if (!FontConfiguration.hasMonoToPropMap()) {
        return;
    }

    if (!maybeMultiAppContext()) {
        if (gPropPref == true) {
            return;
        }
        gPropPref = true;
        createCompositeFonts(fontNameCache, gLocalePref, gPropPref);
        _usingAlternateComposites = true;
    } else {
        AppContext appContext = AppContext.getAppContext();
        if (appContext.get(proportionalFontKey) == proportionalFontKey) {
            return;
        }
        appContext.put(proportionalFontKey, proportionalFontKey);
        boolean acLocalePref =
            appContext.get(localeFontKey) == localeFontKey;
        ConcurrentHashMap<String, Font2D>
            altNameCache = new ConcurrentHashMap<String, Font2D> ();
        /* If there is an existing hashtable, we can drop it. */
        appContext.put(CompositeFont.class, altNameCache);
        _usingPerAppContextComposites = true;
        createCompositeFonts(altNameCache, acLocalePref, true);
    }
}
 

/**
 * 获取消费者分组消费的topic;
 * @param group
 * @return
 */
public Set<String> whichTopicByConsumer(final String group) {
    Set<String> topics = new HashSet<String>();

    Iterator<Entry<String, ConcurrentHashMap<Integer, Long>>> it = this.offsetTable.entrySet().iterator();
    while (it.hasNext()) {
        Entry<String, ConcurrentHashMap<Integer, Long>> next = it.next();
        String topicAtGroup = next.getKey();
        String[] arrays = topicAtGroup.split(TOPIC_GROUP_SEPARATOR);
        if (arrays != null && arrays.length == 2) {
            if (group.equals(arrays[1])) {
                topics.add(arrays[0]);
            }
        }
    }

    return topics;
}
 

private void addCnxn(NIOServerCnxn cnxn) {
    InetAddress addr = cnxn.getSocketAddress();
    Set<NIOServerCnxn> set = ipMap.get(addr);
    if (set == null) {
        // in general we will see 1 connection from each
        // host, setting the initial cap to 2 allows us
        // to minimize mem usage in the common case
        // of 1 entry --  we need to set the initial cap
        // to 2 to avoid rehash when the first entry is added
        // Construct a ConcurrentHashSet using a ConcurrentHashMap
        set = Collections.newSetFromMap(
            new ConcurrentHashMap<NIOServerCnxn, Boolean>(2));
        // Put the new set in the map, but only if another thread
        // hasn't beaten us to it
        Set<NIOServerCnxn> existingSet = ipMap.putIfAbsent(addr, set);
        if (existingSet != null) {
            set = existingSet;
        }
    }
    set.add(cnxn);

    cnxns.add(cnxn);
    touchCnxn(cnxn);
}
 

@Override
public boolean clearExpired(Date date) {
    boolean clearedAny = false;
    SharedPreferences.Editor prefsWriter = cookiePrefs.edit();

    for (ConcurrentHashMap.Entry<String, Cookie> entry : cookies.entrySet()) {
        String name = entry.getKey();
        Cookie cookie = entry.getValue();
        if (cookie.isExpired(date)) {
            // Clear cookies from local store
            cookies.remove(name);

            // Clear cookies from persistent store
            prefsWriter.remove(COOKIE_NAME_PREFIX + name);

            // We've cleared at least one
            clearedAny = true;
        }
    }

    // Update names in persistent store
    if (clearedAny) {
        // This prevents map.keySet to compile to a Java 8+ KeySetView return type
        Map<String, Cookie> map = cookies;
        prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", map.keySet()));
    }
    prefsWriter.apply();

    return clearedAny;
}
 

@SuppressWarnings("unchecked")
public static void init(String esInfo, String context) {

    if (null == info) {
        info = JSONHelper.toObject(esInfo, Map.class);
    }

    if (null == httpAsyncClient) {
        Map<String, Integer> httpParamsMap = JSONHelper.toObject(context, Map.class);
        httpAsyncClient = HttpAsyncClientFactory.build(httpParamsMap.get("max.con"),
                httpParamsMap.get("max.tot.con"), httpParamsMap.get("sock.time.out"),
                httpParamsMap.get("con.time.out"), httpParamsMap.get("req.time.out"));
    }

    if (null == connectionMgrPool) {
        connectionMgrPool = new ConcurrentHashMap<String, ConnectionFailoverMgr>();
        String forwarUrl = getInfoValue("forwar.url");
        forwarUrl = forwarUrl.trim().replace("\n", "").replace("\r", "");
        ConnectionFailoverMgr cfm = ConnectionFailoverMgrHelper.getConnectionFailoverMgr(forwarUrl, 60000);
        connectionMgrPool.put("es.info.forwar.url", cfm);
    }

}
 

public MyCookieStore() {
    cookiePrefs = ToolCache.getContext().getSharedPreferences(COOKIE_PREFS, Context.MODE_PRIVATE);
    cookies = new HashMap<>();

    //将持久化的cookies缓存到内存中,数据结构为 Map<Url.host, Map<Cookie.name, Cookie>>
    Map<String, ?> prefsMap = cookiePrefs.getAll();
    for (Map.Entry<String, ?> entry : prefsMap.entrySet()) {
        if ((entry.getValue()) != null && !entry.getKey().startsWith(COOKIE_NAME_PREFIX)) {
            //获取url对应的所有cookie的key,用","分割
            String[] cookieNames = TextUtils.split((String) entry.getValue(), ",");
            for (String name : cookieNames) {
                //根据对应cookie的Key,从xml中获取cookie的真实值
                String encodedCookie = cookiePrefs.getString(COOKIE_NAME_PREFIX + name, null);
                if (encodedCookie != null) {
                    Cookie decodedCookie = decodeCookie(encodedCookie);
                    if (decodedCookie != null) {
                        if (!cookies.containsKey(entry.getKey()))
                            cookies.put(entry.getKey(), new ConcurrentHashMap<String, Cookie>());
                        cookies.get(entry.getKey()).put(name, decodedCookie);
                    }
                }
            }
        }
    }
}
 

/**
 * Construct a persistent cookie store.
 *
 * @param context Context to attach cookie store to
 */
public PersistentCookieStore(Context context) {
    cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, 0);
    cookies = new ConcurrentHashMap<String, Cookie>();

    // Load any previously stored cookies into the store
    String storedCookieNames = cookiePrefs.getString(COOKIE_NAME_STORE, null);
    if (storedCookieNames != null) {
        String[] cookieNames = TextUtils.split(storedCookieNames, ",");
        for (String name : cookieNames) {
            String encodedCookie = cookiePrefs.getString(COOKIE_NAME_PREFIX + name, null);
            if (encodedCookie != null) {
                Cookie decodedCookie = decodeCookie(encodedCookie);
                if (decodedCookie != null) {
                    cookies.put(name, decodedCookie);
                }
            }
        }

        // Clear out expired cookies
        clearExpired(new Date());
    }
}
 

@Override
public int cleanUnusedTopic(Set<String> topics) {
    Iterator<Entry<String, ConcurrentHashMap<Integer, ConsumeQueue>>> it = this.consumeQueueTable.entrySet().iterator();
    while (it.hasNext()) {
        Entry<String, ConcurrentHashMap<Integer, ConsumeQueue>> next = it.next();
        String topic = next.getKey();
        if (!topics.contains(topic) && !topic.equals(ScheduleMessageService.SCHEDULE_TOPIC)) {
            ConcurrentHashMap<Integer, ConsumeQueue> queueTable = next.getValue();
            for (ConsumeQueue cq : queueTable.values()) {
                cq.destroy();
                log.info("cleanUnusedTopic: {} {} ConsumeQueue cleaned",//
                    cq.getTopic(), //
                    cq.getQueueId() //
                );

                this.commitLog.removeQueurFromTopicQueueTable(cq.getTopic(), cq.getQueueId());
            }
            it.remove();

            log.info("cleanUnusedTopic: {},topic destroyed", topic);
        }
    }

    return 0;
}
 

private void checkCerts(String name, CodeSource cs) {
    int i = name.lastIndexOf('.');
    String pname = (i == -1) ? "" : name.substring(0, i);

    Certificate[] certs = null;
    if (cs != null) {
        certs = cs.getCertificates();
    }
    Certificate[] pcerts = null;
    if (parallelLockMap == null) {
        synchronized (this) {
            pcerts = package2certs.get(pname);
            if (pcerts == null) {
                package2certs.put(pname, (certs == null? nocerts:certs));
            }
        }
    } else {
        pcerts = ((ConcurrentHashMap<String, Certificate[]>)package2certs).
            putIfAbsent(pname, (certs == null? nocerts:certs));
    }
    if (pcerts != null && !compareCerts(pcerts, certs)) {
        throw new SecurityException("class \""+ name +
             "\"'s signer information does not match signer information of other classes in the same package");
    }
}
 

public ClientRMService createRMService() throws IOException {
  YarnScheduler yarnScheduler = mockYarnScheduler();
  RMContext rmContext = mock(RMContext.class);
  mockRMContext(yarnScheduler, rmContext);
  ConcurrentHashMap<ApplicationId, RMApp> apps = getRMApps(rmContext,
      yarnScheduler);
  when(rmContext.getRMApps()).thenReturn(apps);
  when(rmContext.getYarnConfiguration()).thenReturn(new Configuration());
  RMAppManager appManager = new RMAppManager(rmContext, yarnScheduler, null,
      mock(ApplicationACLsManager.class), new Configuration());
  when(rmContext.getDispatcher().getEventHandler()).thenReturn(
      new EventHandler<Event>() {
        public void handle(Event event) {
        }
      });

  ApplicationACLsManager mockAclsManager = mock(ApplicationACLsManager.class);
  QueueACLsManager mockQueueACLsManager = mock(QueueACLsManager.class);
  when(
      mockQueueACLsManager.checkAccess(any(UserGroupInformation.class),
          any(QueueACL.class), anyString())).thenReturn(true);
  return new ClientRMService(rmContext, yarnScheduler, appManager,
      mockAclsManager, mockQueueACLsManager, null);
}
 

private static void initNames() {
    ConcurrentMap<String,String> nameMap = new ConcurrentHashMap<>();

    // Associate a calendar name with its class name and the
    // calendar class name with its date class name.
    StringBuilder clName = new StringBuilder();
    for (int i = 0; i < namePairs.length; i += 2) {
        clName.setLength(0);
        String cl = clName.append(PACKAGE_NAME).append(namePairs[i+1]).toString();
        nameMap.put(namePairs[i], cl);
    }
    synchronized (CalendarSystem.class) {
        if (!initialized) {
            names = nameMap;
            calendars = new ConcurrentHashMap<>();
            initialized = true;
        }
    }
}
 

@Override
protected void notify(URL url, NotifyListener listener, List<URL> urls) {
    if (url == null) {
        throw new IllegalArgumentException("notify url == null");
    }
    if (listener == null) {
        throw new IllegalArgumentException("notify listener == null");
    }
    try {
        doNotify(url, listener, urls);
    } catch (Exception t) {
        // 将失败的通知请求记录到失败列表，定时重试
        Map<NotifyListener, List<URL>> listeners = failedNotified.get(url);
        if (listeners == null) {
            failedNotified.putIfAbsent(url, new ConcurrentHashMap<NotifyListener, List<URL>>());
            listeners = failedNotified.get(url);
        }
        listeners.put(listener, urls);
        logger.error("Failed to notify for subscribe " + url + ", waiting for retry, cause: " + t.getMessage(), t);
    }
}
 

protected static void put(Class clz, List list) {
	Parsed parsed = Parser.get(clz);
	Map<String, Object> map1 = new ConcurrentHashMap<String, Object>();
	map.put(clz, map1);

	try {
		for (Object obj : list) {
			long idOne = parsed.getKeyField(X.KEY_ONE).getLong(obj);
			String key = getKey(clz, idOne);
			map1.put(key, obj);
		}
	} catch (Exception e) {
		e.printStackTrace();
	}

}
 

/**
 * Add group to cache
 *
 * @param group name of the group to add to cache
 * @param users list of users for a given group
 */
public static void add(String group, List<String> users) {
  for (String user : users) {
    Set<String> userGroups = userToNetgroupsMap.get(user);
    // ConcurrentHashMap does not allow null values; 
    // So null value check can be used to check if the key exists
    if (userGroups == null) {
      //Generate a ConcurrentHashSet (backed by the keyset of the ConcurrentHashMap)
      userGroups =
          Collections.newSetFromMap(new ConcurrentHashMap<String,Boolean>());
      Set<String> currentSet = userToNetgroupsMap.putIfAbsent(user, userGroups);
      if (currentSet != null) {
        userGroups = currentSet;
      }
    }
    userGroups.add(group);
  }
}
 

public AtomicCounter(long startTimeMs, long lengthMs){
	this.startTimeMs = startTimeMs;
	this.lengthMs = lengthMs;
	this.countByKey = new ConcurrentHashMap<>(INITIAL_CAPACITY);
	Thread createdByThread = Thread.currentThread();
	this.createdByThreadId = createdByThread.getId() + "-" + createdByThread.getName();
}
 

public VPackCache(final VPackFieldNamingStrategy fieldNamingStrategy,
	final Map<Class<? extends Annotation>, VPackAnnotationFieldFilter<? extends Annotation>> annotationFieldFilter,
	final Map<Class<? extends Annotation>, VPackAnnotationFieldNaming<? extends Annotation>> annotationFieldNaming) {
	super();
	cache = new ConcurrentHashMap<Type, Map<String, FieldInfo>>();
	fieldComparator = new Comparator<Map.Entry<String, FieldInfo>>() {
		@Override
		public int compare(final Entry<String, FieldInfo> o1, final Entry<String, FieldInfo> o2) {
			return o1.getKey().compareTo(o2.getKey());
		}
	};
	this.fieldNamingStrategy = fieldNamingStrategy;
	this.annotationFilter = annotationFieldFilter;
	this.annotationFieldNaming = annotationFieldNaming;
}
 

public static void verifyMetadata(Map<Integer, List<BucketServerLocation66>> clientMap) {
  final PartitionedRegion pr = (PartitionedRegion) region;
  ConcurrentHashMap<Integer, Set<ServerBucketProfile>> serverMap =
      pr.getRegionAdvisor().getAllClientBucketProfilesTest();
  assertEquals(clientMap.size(), serverMap.size());
  assertTrue(clientMap.keySet().containsAll(serverMap.keySet()));
  for (Map.Entry<Integer, List<BucketServerLocation66>> entry : clientMap.entrySet()) {
    int bucketId = entry.getKey();
    List<BucketServerLocation66> list = entry.getValue();
    BucketServerLocation66 primaryBSL = null;
    int primaryCnt = 0;
    for (BucketServerLocation66 bsl : list) {
      if (bsl.isPrimary()) {
        primaryBSL = bsl;
        primaryCnt++;
      }
    }
    assertTrue(primaryCnt == 1);
    Set<ServerBucketProfile> set = serverMap.get(bucketId);
    assertEquals(list.size(), set.size());
    primaryCnt = 0;
    for (ServerBucketProfile bp : set) {
      ServerLocation sl = (ServerLocation) bp.bucketServerLocations.toArray()[0];
      assertTrue(list.contains(sl));
      // should be only one primary
      if (bp.isPrimary) {
        primaryCnt++;
        assertTrue(primaryBSL.equals(sl));
      }
    }
    assertTrue(primaryCnt == 1);
  }
}
 

private void archieveId(ServletRequest request) throws Throwable {
    @SuppressWarnings("unchecked")
    Map<String, String> globalMap = CallChainContext.getContext().get();
    String currentIdValue = "";
    String traceIdValue = "";
    String spanIdValue = "";

    if (null == globalMap) {
        globalMap = new ConcurrentHashMap<String, String>();
        CallChainContext.getContext().add(globalMap);
    }

    traceIdValue = globalMap.get(CallChainContext.TRACEID);
    if (StringUtils.isEmpty(traceIdValue)) {
        traceIdValue = Long.toHexString(System.currentTimeMillis());
    }

    spanIdValue = globalMap.get(CallChainContext.SPANID);
    if (StringUtils.isEmpty(spanIdValue)) {
        spanIdValue = CallChainContext.DEFAULT_ID;
    }


    globalMap.put(CallChainContext.TRACEID, traceIdValue);
    globalMap.put(CallChainContext.SPANID, spanIdValue);
    currentIdValue = globalMap.get(CallChainContext.CURRENTID);
    if (StringUtils.isEmpty(currentIdValue)) {
        //currentIdValue = CallChainContext.DEFAULT_ID;
        globalMap.put(CallChainContext.CURRENTID, spanIdValue);

    }

    RpcContext.getContext().setAttachment(CallChainContext.TRACEID, traceIdValue);
    RpcContext.getContext().setAttachment(CallChainContext.SPANID, spanIdValue);

}
 

/**
 * Create a new Server partition,include load rows.
 *
 * @param partitionKey the partition meta
 * @param rowType      the row type
 */
public ServerPartition(PartitionKey partitionKey, RowType rowType) {
  this.state = PartitionState.INITIALIZING;
  this.partitionKey = partitionKey;
  this.rowType = rowType;
  this.rows = new ConcurrentHashMap<Integer, ServerRow>();
  this.clock = 0;
}
 

public void registerDebuff(Skill debuff)
{
	if (_debuffs == null)
	{
		_debuffs = ConcurrentHashMap.newKeySet();
	}
	
	_debuffs.add(debuff);
}
 

/**
 * 赋值
 * @param map
 */
public void putAllParamRouterMap(Map<String, List<String>> map) {
    if (map != null && !map.isEmpty()) {
        if (paramRouterMap == null) {
            paramRouterMap = new ConcurrentHashMap<String, List<String>>(1, loadFactor, 1);
        }
        paramRouterMap.putAll(map);
    }
}
 

public void truncateDirtyLogicFiles(long phyOffset) {
    ConcurrentHashMap<String, ConcurrentHashMap<Integer, ConsumeQueue>> tables = DefaultMessageStore.this.consumeQueueTable;

    for (ConcurrentHashMap<Integer, ConsumeQueue> maps : tables.values()) {
        for (ConsumeQueue logic : maps.values()) {
            logic.truncateDirtyLogicFiles(phyOffset);
        }
    }
}
 

/** 
 * A new configuration with the same settings cloned from another.
 * 
 * @param other the configuration from which to clone settings.
 */
@SuppressWarnings("unchecked")
public Configuration(Configuration other) {
 this.resources = (ArrayList<Resource>) other.resources.clone();
 synchronized(other) {
   if (other.properties != null) {
     this.properties = (Properties)other.properties.clone();
   }

   if (other.overlay!=null) {
     this.overlay = (Properties)other.overlay.clone();
   }

   this.updatingResource = new ConcurrentHashMap<String, String[]>(
       other.updatingResource);
   this.finalParameters = Collections.newSetFromMap(
       new ConcurrentHashMap<String, Boolean>());
   this.finalParameters.addAll(other.finalParameters);
 }
 
  synchronized(Configuration.class) {
    REGISTRY.put(this, null);
  }
  this.classLoader = other.classLoader;
  this.loadDefaults = other.loadDefaults;
  setQuietMode(other.getQuietMode());
}
 

/**
 * Previous versions used HashMap instead of ConcurrentHashMap.
 * Replace any HashMaps found during deserialization with
 * ConcurrentHashMaps.
 */
private void readObject(ObjectInputStream ois)
    throws IOException, ClassNotFoundException
{
    ois.defaultReadObject();
    if (! (groupTable instanceof ConcurrentHashMap)) {
        groupTable = new ConcurrentHashMap<>(groupTable);
    }
    if (! (idTable instanceof ConcurrentHashMap)) {
        idTable = new ConcurrentHashMap<>(idTable);
    }
}
 

private static Map<String, Set<Class>> createIdToClasses() {
    final Map<String, Set<Class>> map = new ConcurrentHashMap<>();
    for (final Class baseClass : baseClasses) {
        addSimpleClassNames(map, baseClass);
    }
    for (final Class clazz : ReflectionUtil.getAnnotatedTypes(JsonSimpleClassName.class)) {
        addSimpleClassName(map, clazz);
    }

    return map;
}
 

private static Map<Object, Object> a(Type type) {
    Class cls = type;
    while (cls != Properties.class) {
        if (cls == Hashtable.class) {
            return new Hashtable();
        }
        if (cls == IdentityHashMap.class) {
            return new IdentityHashMap();
        }
        if (cls == SortedMap.class || cls == TreeMap.class) {
            return new TreeMap();
        }
        if (cls == ConcurrentMap.class || cls == ConcurrentHashMap.class) {
            return new ConcurrentHashMap();
        }
        if (cls == Map.class || cls == HashMap.class) {
            return new HashMap();
        }
        if (cls == LinkedHashMap.class) {
            return new LinkedHashMap();
        }
        if (cls instanceof ParameterizedType) {
            cls = ((ParameterizedType) cls).getRawType();
        } else {
            Class cls2 = cls;
            if (cls2.isInterface()) {
                throw new IllegalArgumentException("unsupport type " + cls);
            }
            try {
                return (Map) cls2.newInstance();
            } catch (Throwable e) {
                throw new IllegalArgumentException("unsupport type " + cls, e);
            }
        }
    }
    return new Properties();
}
 

/**
 * Returns the ConcurrentHashMap used as a storage for ClassLoaderValue(s)
 * associated with this ClassLoader, creating it if it doesn't already exist.
 */
ConcurrentHashMap<?, ?> createOrGetClassLoaderValueMap() {
    ConcurrentHashMap<?, ?> map = classLoaderValueMap;
    if (map == null) {
        map = new ConcurrentHashMap<>();
        boolean set = trySetObjectField("classLoaderValueMap", map);
        if (!set) {
            // beaten by someone else
            map = classLoaderValueMap;
        }
    }
    return map;
}
 

private static ConcurrentHashMap<Integer, Class> transpose(ConcurrentHashMap<Class, Integer> javaClassToJdbcTypeCodeMap) {
	final ConcurrentHashMap<Integer, Class> transposed = new ConcurrentHashMap<Integer, Class>();

	for ( Map.Entry<Class,Integer> entry : javaClassToJdbcTypeCodeMap.entrySet() ) {
		transposed.put( entry.getValue(), entry.getKey() );
	}

	return transposed;
}
 

public void addWarpedSpace(L2Character creature, int radius)
{
	if (_warpedSpace == null)
	{
		synchronized (this)
		{
			if (_warpedSpace == null)
			{
				_warpedSpace = new ConcurrentHashMap<>();
			}
		}
	}
	_warpedSpace.put(creature, new WarpedSpaceHolder(creature, radius));
}
 

private void readObject(ObjectInputStream s)
    throws IOException, ClassNotFoundException {
    ObjectInputStream.GetField fields = s.readFields();
    @SuppressWarnings("unchecked")
    Hashtable<String,PermissionCollection> permTable =
            (Hashtable<String,PermissionCollection>)
            (fields.get("perms", null));
    if (permTable != null) {
        perms = new ConcurrentHashMap<>(permTable);
    } else {
        perms = new ConcurrentHashMap<>();
    }
}
 

/**
 * Creates a new, empty {@code ConcurrentHashMultiset} using the default
 * initial capacity, load factor, and concurrency settings.
 */
public static <E> ConcurrentHashMultiset<E> create() {
  // TODO(schmoe): provide a way to use this class with other (possibly arbitrary)
  // ConcurrentMap implementors. One possibility is to extract most of this class into
  // an AbstractConcurrentMapMultiset.
  return new ConcurrentHashMultiset<E>(new ConcurrentHashMap<E, AtomicInteger>());
}
 

private PropertyCallback computePropertyCallback(Function<String, T> valueParser,
    Map<String, Map<Class, PropertyCallback>> propertyCallbackMap) {

  PropertyCallback<T> propertyCallback =
      new PropertyCallback<>(list -> list.get(0).valueAsString().map(valueParser).orElse(null));

  propertyCallbackMap.putIfAbsent(name, new ConcurrentHashMap<>());
  Map<Class, PropertyCallback> callbackMap = propertyCallbackMap.get(name);
  callbackMap.putIfAbsent(propertyClass, propertyCallback);
  return callbackMap.get(propertyClass);
}
 

@Override
protected <V> RunnableScheduledFuture<V> decorateTask(Runnable runnable, RunnableScheduledFuture<V> task) {
    RunnableScheduledFuture<V> future = super.decorateTask(runnable, task);
    if (mTasks == null) {
        synchronized (BackgroundScheduledThreadPoolExecutor.class) {
            if (mTasks == null) {
                mTasks = new ConcurrentHashMap<>();
            }
        }
    }
    mTasks.put(future, runnable);
    return future;
}
 

@Test
public void testNonAffinityRouting() throws Throwable {
    Map<ClusterNode, List<String>> received = new ConcurrentHashMap<>();

    MessageReceiver<String> receiver = msg -> {
        ClusterNode localNode = msg.channel().cluster().topology().localNode();

        received.computeIfAbsent(localNode, n -> synchronizedList(new ArrayList<>())).add(msg.get());

        msg.reply(msg.get() + "-reply");
    };

    TestChannel channel1 = createChannel(c -> c.setReceiver(receiver)).join();
    TestChannel channel2 = createChannel(c -> c.setReceiver(receiver)).join();
    TestChannel channel3 = createChannel(c -> c.setReceiver(receiver)).join();

    awaitForChannelsTopology(channel1, channel2, channel3);

    for (int i = 0; i < 100; i++) {
        get(channel1.get().request("test" + i));
    }

    List<String> received1 = received.get(channel1.getNode().localNode());
    List<String> received2 = received.get(channel2.getNode().localNode());
    List<String> received3 = received.get(channel3.getNode().localNode());

    assertNotNull(received1);
    assertNotNull(received2);
    assertNotNull(received3);

    assertFalse(received1.isEmpty());
    assertFalse(received2.isEmpty());
    assertFalse(received3.isEmpty());

    assertEquals(100, received1.size() + received2.size() + received3.size());
}
 

protected Map<Integer, ZclAttribute> initializeAttributes() {
    Map<Integer, ZclAttribute> attributeMap = new ConcurrentHashMap<Integer, ZclAttribute>(7);

    attributeMap.put(ATTR_ZONESTATE, new ZclAttribute(ZclClusterType.IAS_ZONE, ATTR_ZONESTATE, "ZoneState", ZclDataType.ENUMERATION_8_BIT, true, true, false, false));
    attributeMap.put(ATTR_ZONETYPE, new ZclAttribute(ZclClusterType.IAS_ZONE, ATTR_ZONETYPE, "ZoneType", ZclDataType.ENUMERATION_16_BIT, true, true, false, false));
    attributeMap.put(ATTR_ZONESTATUS, new ZclAttribute(ZclClusterType.IAS_ZONE, ATTR_ZONESTATUS, "ZoneStatus", ZclDataType.BITMAP_16_BIT, true, true, false, false));
    attributeMap.put(ATTR_IASCIEADDRESS, new ZclAttribute(ZclClusterType.IAS_ZONE, ATTR_IASCIEADDRESS, "IASCIEAddress", ZclDataType.IEEE_ADDRESS, true, true, true, false));
    attributeMap.put(ATTR_ZONEID, new ZclAttribute(ZclClusterType.IAS_ZONE, ATTR_ZONEID, "ZoneID", ZclDataType.UNSIGNED_8_BIT_INTEGER, true, true, false, false));
    attributeMap.put(ATTR_NUMBEROFZONESENSITIVITYLEVELSSUPPORTED, new ZclAttribute(ZclClusterType.IAS_ZONE, ATTR_NUMBEROFZONESENSITIVITYLEVELSSUPPORTED, "NumberOfZoneSensitivityLevelsSupported", ZclDataType.UNSIGNED_8_BIT_INTEGER, false, true, false, false));
    attributeMap.put(ATTR_CURRENTZONESENSITIVITYLEVEL, new ZclAttribute(ZclClusterType.IAS_ZONE, ATTR_CURRENTZONESENSITIVITYLEVEL, "CurrentZoneSensitivityLevel", ZclDataType.UNSIGNED_8_BIT_INTEGER, false, true, true, false));

    return attributeMap;
}
 

private static Field getField(Class<?> cls, String fieldName) {
    Field result = null;
    if (CLASS_FIELD_CACHE.containsKey(cls) 
        && CLASS_FIELD_CACHE.get(cls).containsKey(fieldName)) {
        return CLASS_FIELD_CACHE.get(cls).get(fieldName);
    }
    try {
        result = cls.getField(fieldName);
    } catch (NoSuchFieldException e) {
        for(Field field : cls.getFields()) {
            if (fieldName.equals(field.getName()) 
                && ReflectUtils.isPublicInstanceField(field)) {
                result = field;
                break;
            }
        }
    }
    if (result != null) {
        ConcurrentMap<String, Field> fields = CLASS_FIELD_CACHE.get(cls);
        if (fields == null) {
            fields = new ConcurrentHashMap<String, Field>();
            CLASS_FIELD_CACHE.putIfAbsent(cls, fields);
        }
        fields = CLASS_FIELD_CACHE.get(cls);
        fields.putIfAbsent(fieldName, result);
    }
    return result;
}
 

/**
 * reduceKeysToDoubleInParallel accumulates mapped values
 */
public void testReduceKeysToDoubleInParallel() {
    ConcurrentHashMap<Long, Long> m = longMap();
    double dr = m.reduceKeysToDouble(1L, (Long x) -> x.doubleValue(), 0.0, Double::sum);
    assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
}
 

@Override
public void register(String service, URL url) {
    super.register(service, url);
    String client = RpcContext.getContext().getRemoteAddressString();
    Map<String, URL> urls = remoteRegistered.get(client);
    if (urls == null) {
        remoteRegistered.putIfAbsent(client, new ConcurrentHashMap<String, URL>());
        urls = remoteRegistered.get(client);
    }
    urls.put(service, url);
    notify(service, getRegistered().get(service));
}
 

/**
 * reduceKeysToIntSequentially accumulates mapped keys
 */
public void testReduceKeysToIntSequentially() {
    ConcurrentHashMap<Long, Long> m = longMap();
    int ir = m.reduceKeysToInt(Long.MAX_VALUE, (Long x) -> x.intValue(), 0, Integer::sum);
    assertEquals(ir, SIZE * (SIZE - 1) / 2);
}
 

@Override
public synchronized void saveCookie(HttpUrl url, Cookie cookie) {
    if (!cookies.containsKey(url.host())) {
        cookies.put(url.host(), new ConcurrentHashMap<String, Cookie>());
    }
    //当前cookie是否过期
    if (isCookieExpired(cookie)) {
        removeCookie(url, cookie);
    } else {
        saveCookie(url, cookie, getCookieToken(cookie));
    }
}
 

public ConcurrentHashMap<MessageQueue, AtomicLong> getOffsetTable() {
    return offsetTable;
}
 

protected Map<Integer, ZclAttribute> initializeAttributes() {
    Map<Integer, ZclAttribute> attributeMap = new ConcurrentHashMap<Integer, ZclAttribute>(0);

    return attributeMap;
}
 

@Override
public void initState(KeyValueState<String, ConcurrentHashMap<String, String>> state) {
}
 

/**
 * Creates an {@code AtomicLongMap}.
 */
public static <K> AtomicLongMap<K> create() {
  return new AtomicLongMap<K>(new ConcurrentHashMap<>());
}
 

public ChatWebSocketCreator() {
    this.users = Collections.newSetFromMap(new ConcurrentHashMap<ChatWebSocket, Boolean>());
    System.out.println("WebSocketCreator created");
}
 

@SuppressWarnings({"unchecked", "rawtypes"})
protected Map<Object, Object> createMap(Type type) {
    if (type == Properties.class) {
        return new Properties();
    }

    if (type == Hashtable.class) {
        return new Hashtable();
    }

    if (type == IdentityHashMap.class) {
        return new IdentityHashMap();
    }

    if (type == SortedMap.class || type == TreeMap.class) {
        return new TreeMap();
    }

    if (type == ConcurrentMap.class || type == ConcurrentHashMap.class) {
        return new ConcurrentHashMap();
    }

    if (type == Map.class || type == HashMap.class) {
        return new HashMap();
    }

    if (type == LinkedHashMap.class) {
        return new LinkedHashMap();
    }

    if (type instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) type;

        return createMap(parameterizedType.getRawType());
    }

    Class<?> clazz = (Class<?>) type;
    if (clazz.isInterface()) {
        throw new JSONException("unsupported type " + type);
    }

    try {
        return (Map<Object, Object>) clazz.newInstance();
    } catch (Exception e) {
        throw new JSONException("unsupported type " + type, e);
    }
}
 

protected Host() {
  labels =
      Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>());
  nms = new ConcurrentHashMap<NodeId, Node>();
}
 

public TimedMap(String name) {
  map = new ConcurrentHashMap<>();
  writeLock = new ReentrantLock();
  timer = new Timer(DefaultThreadFactory.threadNameBuilder(name + '-' + THREAD_SUFFIX, SERIAL_GENERATOR.getAndIncrement()), true);
}
 

/**
 * Instantiates a new default ticket registry.
 */
public DefaultTicketRegistry() {
    this.cache = new ConcurrentHashMap<>();
}
 

public LocaleObjectCache(int initialCapacity, float loadFactor, int concurrencyLevel) {
    map = new ConcurrentHashMap<>(initialCapacity, loadFactor, concurrencyLevel);
}