third-party/triemap/src/test/java/org/opendaylight/yangtools/triemap/TestMultiThreadMapIterator.java

   1 package org.opendaylight.yangtools.triemap;
   2
   3 import java.util.Collection;
   4 import java.util.Iterator;
   5 import java.util.LinkedList;
   6 import java.util.Map;
   7 import java.util.Map.Entry;
   8 import java.util.concurrent.ConcurrentHashMap;
   9 import java.util.concurrent.ExecutorService;
  10 import java.util.concurrent.Executors;
  11 import java.util.concurrent.TimeUnit;
  12
  13 import org.junit.Test;
  14
  15 public class TestMultiThreadMapIterator {
  16     private static final int NTHREADS = 7;
  17
  18     @Test
  19     public void testMultiThreadMapIterator () {
  20         final Map<Object, Object> bt = new TrieMap<Object, Object> ();
  21         for (int j = 0; j < 50 * 1000; j++) {
  22             final Object[] objects = getObjects (j);
  23             for (final Object o : objects) {
  24                 bt.put (o, o);
  25             }
  26         }
  27
  28       System.out.println ("Size of initialized map is " + bt.size ());
  29       int count = 0;
  30         {
  31             final ExecutorService es = Executors.newFixedThreadPool (NTHREADS);
  32             for (int i = 0; i < NTHREADS; i++) {
  33                 final int threadNo = i;
  34                 es.execute (new Runnable () {
  35                     @Override
  36                     public void run () {
  37                         for (final Iterator<Map.Entry<Object, Object>> i = bt.entrySet ().iterator (); i.hasNext ();) {
  38                             final Entry<Object, Object> e = i.next ();
  39                             if (accepts (threadNo, NTHREADS, e.getKey ())) {
  40                                 String newValue = "TEST:" + threadNo;
  41                                 e.setValue (newValue);
  42                             }
  43                         }
  44                     }
  45                 });
  46             }
  47
  48             es.shutdown ();
  49             try {
  50                 es.awaitTermination (3600L, TimeUnit.SECONDS);
  51             } catch (final InterruptedException e) {
  52                 e.printStackTrace ();
  53             }
  54         }
  55
  56         count = 0;
  57         for (final Map.Entry<Object, Object> kv : bt.entrySet ()) {
  58             Object value = kv.getValue ();
  59             TestHelper.assertTrue (value instanceof String);
  60             count++;
  61         }
  62         TestHelper.assertEquals (50000 + 2000 + 1000 + 100, count);
  63
  64         final ConcurrentHashMap<Object, Object> removed = new ConcurrentHashMap<Object, Object> ();
  65
  66         {
  67             final ExecutorService es = Executors.newFixedThreadPool (NTHREADS);
  68             for (int i = 0; i < NTHREADS; i++) {
  69                 final int threadNo = i;
  70                 es.execute (new Runnable () {
  71                     @Override
  72                     public void run () {
  73                         for (final Iterator<Map.Entry<Object, Object>> i = bt.entrySet ().iterator (); i.hasNext ();) {
  74                             final Entry<Object, Object> e = i.next ();
  75                             Object key = e.getKey ();
  76                             if (accepts (threadNo, NTHREADS, key)) {
  77                                 if (null == bt.get (key)) {
  78                                     System.out.println (key);
  79                                 }
  80                                 i.remove ();
  81                                 if (null != bt.get (key)) {
  82                                     System.out.println (key);
  83                                 }
  84                                 removed.put (key, key);
  85                             }
  86                         }
  87                     }
  88                 });
  89             }
  90
  91             es.shutdown ();
  92             try {
  93                 es.awaitTermination (3600L, TimeUnit.SECONDS);
  94             } catch (final InterruptedException e) {
  95                 e.printStackTrace ();
  96             }
  97         }
  98
  99         count = 0;
 100         for (final Object value : bt.keySet ()) {
 101             value.toString ();
 102             count++;
 103         }
 104         for (final Object o : bt.keySet ()) {
 105             if (!removed.contains (bt.get (o))) {
 106                 System.out.println ("Not removed: " + o);
 107             }
 108         }
 109         TestHelper.assertEquals (0, count);
 110         TestHelper.assertEquals (0, bt.size ());
 111         TestHelper.assertTrue (bt.isEmpty ());
 112     }
 113
 114     protected static boolean accepts (final int threadNo, final int nThreads, final Object key) {
 115         int val = getKeyValue (key);
 116         if(val>=0)
 117             return val % nThreads == threadNo;
 118         else
 119             return false;
 120     }
 121
 122     private static int getKeyValue (final Object key) {
 123         int val = 0;
 124         if (key instanceof Integer) {
 125             val = ((Integer) key).intValue ();
 126         }
 127         else if (key instanceof Character) {
 128             val = Math.abs (Character.getNumericValue ((Character) key) + 1);
 129         }
 130         else if (key instanceof Short) {
 131             val = ((Short) key).intValue () + 2;
 132         }
 133         else if (key instanceof Byte) {
 134             val = ((Byte) key).intValue () + 3;
 135         } else
 136             return -1;
 137         return val;
 138     }
 139
 140     static Object[] getObjects (final int j) {
 141         final Collection<Object> results = new LinkedList<Object> ();
 142         results.add (Integer.valueOf (j));
 143         if (j < 2000) {
 144             results.add (Character.valueOf ((char) j));
 145         }
 146         if (j < 1000) {
 147             results.add (Short.valueOf ((short) j));
 148         }
 149         if (j < 100) {
 150             results.add (Byte.valueOf ((byte) j));
 151         }
 152
 153         return results.toArray ();
 154     }
 155 }