# HG changeset patch
# User Jaroslav Tulach <jaroslav.tulach@apidesign.org>
# Date 1458388263 -3600
# Node ID bfaf3300b7baae37bf5be5d9f3953c1318f74bb9
# Parent  75ee4eca04e3ab8ab66a21519464cce786f1a06b
Making java.util.concurrent package compilable except ForkJoinPool

diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/aot-nb-test/pom.xml
--- a/rt/aot-nb-test/pom.xml	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/aot-nb-test/pom.xml	Sat Mar 19 12:51:03 2016 +0100
@@ -53,6 +53,12 @@
             <version>${project.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <type>jar</type>
+        </dependency>
     </dependencies>
     <build>
         <plugins>
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/aot-nb-test/src/main/java/org/apidesign/bck2brwsr/aot/junit/RunTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rt/aot-nb-test/src/main/java/org/apidesign/bck2brwsr/aot/junit/RunTest.java	Sat Mar 19 12:51:03 2016 +0100
@@ -0,0 +1,67 @@
+/**
+ * Back 2 Browser Bytecode Translator
+ * Copyright (C) 2012-2015 Jaroslav Tulach <jaroslav.tulach@apidesign.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. Look for COPYING file in the top folder.
+ * If not, see http://opensource.org/licenses/GPL-2.0.
+ */
+package org.apidesign.bck2brwsr.aot.junit;
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import junit.framework.AssertionFailedError;
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.Test;
+import junit.framework.TestListener;
+import junit.framework.TestResult;
+import junit.textui.ResultPrinter;
+
+public class RunTest extends ResultPrinter {
+    public static void main(String... args) throws UnsupportedEncodingException {
+        System.err.println(run());
+    }
+
+    public static String run() throws UnsupportedEncodingException {
+        TestResult tr = new TestResult();
+        class L implements TestListener {
+            StringBuilder sb = new StringBuilder();
+
+            @Override
+            public void addError(Test test, Throwable e) {
+                sb.append(test.toString()).append("\n");
+            }
+
+            @Override
+            public void addFailure(Test test, AssertionFailedError e) {
+                sb.append(test.toString()).append("\n");;
+            }
+
+            @Override
+            public void endTest(Test test) {
+            }
+
+            @Override
+            public void startTest(Test test) {
+            }
+        }
+        L listener = new L();
+        tr.addListener(listener);
+        JUnit4TestAdapter suite = new JUnit4TestAdapter(TestedTest.class);
+        suite.run(tr);
+        return listener.sb.toString();
+    }
+
+    RunTest(PrintStream writer) {
+        super(writer);
+    }
+}
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/aot-nb-test/src/main/java/org/apidesign/bck2brwsr/aot/junit/TestedTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rt/aot-nb-test/src/main/java/org/apidesign/bck2brwsr/aot/junit/TestedTest.java	Sat Mar 19 12:51:03 2016 +0100
@@ -0,0 +1,32 @@
+/**
+ * Back 2 Browser Bytecode Translator
+ * Copyright (C) 2012-2015 Jaroslav Tulach <jaroslav.tulach@apidesign.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. Look for COPYING file in the top folder.
+ * If not, see http://opensource.org/licenses/GPL-2.0.
+ */
+package org.apidesign.bck2brwsr.aot.junit;
+
+import org.junit.Test;
+import static org.junit.Assert.fail;
+
+public class TestedTest {
+    @Test
+    public void ok() {
+    }
+
+    @Test
+    public void error() {
+        fail("Failing");
+    }
+}
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/aot-nb-test/src/test/java/org/apidesign/bck2brwsr/aot/junit/test/JUnitRunTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rt/aot-nb-test/src/test/java/org/apidesign/bck2brwsr/aot/junit/test/JUnitRunTest.java	Sat Mar 19 12:51:03 2016 +0100
@@ -0,0 +1,37 @@
+/**
+ * Back 2 Browser Bytecode Translator
+ * Copyright (C) 2012-2015 Jaroslav Tulach <jaroslav.tulach@apidesign.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. Look for COPYING file in the top folder.
+ * If not, see http://opensource.org/licenses/GPL-2.0.
+ */
+package org.apidesign.bck2brwsr.aot.junit.test;
+
+import org.apidesign.bck2brwsr.aot.junit.RunTest;
+import org.apidesign.bck2brwsr.vmtest.Compare;
+import org.apidesign.bck2brwsr.vmtest.VMTest;
+import org.testng.annotations.Factory;
+
+/**
+ *
+ * @author Jaroslav Tulach
+ */
+public class JUnitRunTest {
+    @Compare public String runTests() throws Exception {
+        return RunTest.run();
+    }
+
+    @Factory public static Object[] create() {
+        return VMTest.create(JUnitRunTest.class);
+    }
+}
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/ConcurrentLinkedDeque.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/ConcurrentLinkedDeque.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/ConcurrentLinkedDeque.java	Sat Mar 19 12:51:03 2016 +0100
@@ -302,49 +302,39 @@
          * only be seen after publication via casNext or casPrev.
          */
         Node(E item) {
-            UNSAFE.putObject(this, itemOffset, item);
+            this.item = item;
         }
 
         boolean casItem(E cmp, E val) {
-            return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
+            if (item == cmp) {
+                item = val;
+                return true;
+            }
+            return false;
         }
 
         void lazySetNext(Node<E> val) {
-            UNSAFE.putOrderedObject(this, nextOffset, val);
+            this.next = val;
         }
 
         boolean casNext(Node<E> cmp, Node<E> val) {
-            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
+            if (next == cmp) {
+                next = val;
+                return true;
+            }
+            return false;
         }
 
         void lazySetPrev(Node<E> val) {
-            UNSAFE.putOrderedObject(this, prevOffset, val);
+            this.prev = val;
         }
 
         boolean casPrev(Node<E> cmp, Node<E> val) {
-            return UNSAFE.compareAndSwapObject(this, prevOffset, cmp, val);
-        }
-
-        // Unsafe mechanics
-
-        private static final sun.misc.Unsafe UNSAFE;
-        private static final long prevOffset;
-        private static final long itemOffset;
-        private static final long nextOffset;
-
-        static {
-            try {
-                UNSAFE = sun.misc.Unsafe.getUnsafe();
-                Class k = Node.class;
-                prevOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("prev"));
-                itemOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("item"));
-                nextOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("next"));
-            } catch (Exception e) {
-                throw new Error(e);
+            if (prev == cmp) {
+                prev = val;
+                return true;
             }
+            return false;
         }
     }
 
