ClassLoader中文类加载器，java编写出来的是.java文件，然后编译成.class文件，而ClassLoader就是把class文件加载到jvm内存中；但jvm启动时，通过不同的类加载器，动态的加载class文件；java比较重要的三类加载器Bootstrap ClassLoader、 Extention ClassLoader、Appclass Loader。

Bootstrap ClassLoader、 Extention ClassLoader、Appclass Loader这三个类加载器分别负责加载不同路径下的文件

它是最顶级的类加载，主要加载载核心类库，其路径为%JRE_HOME%\lib下的rt.jar、resources.jar、charsets.jar和class等，而这个路径是可以通过jvm启动参数-Xbootclasspath来设置

扩展的类加载器，加载目录%JRE_HOME%\lib\ext目录下的jar包和class文件。

当前应用的classpath的所有类

 

  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by Fernflower decompiler)
  4. //
  5.  
  6. package sun.misc;
  8. import java.io.File;
  9. import java.io.IOException;
  10. import java.net.MalformedURLException;
  11. import java.net.URL;
  12. import java.net.URLClassLoader;
  13. import java.net.URLStreamHandler;
  14. import java.net.URLStreamHandlerFactory;
  15. import java.security.AccessControlContext;
  16. import java.security.AccessController;
  17. import java.security.CodeSource;
  18. import java.security.PermissionCollection;
  19. import java.security.PrivilegedAction;
  20. import java.security.PrivilegedActionException;
  21. import java.security.PrivilegedExceptionAction;
  22. import java.security.ProtectionDomain;
  23. import java.security.cert.Certificate;
  24. import java.util.HashSet;
  25. import java.util.StringTokenizer;
  26. import java.util.Vector;
  27. import sun.net.www.ParseUtil;
  29. public class Launcher {
  30.     private static URLStreamHandlerFactory factory = new Launcher.Factory();
  31.     private static Launcher launcher = new Launcher();
    　　
  32.     private static String bootClassPath = System.getProperty("sun.boot.class.path");
  33.     

    　　private ClassLoader loader;
  34.     private static URLStreamHandler fileHandler;
  36.     public static Launcher getLauncher() {
  37.         return launcher;
  38.     }
  40.     public Launcher() {
  41.         Launcher.ExtClassLoader var1;
  42.         try {
  43.             var1 = Launcher.ExtClassLoader.getExtClassLoader();
  44.         } catch (IOException var10) {
  45.             throw new InternalError("Could not create extension class loader");
  46.         }
  48.         try {
  49.             this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
  50.         } catch (IOException var9) {
  51.             throw new InternalError("Could not create application class loader");
  52.         }
  54.         Thread.currentThread().setContextClassLoader(this.loader);
  55.         String var2 = System.getProperty("java.security.manager");
  56.         if (var2 != null) {
  57.             SecurityManager var3 = null;
  58.             if (!"".equals(var2) && !"default".equals(var2)) {
  59.                 try {
  60.                     var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
  61.                 } catch (IllegalAccessException var5) {
  62.                     ;
  63.                 } catch (InstantiationException var6) {
  64.                     ;
  65.                 } catch (ClassNotFoundException var7) {
  66.                     ;
  67.                 } catch (ClassCastException var8) {
  68.                     ;
  69.                 }
  70.             } else {
  71.                 var3 = new SecurityManager();
  72.             }
  74.             if (var3 == null) {
  75.                 throw new InternalError("Could not create SecurityManager: " + var2);
  76.             }
  78.             System.setSecurityManager(var3);
  79.         }
  81.     }
  83.     public ClassLoader getClassLoader() {
  84.         return this.loader;
  85.     }
  87.     public static URLClassPath getBootstrapClassPath() {
  88.         return Launcher.BootClassPathHolder.bcp;
  89.     }

  90. 　　………………………………
  91.    
  92. }

 

1. 没有看到 Bootstrap ClassLoader，只有bootClassPath，这个应该就是顶级类加载器的加载路径；

