JVM 为什么要3个类加载器？_百度知道
JVM 为什么要3个类加载器？
dirs AppClassLoader，这个 Bootstrap Loader 所做的初始工作中，这才是真正的 Java 虚拟机器 。当执行 java ***，如果没有找到的话： sun.java 之中的 AppClassLoader ，才使用自己的搜索路径来来搜索类，另外也是为了实现委托模型.ext，所以 Parent 和由哪个类加载器加载没有关系.class.path ExtClassLoader，就会产生第一个类加载器―― Bootstrap Loader .class.boot，最重要的就是加载 Launcher，除了一些基本的初始化动作之外。然后 Bootstrap Loader 再要求加载 Launcher。他们主要是分工不一样： BootstrapLoader ，其实就是当类加载器有加载需求的时候, 最后加载动态库， Bootstrap Loader 是由 C++ 所撰写而成。他们分别从以下的路径寻找程序所需要的类.class 与 Launcher$AppClassL---(Extends)----ExtClassLoader 这三个加载器就构成我们的 Java 类加载体系JVM有三种类加载器: java，会先做一些初始化的动作: java，先请示他的父类使用父类的搜索路径来加入，比如说读取系统参数等，并设定其 Parent 为 null ：bootstrap负责加载系统类： BootstrapLoader &lt.exe 会帮助我们找到 JRE 。这两个加载器都是以静态类的形式存在的，代表其父加载器为 BootstrapLoader 。虚拟机器激活以后.java 之中的 ExtClassLoader ，各自负责不同的区域.class 都是由 Bootstrap Loader 所加载，接着找到位于 JRE 内部的 jvm，激活 Java 虚拟机器，extclassloader负责加载扩展类.class 的时候.getProperty() 函数得到具体对应的路径。这里要请大家注意的是。什么是委托模型呢，appclassloader负责加载应用类。 下面的图形可以表示三者之间的关系.path 这三个系统参量可以通过 S---(Extends)----AppClassLoader &lt。一旦初始化动作完成之后， java.dll 。大家可以自己编程实现查看具体的路径，并设定其 Parent 为之前产生的 ExtClassLoader 实体， Launcher$ExtClassLoader
来自团队：
其他类似问题
为您推荐：
jvm的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁The page is temporarily unavailable
nginx error!
The page you are looking for is temporarily unavailable.
Please try again later.
Website Administrator
Something has triggered an error on your
This is the default error page for
nginx that is distributed with
It is located
/usr/share/nginx/html/50x.html
You should customize this error page for your own
site or edit the error_page directive in
the nginx configuration file
/etc/nginx/nginx.conf.当前访客身份：游客 [
：有点意思，学习了
：引用来自“纳兰清风”的评论直接sentence.split(...
：引用来自“纳兰清风”的评论直接sentence.split(...
：直接sentence.split(' ')得到单词数组，逆序输出...
：详细研究参见： http://my.oschina.net/kanlianh...
：http2协议规范已经确定 http://www.rfc-editor....
：CopyOnWrite其实是一个不错的理念，当然他也有他...
：另外用CopyOnWriteArrayList来替换ArrayList博主...
：其实fail-fast也可以导致问题：就比如ArrayList...
：引用来自“kanlianhui”的评论 最近HTTP2经过SPD...
今日访问：14
昨日访问：25
本周访问：14
本月访问：69
所有访问：2409
JVM 类加载器的工作原理
发表于1年前( 23:10)&&
阅读（233）&|&评论（）
0人收藏此文章,
面向对象的原理：认为万事万物都是对象，类也是对象，是class类的对象叫做类类型。（why）Java类加载器的作用就是在运行时加载类。（How？）Java类加载器基于三个机制：委托、可见性和单一性。委托机制是指将加载一个类的请求交给父类加载器，如果这个父类加载器不能够找到或者加载这个类，那么再加载它。可见性的原理是子类的加载器可以看见所有的父类加载器加载的类，而父类加载器看不到子类加载器加载的类。单一性原理是指仅加载一个类一次，这是由委托机制确保子类加载器不会再次加载父类加载器加载过的类。正确理解类加载器能够帮你解决NoClassDefFoundError和java.lang.ClassNotFoundException，因为它们和类的加载相关。类加载器通常也是比较高级的Java面试中的重要考题，Java类加载器和工作原理以及classpath如何运作的经常被问到。Java面试题中也经常出现“一个类是否能被两个不同类加载器加载”这样的问题。这篇教程中，我们将学到类加载器是什么，它的工作原理以及一些关于类加载器的知识点。什么是类加载器类加载就是寻找一个类或是一个接口的字节码文件（通常是.class 或 .jar文件）并通过解析该字节码来构造代表这个类或是这个接口的 class 对象的过程。（what：解析字节码文件，构造class对象）(《深入理解jvm》——类加载机制：把描述类的数据从class文件加载到内存中，并对数据进行校验、转换解析和初始化，最终形成可以被jvm直接使用的java类型。)类加载器是一个用来加载类文件的类。Java源代码通过javac编译器编译成类文件。然后JVM来执行类文件中的字节码来执行程序。类加载器负责加载文件系统、网络或其他来源的类文件。有三种默认使用的类加载器：Bootstrap类加载器、Extension类加载器和System类加载器（或者叫作Application类加载器）。每种类加载器都有设定好从哪里加载类。Bootstrap类加载器负责加载rt.jar中的JDK类文件，它是所有类加载器的父加载器。Bootstrap类加载器没有任何父类加载器，如果你调用String.class.getClassLoader()，会返回null，任何基于此的代码会抛出NUllPointerException异常。Bootstrap加载器被称为初始类加载器。而Extension将加载类的请求先委托给它的父加载器，也就是Bootstrap，如果没有成功加载的话，再从jre/lib/ext目录下或者java.ext.dirs系统属性定义的目录下加载类。Extension加载器由sun.misc.Launcher$ExtClassLoader实现。第三种默认的加载器就是System类加载器（又叫作Application类加载器）了。它负责从classpath环境变量中加载某些应用相关的类，classpath环境变量通常由-classpath或-cp命令行选项来定义，或者是JAR中的Manifest的classpath属性。Application类加载器是Extension类加载器的子加载器。通过sun.misc.Launcher$AppClassLoader实现。除了Bootstrap类加载器是大部分由C来写的，其他的类加载器都是通过java.lang.ClassLoader来实现的。总结一下，下面是三种类加载器加载类文件的地方：1) Bootstrap类加载器 – JRE/lib/rt.jar&负责加载核心Java Class（即所有java.*开头的类）2) Extension类加载器 – JRE/lib/ext或者java.ext.dirs指向的目录&javax.*开头的类和存放在JRE的ext目录下的类）3) Application类加载器 – CLASSPATH环境变量, 由-classpath或-cp选项定义,或者是JAR中的Manifest的classpath属性定义 负责加载应用程序自身的类.类加载器的工作原理双亲委托机制（防止内存中出现多个相同的字节码）（1）当前ClassLoader首先从自己已经加载的类中查询是否此类已经加载，如果已经加载则直接返回原来已经加载的类。每个类加载器都有自己的加载缓存，当一个类被加载了以后就会放入缓存，等下次加载的时候就可以直接返回了。（2）当前classLoader的缓存中没有找到被加载的类的时候，委托父类加载器去加载，父类加载器采用同样的策略，首先查看自己的缓存，然后委托父类的父类去加载，一直到bootstrap ClassLoader.（3）当所有的父类加载器都没有加载的时候，再由当前的类加载器加载，并将其放入它自己的缓存中，以便下次有加载请求的时候直接返回。说到这里大家可能会想，Java为什么要采用这样的委托机制？理解这个问题，我们引入另外一个关于Classloader的概念“命名空间”， 它是指要确定某一个类，需要类的全限定名以及加载此类的ClassLoader来共同确定。也就是说即使两个类的全限定名是相同的，但是因为不同的 ClassLoader加载了此类，那么在JVM中它是不同的类。明白了命名空间以后，我们再来看看委托模型。采用了委托模型以后加大了不同的 ClassLoader的交互能力，比如上面说的，我们JDK本生提供的类库，比如hashmap,linkedlist等等，这些类由bootstrap 类加载器加载了以后，无论你程序中有多少个类加载器，那么这些类其实都是可以共享的，这样就避免了不同的类加载器加载了同样名字的不同类以后造成混乱。当一个类加载和初始化的时候，类仅在有需要加载的时候被加载。假设你有一个应用需要的类叫作Abc.class，首先加载这个类的请求由Application类加载器委托给它的父类加载器Extension类加载器，然后再委托给Bootstrap类加载器。Bootstrap类加载器会先看看rt.jar中有没有这个类，因为并没有这个类，所以这个请求由回到Extension类加载器，它会查看jre/lib/ext目录下有没有这个类，如果这个类被Extension类加载器找到了，那么它将被加载，而Application类加载器不会加载这个类；而如果这个类没有被Extension类加载器找到，那么再由Application类加载器从classpath中寻找。(记住classpath定义的是类文件的加载目录，而PATH是定义的是可执行程序如javac，java等的执行路径。)可见性机制子类加载器可以看到父类加载器加载的类，而反之则不行。所以下面的例子中，当Abc.class已经被Application类加载器加载过了，然后如果想要使用Extension类加载器加载这个类，将会抛出java.lang.ClassNotFoundException异常。package&
&&&&import&java.util.logging.L
&&&&import&java.util.logging.L
&&&&&*&Java&program&to&demonstrate&How&ClassLoader&works&in&Java,
&&&&&*&in&particular&about&visibility&principle&of&ClassLoader.
&&&&&*&@author&Javin&Paul
&&&&public&class&ClassLoaderTest&{
&&&&&&&&public&static&void&main(String&args[])&{
&&&&&&&&&&&&try&{&&&&&&&&&&
&&&&&&&&&&&&&&&&//printing&ClassLoader&of&this&class
&&&&&&&&&&&&&&&&System.out.println("ClassLoaderTest.getClass().getClassLoader()&:&"
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&+&ClassLoaderTest.class.getClassLoader());
&&&&&&&&&&&&&&&&//trying&to&explicitly&load&this&class&again&using&Extension&class&loader
&&&&&&&&&&&&&&&&Class.forName("test.ClassLoaderTest",&true
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&,&&ClassLoaderTest.class.getClassLoader().getParent());
&&&&&&&&&&&&}&catch&(ClassNotFoundException&ex)&{
&&&&&&&&&&&&&&&&Logger.getLogger(ClassLoaderTest.class.getName()).log(Level.SEVERE,&null,&ex);
&&&&&&&&&&&&}
&&&&}输出:ClassLoaderTest.getClass().getClassLoader()&:&sun.misc.Launcher$AppClassLoader@601bb1
16/08/:48&AM&test.ClassLoaderTest&main
SEVERE:&null
java.lang.ClassNotFoundException:&test.ClassLoaderTest
&&&&&&&&at&java.net.URLClassLoader$1.run(URLClassLoader.java:202)
&&&&&&&&at&java.security.AccessController.doPrivileged(Native&Method)
&&&&&&&&at&java.net.URLClassLoader.findClass(URLClassLoader.java:190)
&&&&&&&&at&sun.misc.Launcher$ExtClassLoader.findClass(Launcher.java:229)
&&&&&&&&at&java.lang.ClassLoader.loadClass(ClassLoader.java:306)
&&&&&&&&at&java.lang.ClassLoader.loadClass(ClassLoader.java:247)
&&&&&&&&at&java.lang.Class.forName0(Native&Method)
&&&&&&&&at&java.lang.Class.forName(Class.java:247)
&&&&&&&&at&test.ClassLoaderTest.main(ClassLoaderTest.java:29)单一性机制父加载器加载过的类不能被子加载器加载第二次。虽然重写违反委托和单一性机制的类加载器是可能的，但这样做并不可取。你写自己的类加载器的时候应该严格遵守这三条机制。如何显式的加载类Java提供了显式加载类的API：Class.forName(classname)和Class.forName(classname, initialized, classloader)。就像上面的例子中，你可以指定类加载器的名称以及要加载的类的名称。类的加载是通过调用java.lang.ClassLoader的loadClass()方法，而loadClass()方法则调用了findClass()方法来定位相应类的字节码。在这个例子中Extension类加载器使用了java.net.URLClassLoader，它从JAR和目录中进行查找类文件，所有以”/”结尾的查找路径被认为是目录。如果findClass()没有找到那么它会抛出java.lang.ClassNotFoundException异常，而如果找到的话则会调用defineClass()将字节码转化成类实例，然后返回。如何自定义ClassLoaderJava除了上面所说的默认提供的classloader以外，它还容许应用程序可以自定义classloader，那么要想自定义classloader我们需要通过继承java.lang.ClassLoader来实现,接下来我们就来看看再自定义Classloader的时候，我们需要注意的几个重要的方法：1.loadClass 方法loadClass method declarepublic&Class&?&&loadClass(String&name)&&throws&ClassNotFoundException上面是loadClass方法的原型声明，上面所说的双亲委托机制的实现其实就实在此方法中实现的。下面我们就来看看此方法的代码来看看它到底如何实现双亲委托的。loadClass method implementpublic&Class&?&&loadClass(String&name)&throws&ClassNotFoundException
return&loadClass(name,&false);
}从上面可以看出loadClass方法调用了loadcClass(name,false)方法，那么接下来我们再来看看另外一个loadClass方法的实现。Class loadClass(String name, boolean resolve)protected&synchronized&Class&?&&loadClass(String&name,&boolean&resolve)&&throws&ClassNotFoundException&&&
&{&&//&First,&check&if&the&class&has&already&been&loaded&&Class&c&=&findLoadedClass(name);
//检查class是否已经被加载过了&&if&(c&==&null)
&try&{&&&&&&
if&(parent&!=&null)&{&&&&&&&&&
&c&=&parent.loadClass(name,&false);&//如果没有被加载，且指定了父类加载器，则委托父加载器加载。&&&&
&&}&else&{&&&&&&&&
&&c&=&findBootstrapClass0(name);//如果没有父类加载器，则委托bootstrap加载器加载&&&&&&}&
&&&&&}&catch&(ClassNotFoundException&e)&{&&&&&&&&&
&//&If&still&not&found,&then&invoke&findClass&in&order&&&&&&&&&&
//&to&find&the&class.&&&&&&&&&
&c&=&findClass(name);//如果父类加载没有加载到，则通过自己的findClass来加载。&&&&&&}&
&if&(resolve)&
&resolveClass(c);&
}上面的代码，我加了注释通过注释可以清晰看出loadClass的双亲委托机制是如何工作的。 这里我们需要注意一点就是public Class&?& loadClass(String name) throws ClassNotFoundException没有被标记为final，也就意味着我们是可以override这个方法的，也就是说双亲委托机制是可以打破的。另外上面注意到有个findClass方法，接下来我们就来说说这个方法到底是搞末子的。2.findClass我们查看java.lang.ClassLoader的源代码，我们发现findClass的实现如下：&protected&Class&?&&findClass(String&name)&throws&ClassNotFoundException
throw&new&ClassNotFoundException(name);
}我们可以看出此方法默认的实现是直接抛出异常，其实这个方法就是留给我们应用程序来override的。那么具体的实现就看你的实现逻辑了，你可以从磁盘读取，也可以从网络上获取class文件的字节流，获取class二进制了以后就可以交给defineClass来实现进一步的加载。defineClass我们再下面再来描述。 ok，通过上面的分析，我们可以得出如下结论：我们在写自己的ClassLoader的时候，如果想遵循双亲委托机制，则只需要override&findClass.3.defineClass我们首先还是来看看defineClass的源码：defineClassprotected&final&Class&?&&defineClass(String&name,&byte[]&b,&int&off,&int&len)&&
throws&ClassFormatError
&return&defineClass(name,&b,&off,&len,&null);
}从上面的代码我们看出此方法被定义为了final，这也就意味着此方法不能被Override，其实这也是jvm留给我们的唯一的入口，通过这个唯 一的入口，jvm保证了类文件必须符合Java虚拟机规范规定的类的定义。此方法最后会调用native的方法来实现真正的类的加载工作。Ok,通过上面的描述，我们来思考下面一个问题：假如我们自己写了一个java.lang.String的类，我们是否可以替换调JDK本身的类？答案是否定的。我们不能实现。为什么呢？我看很多网上解释是说双亲委托机制解决这个问题，其实不是非常的准确。因为双亲委托机制是可以打破的，你完全可以自己写一个classLoader来加载自己写的java.lang.String类，但是你会发现也不会加载成功，具体就是因为针对java.*开头的类，jvm的实现中已经保证了必须由bootstrp来加载。不遵循“双亲委托机制”的场景(双亲委派模型不是一个强制性的约束模型)上面说了双亲委托机制主要是为了实现不同的ClassLoader之间加载的类的交互问题，被大家公用的类就交由父加载器去加载，但是Java中确实也存在父类加载器加载的类需要用到子加载器加载的类的情况。下面我们就来说说这种情况的发生。Java中有一个SPI(Service Provider Interface)标准,使用了SPI的库，比如JDBC，JNDI等，我们都知道JDBC需要第三方提供的驱动才可以，而驱动的jar包是放在我们应用程序本身的classpath的，而jdbc 本身的api是jdk提供的一部分，它已经被bootstrp加载了，那第三方厂商提供的实现类怎么加载呢？这里面JAVA引入了线程上下文类加载的概念，线程类加载器默认会从父线程继承，如果没有指定的话，默认就是系统类加载器（AppClassLoader）,这样的话当加载第三方驱动的时候，就可 以通过线程的上下文类加载器来加载。(就是打通双亲委派模型的层次结构来逆向使用类加载器)另外为了实现更灵活的类加载器OSGI以及一些Java app server也打破了双亲委托机制。
更多开发者职位上
1)">1)">1" ng-class="{current:{{currentPage==page}}}" ng-repeat="page in pages"><li class='page' ng-if="(endIndex<li class='page next' ng-if="(currentPage
相关文章阅读&&国之画&&布布分享&&&& &&&&
版权所有 京ICP备号-2
迷上了代码！类加载器的工作原理 - ImportNew
Java类加载器的作用就是在运行时加载类。Java类加载器基于三个机制：委托、可见性和单一性。委托机制是指将加载一个类的请求交给父类加载器，如果这个父类加载器不能够找到或者加载这个类，那么再加载它。可见性的原理是子类的加载器可以看见所有的父类加载器加载的类，而父类加载器看不到子类加载器加载的类。单一性原理是指仅加载一个类一次，这是由委托机制确保子类加载器不会再次加载父类加载器加载过的类。正确理解类加载器能够帮你解决NoClassDefFoundError和java.lang.ClassNotFoundException，因为它们和类的加载相关。类加载器通常也是比较高级的Java面试中的重要考题，Java类加载器和工作原理以及classpath如何运作的经常被问到。Java面试题中也经常出现“一个类是否能被两个不同类加载器加载”这样的问题。这篇教程中，我们将学到类加载器是什么，它的工作原理以及一些关于类加载器的知识点。
什么是类加载器
类加载器是一个用来加载类文件的类。Java源代码通过javac编译器编译成类文件。然后JVM来执行类文件中的字节码来执行程序。类加载器负责加载文件系统、网络或其他来源的类文件。有三种默认使用的类加载器：Bootstrap类加载器、Extension类加载器和System类加载器（或者叫作Application类加载器）。每种类加载器都有设定好从哪里加载类。
Bootstrap类加载器负责加载rt.jar中的JDK类文件，它是所有类加载器的父加载器。Bootstrap类加载器没有任何父类加载器，如果你调用String.class.getClassLoader()，会返回null，任何基于此的代码会抛出NUllPointerException异常。Bootstrap加载器被称为初始类加载器。
而Extension将加载类的请求先委托给它的父加载器，也就是Bootstrap，如果没有成功加载的话，再从jre/lib/ext目录下或者java.ext.dirs系统属性定义的目录下加载类。Extension加载器由sun.misc.Launcher$ExtClassLoader实现。
第三种默认的加载器就是System类加载器（又叫作Application类加载器）了。它负责从classpath环境变量中加载某些应用相关的类，classpath环境变量通常由-classpath或-cp命令行选项来定义，或者是JAR中的Manifest的classpath属性。Application类加载器是Extension类加载器的子加载器。通过sun.misc.Launcher$AppClassLoader实现。
除了Bootstrap类加载器是大部分由C来写的，其他的类加载器都是通过java.lang.ClassLoader来实现的。
总结一下，下面是三种类加载器加载类文件的地方：
1) Bootstrap类加载器 &#8211; JRE/lib/rt.jar
2) Extension类加载器 &#8211; JRE/lib/ext或者java.ext.dirs指向的目录
3) Application类加载器 &#8211; CLASSPATH环境变量, 由-classpath或-cp选项定义,或者是JAR中的Manifest的classpath属性定义.
类加载器的工作原理
我之前已经提到过了，类加载器的工作原理基于三个机制：委托、可见性和单一性。这一节，我们来详细看看这些规则，并用一个实例来理解工作原理。下面显示的是类加载器使用委托机制的工作原理。
当一个类加载和初始化的时候，类仅在有需要加载的时候被加载。假设你有一个应用需要的类叫作Abc.class，首先加载这个类的请求由Application类加载器委托给它的父类加载器Extension类加载器，然后再委托给Bootstrap类加载器。Bootstrap类加载器会先看看rt.jar中有没有这个类，因为并没有这个类，所以这个请求由回到Extension类加载器，它会查看jre/lib/ext目录下有没有这个类，如果这个类被Extension类加载器找到了，那么它将被加载，而Application类加载器不会加载这个类；而如果这个类没有被Extension类加载器找到，那么再由Application类加载器从classpath中寻找。记住classpath定义的是类文件的加载目录，而PATH是定义的是可执行程序如javac，java等的执行路径。
可见性机制
根据可见性机制，子类加载器可以看到父类加载器加载的类，而反之则不行。所以下面的例子中，当Abc.class已经被Application类加载器加载过了，然后如果想要使用Extension类加载器加载这个类，将会抛出java.lang.ClassNotFoundException异常。
import java.util.logging.L
import java.util.logging.L
* Java program to demonstrate How ClassLoader works in Java,
* in particular about visibility principle of ClassLoader.
* @author Javin Paul
public class ClassLoaderTest {
public static void main(String args[]) {
//printing ClassLoader of this class
System.out.println(&ClassLoaderTest.getClass().getClassLoader() : &
+ ClassLoaderTest.class.getClassLoader());
//trying to explicitly load this class again using Extension class loader
Class.forName(&test.ClassLoaderTest&, true
ClassLoaderTest.class.getClassLoader().getParent());
} catch (ClassNotFoundException ex) {
Logger.getLogger(ClassLoaderTest.class.getName()).log(Level.SEVERE, null, ex);
ClassLoaderTest.getClass().getClassLoader() : sun.misc.Launcher$AppClassLoader@601bb1
16/08/:48 AM test.ClassLoaderTest main
SEVERE: null
java.lang.ClassNotFoundException: test.ClassLoaderTest
at java.net.URLClassLoader$1.run(URLClassLoader.java:202)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:190)
at sun.misc.Launcher$ExtClassLoader.findClass(Launcher.java:229)
at java.lang.ClassLoader.loadClass(ClassLoader.java:306)
at java.lang.ClassLoader.loadClass(ClassLoader.java:247)
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Class.java:247)
at test.ClassLoaderTest.main(ClassLoaderTest.java:29)
单一性机制
根据这个机制，父加载器加载过的类不能被子加载器加载第二次。虽然重写违反委托和单一性机制的类加载器是可能的，但这样做并不可取。你写自己的类加载器的时候应该严格遵守这三条机制。
如何显式的加载类
Java提供了显式加载类的API：Class.forName(classname)和Class.forName(classname, initialized, classloader)。就像上面的例子中，你可以指定类加载器的名称以及要加载的类的名称。类的加载是通过调用java.lang.ClassLoader的loadClass()方法，而loadClass()方法则调用了findClass()方法来定位相应类的字节码。在这个例子中Extension类加载器使用了java.net.URLClassLoader，它从JAR和目录中进行查找类文件，所有以&#8221;/&#8221;结尾的查找路径被认为是目录。如果findClass()没有找到那么它会抛出java.lang.ClassNotFoundException异常，而如果找到的话则会调用defineClass()将字节码转化成类实例，然后返回。
什么地方使用类加载器
类加载器是个很强大的概念，很多地方被运用。最经典的例子就是AppletClassLoader，它被用来加载Applet使用的类，而Applets大部分是在网上使用，而非本地的操作系统使用。使用不同的类加载器，你可以从不同的源地址加载同一个类，它们被视为不同的类。J2EE使用多个类加载器加载不同地方的类，例如WAR文件由Web-app类加载器加载，而EJB-JAR中的类由另外的类加载器加载。有些服务器也支持热部署，这也由类加载器实现。你也可以使用类加载器来加载数据库或者其他持久层的数据。
以上是关于类加载器的工作原理。我们已经知道了委托、可见性以及单一性原理，这些对于调试类加载器相关问题时至关重要。这些对于Java程序员和架构师来说都是必不可少的知识。
原文链接：
- 译文链接： [ 转载请保留原文出处、译者和译文链接。]
关于作者：
一名在路上的程旭媛
/?post=8对上面文章中，链表反转部分的图示，进行注解
关于ImportNew
ImportNew 专注于 Java 技术分享。于日 11:11正式上线。是的，这是一个很特别的时刻 :)
ImportNew 由两个 Java 关键字 import 和 new 组成，意指：Java 开发者学习新知识的网站。 import 可认为是学习和吸收， new 则可认为是新知识、新技术圈子和新朋友……
新浪微博：
推荐微信号
反馈建议：@
广告与商务合作QQ：
&#8211; 好的话题、有启发的回复、值得信赖的圈子
&#8211; 写了文章？看干货？去头条！
&#8211; 为IT单身男女服务的征婚传播平台
&#8211; 优秀的工具资源导航
&#8211; 活跃 &#038; 专业的翻译小组
&#8211; 国内外的精选博客文章
&#8211; UI,网页，交互和用户体验
&#8211; JavaScript, HTML5, CSS
&#8211; 专注Android技术分享
&#8211; 专注iOS技术分享
&#8211; 专注Java技术分享
&#8211; 专注Python技术分享
& 2016 ImportNew}