#2782 - Removing ConcurrentIdentityHashMap and shake this all about

akka-actor-tests/src/test/scala/akka/actor/dispatch/ActorModelSpec.scala

@@ -425,7 +425,7 @@ abstract class ActorModelSpec(config: String) extends AkkaSpec(config) with Defa
           Thread.getAllStackTraces().asScala foreach {
             case (thread, stack) ⇒
               println(s"$thread:")
-              stack foreach (s => println(s"\t$s"))
+              stack foreach (s ⇒ println(s"\t$s"))
           }
         }
         assert(Await.result(f1, remaining) === "foo")

akka-actor/src/main/java/akka/util/internal/HashedWheelTimer.java

@@ -20,10 +20,13 @@ import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.Iterator;
 import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
+import akka.dispatch.SystemMessage;
 import akka.util.Helpers;
 import scala.concurrent.duration.Duration;
 import scala.concurrent.duration.FiniteDuration;
@@ -89,7 +92,6 @@ public class HashedWheelTimer implements Timer {
     boolean shutdown = false;
     final long tickDuration;
     final Set<HashedWheelTimeout>[] wheel;
-    final ReusableIterator<HashedWheelTimeout>[] iterators;
     final int mask;
     final ReadWriteLock lock = new ReentrantReadWriteLock();
     volatile int wheelCursor;
@@ -127,7 +129,6 @@ public class HashedWheelTimer implements Timer {
 
         // Normalize ticksPerWheel to power of two and initialize the wheel.
         wheel = createWheel(ticksPerWheel);
-        iterators = createIterators(wheel);
         mask = wheel.length - 1;
 
         // Convert to standardized tickDuration
@@ -152,20 +153,11 @@ public class HashedWheelTimer implements Timer {
 
         final Set<HashedWheelTimeout>[] wheel = new Set[normalizeTicksPerWheel(ticksPerWheel)];
         for (int i = 0; i < wheel.length; i ++) {
-            wheel[i] = Collections.newSetFromMap(new ConcurrentIdentityHashMap<HashedWheelTimeout, Boolean>(16, 0.95f, 4));
+            wheel[i] = Collections.newSetFromMap(new ConcurrentHashMap<HashedWheelTimeout, Boolean>(16, 0.95f, 4));
         }
         return wheel;
     }
 
-    @SuppressWarnings("unchecked")
-    private static ReusableIterator<HashedWheelTimeout>[] createIterators(Set<HashedWheelTimeout>[] wheel) {
-        ReusableIterator<HashedWheelTimeout>[] iterators = new ReusableIterator[wheel.length];
-        for (int i = 0; i < wheel.length; i ++) {
-            iterators[i] = (ReusableIterator<HashedWheelTimeout>) wheel[i].iterator();
-        }
-        return iterators;
-    }
-
     private static int normalizeTicksPerWheel(int ticksPerWheel) {
         int normalizedTicksPerWheel = 1;
         while (normalizedTicksPerWheel < ticksPerWheel) {
@@ -323,16 +315,16 @@ public class HashedWheelTimer implements Timer {
             lock.writeLock().lock();
             try {
                 final int newWheelCursor = wheelCursor = wheelCursor + 1 & mask;
-                return fetchExpiredTimeouts(iterators[newWheelCursor], deadline);
+                return fetchExpiredTimeouts(wheel[newWheelCursor], deadline);
             } finally {
                 lock.writeLock().unlock();
             }
         }
 
-        private ArrayList<HashedWheelTimeout> fetchExpiredTimeouts(final ReusableIterator<HashedWheelTimeout> i, final long deadline) {
+        private ArrayList<HashedWheelTimeout> fetchExpiredTimeouts(final Iterable<HashedWheelTimeout> it, final long deadline) {
             final ArrayList<HashedWheelTimeout> expiredTimeouts = new ArrayList<HashedWheelTimeout>();
             List<HashedWheelTimeout> slipped = null;
-            i.rewind();
+            Iterator<HashedWheelTimeout> i = it.iterator();
             while (i.hasNext()) {
                 HashedWheelTimeout timeout = i.next();
                 if (timeout.remainingRounds <= 0) {
@@ -483,6 +475,14 @@ public class HashedWheelTimer implements Timer {
             }
         }
 
+        @Override public final int hashCode() {
+            return System.identityHashCode(this);
+        }
+
+        @Override public final boolean equals(final Object that) {
+            return this == that;
+        }
+
         @Override
         public String toString() {
             final long currentTime = System.nanoTime();

akka-actor/src/main/java/akka/util/internal/ReusableIterator.java

@@ -1,27 +0,0 @@
-/*
- * Copyright 2009 Red Hat, Inc.
- *
- * Red Hat licenses this file to you under the Apache License, version 2.0
- * (the "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at:
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- */
-package akka.util.internal;
-
-import java.util.Iterator;
-
-/**
- * @author <a href="http://www.jboss.org/netty/">The Netty Project</a>
- * @author <a href="http://gleamynode.net/">Trustin Lee</a>
- * @version $Rev: 2080 $, $Date: 2010-01-26 18:04:19 +0900 (Tue, 26 Jan 2010) $
- */
-public interface ReusableIterator<E> extends Iterator<E> {
-    void rewind();
-}

akka-actor/src/main/scala/akka/actor/ActorSystem.scala

@@ -16,8 +16,8 @@ import scala.util.{ Failure, Success }
 import scala.util.control.NonFatal
 import akka.util._
 import java.io.Closeable
-import akka.util.internal.{ HashedWheelTimer, ConcurrentIdentityHashMap }
-import java.util.concurrent.{ ThreadFactory, CountDownLatch, TimeoutException, RejectedExecutionException }
+import akka.util.internal.{ HashedWheelTimer }
+import java.util.concurrent.{ ConcurrentHashMap, ThreadFactory, CountDownLatch, TimeoutException, RejectedExecutionException }
 import java.util.concurrent.TimeUnit.MILLISECONDS
 import akka.actor.dungeon.ChildrenContainer
 
@@ -628,7 +628,7 @@ private[akka] class ActorSystemImpl(val name: String, applicationConfig: Config,
     case _            ⇒
   }
 
-  private val extensions = new ConcurrentIdentityHashMap[ExtensionId[_], AnyRef]
+  private val extensions = new ConcurrentHashMap[ExtensionId[_], AnyRef]
 
   /**
    * Returns any extension registered to the specified Extension or returns null if not registered

akka-actor/src/main/scala/akka/actor/Extension.scala

@@ -52,6 +52,9 @@ trait ExtensionId[T <: Extension] {
    * internal use only.
    */
   def createExtension(system: ExtendedActorSystem): T
+
+  override final def hashCode: Int = System.identityHashCode(this)
+  override final def equals(other: Any): Boolean = this eq other.asInstanceOf[AnyRef]
 }
 
 /**