@@ -1438,32 +1428,25 @@
 
 
     private boolean casHead(Node<E> cmp, Node<E> val) {
-        return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
+        if (head == cmp) {
+            head = val;
+            return true;
+        }
+        return false;
     }
 
     private boolean casTail(Node<E> cmp, Node<E> val) {
-        return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);
+        if (tail == cmp) {
+            tail = val;
+            return true;
+        }
+        return false;
     }
 
-    // Unsafe mechanics
-
-    private static final sun.misc.Unsafe UNSAFE;
-    private static final long headOffset;
-    private static final long tailOffset;
     static {
         PREV_TERMINATOR = new Node<Object>();
         PREV_TERMINATOR.next = PREV_TERMINATOR;
         NEXT_TERMINATOR = new Node<Object>();
         NEXT_TERMINATOR.prev = NEXT_TERMINATOR;
-        try {
-            UNSAFE = sun.misc.Unsafe.getUnsafe();
-            Class k = ConcurrentLinkedDeque.class;
-            headOffset = UNSAFE.objectFieldOffset
-                (k.getDeclaredField("head"));
-            tailOffset = UNSAFE.objectFieldOffset
-                (k.getDeclaredField("tail"));
-        } catch (Exception e) {
-            throw new Error(e);
-        }
     }
 }
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/ConcurrentLinkedQueue.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/ConcurrentLinkedQueue.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/ConcurrentLinkedQueue.java	Sat Mar 19 12:51:03 2016 +0100
@@ -184,38 +184,27 @@
          * only be seen after publication via casNext.
          */
         Node(E item) {
-            UNSAFE.putObject(this, itemOffset, item);
+            this.item = item;
         }
 
         boolean casItem(E cmp, E val) {
-            return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
+            if (item == cmp) {
+                item = val;
+                return true;
+            }
+            return false;
         }
 
         void lazySetNext(Node<E> val) {
-            UNSAFE.putOrderedObject(this, nextOffset, val);
+            this.next = val;
         }
 
         boolean casNext(Node<E> cmp, Node<E> val) {
-            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
-        }
-
-        // Unsafe mechanics
-
-        private static final sun.misc.Unsafe UNSAFE;
-        private static final long itemOffset;
-        private static final long nextOffset;
-
-        static {
-            try {
-                UNSAFE = sun.misc.Unsafe.getUnsafe();
-                Class k = Node.class;
-                itemOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("item"));
-                nextOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("next"));
-            } catch (Exception e) {
-                throw new Error(e);
+            if (next == cmp) {
+                next = val;
+                return true;
             }
+            return false;
         }
     }
 
@@ -808,28 +797,19 @@
     }
 
     private boolean casTail(Node<E> cmp, Node<E> val) {
-        return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);
+        if (tail == cmp) {
+            tail = val;
+            return true;
+        }
+        return false;
     }
 
     private boolean casHead(Node<E> cmp, Node<E> val) {
-        return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
+        if (head == cmp) {
+            head = val;
+            return true;
+        }
+        return false;
     }
 
-    // Unsafe mechanics
-
-    private static final sun.misc.Unsafe UNSAFE;
-    private static final long headOffset;
-    private static final long tailOffset;
-    static {
-        try {
-            UNSAFE = sun.misc.Unsafe.getUnsafe();
-            Class k = ConcurrentLinkedQueue.class;
-            headOffset = UNSAFE.objectFieldOffset
-                (k.getDeclaredField("head"));
-            tailOffset = UNSAFE.objectFieldOffset
-                (k.getDeclaredField("tail"));
-        } catch (Exception e) {
-            throw new Error(e);
-        }
-    }
 }
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/ConcurrentSkipListMap.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/ConcurrentSkipListMap.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/ConcurrentSkipListMap.java	Sat Mar 19 12:51:03 2016 +0100
@@ -35,7 +35,6 @@
 
 package java.util.concurrent;
 import java.util.*;
-import java.util.concurrent.atomic.*;
 
 /**
  * A scalable concurrent {@link ConcurrentNavigableMap} implementation.
@@ -379,7 +378,11 @@
      * compareAndSet head node
      */
     private boolean casHead(HeadIndex<K,V> cmp, HeadIndex<K,V> val) {
-        return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
+        if (head == cmp) {
+            head = val;
+            return true;
+        }
+        return false;
     }
 
     /* ---------------- Nodes -------------- */
