--- jsr166/src/jsr166y/Phaser.java	2009/07/23 23:07:57	1.18
+++ jsr166/src/jsr166y/Phaser.java	2009/07/26 17:33:37	1.22
@@ -7,10 +7,9 @@
 package jsr166y;
 
 import java.util.concurrent.*;
-import java.util.concurrent.atomic.*;
+
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.LockSupport;
-import sun.misc.Unsafe;
-import java.lang.reflect.*;
 
 /**
  * A reusable synchronization barrier, similar in functionality to a
@@ -931,49 +930,52 @@ public class Phaser {
         return p;
     }
 
-    // Temporary Unsafe mechanics for preliminary release
-    private static Unsafe getUnsafe() throws Throwable {
-        try {
-            return Unsafe.getUnsafe();
-        } catch (SecurityException se) {
-            try {
-                return java.security.AccessController.doPrivileged
-                    (new java.security.PrivilegedExceptionAction<Unsafe>() {
-                        public Unsafe run() throws Exception {
-                            return getUnsafePrivileged();
-                        }});
-            } catch (java.security.PrivilegedActionException e) {
-                throw e.getCause();
-            }
-        }
-    }
+    // Unsafe mechanics
 
-    private static Unsafe getUnsafePrivileged()
-            throws NoSuchFieldException, IllegalAccessException {
-        Field f = Unsafe.class.getDeclaredField("theUnsafe");
-        f.setAccessible(true);
-        return (Unsafe) f.get(null);
-    }
+    private static final sun.misc.Unsafe UNSAFE = getUnsafe();
+    private static final long stateOffset =
+        objectFieldOffset("state", Phaser.class);
 
-    private static long fieldOffset(String fieldName)
-            throws NoSuchFieldException {
-        return UNSAFE.objectFieldOffset
-            (Phaser.class.getDeclaredField(fieldName));
+    private final boolean casState(long cmp, long val) {
+        return UNSAFE.compareAndSwapLong(this, stateOffset, cmp, val);
     }
 
-    static final Unsafe UNSAFE;
-    static final long stateOffset;
-
-    static {
+    private static long objectFieldOffset(String field, Class<?> klazz) {
         try {
-            UNSAFE = getUnsafe();
-            stateOffset = fieldOffset("state");
-        } catch (Throwable e) {
-            throw new RuntimeException("Could not initialize intrinsics", e);
+            return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
+        } catch (NoSuchFieldException e) {
+            // Convert Exception to corresponding Error
+            NoSuchFieldError error = new NoSuchFieldError(field);
+            error.initCause(e);
+            throw error;
         }
     }
 
-    final boolean casState(long cmp, long val) {
-        return UNSAFE.compareAndSwapLong(this, stateOffset, cmp, val);
+    /**
+     * Returns a sun.misc.Unsafe.  Suitable for use in a 3rd party package.
+     * Replace with a simple call to Unsafe.getUnsafe when integrating
+     * into a jdk.
+     *
+     * @return a sun.misc.Unsafe
+     */
+    private static sun.misc.Unsafe getUnsafe() {
+        try {
+            return sun.misc.Unsafe.getUnsafe();
+        } catch (SecurityException se) {
+            try {
+                return java.security.AccessController.doPrivileged
+                    (new java.security
+                     .PrivilegedExceptionAction<sun.misc.Unsafe>() {
+                        public sun.misc.Unsafe run() throws Exception {
+                            java.lang.reflect.Field f = sun.misc
+                                .Unsafe.class.getDeclaredField("theUnsafe");
+                            f.setAccessible(true);
+                            return (sun.misc.Unsafe) f.get(null);
+                        }});
+            } catch (java.security.PrivilegedActionException e) {
+                throw new RuntimeException("Could not initialize intrinsics",
+                                           e.getCause());
+            }
+        }
     }
 }