2.Launcher 先初始化了Extention ClassLoader ，然后把传入它实例再初始化AppClassLoader。

  1. static class ExtClassLoader extends URLClassLoader {
  2.         public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
    　　　　　　　　
    　　　　　　　//获取加载的文件，进入getExtDirs可以看到加载的文件路径    String var0 = System.getProperty("java.ext.dirs")
  1. final File[] var0 = getExtDirs();
  3.             try {
  4.                 return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction<Launcher.ExtClassLoader>() {
  5.                     public Launcher.ExtClassLoader run() throws IOException {
  6.                         int var1 = var0.length;
  8.                         for(int var2 = 0; var2 < var1; ++var2) {
  9.                             MetaIndex.registerDirectory(var0[var2]);
  10.                         }
  11. 　　　　　　　　　　　　　　//创建类加载
  12.                         return new Launcher.ExtClassLoader(var0);
  13.                     }
  14.                 });
  15.             } catch (PrivilegedActionException var2) {
  16.                 throw (IOException)var2.getException();
  17.             }
  18.         }
  20.         void addExtURL(URL var1) {
  21.             super.addURL(var1);
  22.         }
  23. 　　　　　　
  24.         public ExtClassLoader(File[] var1) throws IOException {
    　　　　　　　
    　　　　　　　　//调用父类方法创建，留意到第二个参数为null,这个参数是父加载器，预测ExtClassLoader是没有父加载器的
    　　　　　　　　super(getExtURLs(var1), (ClassLoader)null, Launcher.factory);
  1.         }
  3.         private static File[] getExtDirs() {
  4.             String var0 = System.getProperty("java.ext.dirs");
  5.             File[] var1;
  6.             if (var0 != null) {
  7.                 StringTokenizer var2 = new StringTokenizer(var0, File.pathSeparator);
  8.                 int var3 = var2.countTokens();
  9.                 var1 = new File[var3];
  11.                 for(int var4 = 0; var4 < var3; ++var4) {
  12.                     var1[var4] = new File(var2.nextToken());
  13.                 }
  14.             } else {
  15.                 var1 = new File[0];
  16.             }
  18.             return var1;
  19.         }
  21.         private static URL[] getExtURLs(File[] var0) throws IOException {
  22.             Vector var1 = new Vector();
  24.             for(int var2 = 0; var2 < var0.length; ++var2) {
  25.                 String[] var3 = var0[var2].list();
  26.                 if (var3 != null) {
  27.                     for(int var4 = 0; var4 < var3.length; ++var4) {
  28.                         if (!var3[var4].equals("meta-index")) {
  29.                             File var5 = new File(var0[var2], var3[var4]);
  30.                             var1.add(Launcher.getFileURL(var5));
  31.                         }
  32.                     }
  33.                 }
  34.             }
  36.             URL[] var6 = new URL[var1.size()];
  37.             var1.copyInto(var6);
  38.             return var6;
  39.         }
  41.         public String findLibrary(String var1) {
  42.             var1 = System.mapLibraryName(var1);
  43.             URL[] var2 = super.getURLs();
  44.             File var3 = null;
  46.             for(int var4 = 0; var4 < var2.length; ++var4) {
  47.                 File var5 = (new File(var2[var4].getPath())).getParentFile();
  48.                 if (var5 != null && !var5.equals(var3)) {
  49.                     String var6 = VM.getSavedProperty("os.arch");
  50.                     File var7;
  51.                     if (var6 != null) {
  52.                         var7 = new File(new File(var5, var6), var1);
  53.                         if (var7.exists()) {
  54.                             return var7.getAbsolutePath();
  55.                         }
  56.                     }
  58.                     var7 = new File(var5, var1);
  59.                     if (var7.exists()) {
  60.                         return var7.getAbsolutePath();
  61.                     }
  62.                 }
  64.                 var3 = var5;
  65.             }
  67.             return null;
  68.         }
  70.         private static AccessControlContext getContext(File[] var0) throws IOException {
  71.             PathPermissions var1 = new PathPermissions(var0);
  72.             ProtectionDomain var2 = new ProtectionDomain(new CodeSource(var1.getCodeBase(), (Certificate[])null), var1);
  73.             AccessControlContext var3 = new AccessControlContext(new ProtectionDomain[]{var2});
  74.             return var3;
  75.         }
  77.         static {
  78.             ClassLoader.registerAsParallelCapable();
  79.         }
  80.     }




