diff --git a/akka-actor/src/main/java/akka/dispatch/AbstractPromise.java b/akka-actor/src/main/java/akka/dispatch/AbstractPromise.java
index 90344eb10a..7e534cb7e0 100644
--- a/akka-actor/src/main/java/akka/dispatch/AbstractPromise.java
+++ b/akka-actor/src/main/java/akka/dispatch/AbstractPromise.java
@@ -4,10 +4,31 @@
 
 package akka.dispatch;
 
-import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+import akka.util.Unsafe;
 
 abstract class AbstractPromise {
-    private volatile Object _ref = DefaultPromise.EmptyPending();
-    protected final static AtomicReferenceFieldUpdater<AbstractPromise, Object> updater =
-            AtomicReferenceFieldUpdater.newUpdater(AbstractPromise.class, Object.class, "_ref");
+    private volatile Object _ref;
+
+    {
+    	if (!updateState(null, DefaultPromise.EmptyPending()))
+    		throw new ExceptionInInitializerError(new IllegalStateException("AbstractPromise initial value not null!"));
+    }
+
+    final static long _refOffset;
+
+    static {
+        try {
+          _refOffset = Unsafe.instance.objectFieldOffset(AbstractPromise.class.getDeclaredField("_ref"));
+        } catch(Throwable t){
+            throw new ExceptionInInitializerError(t);
+        }
+    }
+
+  protected final boolean updateState(Object oldState, Object newState) { 
+  	return Unsafe.instance.compareAndSwapObject(this, _refOffset, oldState, newState);
+  }
+
+  protected final Object getState() {
+  	return Unsafe.instance.getObjectVolatile(this, _refOffset);
+  }
 }
diff --git a/akka-actor/src/main/scala/akka/dispatch/Future.scala b/akka-actor/src/main/scala/akka/dispatch/Future.scala
index 300d44f0be..3765fe3546 100644
--- a/akka-actor/src/main/scala/akka/dispatch/Future.scala
+++ b/akka-actor/src/main/scala/akka/dispatch/Future.scala
@@ -19,7 +19,7 @@ import akka.event.Logging.LogEventException
 import akka.event.Logging.Debug
 import java.util.concurrent.TimeUnit.NANOSECONDS
 import java.util.concurrent.{ ExecutionException, Callable, TimeoutException }
-import java.util.concurrent.atomic.{ AtomicInteger, AtomicReferenceFieldUpdater }
+import java.util.concurrent.atomic.{ AtomicInteger }
 import akka.pattern.AskTimeoutException
 import scala.util.DynamicVariable
 import scala.runtime.BoxedUnit
@@ -887,15 +887,6 @@ class DefaultPromise[T](implicit val executor: ExecutionContext) extends Abstrac
     case _               ⇒ false
   }
 
-  @inline
-  private[this] final def updater = AbstractPromise.updater.asInstanceOf[AtomicReferenceFieldUpdater[AbstractPromise, AnyRef]]
-
-  @inline
-  protected final def updateState(oldState: AnyRef, newState: AnyRef): Boolean = updater.compareAndSet(this, oldState, newState)
-
-  @inline
-  protected final def getState: AnyRef = updater.get(this)
-
   def tryComplete(value: Either[Throwable, T]): Boolean = {
     val callbacks: List[Either[Throwable, T] ⇒ Unit] = {
       try {