/** * Returns the bit number for the given name. If the name does not exist * a new new bit number for that name is created. * * @param name the name to lookup * @return the bit number for the given name */ private int getBitNumber(Name name) { Integer i = (Integer) nameIndex.get(name); if (i == null) { synchronized (nameIndex) { i = (Integer) nameIndex.get(name); if (i == null) { int idx = nameIndex.size(); i = new Integer(idx); nameIndex.put(name, i); if (idx >= names.length) { Name[] newNames = new Name[names.length * 2]; System.arraycopy(names, 0, newNames, 0, names.length); names = newNames; } names[idx] = name; } } } return i.intValue(); }
public AlarmFacilityImpl(AlarmMBeanImpl aMBean) { mBean = aMBean; /* We use a ConcurrentReaderHashMap to ensure thread safety but to avoid * synchronizong all methods. Reads outnumber writes. */ registeredComps = new ConcurrentReaderHashMap(); /* We also use a ConcurrentReaderHashMap on the notification types. * The concurrency library does not have ConcurrentReaderHashSet so we * can just use the map instead and insert same reference in key and value. */ notificationTypes = new ConcurrentReaderHashMap(); }
void clear() { classes.clear(); } }
this.classes.remove(cls); Set pkgSet = (Set) packagesMap.get(pkgName); if (pkgSet != null) packagesMap.put(pkgName, newSet); if (pkgSet.isEmpty()) packagesMap.remove(pkgName); for (Iterator i = packagesMap.entrySet().iterator(); i.hasNext();) newSet.addAll(pkgSet); newSet.remove(cl); packagesMap.put(entry.getKey(), newSet);
public long getNextSequence(Object key) throws SequenceGeneratorException { Sequence seq = (Sequence) map.get(key); if (seq != null) return seq.next(); synchronized (map) { if (!map.containsKey(key)) { if (listener != null) listener.sequenceCreatedFor(key); map.put(key, (seq = new SimpleSequence())); } else { seq = (Sequence) map.get(key); } } return seq.next(); }
/** * Provides the same functionality as {@link java.net.URLClassLoader#getResource}. */ public URL getResourceLocally(String name) { URL resURL = (URL) resourceCache.get(name); if (resURL != null) return resURL; if (isResourceBlackListed(name)) return null; resURL = super.getResource(name); if( log.isTraceEnabled() == true ) log.trace("getResourceLocally("+this+"), name="+name+", resURL:"+resURL); if (resURL == null) addToResourceBlackList(name); else resourceCache.put(name, resURL); return resURL; }
/** * @jmx:managed-operation * */ public Object resolveMetaData(Object key) { return metadata.get(key); }
/** * @jmx:managed-operation * */ public void addMetaData(Object key, Object value) { metadata.put(key, value); }
public void clearSequenceFor(Object key) { if (map.remove(key) != null && listener != null) { listener.sequenceDestroyedFor(key); } }
/** Get the passivated count. * @jmx:managed-attribute * @return the number of passivated instances. */ public long getPassivatedCount() { return passivatedIDs.size(); }
log.debug("removePassivated, now="+now+", maxLifeAfterPassivation="+maxLifeAfterPassivation); boolean trace = log.isTraceEnabled(); Iterator entries = passivatedIDs.entrySet().iterator(); while (entries.hasNext())
public Class getCachedClass(String classname) { return (Class)classes.get(classname); }
/** * Add a class to the the cache */ void cacheLoadedClass(String name, Class cls, ClassLoader cl) { synchronized( classes ) { // Update the global cache classes.put(name, cls); if( log.isTraceEnabled() ) { log.trace("cacheLoadedClass, classname: "+name+", class: "+cls +", cl: "+cl); } /** * TODO: Adding this implementation is a hack for jmx 1.2 checkin. * Had to add this because need getCachedClass() to work. * However, this method does not add loaded classes to collection * to be unloaded when called to remove classloader. * Hopefully this will be a short term workaround. * Contact telrod@e2technologies.net if you have questions. -TME */ } }
/** * Remove a class loader previously added via addClassLoader * @param cl - the ClassLoader previously added via addClassLoader */ public void removeClassLoader(ClassLoader cl) { String key = getClassLoaderKey(cl); loaderMap.remove(key); }
public int getCacheSize() { return classes.size(); }
/** * Returns the bit number for the given name. If the name does not exist * a new new bit number for that name is created. * * @param name the name to lookup * @return the bit number for the given name */ private int getBitNumber(Name name) { Integer i = (Integer) nameIndex.get(name); if (i == null) { synchronized (nameIndex) { i = (Integer) nameIndex.get(name); if (i == null) { int idx = nameIndex.size(); i = new Integer(idx); nameIndex.put(name, i); if (idx >= names.length) { Name[] newNames = new Name[names.length * 2]; System.arraycopy(names, 0, newNames, 0, names.length); names = newNames; } names[idx] = name; } } } return i.intValue(); }
public Class getCachedClass(String classname) { return (Class) classes.get(classname); }
/** Add a Class to the repository cache. * @param name the fully qualified class name * @param cls the Class instance * @param cl the repository UCL */ public void cacheLoadedClass(String name, Class cls, ClassLoader cl) { synchronized (classes) { // Update the global cache Object prevClass = classes.put(name, cls); if (log.isTraceEnabled()) { log.trace("cacheLoadedClass, classname: " + name + ", class: " + cls + ", ucl: " + cl + ", prevClass: " + prevClass); } // Update the cache for this classloader // This is used to cycling classloaders HashSet loadedClasses = (HashSet) loaderToClassesMap.get(cl); if (loadedClasses == null) { loadedClasses = new HashSet(); loaderToClassesMap.put(cl, loadedClasses); } loadedClasses.add(name); } }
public InvocationStatistics() { methodStats = new ConcurrentReaderHashMap(); }