看看ExtenTionClassLoader初始化做了什么 

从上面可以看到ExtClassLoader extends URLClassLoader，初始化ExtClassLoader先读取java.ext.dirs路径(D:\java7\jre\lib\ext;C:\Windows\Sun\Java\lib\ext)下的文件，然后调用URLClassLoader.supper()–>

SecureClassLoader.supper()–>ClassLoader.supper()–>方法创建,因为传入的parent是null,可以看到ExtClassLoader 没有父加载器的；简单说就是加载java.ext.dirs的文件创建了个无父加载器的类加载器。

 

  1. public static void main(String[] args) {
  2.         System.out.println(System.getProperty("java.ext.dirs"));
  3.     }
  5. /*
  6. D:\java7\jre\lib\ext;C:\Windows\Sun\Java\lib\ext
  7. */

    /*
    URLClassLoader extends SecureClassLoader implements Closeable
  1. */
  1. public URLClassLoader(URL[] urls, ClassLoader parent,
                          URLStreamHandlerFactory factory) {
     super(parent);
        // this is to make the stack depth consistent with 1.1
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkCreateClassLoader();
        }
        ucp = new URLClassPath(urls, factory);
        acc = AccessController.getContext();
    }

　/******************************************************************************/

  /*

  SecureClassLoader extends ClassLoader

  */

  1. protected SecureClassLoader(ClassLoader parent) {
    super(parent);
        // this is to make the stack depth consistent with 1.1
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkCreateClassLoader();
        }
        initialized = true;
    }

  /******************************************************************************/

  1. /*
  1. ClassLoader类
  1. */
  1. protected ClassLoader(ClassLoader parent) {
        this(checkCreateClassLoader(), parent);
    }
  1. private ClassLoader(Void unused, ClassLoader parent) {
        this.parent = parent;
        if (ParallelLoaders.isRegistered(this.getClass())) {
            parallelLockMap = new ConcurrentHashMap<>();
            package2certs = new ConcurrentHashMap<>();
            domains =
                Collections.synchronizedSet(new HashSet<ProtectionDomain>());
            assertionLock = new Object();
        } else {
            // no finer-grained lock; lock on the classloader instance
            parallelLockMap = null;
            package2certs = new Hashtable<>();
            domains = new HashSet<>();
            assertionLock = this;
        }
    }

 

  1. static class AppClassLoader extends URLClassLoader {
  2.         public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
  3.             final String var1 = System.getProperty("java.class.path");
  4.             final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);
  5.             return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
  6.                 public Launcher.AppClassLoader run() {
  7.                     URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);
  8.                     return new Launcher.AppClassLoader(var1x, var0);
  9.                 }
  10.             });
  11.         }
  13.         AppClassLoader(URL[] var1, ClassLoader var2) {
  14.             super(var1, var2, Launcher.factory);
  15.         }
  17.         public Class loadClass(String var1, boolean var2) throws ClassNotFoundException {
  18.             int var3 = var1.lastIndexOf(46);
  19.             if (var3 != -1) {
  20.                 SecurityManager var4 = System.getSecurityManager();
  21.                 if (var4 != null) {
  22.                     var4.checkPackageAccess(var1.substring(0, var3));
  23.                 }
  24.             }
  26.             return super.loadClass(var1, var2);
  27.         }
  29.         protected PermissionCollection getPermissions(CodeSource var1) {
  30.             PermissionCollection var2 = super.getPermissions(var1);
  31.             var2.add(new RuntimePermission("exitVM"));
  32.             return var2;
  33.         }
  35.         private void appendToClassPathForInstrumentation(String var1) {
  36.             assert Thread.holdsLock(this);
  38.             super.addURL(Launcher.getFileURL(new File(var1)));
  39.         }
  41.         private static AccessControlContext getContext(File[] var0) throws MalformedURLException {
  42.             PathPermissions var1 = new PathPermissions(var0);
  43.             ProtectionDomain var2 = new ProtectionDomain(new CodeSource(var1.getCodeBase(), (Certificate[])null), var1);
  44.             AccessControlContext var3 = new AccessControlContext(new ProtectionDomain[]{var2});
  45.             return var3;
  46.         }
  48.         static {
  49.             ClassLoader.registerAsParallelCapable();
  50.         }
  51.     }

 