@@ -422,14 +425,22 @@
          * compareAndSet value field
          */
         boolean casValue(Object cmp, Object val) {
-            return UNSAFE.compareAndSwapObject(this, valueOffset, cmp, val);
+            if (value == cmp) {
+                value = val;
+                return true;
+            }
+            return false;
         }
 
         /**
          * compareAndSet next field
          */
         boolean casNext(Node<K,V> cmp, Node<K,V> val) {
-            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
+            if (next == cmp) {
+                next = val;
+                return true;
+            }
+            return false;
         }
 
         /**
@@ -507,25 +518,6 @@
                 return null;
             return new AbstractMap.SimpleImmutableEntry<K,V>(key, v);
         }
-
-        // UNSAFE mechanics
-
-        private static final sun.misc.Unsafe UNSAFE;
-        private static final long valueOffset;
-        private static final long nextOffset;
-
-        static {
-            try {
-                UNSAFE = sun.misc.Unsafe.getUnsafe();
-                Class k = Node.class;
-                valueOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("value"));
-                nextOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("next"));
-            } catch (Exception e) {
-                throw new Error(e);
-            }
-        }
     }
 
     /* ---------------- Indexing -------------- */
@@ -555,7 +547,11 @@
          * compareAndSet right field
          */
         final boolean casRight(Index<K,V> cmp, Index<K,V> val) {
-            return UNSAFE.compareAndSwapObject(this, rightOffset, cmp, val);
+            if (right == cmp) {
+                right = val;
+                return true;
+            }
+            return false;
         }
 
         /**
@@ -590,20 +586,6 @@
         final boolean unlink(Index<K,V> succ) {
             return !indexesDeletedNode() && casRight(succ, succ.right);
         }
-
-        // Unsafe mechanics
-        private static final sun.misc.Unsafe UNSAFE;
-        private static final long rightOffset;
-        static {
-            try {
-                UNSAFE = sun.misc.Unsafe.getUnsafe();
-                Class k = Index.class;
-                rightOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("right"));
-            } catch (Exception e) {
-                throw new Error(e);
-            }
-        }
     }
 
     /* ---------------- Head nodes -------------- */
@@ -3102,18 +3084,4 @@
             }
         }
     }
-
-    // Unsafe mechanics
-    private static final sun.misc.Unsafe UNSAFE;
-    private static final long headOffset;
-    static {
-        try {
-            UNSAFE = sun.misc.Unsafe.getUnsafe();
-            Class k = ConcurrentSkipListMap.class;
-            headOffset = UNSAFE.objectFieldOffset
-                (k.getDeclaredField("head"));
-        } catch (Exception e) {
-            throw new Error(e);
-        }
-    }
 }
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/ConcurrentSkipListSet.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/ConcurrentSkipListSet.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/ConcurrentSkipListSet.java	Sat Mar 19 12:51:03 2016 +0100
@@ -35,7 +35,6 @@
 
 package java.util.concurrent;
 import java.util.*;
-import sun.misc.Unsafe;
 
 /**
  * A scalable concurrent {@link NavigableSet} implementation based on
@@ -93,7 +92,7 @@
      * element.  This field is declared final for the sake of thread
      * safety, which entails some ugliness in clone()
      */
-    private final ConcurrentNavigableMap<E,Object> m;
+    private ConcurrentNavigableMap<E,Object> m;
 
     /**
      * Constructs a new, empty set that orders its elements according to
@@ -473,19 +472,6 @@
 
     // Support for resetting map in clone
     private void setMap(ConcurrentNavigableMap<E,Object> map) {
-        UNSAFE.putObjectVolatile(this, mapOffset, map);
-    }
-
-    private static final sun.misc.Unsafe UNSAFE;
-    private static final long mapOffset;
-    static {
-        try {
-            UNSAFE = sun.misc.Unsafe.getUnsafe();
-            Class k = ConcurrentSkipListSet.class;
-            mapOffset = UNSAFE.objectFieldOffset
-                (k.getDeclaredField("m"));
-        } catch (Exception e) {
-            throw new Error(e);
-        }
+        this.m = map;
     }
 }
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java	Sat Mar 19 12:51:03 2016 +0100
@@ -36,7 +36,6 @@
 package java.util.concurrent;
 import java.util.*;
 import java.util.concurrent.locks.*;
-import sun.misc.Unsafe;
 
 /**
  * A thread-safe variant of {@link java.util.ArrayList} in which all mutative
@@ -80,7 +79,7 @@
     private static final long serialVersionUID = 8673264195747942595L;
 
     /** The lock protecting all mutators */
-    transient final ReentrantLock lock = new ReentrantLock();
+    transient ReentrantLock lock = new ReentrantLock();
 
     /** The array, accessed only via getArray/setArray. */
     private volatile transient Object[] array;
