public boolean containsKey(long key) { return get(key) != null; }
public V remove(long key) { long h = hash(key); return getSection(h).remove(key, null, (int) h); }
private static <V> void insertKeyValueNoLock(long[] keys, V[] values, long key, V value) { int bucket = (int) hash(key); while (true) { bucket = signSafeMod(bucket, keys.length); V storedValue = values[bucket]; if (storedValue == EmptyValue) { // The bucket is empty, so we can use it keys[bucket] = key; values[bucket] = value; return; } ++bucket; } } }
@Test public void testHashConflictWithDeletion() { final int Buckets = 16; ConcurrentLongHashMap<String> map = new ConcurrentLongHashMap<>(Buckets, 1); // Pick 2 keys that fall into the same bucket long key1 = 1; long key2 = 27; int bucket1 = ConcurrentLongHashMap.signSafeMod(ConcurrentLongHashMap.hash(key1), Buckets); int bucket2 = ConcurrentLongHashMap.signSafeMod(ConcurrentLongHashMap.hash(key2), Buckets); assertEquals(bucket1, bucket2); assertEquals(map.put(key1, "value-1"), null); assertEquals(map.put(key2, "value-2"), null); assertEquals(map.size(), 2); assertEquals(map.remove(key1), "value-1"); assertEquals(map.size(), 1); assertEquals(map.put(key1, "value-1-overwrite"), null); assertEquals(map.size(), 2); assertEquals(map.remove(key1), "value-1-overwrite"); assertEquals(map.size(), 1); assertEquals(map.put(key2, "value-2-overwrite"), "value-2"); assertEquals(map.get(key2), "value-2-overwrite"); assertEquals(map.size(), 1); assertEquals(map.remove(key2), "value-2-overwrite"); assertTrue(map.isEmpty()); }
@Test public void simpleInsertions() { ConcurrentLongHashMap<String> map = new ConcurrentLongHashMap<>(16); assertTrue(map.isEmpty()); assertNull(map.put(1, "one")); assertFalse(map.isEmpty()); assertNull(map.put(2, "two")); assertNull(map.put(3, "three")); assertEquals(map.size(), 3); assertEquals(map.get(1), "one"); assertEquals(map.size(), 3); assertEquals(map.remove(1), "one"); assertEquals(map.size(), 2); assertEquals(map.get(1), null); assertEquals(map.get(5), null); assertEquals(map.size(), 2); assertNull(map.put(1, "one")); assertEquals(map.size(), 3); assertEquals(map.put(1, "uno"), "one"); assertEquals(map.size(), 3); }
@Test public void testRehashing() { int n = 16; ConcurrentLongHashMap<Integer> map = new ConcurrentLongHashMap<>(n / 2, 1); assertEquals(map.capacity(), n); assertEquals(map.size(), 0); for (int i = 0; i < n; i++) { map.put(i, i); } assertEquals(map.capacity(), 2 * n); assertEquals(map.size(), n); }
public void benchConcurrentLongHashMap() throws Exception { // public static void main(String args[]) { ConcurrentLongHashMap<String> map = new ConcurrentLongHashMap<>(N, 1); for (long i = 0; i < Iterations; i++) { for (int j = 0; j < N; j++) { map.put(i, "value"); } for (long h = 0; h < ReadIterations; h++) { for (int j = 0; j < N; j++) { map.get(i); } } for (int j = 0; j < N; j++) { map.remove(i); } } }
@Test public void testIteration() { ConcurrentLongHashMap<String> map = new ConcurrentLongHashMap<>(); assertEquals(map.keys(), Collections.emptyList()); assertEquals(map.values(), Collections.emptyList()); map.put(0, "zero"); assertEquals(map.keys(), Arrays.asList(0L)); assertEquals(map.values(), Arrays.asList("zero")); map.remove(0); assertEquals(map.keys(), Collections.emptyList()); assertEquals(map.values(), Collections.emptyList()); map.put(0, "zero"); map.put(1, "one"); map.put(2, "two"); List<Long> keys = map.keys(); Collections.sort(keys); assertEquals(keys, Arrays.asList(0L, 1L, 2L)); List<String> values = map.values(); Collections.sort(values); assertEquals(values, Arrays.asList("one", "two", "zero")); map.put(1, "uno"); keys = map.keys(); Collections.sort(keys); assertEquals(keys, Arrays.asList(0L, 1L, 2L)); values = map.values(); Collections.sort(values); assertEquals(values, Arrays.asList("two", "uno", "zero")); map.clear(); assertTrue(map.isEmpty()); }
@Test public void testNegativeUsedBucketCount() { ConcurrentLongHashMap<String> map = new ConcurrentLongHashMap<>(16, 1); map.put(0, "zero"); assertEquals(1, map.getUsedBucketCount()); map.put(0, "zero1"); assertEquals(1, map.getUsedBucketCount()); map.remove(0); assertEquals(0, map.getUsedBucketCount()); map.remove(0); assertEquals(0, map.getUsedBucketCount()); }
@Test public void testRemove() { ConcurrentLongHashMap<String> map = new ConcurrentLongHashMap<>(); assertTrue(map.isEmpty()); assertNull(map.put(1, "one")); assertFalse(map.isEmpty()); assertFalse(map.remove(0, "zero")); assertFalse(map.remove(1, "uno")); assertFalse(map.isEmpty()); assertTrue(map.remove(1, "one")); assertTrue(map.isEmpty()); }
@Override public void onReadDeleteRecordTX(final long transactionID, final RecordInfo info) throws Exception { hasData.lazySet(true); TransactionHolder tx = loadTransactions.get(transactionID); if (tx == null) { tx = new TransactionHolder(transactionID); loadTransactions.put(transactionID, tx); } tx.recordsToDelete.add(info); JournalTransaction tnp = transactions.get(transactionID); if (tnp == null) { tnp = new JournalTransaction(transactionID, JournalImpl.this); transactions.put(transactionID, tnp); } tnp.addNegative(file, info.id); }
/** * This methods informs the Compactor about the existence of a pending (non committed) transaction */ public void addPendingTransaction(final long transactionID, final long[] ids) { if (logger.isTraceEnabled()) { logger.trace("addPendingTransaction::tx=" + transactionID + ", ids=" + Arrays.toString(ids)); } pendingTransactions.put(transactionID, new PendingTransaction(ids)); }
@Test public void testPutIfAbsent() { ConcurrentLongHashMap<String> map = new ConcurrentLongHashMap<>(); assertEquals(map.putIfAbsent(1, "one"), null); assertEquals(map.get(1), "one"); assertEquals(map.putIfAbsent(1, "uno"), "one"); assertEquals(map.get(1), "one"); }
while (true) { int capacity = this.capacity; bucket = signSafeMod(bucket, capacity); V nextValueInArray = values[signSafeMod(bucket + 1, capacity)]; if (nextValueInArray == EmptyValue) { values[bucket] = (V) EmptyValue;
@Test public void testComputeIfAbsent() { ConcurrentLongHashMap<Integer> map = new ConcurrentLongHashMap<>(16, 1); AtomicInteger counter = new AtomicInteger(); LongFunction<Integer> provider = key -> counter.getAndIncrement(); assertEquals(map.computeIfAbsent(0, provider).intValue(), 0); assertEquals(map.get(0).intValue(), 0); assertEquals(map.computeIfAbsent(1, provider).intValue(), 1); assertEquals(map.get(1).intValue(), 1); assertEquals(map.computeIfAbsent(1, provider).intValue(), 1); assertEquals(map.get(1).intValue(), 1); assertEquals(map.computeIfAbsent(2, provider).intValue(), 2); assertEquals(map.get(2).intValue(), 2); }
Section(int capacity) { this.capacity = alignToPowerOfTwo(capacity); this.keys = new long[this.capacity]; this.values = (V[]) new Object[this.capacity]; this.size = 0; this.usedBuckets = 0; this.resizeThreshold = (int) (this.capacity * MapFillFactor); }
public Packet remove(long correlationID) { return store.remove(correlationID); }
public ResponseCache() { this.store = new ConcurrentLongHashMap<>(); }