Examples of ConcurrentHashMap

EDU.oswego.cs.dl.util.concurrent.ConcurrentHashMap
s.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. ]
edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap
A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates. This class obeys the same functional specification as {@link java.util.Hashtable}, and includes versions of methods corresponding to each method of Hashtable. However, even though all operations are thread-safe, retrieval operations do not entail locking, and there is not any support for locking the entire table in a way that prevents all access. This class is fully interoperable with Hashtable in programs that rely on its thread safety but not on its synchronization details.
Retrieval operations (including get) generally do not block, so may overlap with update operations (including put and remove). Retrievals reflect the results of the most recently completed update operations holding upon their onset. For aggregate operations such as putAll and clear, concurrent retrievals may reflect insertion or removal of only some entries. Similarly, Iterators and Enumerations return elements reflecting the state of the hash table at some point at or since the creation of the iterator/enumeration. They do not throw {@link ConcurrentModificationException}. However, iterators are designed to be used by only one thread at a time.
The allowed concurrency among update operations is guided by the optional concurrencyLevel constructor argument (default 16), which is used as a hint for internal sizing. The table is internally partitioned to try to permit the indicated number of concurrent updates without contention. Because placement in hash tables is essentially random, the actual concurrency will vary. Ideally, you should choose a value to accommodate as many threads as will ever concurrently modify the table. Using a significantly higher value than you need can waste space and time, and a significantly lower value can lead to thread contention. But overestimates and underestimates within an order of magnitude do not usually have much noticeable impact. A value of one is appropriate when it is known that only one thread will modify and all others will only read. Also, resizing this or any other kind of hash table is a relatively slow operation, so, when possible, it is a good idea to provide estimates of expected table sizes in constructors.
This class and its views and iterators implement all of the optional methods of the {@link Map} and {@link Iterator}interfaces.
Like {@link Hashtable} but unlike {@link HashMap}, this class does not allow null to be used as a key or value.
This class is a member of the Java Collections Framework. @since 1.5 @author Doug Lea
java.util.concurrent.ConcurrentHashMap
google.com/docreader/#p=google-web-toolkit-doc-1-5&t=DevGuideJavaCompatibility"> single-threaded, it is essentially a {@link java.util.HashMap}, implementing the new methods introduced by {@link ConcurrentMap}. @author Hayward Chan
org.apache.openjpa.lib.util.concurrent.ConcurrentHashMap
This class implements a HashMap which has limited synchronization. In particular mutators are generally synchronized while accessors are generally not. Additionally the Iterators returned by this class are not "fail-fast", but instead try to continue to iterate over the data structure after changes have been made. The synchronization semantics are built right in to the implementation rather than using a delegating wrapper like the other collection classes do because it wasn't clear to me that the how the two should be seperated or that it would be useful to do so. This can probably be a topic for further debate in the future. This class is based heavily on the HashMap class in the Java collections package.
org.apache.wicket.util.concurrent.ConcurrentHashMap
s.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. ]