从上面看APPClassLoader也是继承URLClassLoader，与ExtClassLoader不同的是，

1.读取的路径是java.class.path

2.把ExtClassLoader的实例作为APPClassLoader的父加载器，也就是说APPClassLoader的父类加载器是ExtClassLoader

3.加载顺序Bootstrap ClassLoader 到 ExtClassLoader 到 APPClassLoader

首先我们先要明确一点是父加载器并不是父类，我们可以通过下面的代码看到

  1. public class MyClassLoader extends URLClassLoader {
  3.     public MyClassLoader(URL[] repositories) {
  4.         super(repositories);
  5.     }
  7.     public MyClassLoader(URL[] repositories, ClassLoader parent) {
  8.         super(repositories, parent);
  9.     }
  11. }
  13. 　　public static void main(String[] args) {
  14.         ClassLoader cl = MyClassLoader.class.getClassLoader();
  15.         System.out.println("ClassLoader is:"+cl.toString());
  16.         System.out.println("ClassLoader\'s parent is:"+cl.getParent().toString());
  17. //        System.out.println("ClassLoader\'s grand father is:"+cl.getParent().getParent().toString());
  18.     }
  21. ClassLoader is:sun.misc.Launcher$AppClassLoader@31fc6b2
  22. ClassLoader's parent is:sun.misc.Launcher$ExtClassLoader@1b2dd1b8

 

1.MyClassLoader 继承URLClassLoader，但是可以到店MyClassLoader的父加载器是AppClassLoader

2.AppClassLoader 的父加载器是ExtClassLoader，这个在上面分析初始化的APPClassLoader的时候，就可以看到传入ExtClassLoader的实例作为它的加载器，那么ExtClassLoader的父加载器上面初始时是null，我们可以验证一下

  1.     public static void main(String[] args) {
  2.         ClassLoader cl = MyClassLoader.class.getClassLoader();
  3. //        System.out.println("ClassLoader is:"+cl.toString());
  4. //        System.out.println("ClassLoader\'s parent is:"+cl.getParent().toString());
  5.         System.out.println("ClassLoader\'s grand father is:"+cl.getParent().getParent().toString());
  6.     }
  9. Exception in thread "main" java.lang.NullPointerException
  10.     at com.suntek.vdm.gw.util.NotifyHandler.main(NotifyHandler.java:373)

 

从上面的代码可以看到，我们的上面是对的ExtClassLoader的父加载器的确是null.

3.那么其他的没有指定父加载器的ClassLoader的父加载器是什么呢?从上面的代码我们可以看到MyClassLoader的的是APPClassLoader，那么这是为什么呢？难道没有指定父加载器的ClassLoader的默认是APP

  1.         
  2.     /*
  3. 这ClassLoader是没有指定父加载器创建方法
  4. */
  5.     protected ClassLoader() {
  6.         this(checkCreateClassLoader(), getSystemClassLoader());
  7.     }
  9. //这里我们可以看到getSytemClassLoader()这个方法获取父加载器
  10. private ClassLoader(Void unused, ClassLoader parent) {
  11.         this.parent = parent;
  12.         if (ParallelLoaders.isRegistered(this.getClass())) {
  13.             parallelLockMap = new ConcurrentHashMap<>();
  14.             package2certs = new ConcurrentHashMap<>();
  15.             domains =
  16.                 Collections.synchronizedSet(new HashSet<ProtectionDomain>());
  17.             assertionLock = new Object();
  18.         } else {
  19.             // no finer-grained lock; lock on the classloader instance
  20.             parallelLockMap = null;
  21.             package2certs = new Hashtable<>();
  22.             domains = new HashSet<>();
  23.             assertionLock = this;
  24.         }
  25.     }
  27. 　　//看到return的是scl，而scl赋值是initSystemClassLoader()方法
  28.     public static ClassLoader getSystemClassLoader() {
  29.         initSystemClassLoader();
  30.         if (scl == null) {
  31.             return null;
  32.         }
  33.         SecurityManager sm = System.getSecurityManager();
  34.         if (sm != null) {
  35.             checkClassLoaderPermission(scl, Reflection.getCallerClass());
  36.         }
  37.         return scl;
  38.     }
  40. 　　//真相就在这里了，就是Launcher的getClassLoader()，而Luancher初始化的前面有看过了，也可以往下看
  41.     private static synchronized void initSystemClassLoader() {
  42.         if (!sclSet) {
  43.             if (scl != null)
  44.                 throw new IllegalStateException("recursive invocation");
  45.             sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
  46.             if (l != null) {
  47.                 Throwable oops = null;
  48.                 scl = l.getClassLoader();
  49.                 try {
  50.                     scl = AccessController.doPrivileged(
  51.                         new SystemClassLoaderAction(scl));
  52.                 } catch (PrivilegedActionException pae) {
  53.                     oops = pae.getCause();
  54.                     if (oops instanceof InvocationTargetException) {
  55.                         oops = oops.getCause();
  56.                     }
  57.                 }
  58.                 if (oops != null) {
  59.                     if (oops instanceof Error) {
  60.                         throw (Error) oops;
  61.                     } else {
  62.                         // wrap the exception
  63.                         throw new Error(oops);
  64.                     }
  65.                 }
  66.             }
  67.             sclSet = true;
  68.         }
  69.     }
  72. //这个是Launcher对的getClassLoader,然后在看看下面的图，明白了，就是APPClassLoader
  73.  public ClassLoader getClassLoader() {
  74.         return this.loader;
  75.     }