@@ -1323,18 +1322,6 @@
 
     // Support for resetting lock while deserializing
     private void resetLock() {
-        UNSAFE.putObjectVolatile(this, lockOffset, new ReentrantLock());
-    }
-    private static final sun.misc.Unsafe UNSAFE;
-    private static final long lockOffset;
-    static {
-        try {
-            UNSAFE = sun.misc.Unsafe.getUnsafe();
-            Class k = CopyOnWriteArrayList.class;
-            lockOffset = UNSAFE.objectFieldOffset
-                (k.getDeclaredField("lock"));
-        } catch (Exception e) {
-            throw new Error(e);
-        }
+        this.lock = new ReentrantLock();
     }
 }
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/Exchanger.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/Exchanger.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/Exchanger.java	Sat Mar 19 12:51:03 2016 +0100
@@ -210,7 +210,7 @@
      */
 
     /** The number of CPUs, for sizing and spin control */
-    private static final int NCPU = Runtime.getRuntime().availableProcessors();
+    private static final int NCPU = 1;
 
     /**
      * The capacity of the arena.  Set to a value that provides more
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/Executors.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/Executors.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/Executors.java	Sat Mar 19 12:51:03 2016 +0100
@@ -36,13 +36,9 @@
 package java.util.concurrent;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.security.AccessControlContext;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.security.PrivilegedExceptionAction;
-import java.security.PrivilegedActionException;
-import java.security.AccessControlException;
-import sun.security.util.SecurityConstants;
 
 /**
  * Factory and utility methods for {@link Executor}, {@link
@@ -350,7 +346,7 @@
      * class loader.
      */
     public static ThreadFactory privilegedThreadFactory() {
-        return new PrivilegedThreadFactory();
+        throw new SecurityException();
     }
 
     /**
@@ -450,9 +446,7 @@
      * class loader.
      */
     public static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable) {
-        if (callable == null)
-            throw new NullPointerException();
-        return new PrivilegedCallableUsingCurrentClassLoader<T>(callable);
+        throw new SecurityException();
     }
 
     // Non-public classes supporting the public methods
@@ -478,76 +472,13 @@
      */
     static final class PrivilegedCallable<T> implements Callable<T> {
         private final Callable<T> task;
-        private final AccessControlContext acc;
 
         PrivilegedCallable(Callable<T> task) {
             this.task = task;
-            this.acc = AccessController.getContext();
         }
 
         public T call() throws Exception {
-            try {
-                return AccessController.doPrivileged(
-                    new PrivilegedExceptionAction<T>() {
-                        public T run() throws Exception {
-                            return task.call();
-                        }
-                    }, acc);
-            } catch (PrivilegedActionException e) {
-                throw e.getException();
-            }
-        }
-    }
-
-    /**
-     * A callable that runs under established access control settings and
-     * current ClassLoader
-     */
-    static final class PrivilegedCallableUsingCurrentClassLoader<T> implements Callable<T> {
-        private final Callable<T> task;
-        private final AccessControlContext acc;
-        private final ClassLoader ccl;
-
-        PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {
-            SecurityManager sm = System.getSecurityManager();
-            if (sm != null) {
-                // Calls to getContextClassLoader from this class
-                // never trigger a security check, but we check
-                // whether our callers have this permission anyways.
-                sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
-
-                // Whether setContextClassLoader turns out to be necessary
-                // or not, we fail fast if permission is not available.
-                sm.checkPermission(new RuntimePermission("setContextClassLoader"));
-            }
-            this.task = task;
-            this.acc = AccessController.getContext();
-            this.ccl = Thread.currentThread().getContextClassLoader();
-        }
-
-        public T call() throws Exception {
-            try {
-                return AccessController.doPrivileged(
-                    new PrivilegedExceptionAction<T>() {
-                        public T run() throws Exception {
-                            ClassLoader savedcl = null;
-                            Thread t = Thread.currentThread();
-                            try {
-                                ClassLoader cl = t.getContextClassLoader();
-                                if (ccl != cl) {
-                                    t.setContextClassLoader(ccl);
-                                    savedcl = cl;
-                                }
-                                return task.call();
-                            } finally {
-                                if (savedcl != null)
-                                    t.setContextClassLoader(savedcl);
-                            }
-                        }
-                    }, acc);
-            } catch (PrivilegedActionException e) {
-                throw e.getException();
-            }
+            return task.call();
         }
     }
 