Examples of java.util.concurrent.ConcurrentHashMap

    /**
     * Return a string naming the threads which currently hold this lock.
     */
    protected String getCurrentLockHolderNames(File file) {
        StringBuilder sb = new StringBuilder();
        ConcurrentHashMap m = (ConcurrentHashMap) currentLockHolders.get(file);
        if (m == null) {
            return "(NULL)";
        }
        Enumeration threads = m.keys();
        while (threads.hasMoreElements()) {
            Thread t = (Thread) threads.nextElement();
            sb.append(t.toString());
            if (threads.hasMoreElements()) {
                sb.append(", ");

View Full Code Here

Examples of java.util.concurrent.ConcurrentHashMap

        {
            // test by type lookup with the 'optional' flag set to false
            try
            {
                // guess we can safely assume that there is no producer for a ConcurrentHashMap in the system...
                ConcurrentHashMap chm = BeanProvider.getContextualReference(ConcurrentHashMap.class);
                Assert.fail("BeanProvider#getContextualReference should have blown up with a non-existing bean!");
            }
            catch(IllegalStateException ise)
            {
                // all is well, this is exactly what should happen!

View Full Code Here

Examples of java.util.concurrent.ConcurrentHashMap

        throws AxisFault {
        super.init(cfgCtx, trpInDesc);


        // set the synchronise callback table
        if (cfgCtx.getProperty(BaseConstants.CALLBACK_TABLE) == null){
            cfgCtx.setProperty(BaseConstants.CALLBACK_TABLE, new ConcurrentHashMap());
        }
    }

View Full Code Here

Examples of java.util.concurrent.ConcurrentHashMap


        MailUtils.setupLogging(session, log, transportOut);


        // set the synchronise callback table
        if (cfgCtx.getProperty(BaseConstants.CALLBACK_TABLE) == null){
            cfgCtx.setProperty(BaseConstants.CALLBACK_TABLE, new ConcurrentHashMap());
        }
    }

View Full Code Here

Examples of java.util.concurrent.ConcurrentHashMap

        AbstractBrokerFactory factory = getPooledFactoryForKey(_poolKey);
        if (factory != null)
            return factory;


        // reset these transient fields to empty values
        _transactional = new ConcurrentHashMap();
        _brokers = newBrokerSet();


        makeReadOnly();
        return this;
    }

View Full Code Here

Examples of java.util.concurrent.ConcurrentHashMap

        else
            bv = (BrokerValue) _conf.getValue(BrokerValue.KEY);


        if (FinalizingBrokerImpl.class.isAssignableFrom(
            bv.getTemplateBrokerType(_conf))) {
            return MapBackedSet.decorate(new ConcurrentHashMap(),
                new Object() { });
        } else {
            return new ConcurrentReferenceHashSet(
                ConcurrentReferenceHashSet.WEAK);
        }

View Full Code Here

Examples of java.util.concurrent.ConcurrentHashMap

     */
    private void mergeParameters() {


        if (parameters != null)
            return;
        Map results = new ConcurrentHashMap();
        String names[] = context.findParameters();
        for (int i = 0; i < names.length; i++)
            results.put(names[i], context.findParameter(names[i]));
        ApplicationParameter params[] =
            context.findApplicationParameters();
        for (int i = 0; i < params.length; i++) {
            if (params[i].getOverride()) {
                if (results.get(params[i].getName()) == null)
                    results.put(params[i].getName(), params[i].getValue());
            } else {
                results.put(params[i].getName(), params[i].getValue());
            }
        }
        parameters = results;


    }

View Full Code Here

Examples of java.util.concurrent.ConcurrentHashMap

        if (sipStack.isLoggingEnabled(LogWriter.TRACE_DEBUG)) {
            sipStack.getStackLogger().logDebug("Creating clientTransaction " + this);
            sipStack.getStackLogger().logStackTrace();
        }
        // this.startTransactionTimer();
        this.sipDialogs = new ConcurrentHashMap();
    }

View Full Code Here

Examples of java.util.concurrent.ConcurrentHashMap


                  continue;
               }
            }


            Map<String, ProtocolManager> supportedProtocols = new ConcurrentHashMap();


            String protocol = ConfigurationHelper.getStringProperty(TransportConstants.PROTOCOL_PROP_NAME, null,
                  info.getParams());


            if(protocol != null)
            {
               HornetQServerLogger.LOGGER.warnDeprecatedProtocol();
               ProtocolManager protocolManager = protocolMap.get(protocol);


               if(protocolManager == null)
               {
                  throw HornetQMessageBundle.BUNDLE.noProtocolManagerFound(protocol);
               }
               else
               {
                  supportedProtocols.put(protocol, protocolManager);
               }
            }


            String protocols = ConfigurationHelper.getStringProperty(TransportConstants.PROTOCOLS_PROP_NAME, null,
                  info.getParams());


            if(protocols != null)
            {
               String[] actualProtocols = protocols.split(",");


               if(actualProtocols != null)
               {
                  for (String actualProtocol : actualProtocols)
                  {
                     ProtocolManager protocolManager = protocolMap.get(actualProtocol);


                     if(protocolManager == null)
                     {
                        throw HornetQMessageBundle.BUNDLE.noProtocolManagerFound(actualProtocol);
                     }
                     else
                     {
                        supportedProtocols.put(actualProtocol, protocolManager);
                     }
                  }
               }
            }


            ClusterConnection clusterConnection = lookupClusterConnection(info);


            Acceptor acceptor = factory.createAcceptor(info.getName(),
                                                       clusterConnection,
                                                       info.getParams(),
                                                       new DelegatingBufferHandler(),
                                                       this,
                                                       threadPool,
                                                       scheduledThreadPool,
                                                       supportedProtocols.isEmpty()?protocolMap:supportedProtocols);


            if(defaultInvmSecurityPrincipal != null && acceptor.isUnsecurable())
            {
               acceptor.setDefaultHornetQPrincipal(defaultInvmSecurityPrincipal);
            }

View Full Code Here

Examples of org.apache.openjpa.lib.util.concurrent.ConcurrentHashMap

        // can't have a null reference in the map, so use symbolic 
        // constant as key
        Object key = loader == null ? NULL_LOADER : loader;
        Map loaderCache = (Map) _loaders.get(key);
        if (loaderCache == null) { // We don't have a cache for this loader.
            loaderCache = new ConcurrentHashMap();
            _loaders.put(key, loaderCache);
        } else {  // We have a cache for this loader.
            cls = (Class) loaderCache.get(clsName);
        }

View Full Code Here

0 1 2 3 4 5

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.