Examples of org.jdk8.backport.ConcurrentLinkedHashMap

org.jdk8.backport.LongAdder
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 implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is the order in which keys were inserted into the map (insertion-order).
NOTE: Access order is not supported by this map. Note that insertion order is not affected if a key is re-inserted into the map. (A key k is reinserted into a map m if m.put(k, v) is invoked when m.containsKey(k) would return true immediately prior to the invocation.)
An optional {@code maxCap} may be passed to the map constructor tocreate bounded map that will remove stale mappings automatically when new mappings are added to the map.
When iterating over the key set in insertion order one should note that iterator will see all removes done since the iterator was created, but will see no inserts to map.
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. @author Doug Lea @param < K> the type of keys maintained by this map @param < V> the type of mapped values


    /**
     * @param args Arguments.
     */
    public static void main(String[] args) throws Exception {
        QueuePolicy qPlc = args.length > 0 ? QueuePolicy.valueOf(args[0]) : SINGLE_Q;
        int threadCnt = args.length > 1 ? Integer.valueOf(args[1]) : Runtime.getRuntime().availableProcessors();


        X.println("Queue policy: " + qPlc);
        X.println("Threads: " + threadCnt);

View Full Code Here


    /**
     * @param args Arguments.
     */
    public static void main(String[] args) throws Exception {
        QueuePolicy qPlc = args.length > 0 ? QueuePolicy.valueOf(args[0]) : SINGLE_Q;
        int threadCnt = args.length > 1 ? Integer.valueOf(args[1]) : Runtime.getRuntime().availableProcessors();


        X.println("Queue policy: " + qPlc);
        X.println("Threads: " + threadCnt);

View Full Code Here


        for (int i = 0; i < 5; i++) {
            final int loops = 5000;
            int threads = 17;


            final LongAdder sum = new LongAdder();


            multithreaded(new Callable<Object>() {
                @Override public Object call() throws Exception {
                    for (int i = 0; i < loops; i++) {
                        exec.submit(new Callable<Void>() {
                            @Override
                            public Void call() throws Exception {
                                sum.increment();


                                return null;
                            }
                        });
                    }


                    return null;
                }
            }, threads);


            while (exec.active() != 0) {
                X.println("__ active: " + exec.active());


                Thread.sleep(200);
            }


            assertEquals(threads * loops, sum.sum());


            X.println("_ ok");
        }


        assertTrue(exec.shutdown(0));

View Full Code Here

     */
    public void testShutdown() throws Exception {
        for (int i = 0; i < 5; i++) {
            final GridHadoopExecutorService exec = new GridHadoopExecutorService(log, "_GRID_NAME_", 10, 5);


            final LongAdder sum = new LongAdder();


            final AtomicBoolean finish = new AtomicBoolean();


            GridFuture<?> fut = multithreadedAsync(new Callable<Object>() {
                @Override public Object call() throws Exception {
                    while (!finish.get()) {
                        exec.submit(new Callable<Void>() {
                            @Override public Void call() throws Exception {
                                sum.increment();


                                return null;
                            }
                        });
                    }


                    return null;
                }
            }, 19);


            Thread.sleep(200);


            assertTrue(exec.shutdown(50));


            long res = sum.sum();


            assertTrue(res > 0);


            finish.set(true);


            fut.get();


            assertEquals(res, sum.sum()); // Nothing was executed after shutdown.


            X.println("_ ok");
        }
    }

View Full Code Here

TOP

Related Classes of org.jdk8.backport.ConcurrentLinkedHashMap

org.gridgain.grid.kernal.processors.hadoop.taskexecutor.GridHadoopExecutorServiceTest

org.gridgain.loadtests.hashmap.GridBoundedConcurrentLinkedHashSetLoadTest

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.