一层层往下最终APPClassLoader作为默认的ClassLoader；

也就是没有指定的父加载器的默认为是APPClassLoader；

有了父加载器的概念之后，我们就可以开始双亲委托这个玩意了！这部分，发现个哥们写得不错 https://blog.csdn.net/briblue/article/details/54973413，于是就复制了！

 

一个类加载器查找class和resource时，是通过“委托模式”进行的，它首先判断这个class是不是已经加载成功，如果没有的话它并不是自己进行查找，而是先通过父加载器，然后递归下去，直到Bootstrap ClassLoader，如果Bootstrap classloader找到了，直接返回，如果没有找到，则一级一级返回，最后到达自身去查找这些对象。这种机制就叫做双亲委托。 
整个流程可以如下图所示： 

大家可以看到2根箭头，蓝色的代表类加载器向上委托的方向，如果当前的类加载器没有查询到这个class对象已经加载就请求父加载器（不一定是父类）进行操作，然后以此类推。直到Bootstrap ClassLoader。如果Bootstrap ClassLoader也没有加载过此class实例，那么它就会从它指定的路径中去查找，如果查找成功则返回，如果没有查找成功则交给子类加载器，也就是ExtClassLoader,这样类似操作直到终点，也就是我上图中的红色箭头示例。 
用序列描述一下： 
1. 一个AppClassLoader查找资源时，先看看缓存是否有，缓存有从缓存中获取，否则委托给父加载器。 
2. 递归，重复第1部的操作。 
3. 如果ExtClassLoader也没有加载过，则由Bootstrap ClassLoader出面，它首先查找缓存，如果没有找到的话，就去找自己的规定的路径下，也就是sun.mic.boot.class下面的路径。找到就返回，没有找到，让子加载器自己去找。 
4. Bootstrap ClassLoader如果没有查找成功，则ExtClassLoader自己在java.ext.dirs路径中去查找，查找成功就返回，查找不成功，再向下让子加载器找。 
5. ExtClassLoader查找不成功，AppClassLoader就自己查找，在java.class.path路径下查找。找到就返回。如果没有找到就让子类找，如果没有子类会怎么样？抛出各种异常。

上面的序列，详细说明了双亲委托的加载流程。我们可以发现委托是从下向上，然后具体查找过程却是自上至下。

 

