< prev index next >

src/java.base/share/classes/jdk/internal/misc/SharedSecrets.java

Print this page

        

@@ -42,17 +42,20 @@
     provided through a third package to which access is restricted.
     This framework avoids the primary disadvantage of using reflection
     for this purpose, namely the loss of compile-time checking. */
 
 public class SharedSecrets {
-    private static final Unsafe unsafe = Unsafe.getUnsafe();
+    private static final class U {
+        static final Unsafe unsafe = Unsafe.getUnsafe();
+    }
     private static JavaUtilJarAccess javaUtilJarAccess;
     private static JavaLangAccess javaLangAccess;
     private static JavaLangModuleAccess javaLangModuleAccess;
     private static JavaLangReflectModuleAccess javaLangReflectModuleAccess;
     private static JavaLangInvokeAccess javaLangInvokeAccess;
     private static JavaLangRefAccess javaLangRefAccess;
+    private static JavaLangThreadAccess javaLangThreadAccess;
     private static JavaIOAccess javaIOAccess;
     private static JavaNetAccess javaNetAccess;
     private static JavaNetInetAddressAccess javaNetInetAddressAccess;
     private static JavaNetHttpCookieAccess javaNetHttpCookieAccess;
     private static JavaNioAccess javaNioAccess;

@@ -69,11 +72,11 @@
 
     public static JavaUtilJarAccess javaUtilJarAccess() {
         if (javaUtilJarAccess == null) {
             // Ensure JarFile is initialized; we know that that class
             // provides the shared secret
-            unsafe.ensureClassInitialized(JarFile.class);
+            U.unsafe.ensureClassInitialized(JarFile.class);
         }
         return javaUtilJarAccess;
     }
 
     public static void setJavaUtilJarAccess(JavaUtilJarAccess access) {

@@ -94,11 +97,11 @@
 
     public static JavaLangInvokeAccess getJavaLangInvokeAccess() {
         if (javaLangInvokeAccess == null) {
             try {
                 Class<?> c = Class.forName("java.lang.invoke.MemberName");
-                unsafe.ensureClassInitialized(c);
+                U.unsafe.ensureClassInitialized(c);
             } catch (ClassNotFoundException e) {};
         }
         return javaLangInvokeAccess;
     }
 

@@ -106,22 +109,22 @@
         javaLangModuleAccess = jlrma;
     }
 
     public static JavaLangModuleAccess getJavaLangModuleAccess() {
         if (javaLangModuleAccess == null) {
-            unsafe.ensureClassInitialized(ModuleDescriptor.class);
+            U.unsafe.ensureClassInitialized(ModuleDescriptor.class);
         }
         return javaLangModuleAccess;
     }
 
     public static void setJavaLangReflectModuleAccess(JavaLangReflectModuleAccess jlrma) {
         javaLangReflectModuleAccess = jlrma;
     }
 
     public static JavaLangReflectModuleAccess getJavaLangReflectModuleAccess() {
         if (javaLangReflectModuleAccess == null)
-            unsafe.ensureClassInitialized(java.lang.reflect.Module.class);
+            U.unsafe.ensureClassInitialized(java.lang.reflect.Module.class);
         return javaLangReflectModuleAccess;
     }
 
     public static void setJavaLangRefAccess(JavaLangRefAccess jlra) {
         javaLangRefAccess = jlra;

@@ -129,37 +132,45 @@
 
     public static JavaLangRefAccess getJavaLangRefAccess() {
         return javaLangRefAccess;
     }
 
+    public static void setJavaLangThreadAccess(JavaLangThreadAccess jlta) {
+        SharedSecrets.javaLangThreadAccess = jlta;
+    }
+
+    public static JavaLangThreadAccess getJavaLangThreadAccess() {
+        return javaLangThreadAccess;
+    }
+
     public static void setJavaNetAccess(JavaNetAccess jna) {
         javaNetAccess = jna;
     }
 
     public static JavaNetAccess getJavaNetAccess() {
         if (javaNetAccess == null)
-            unsafe.ensureClassInitialized(java.net.URLClassLoader.class);
+            U.unsafe.ensureClassInitialized(java.net.URLClassLoader.class);
         return javaNetAccess;
     }
 
     public static void setJavaNetInetAddressAccess(JavaNetInetAddressAccess jna) {
         javaNetInetAddressAccess = jna;
     }
 
     public static JavaNetInetAddressAccess getJavaNetInetAddressAccess() {
         if (javaNetInetAddressAccess == null)
-            unsafe.ensureClassInitialized(java.net.InetAddress.class);
+            U.unsafe.ensureClassInitialized(java.net.InetAddress.class);
         return javaNetInetAddressAccess;
     }
 
     public static void setJavaNetHttpCookieAccess(JavaNetHttpCookieAccess a) {
         javaNetHttpCookieAccess = a;
     }
 
     public static JavaNetHttpCookieAccess getJavaNetHttpCookieAccess() {
         if (javaNetHttpCookieAccess == null)
-            unsafe.ensureClassInitialized(java.net.HttpCookie.class);
+            U.unsafe.ensureClassInitialized(java.net.HttpCookie.class);
         return javaNetHttpCookieAccess;
     }
 
     public static void setJavaNioAccess(JavaNioAccess jna) {
         javaNioAccess = jna;

@@ -168,33 +179,33 @@
     public static JavaNioAccess getJavaNioAccess() {
         if (javaNioAccess == null) {
             // Ensure java.nio.ByteOrder is initialized; we know that
             // this class initializes java.nio.Bits that provides the
             // shared secret.
-            unsafe.ensureClassInitialized(java.nio.ByteOrder.class);
+            U.unsafe.ensureClassInitialized(java.nio.ByteOrder.class);
         }
         return javaNioAccess;
     }
 
     public static void setJavaIOAccess(JavaIOAccess jia) {
         javaIOAccess = jia;
     }
 
     public static JavaIOAccess getJavaIOAccess() {
         if (javaIOAccess == null) {
-            unsafe.ensureClassInitialized(Console.class);
+            U.unsafe.ensureClassInitialized(Console.class);
         }
         return javaIOAccess;
     }
 
     public static void setJavaIOFileDescriptorAccess(JavaIOFileDescriptorAccess jiofda) {
         javaIOFileDescriptorAccess = jiofda;
     }
 
     public static JavaIOFileDescriptorAccess getJavaIOFileDescriptorAccess() {
         if (javaIOFileDescriptorAccess == null)
-            unsafe.ensureClassInitialized(FileDescriptor.class);
+            U.unsafe.ensureClassInitialized(FileDescriptor.class);
 
         return javaIOFileDescriptorAccess;
     }
 
     public static void setJavaSecurityProtectionDomainAccess

@@ -203,28 +214,28 @@
     }
 
     public static JavaSecurityProtectionDomainAccess
         getJavaSecurityProtectionDomainAccess() {
             if (javaSecurityProtectionDomainAccess == null)
-                unsafe.ensureClassInitialized(ProtectionDomain.class);
+                U.unsafe.ensureClassInitialized(ProtectionDomain.class);
             return javaSecurityProtectionDomainAccess;
     }
 
     public static void setJavaSecurityAccess(JavaSecurityAccess jsa) {
         javaSecurityAccess = jsa;
     }
 
     public static JavaSecurityAccess getJavaSecurityAccess() {
         if (javaSecurityAccess == null) {
-            unsafe.ensureClassInitialized(AccessController.class);
+            U.unsafe.ensureClassInitialized(AccessController.class);
         }
         return javaSecurityAccess;
     }
 
     public static JavaUtilZipFileAccess getJavaUtilZipFileAccess() {
         if (javaUtilZipFileAccess == null)
-            unsafe.ensureClassInitialized(java.util.zip.ZipFile.class);
+            U.unsafe.ensureClassInitialized(java.util.zip.ZipFile.class);
         return javaUtilZipFileAccess;
     }
 
     public static void setJavaUtilZipFileAccess(JavaUtilZipFileAccess access) {
         javaUtilZipFileAccess = access;

@@ -266,11 +277,11 @@
         javaUtilResourceBundleAccess = access;
     }
 
     public static JavaObjectInputStreamAccess getJavaObjectInputStreamAccess() {
         if (javaObjectInputStreamAccess == null) {
-            unsafe.ensureClassInitialized(ObjectInputStream.class);
+            U.unsafe.ensureClassInitialized(ObjectInputStream.class);
         }
         return javaObjectInputStreamAccess;
     }
 
     public static void setJavaObjectInputStreamAccess(JavaObjectInputStreamAccess access) {

@@ -281,10 +292,10 @@
         javaIORandomAccessFileAccess = jirafa;
     }
 
     public static JavaIORandomAccessFileAccess getJavaIORandomAccessFileAccess() {
         if (javaIORandomAccessFileAccess == null) {
-            unsafe.ensureClassInitialized(RandomAccessFile.class);
+            U.unsafe.ensureClassInitialized(RandomAccessFile.class);
         }
         return javaIORandomAccessFileAccess;
     }
 }
< prev index next >