@@ -556,23 +487,19 @@
      */
     static class DefaultThreadFactory implements ThreadFactory {
         private static final AtomicInteger poolNumber = new AtomicInteger(1);
-        private final ThreadGroup group;
         private final AtomicInteger threadNumber = new AtomicInteger(1);
         private final String namePrefix;
 
         DefaultThreadFactory() {
-            SecurityManager s = System.getSecurityManager();
-            group = (s != null) ? s.getThreadGroup() :
-                                  Thread.currentThread().getThreadGroup();
             namePrefix = "pool-" +
                           poolNumber.getAndIncrement() +
                          "-thread-";
         }
 
         public Thread newThread(Runnable r) {
-            Thread t = new Thread(group, r,
-                                  namePrefix + threadNumber.getAndIncrement(),
-                                  0);
+            Thread t = new Thread(r,
+                                  namePrefix + threadNumber.getAndIncrement()
+                                  );
             if (t.isDaemon())
                 t.setDaemon(false);
             if (t.getPriority() != Thread.NORM_PRIORITY)
@@ -582,44 +509,6 @@
     }
 
     /**
-     * Thread factory capturing access control context and class loader
-     */
-    static class PrivilegedThreadFactory extends DefaultThreadFactory {
-        private final AccessControlContext acc;
-        private final ClassLoader ccl;
-
-        PrivilegedThreadFactory() {
-            super();
-            SecurityManager sm = System.getSecurityManager();
-            if (sm != null) {
-                // Calls to getContextClassLoader from this class
-                // never trigger a security check, but we check
-                // whether our callers have this permission anyways.
-                sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
-
-                // Fail fast
-                sm.checkPermission(new RuntimePermission("setContextClassLoader"));
-            }
-            this.acc = AccessController.getContext();
-            this.ccl = Thread.currentThread().getContextClassLoader();
-        }
-
-        public Thread newThread(final Runnable r) {
-            return super.newThread(new Runnable() {
-                public void run() {
-                    AccessController.doPrivileged(new PrivilegedAction<Void>() {
-                        public Void run() {
-                            Thread.currentThread().setContextClassLoader(ccl);
-                            r.run();
-                            return null;
-                        }
-                    }, acc);
-                }
-            });
-        }
-    }
-
-    /**
      * A wrapper class that exposes only the ExecutorService methods
      * of an ExecutorService implementation.
      */
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/ForkJoinPool.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/ForkJoinPool.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/ForkJoinPool.java	Sat Mar 19 12:51:03 2016 +0100
@@ -48,7 +48,6 @@
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.RunnableFuture;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.locks.LockSupport;
 import java.util.concurrent.locks.ReentrantLock;
@@ -399,19 +398,11 @@
         defaultForkJoinWorkerThreadFactory;
 
     /**
-     * Permission required for callers of methods that may start or
-     * kill threads.
-     */
-    private static final RuntimePermission modifyThreadPermission;
-
-    /**
      * If there is a security manager, makes sure caller has
      * permission to modify threads.
      */
     private static void checkPermission() {
-        SecurityManager security = System.getSecurityManager();
-        if (security != null)
-            security.checkPermission(modifyThreadPermission);
+        throw new SecurityException();
     }
 
     /**
@@ -1411,7 +1402,7 @@
      *         java.lang.RuntimePermission}{@code ("modifyThread")}
      */
     public ForkJoinPool() {
-        this(Runtime.getRuntime().availableProcessors(),
+        this(1,
              defaultForkJoinWorkerThreadFactory, null, false);
     }
 
@@ -2131,7 +2122,6 @@
     }
 
     // Unsafe mechanics
-    private static final sun.misc.Unsafe UNSAFE;
     private static final long ctlOffset;
     private static final long stealCountOffset;
     private static final long blockedCountOffset;
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/LinkedTransferQueue.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/LinkedTransferQueue.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/LinkedTransferQueue.java	Sat Mar 19 12:51:03 2016 +0100
@@ -408,8 +408,7 @@
      */
 
     /** True if on multiprocessor */
-    private static final boolean MP =
-        Runtime.getRuntime().availableProcessors() > 1;
+    private static final boolean MP = false;
 
     /**
      * The number of times to spin (with randomly interspersed calls
@@ -453,12 +452,19 @@
 
         // CAS methods for fields
         final boolean casNext(Node cmp, Node val) {
-            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
+            if (next == cmp) {
+                next = val;
+                return true;
+            }
+            return false;
         }
 
         final boolean casItem(Object cmp, Object val) {
-            // assert cmp == null || cmp.getClass() != Node.class;
-            return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
+            if (item == cmp) {
+                item = val;
+                return true;
+            }
+            return false;
         }
 
         /**
@@ -466,7 +472,7 @@
          * only be seen after publication via casNext.
          */
         Node(Object item, boolean isData) {
-            UNSAFE.putObject(this, itemOffset, item); // relaxed write
+            this.item = item;
             this.isData = isData;
         }
 
@@ -475,7 +481,7 @@
          * only after CASing head field, so uses relaxed write.
          */
         final void forgetNext() {
-            UNSAFE.putObject(this, nextOffset, this);
+            this.next = this;
         }
 
         /**
@@ -488,8 +494,8 @@
          * else we don't care).
          */
         final void forgetContents() {
-            UNSAFE.putObject(this, itemOffset, this);
-            UNSAFE.putObject(this, waiterOffset, null);
+            this.item = this;
+            this.waiter = null;
         }
 
         /**
@@ -533,26 +539,6 @@
         }
 
         private static final long serialVersionUID = -3375979862319811754L;
-
-        // Unsafe mechanics
-        private static final sun.misc.Unsafe UNSAFE;
-        private static final long itemOffset;
-        private static final long nextOffset;
-        private static final long waiterOffset;
-        static {
-            try {
-                UNSAFE = sun.misc.Unsafe.getUnsafe();
-                Class k = Node.class;
-                itemOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("item"));
-                nextOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("next"));
-                waiterOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("waiter"));
-            } catch (Exception e) {
-                throw new Error(e);
-            }
-        }
     }
 
     /** head of the queue; null until first enqueue */
@@ -566,15 +552,27 @@
 
     // CAS methods for fields
     private boolean casTail(Node cmp, Node val) {
-        return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);
+        if (tail == cmp) {
+            tail = val;
+            return true;
+        }
+        return false;
     }
 
     private boolean casHead(Node cmp, Node val) {
-        return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
+        if (head == cmp) {
+            head = val;
+            return true;
+        }
+        return false;
     }
 
     private boolean casSweepVotes(int cmp, int val) {
-        return UNSAFE.compareAndSwapInt(this, sweepVotesOffset, cmp, val);
+        if (sweepVotes == cmp) {
+            sweepVotes = val;
+            return true;
+        }
+        return false;
     }
 
     /*
@@ -1327,25 +1325,4 @@
                 offer(item);
         }
     }
-
-    // Unsafe mechanics
-
-    private static final sun.misc.Unsafe UNSAFE;
-    private static final long headOffset;
-    private static final long tailOffset;
-    private static final long sweepVotesOffset;
-    static {
-        try {
-            UNSAFE = sun.misc.Unsafe.getUnsafe();
-            Class k = LinkedTransferQueue.class;
-            headOffset = UNSAFE.objectFieldOffset
-                (k.getDeclaredField("head"));
-            tailOffset = UNSAFE.objectFieldOffset
-                (k.getDeclaredField("tail"));
-            sweepVotesOffset = UNSAFE.objectFieldOffset
-                (k.getDeclaredField("sweepVotes"));
-        } catch (Exception e) {
-            throw new Error(e);
-        }
-    }
 }
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/Phaser.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/Phaser.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/Phaser.java	Sat Mar 19 12:51:03 2016 +0100
@@ -388,7 +388,7 @@
                 if (root == this || reconcileState() == s)
                     throw new IllegalStateException(badArrive(s));
             }
-            else if (UNSAFE.compareAndSwapLong(this, stateOffset, s, s-=adj)) {
+            else if (compareAndSwapLong(s, s-=adj)) {
                 if (unarrived == 0) {
                     long n = s & PARTIES_MASK;  // base of next state
                     int nextUnarrived = (int)n >>> PARTIES_SHIFT;
@@ -401,7 +401,7 @@
                     else
                         n |= nextUnarrived;
                     n |= (long)((phase + 1) & MAX_PHASE) << PHASE_SHIFT;
-                    UNSAFE.compareAndSwapLong(this, stateOffset, s, n);
+                    compareAndSwapLong(s, n);
                     releaseWaiters(phase);
                 }
                 return phase;
@@ -433,14 +433,13 @@
                 if (parent == null || reconcileState() == s) {
                     if (unarrived == 0)             // wait out advance
                         root.internalAwaitAdvance(phase, null);
-                    else if (UNSAFE.compareAndSwapLong(this, stateOffset,
-                                                       s, s + adj))
+                    else if (compareAndSwapLong(                                                       s, s + adj))
                         break;
                 }
             }
             else if (parent == null) {              // 1st root registration
                 long next = ((long)phase << PHASE_SHIFT) | adj;
-                if (UNSAFE.compareAndSwapLong(this, stateOffset, s, next))
+                if (compareAndSwapLong(s, next))
                     break;
             }
             else {
@@ -450,8 +449,8 @@
                         do {                        // force current phase
                             phase = (int)(root.state >>> PHASE_SHIFT);
                             // assert phase < 0 || (int)state == EMPTY;
-                        } while (!UNSAFE.compareAndSwapLong
-                                 (this, stateOffset, state,
+                        } while (!compareAndSwapLong
+                                 (state,
                                   ((long)phase << PHASE_SHIFT) | adj));
                         break;
                     }
@@ -482,8 +481,8 @@
             // CAS root phase with current parties; possibly trip unarrived
             while ((phase = (int)(root.state >>> PHASE_SHIFT)) !=
                    (int)(s >>> PHASE_SHIFT) &&
-                   !UNSAFE.compareAndSwapLong
-                   (this, stateOffset, s,
+                   !compareAndSwapLong
+                   (s,
                     s = (((long)phase << PHASE_SHIFT) |
                          (s & PARTIES_MASK) |
                          ((p = (int)s >>> PARTIES_SHIFT) == 0 ? EMPTY :
@@ -674,7 +673,7 @@
                 if (reconcileState() == s)
                     throw new IllegalStateException(badArrive(s));
             }
-            else if (UNSAFE.compareAndSwapLong(this, stateOffset, s,
+            else if (compareAndSwapLong(s,
                                                s -= ONE_ARRIVAL)) {
                 if (unarrived != 0)
                     return root.internalAwaitAdvance(phase, null);
@@ -690,7 +689,7 @@
                     n |= nextUnarrived;
                 int nextPhase = (phase + 1) & MAX_PHASE;
                 n |= (long)nextPhase << PHASE_SHIFT;
-                if (!UNSAFE.compareAndSwapLong(this, stateOffset, s, n))
+                if (!compareAndSwapLong(s, n))
                     return (int)(state >>> PHASE_SHIFT); // terminated
                 releaseWaiters(phase);
                 return nextPhase;
@@ -806,8 +805,7 @@
         final Phaser root = this.root;
         long s;
         while ((s = root.state) >= 0) {
-            if (UNSAFE.compareAndSwapLong(root, stateOffset,
-                                          s, s | TERMINATION_BIT)) {
+            if (compareAndSwapLong(                                          s, s | TERMINATION_BIT)) {
                 // signal all threads
                 releaseWaiters(0);
                 releaseWaiters(1);
@@ -999,7 +997,7 @@
     }
 
     /** The number of CPUs, for spin control */
