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 org.apache.openjpa.lib.util.concurrent.ConcurrentHashMap

     */
    public CacheMap(boolean lru, int max, int size, float load) {
        if (size < 0)
            size = 500;
        if (!lru) {
            cacheMap = new ConcurrentHashMap(size, load) {
                public void overflowRemoved(Object key, Object value) {
                    cacheMapOverflowRemoved(key, value);
                }
            };
            softMap = new ConcurrentReferenceHashMap(ReferenceMap.HARD,
                ReferenceMap.SOFT, size, load) {
                public void overflowRemoved(Object key, Object value) {
                    softMapOverflowRemoved(key, value);
                }


                public void valueExpired(Object key) {
                    softMapValueExpired(key);
                }
            };
            pinnedMap = new ConcurrentHashMap();
            _readLock = null;
        } else {
            cacheMap = new LRUMap(size, load) {
                public void overflowRemoved(Object key, Object value) {
                    cacheMapOverflowRemoved(key, value);

View Full Code Here

Examples of org.apache.wicket.util.concurrent.ConcurrentHashMap

  {
    IClassCache classesToGetAndSetters = getClassesToGetAndSetters();
    Map getAndSetters = (Map)classesToGetAndSetters.get(clz);
    if (getAndSetters == null)
    {
      getAndSetters = new ConcurrentHashMap(8);
      classesToGetAndSetters.put(clz, getAndSetters);
    }


    IGetAndSet getAndSetter = (IGetAndSet)getAndSetters.get(exp);
    if (getAndSetter == null)

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.