这里要说一下ExtClassLoader 这个是没有父加载器，就通过BootStrapClassLoader这个来查找的，下面这个代码的ClassLoader这个类的方法，

  1.     protected Class<?> loadClass(String name, boolean resolve)
  2.         throws ClassNotFoundException
  3.     {
  4.         synchronized (getClassLoadingLock(name)) {
  5.             // First, check if the class has already been loaded
    　　　　　　　// 首先到缓存寻找
  6.             Class c = findLoadedClass(name);
  7.             if (c == null) {
  8.                 long t0 = System.nanoTime();
  9.                 try {
  10.                     if (parent != null) {
    　　　　　　　　　　　　　　//如果父加强是空，往上找
  11.                         c = parent.loadClass(name, false);
  12.                     } else {
    　　　　　　　　　　　　　　//否则就通过BootStrapClassLoader找，也就应该是ExtClassLoader
  13.                         c = findBootstrapClassOrNull(name);
  14.                     }
  15.                 } catch (ClassNotFoundException e) {
  16.                     // ClassNotFoundException thrown if class not found
  17.                     // from the non-null parent class loader
  18.                 }
  20.                 if (c == null) {
  21.                     // If still not found, then invoke findClass in order
  22.                     // to find the class.
  23.                     long t1 = System.nanoTime();
  24.                     c = findClass(name);
  26.                     // this is the defining class loader; record the stats
  27.                     sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
  28.                     sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
  29.                     sun.misc.PerfCounter.getFindClasses().increment();
  30.                 }
  31.             }
  32.             if (resolve) {
  33.                 resolveClass(c);
  34.             }
  35.             return c;
  36.         }
  37.     }

了解我们可以自己写一个简单的加载类

  1. public class MyClassLoader extends URLClassLoader {
  3.     public MyClassLoader(URL[] repositories) {
  4.         super(repositories);
  5.     }
  7.     public MyClassLoader(URL[] repositories, ClassLoader parent) {
  8.         super(repositories, parent);
  9.     }
  11. }
  16. public final class MyClassLoaderFactory {
  18.     public static ClassLoader createClassLoader(File unpacked[], final ClassLoader parent)
  19.             throws Exception {
  21.         Set<URL> set = new LinkedHashSet<URL>();
  23.         if (unpacked != null) {
  24.             for (int i = 0; i < unpacked.length; i++) {
  25.                 File file = unpacked[i];
  26.                 if (!file.exists() || !file.canRead()){
  27.                     continue;
  28.                 }
  29.                 file = new File(file.getCanonicalPath() + File.separator);
  30.                 URL url = file.toURI().toURL();
  31.                 set.add(url);
  32.             }
  33.         }
  35.         final URL[] array = set.toArray(new URL[set.size()]);
  36.         return AccessController.doPrivileged(new PrivilegedAction<MyClassLoader>() {
  38.             @Override
  39.             public MyClassLoader run() {
  40.                 if (parent == null){
  41.                     return new MyClassLoader(array);
  42.                 }else {
  43.                     return new MyClassLoader(array, parent);
  44.                 }
  45.             }
  46.         });
  47.     }
  48. }


  53.     private static void startWithClassloader(String path) throws Exception {
  54.         String classPath= path;
  55.         File[] packed = new File[] { new File(path) };
  56.         ClassLoader catalinaLoader = MyClassLoaderFactory.createClassLoader(null, packed, null);
  57.         Thread.currentThread().setContextClassLoader(catalinaLoader);
  59.         Class<?> startupClass = catalinaLoader.loadClass(MAIN_CLASS);
  60.         Object startupInstance = startupClass.newInstance();
  61.         Method method = startupInstance.getClass().getMethod("start");
  62.         method.invoke(startupInstance);
  63.     }

 

一步一步来吧，首先自定义一个MyClassLoader类继承了URlClassLoader，再对比一下AppClassLoader 的创建，可以说基本一样；

a.获取路径的File[] 文件；

b.然后就调用了AccessController 的native <T> T doPrivileged(PrivilegedAction<T> action)，而关于这个方法的说法，网友们是这么说的：一个调用者在调用doPrivileged方法时，可被标识为 “特权”。在做访问控制决策时，如果checkPermission方法遇到一个通过doPrivileged调用而被表示为 “特权”的调用者，并且没有上下文自变量，checkPermission方法则将终止检查。如果那个调用者的域具有特定的许可，则不做进一步检查，checkPermission安静地返回，表示那个访问请求是被允许的；如果那个域没有特定的许可，则象通常一样，一个异常被抛出

c.调用福利的supper方法创建

 