-    private static final int NCPU = Runtime.getRuntime().availableProcessors();
+    private static final int NCPU = 1;
 
     /**
      * The number of times to spin before blocking while waiting for
@@ -1072,6 +1070,14 @@
         return p;
     }
 
+    private boolean compareAndSwapLong(long s, long l) {
+        if (this.state == s) {
+            this.state = l;
+            return true;
+        }
+        return false;
+    }
+
     /**
      * Wait nodes for Treiber stack representing wait queue
      */
@@ -1134,19 +1140,4 @@
             return isReleasable();
         }
     }
-
-    // Unsafe mechanics
-
-    private static final sun.misc.Unsafe UNSAFE;
-    private static final long stateOffset;
-    static {
-        try {
-            UNSAFE = sun.misc.Unsafe.getUnsafe();
-            Class k = Phaser.class;
-            stateOffset = UNSAFE.objectFieldOffset
-                (k.getDeclaredField("state"));
-        } catch (Exception e) {
-            throw new Error(e);
-        }
-    }
 }
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/PriorityBlockingQueue.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/PriorityBlockingQueue.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/PriorityBlockingQueue.java	Sat Mar 19 12:51:03 2016 +0100
@@ -276,9 +276,8 @@
     private void tryGrow(Object[] array, int oldCap) {
         lock.unlock(); // must release and then re-acquire main lock
         Object[] newArray = null;
-        if (allocationSpinLock == 0 &&
-            UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset,
-                                     0, 1)) {
+        if (allocationSpinLock == 0) {
+            allocationSpinLock = 1;
             try {
                 int newCap = oldCap + ((oldCap < 64) ?
                                        (oldCap + 2) : // grow faster if small
@@ -961,18 +960,4 @@
             q = null;
         }
     }
-
-    // Unsafe mechanics
-    private static final sun.misc.Unsafe UNSAFE;
-    private static final long allocationSpinLockOffset;
-    static {
-        try {
-            UNSAFE = sun.misc.Unsafe.getUnsafe();
-            Class k = PriorityBlockingQueue.class;
-            allocationSpinLockOffset = UNSAFE.objectFieldOffset
-                (k.getDeclaredField("allocationSpinLock"));
-        } catch (Exception e) {
-            throw new Error(e);
-        }
-    }
 }
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/SynchronousQueue.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/SynchronousQueue.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/SynchronousQueue.java	Sat Mar 19 12:51:03 2016 +0100
@@ -36,7 +36,6 @@
 
 package java.util.concurrent;
 import java.util.concurrent.locks.*;
-import java.util.concurrent.atomic.*;
 import java.util.*;
 
 /**
@@ -181,7 +180,7 @@
     }
 
     /** The number of CPUs, for spin control */
-    static final int NCPUS = Runtime.getRuntime().availableProcessors();
+    static final int NCPUS = 1;
 
     /**
      * The number of times to spin before blocking in timed waits.
@@ -242,8 +241,11 @@
             }
 
             boolean casNext(SNode cmp, SNode val) {
-                return cmp == next &&
-                    UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
+                if (next == cmp) {
+                    next = val;
+                    return true;
+                }
+                return false;
             }
 
             /**
@@ -255,8 +257,8 @@
              * @return true if successfully matched to s
              */
             boolean tryMatch(SNode s) {
-                if (match == null &&
-                    UNSAFE.compareAndSwapObject(this, matchOffset, null, s)) {
+                if (match == null) {
+                    match = s;
                     Thread w = waiter;
                     if (w != null) {    // waiters need at most one unpark
                         waiter = null;
@@ -271,38 +273,25 @@
              * Tries to cancel a wait by matching node to itself.
              */
             void tryCancel() {
-                UNSAFE.compareAndSwapObject(this, matchOffset, null, this);
+                if (match == null) {
+                    match = this;
+                }
             }
 
             boolean isCancelled() {
                 return match == this;
             }
-
-            // Unsafe mechanics
-            private static final sun.misc.Unsafe UNSAFE;
-            private static final long matchOffset;
-            private static final long nextOffset;
-
-            static {
-                try {
-                    UNSAFE = sun.misc.Unsafe.getUnsafe();
-                    Class k = SNode.class;
-                    matchOffset = UNSAFE.objectFieldOffset
-                        (k.getDeclaredField("match"));
-                    nextOffset = UNSAFE.objectFieldOffset
-                        (k.getDeclaredField("next"));
-                } catch (Exception e) {
-                    throw new Error(e);
-                }
-            }
         }
 
         /** The head (top) of the stack */
         volatile SNode head;
 
         boolean casHead(SNode h, SNode nh) {
-            return h == head &&
-                UNSAFE.compareAndSwapObject(this, headOffset, h, nh);
+            if (head == h) {
+                head = nh;
+                return true;
+            }
+            return false;
         }
 
         /**
@@ -506,20 +495,6 @@
                     p = n;
             }
         }
-
-        // Unsafe mechanics
-        private static final sun.misc.Unsafe UNSAFE;
-        private static final long headOffset;
-        static {
-            try {
-                UNSAFE = sun.misc.Unsafe.getUnsafe();
-                Class k = TransferStack.class;
-                headOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("head"));
-            } catch (Exception e) {
-                throw new Error(e);
-            }
-        }
     }
 
     /** Dual Queue */
@@ -546,20 +521,28 @@
             }
 
             boolean casNext(QNode cmp, QNode val) {
-                return next == cmp &&
-                    UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
+                if (next == cmp) {
+                    next = val;
+                    return true;
+                }
+                return false;
             }
 
             boolean casItem(Object cmp, Object val) {
-                return item == cmp &&
-                    UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
+                if (item == cmp) {
+                    item = val;
+                    return true;
+                }
+                return false;
             }
 
             /**
              * Tries to cancel by CAS'ing ref to this as item.
              */
             void tryCancel(Object cmp) {
-                UNSAFE.compareAndSwapObject(this, itemOffset, cmp, this);
+                if (item == cmp) {
+                    item = this;
+                }
             }
 
             boolean isCancelled() {
@@ -574,24 +557,6 @@
             boolean isOffList() {
                 return next == this;
             }
-
-            // Unsafe mechanics
-            private static final sun.misc.Unsafe UNSAFE;
-            private static final long itemOffset;
-            private static final long nextOffset;
-
-            static {
-                try {
-                    UNSAFE = sun.misc.Unsafe.getUnsafe();
-                    Class k = QNode.class;
-                    itemOffset = UNSAFE.objectFieldOffset
-                        (k.getDeclaredField("item"));
-                    nextOffset = UNSAFE.objectFieldOffset
-                        (k.getDeclaredField("next"));
-                } catch (Exception e) {
-                    throw new Error(e);
-                }
-            }
         }
 
         /** Head of queue */
@@ -616,25 +581,30 @@
          * old head's next node to avoid garbage retention.
          */
         void advanceHead(QNode h, QNode nh) {
-            if (h == head &&
-                UNSAFE.compareAndSwapObject(this, headOffset, h, nh))
+            if (head == h) {
+                head = nh;
                 h.next = h; // forget old next
+            }
         }
 
         /**
          * Tries to cas nt as new tail.
          */
         void advanceTail(QNode t, QNode nt) {
-            if (tail == t)
-                UNSAFE.compareAndSwapObject(this, tailOffset, t, nt);
+            if (tail == t) {
+                tail = nt;
+            }
         }
 
         /**
          * Tries to CAS cleanMe slot.
          */
         boolean casCleanMe(QNode cmp, QNode val) {
-            return cleanMe == cmp &&
-                UNSAFE.compareAndSwapObject(this, cleanMeOffset, cmp, val);
+            if (cleanMe == cmp) {
+                cleanMe = val;
+                return true;
+            }
+            return false;
         }
 
         /**
@@ -819,25 +789,6 @@
                     return;          // Postpone cleaning s
             }
         }
-
-        private static final sun.misc.Unsafe UNSAFE;
-        private static final long headOffset;
-        private static final long tailOffset;
-        private static final long cleanMeOffset;
-        static {
-            try {
-                UNSAFE = sun.misc.Unsafe.getUnsafe();
-                Class k = TransferQueue.class;
-                headOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("head"));
-                tailOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("tail"));
-                cleanMeOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("cleanMe"));
-            } catch (Exception e) {
-                throw new Error(e);
-            }
-        }
     }
 
     /**
@@ -1180,17 +1131,5 @@
             transferer = new TransferStack();
     }
 
-    // Unsafe mechanics
-    static long objectFieldOffset(sun.misc.Unsafe UNSAFE,
-                                  String field, Class<?> klazz) {
-        try {
-            return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
-        } catch (NoSuchFieldException e) {
-            // Convert Exception to corresponding Error
-            NoSuchFieldError error = new NoSuchFieldError(field);
-            error.initCause(e);
-            throw error;
-        }
-    }
 
 }
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/ThreadPoolExecutor.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/ThreadPoolExecutor.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/ThreadPoolExecutor.java	Sat Mar 19 12:51:03 2016 +0100
@@ -557,8 +557,8 @@
      * and failure to actually interrupt will merely delay response to
      * configuration changes so is not handled exceptionally.
      */
-    private static final RuntimePermission shutdownPerm =
-        new RuntimePermission("modifyThread");
+//    private static final RuntimePermission shutdownPerm =
+//        new RuntimePermission("modifyThread");
 
     /**
      * Class Worker mainly maintains interrupt control state for
@@ -706,18 +706,18 @@
      * specially.
      */
     private void checkShutdownAccess() {
-        SecurityManager security = System.getSecurityManager();
-        if (security != null) {
-            security.checkPermission(shutdownPerm);
-            final ReentrantLock mainLock = this.mainLock;
-            mainLock.lock();
-            try {
-                for (Worker w : workers)
-                    security.checkAccess(w.thread);
-            } finally {
-                mainLock.unlock();
-            }
-        }
+//        SecurityManager security = System.getSecurityManager();
+//        if (security != null) {
+//            security.checkPermission(shutdownPerm);
+//            final ReentrantLock mainLock = this.mainLock;
+//            mainLock.lock();
+//            try {
+//                for (Worker w : workers)
+//                    security.checkAccess(w.thread);
+//            } finally {
+//                mainLock.unlock();
+//            }
+//        }
     }
 
     /**
diff -r 75ee4eca04e3 -r bfaf3300b7ba rt/emul/compact/src/main/java/java/util/concurrent/TimeUnit.java
--- a/rt/emul/compact/src/main/java/java/util/concurrent/TimeUnit.java	Sat Mar 19 11:01:40 2016 +0100
+++ b/rt/emul/compact/src/main/java/java/util/concurrent/TimeUnit.java	Sat Mar 19 12:51:03 2016 +0100
@@ -362,6 +362,3 @@
     }
 
 }
-    }
-
-}