a.在java的应用中，每个线程都有一个contextClassLoad，而充init（）方法可以看到，默认是父线程的上下文类加载器，当月我们也可以通过Thread.currentThread().setContextClassLoader(catalinaLoader)来设置;

b.这个上下文的加载器的作用简单的说，就是当这个线程加载某些类时，通过这加载器进行加载；

c.网友说法：

每个运行中的线程都有一个成员contextClassLoader，用来在运行时动态地载入其它类
系统默认的contextClassLoader是systemClassLoader，所以一般而言java程序在执行时可以使用JVM自带的类、$JAVA_HOME/jre/lib/ext/中的类和$CLASSPATH/中的类
可以使用Thread.currentThread().setContextClassLoader(…);更改当前线程的contextClassLoader，来改变其载入类的行为
ClassLoader被组织成树形，一般的工作原理是：
1) 线程需要用到某个类，于是contextClassLoader被请求来载入该类
2) contextClassLoader请求它的父ClassLoader来完成该载入请求
3) 如果父ClassLoader无法载入类，则contextClassLoader试图自己来载入
注意：WebApp?ClassLoader的工作原理和上述有少许不同：
它先试图自己载入类（在ContextBase?/WEB-INF/…中载入类），如果无法载入，再请求父ClassLoader完成

  1. public
  2. class Thread implements Runnable {
  3.     /* Make sure registerNatives is the first thing <clinit> does. */
  4.     private static native void registerNatives();
  5.     static {
  6.         registerNatives();
  7.     }
  9.     private char        name[];
  10.     private int         priority;
  11.     private Thread      threadQ;
  12.     private long        eetop;
  14.     /* Whether or not to single_step this thread. */
  15.     private boolean     single_step;
  17.     /* Whether or not the thread is a daemon thread. */
  18.     private boolean     daemon = false;
  20.     /* JVM state */
  21.     private boolean     stillborn = false;
  23.     /* What will be run. */
  24.     private Runnable target;
  26.     /* The group of this thread */
  27.     private ThreadGroup group;
  29.     /* The context ClassLoader for this thread */
  30.     private ClassLoader contextClassLoader;




  31.     ………………
  32.       
  33. }

 

  1.     private void init(ThreadGroup g, Runnable target, String name,
  2.                       long stackSize, AccessControlContext acc) {
  3.         if (name == null) {
  4.             throw new NullPointerException("name cannot be null");
  5.         }
  7.         this.name = name.toCharArray();
  9.         Thread parent = currentThread();
  10.         SecurityManager security = System.getSecurityManager();
  11.         if (g == null) {
  12.             /* Determine if it's an applet or not */
  13.  
  14.             /* If there is a security manager, ask the security manager
  15.                what to do. */
  16.             if (security != null) {
  17.                 g = security.getThreadGroup();
  18.             }
  20.             /* If the security doesn't have a strong opinion of the matter
  21.                use the parent thread group. */
  22.             if (g == null) {
  23.                 g = parent.getThreadGroup();
  24.             }
  25.         }
  27.         /* checkAccess regardless of whether or not threadgroup is
  28.            explicitly passed in. */
  29.         g.checkAccess();
  31.         /*
  32.          * Do we have the required permissions?
  33.          */
  34.         if (security != null) {
  35.             if (isCCLOverridden(getClass())) {
  36.                 security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
  37.             }
  38.         }
  40.         g.addUnstarted();
  42.         this.group = g;
  43.         this.daemon = parent.isDaemon();
  44.         this.priority = parent.getPriority();
  45.         if (security == null || isCCLOverridden(parent.getClass()))
  46.             this.contextClassLoader = parent.getContextClassLoader();
  47.         else
  48.             this.contextClassLoader = parent.contextClassLoader;
  49.         this.inheritedAccessControlContext =
  50.                 acc != null ? acc : AccessController.getContext();
  51.         this.target = target;
  52.         setPriority(priority);
  53.         if (parent.inheritableThreadLocals != null)
  54.             this.inheritableThreadLocals =
  55.                 ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
  56.         /* Stash the specified stack size in case the VM cares */
  57.         this.stackSize = stackSize;
  59.         /* Set thread ID */
  60.         tid = nextThreadID();
  61.     }

 

 

版权声明：本文为nedhome原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/nedhome/p/9053132.html