深入理解 Java 虚拟机（二）

public class ClinitThreadTest {
    public static void main(String[] args) {
        new Thread(()->new SimpleObj()).start();
    }

    static class SimpleObj{
        private static AtomicBoolean init=new AtomicBoolean(true);

        static {
            System.out.println(Thread.currentThread().getName()+" i will be init");
            while (init.get()){

            }
            System.out.println("i am finished");
       }
    }
}

public class SingleTon {
    private static SingleTon ins=new SingleTon();

    public static  int x=0;

    public static int y;

    private SingleTon(){
        x++;y++;
    }

    public static SingleTon getIns(){
        return ins;
    }

    public static void main(String[] args) {
        SingleTon singleTon=getIns();
        System.out.println(singleTon.x);
        System.out.println(singleTon.y);
    }
}

package classloader_study.misc;
public class ClassActiveUse {
    static {
        System.out.println("main is init");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //System.out.println(Obj.t);
        //Obj.getObj();
        //Class.forName("classloader_study.Obj");
        //System.out.println(ObjChild.age);
        
        //父类会被初始化 通过子类调用父类的静态变量，子类不会初始化但是会被加载 
        //1. System.out.println(ObjChild.n);
        //不会初始化 定义应用数组也不会初始化类，但是会加载类
        //2. Obj [] arrays=new Obj[10]; 
        //不会初始化 常量会在编译期间放到常量池中不会初始化类也不会加载，子类加载也一样
        //3. System.out.println(Obj.t); 
        //Obj 会被初始化   final 修饰的复杂化类型再编译期间无法计算得到，会初始化类
        //4. System.out.println(Obj.x); 
        // 类加载器去加载
        //5. ClassLoader.loadClass();
    }
}

class Obj{

    public static  final int t=10;  //编译期间就已经确定了就是 10
	
    public static int n=111;
    
    public static final int x=new Random().nextInt(100); //值不是常量，运行期间才会确定
    static { 
        System.out.println("Obj is init");
    }

    public static void getObj(){
        System.out.println("NULL");
    }
}

class ObjChild extends Obj{
    public static int age=12;

    static {
        System.out.println("Child is init");
    }
}
interface I{
    final static int a=0;
}

System.out.println(System.getProperty("sun.boot.class.path"));
D:\java\jre\lib\resources.jar;D:\java\jre\lib\rt.jar;D:\java\jre\lib\sunrsasign.jar;D:\java\jre\lib\jsse.jar;D:\java\jre\lib\jce.jar;D:\java\jre\lib\charsets.jar;D:\java\jre\lib\jfr.jar;D:\java\jre\classes

System.out.println(System.getProperty("java.ext.dirs")); //java.ext.dirs 属性
D:\java\jre\lib\ext;C:\WINDOWS\Sun\Java\lib\ext

System.out.println(System.getProperty("java.class.path"));
D:\java\jre\lib\charsets.jar;D:\java\jre\lib\deploy.jar;
D:\java\jre\lib\ext\access-bridge-64.jar;
D:\java\jre\lib\ext\cldrdata.jar;
D:\java\jre\lib\ext\dnsns.jar;
D:\java\jre\lib\ext\jaccess.jar;
D:\java\jre\lib\ext\jfxrt.jar;
D:\java\jre\lib\ext\localedata.jar;
D:\java\jre\lib\ext\nashorn.jar;
D:\java\jre\lib\ext\sunec.jar;
D:\java\jre\lib\ext\sunjce_provider.jar;
D:\java\jre\lib\ext\sunmscapi.jar;
D:\java\jre\lib\ext\sunpkcs11.jar;
D:\java\jre\lib\ext\zipfs.jar;
D:\java\jre\lib\javaws.jar;
D:\java\jre\lib\jce.jar;
D:\java\jre\lib\jfr.jar;
D:\java\jre\lib\jfxswt.jar;
D:\java\jre\lib\jsse.jar;
D:\java\jre\lib\management-agent.jar;
D:\java\jre\lib\plugin.jar;
D:\java\jre\lib\resources.jar;
D:\java\jre\lib\rt.jar;
C:\WorkSpace\concurrent_package\out\production\concurrent_package;
C:\JetBrains\IntelliJ IDEA 2018.1.4\lib\idea_rt.jar

 protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        //没有父加载器就交给根加载器
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    //需要子类去实现
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

if(parent!=null){  c = parent.loadClass(name, false);}

protected Class<?> findClass(String name) throws ClassNotFoundException {
    throw new ClassNotFoundException(name);
}

public class MyClassLoader extends ClassLoader {
    //将字节码放到这个路径下
    private static final String DEFAULT_DIR = "D:\\ClassLoaderTest";

    private String dir = DEFAULT_DIR;

    private String classLoaderName;

    public MyClassLoader() {
        
    }

    public MyClassLoader(String classLoaderName) {
        this.classLoaderName = classLoaderName;
    }

    public MyClassLoader(ClassLoader parent, String classLoaderName) {
        super(parent);
        this.classLoaderName = classLoaderName;
    }

    public String getDir() {
        return dir;
    }

    public void setDir(String dir) {
        this.dir = dir;
    }

    public String getClassLoaderName() {
        return classLoaderName;
    }

    /**
     * xx.xx.xx.xx.xx.AAA
     * xx/xx/xx/xx/xx/.AAA.class
     *
     * @param name
     * @return
     * @throws ClassNotFoundException
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String classPath = name.replace(".", "/");
        File classFile = new File(dir, classPath + ".class");
        if (!classFile.exists()) {
            throw new ClassNotFoundException("The class " + name + " not found under " + dir);
        }
		//字节码文件的字节流
        byte[] classBytes = loadClassBytes(classFile);
        if (null == classBytes || classBytes.length == 0)
            throw new ClassNotFoundException("load the class " + name + " failed");
		//defineClass 方法可以把二进制流字节组成的文件转换为一个 java.lang.Class
        return this.defineClass(name, classBytes, 0, classBytes.length);
    }
	
    //将文件流转换为字节流
    private byte[] loadClassBytes(File classFile) {
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
             FileInputStream fis = new FileInputStream(classFile)) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            baos.flush();
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

//自定义的需要加载的类
public class MyObject {
    static {
        System.out.println("MyObject static is init");
    }

    public void Hello(){
        System.out.println("Hello World");
    }
}

public class ClassLoaderTest {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        MyClassLoader loader=new MyClassLoader("Resolmi");
        //Class<?> aClass = loader.loadClass("classloader_study.myClassLoader.MyObject");
        Class<?> aClass = Class.forName("classloader_study.myClassLoader.MyObject", true, loader);
        System.out.println(aClass);
        System.out.println(aClass.getClassLoader());

        Object obj=aClass.newInstance();
        Method hello = aClass.getMethod("Hello", null);
        hello.invoke(obj, new Object[]{});
    }
}

MyObject static is init
class classloader_study.myClassLoader.MyObject
classloader_study.myClassLoader.MyClassLoader@74a14482
Hello World

public class MyClassLoaderTest2 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, ClassNotFoundException {
        //loader1 的加载目录是 D:\\ClassLoaderTest（默认的）
        MyClassLoader loader1=new MyClassLoader("Resolmi-father");
        //设置 loader1 为 loader2 的父加载器
        MyClassLoader loader2=new MyClassLoader(loader1,"Resolmi2-son");
        //这个类存放在 D:\\ClassLoaderTest\\classloader_study\\myClassLoader 下面
        Class<?> aClass = loader2.loadClass("classloader_study.myClassLoader.MyObject");
        //设置 Loader2 的加载目录，这是个空目录，下面什么都没有
        loader2.setDir("D:\\ClassLoaderTest2");
        System.out.println(aClass);
        System.out.println(aClass.getClassLoader());
        System.out.println(((MyClassLoader)aClass.getClassLoader()).getClassLoaderName());
     }
}

class classloader_study.myClassLoader.MyObject
classloader_study.myClassLoader.MyClassLoader@74a14482
Resolmi-father

Exception in thread "main" java.lang.SecurityException: Prohibited package name: java.lang

public final class EncryptUtil {
	//相当于密钥
    public static final byte ENCRYPT_FACTOR = (byte) 0xff;

    private EncryptUtil() {

    }

    public static void encrypt(String source, String target) throws FileNotFoundException {
        try (FileInputStream in= new FileInputStream(source); FileOutputStream out = new FileOutputStream(target)) {
            int data;
            while ((data=in.read())!=-1){
                out.write(data^ENCRYPT_FACTOR);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws FileNotFoundException {
        encrypt("D:\\ClassLoaderTest\\classloader_study\\myClassLoader\\MyObject.class","D:\\ClassLoaderTest\\classloader_study\\myClassLoader\\MyObject2.class");
    }
}

public class DecryptClassLoader extends ClassLoader {

    private final String DEFAULT_DIR = "D:\\ClassLoaderTest";

    private String dir = DEFAULT_DIR;

    public DecryptClassLoader() {
        super();
    }

    public DecryptClassLoader(ClassLoader parent) {
        super(parent);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String classPath = name.replace(".", "/");
        File classFile = new File(dir, classPath + ".class");
        if (!classFile.exists()) {
            throw new ClassNotFoundException("没找到对应的类文件 ：" + dir);
        }
        byte[] classBytes = loadClassByte(classFile);
        if (null == classBytes || classBytes.length == 0) {
            throw new ClassNotFoundException("加载失败");
        }
        return this.defineClass(name, classBytes, 0, classBytes.length);
    }

    private byte[] loadClassByte(File classFile) {
        try (FileInputStream in = new FileInputStream(classFile); ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            int data;
            while ((data=in.read())!=-1){
                //主要就是这里发生了变化，异或了 0xff
                baos.write(data^0xff);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    public void setDir(String dir) {
        this.dir = dir;
    }
}

Exception in thread "main" java.lang.ClassFormatError: Incompatible magic value 889275713 in class file classloader_study/myClassLoader/MyObject
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:642)
	at classloader_study.myClassLoader.MyClassLoader.findClass(MyClassLoader.java:64)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	at classloader_study.encryption_study.ClassLoaderTest.main(ClassLoaderTest.java:15)

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
    Class<?> clazz = null;

    //让父加载器加载 java 核心的包，因为有些类是继承的 Java 内部的核心类比如 Object 类
    if (name.startsWith("java.")) {
        try {
            ClassLoader system = ClassLoader.getSystemClassLoader();
            //这里仍然是委托上级
            clazz = system.loadClass(name);
            if (clazz != null) {
                if (resolve)
                    resolveClass(clazz);
                return clazz;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    try {
        //自己先找
        clazz = findClass(name);
    } catch (Exception e) {
        e.printStackTrace();
    }
	//找不到就交给父加载器
    if (clazz == null && getParent() != null) {
        getParent().loadClass(name);
    }

    return clazz;
}

public class SimpleClassLoaderTest {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        SimpleClassLoader simpleClassLoader = new SimpleClassLoader();
        Class<?> aClass = simpleClassLoader.loadClass("classloader_study.break_parent.SimpleObject");
        System.out.println(aClass.getClassLoader());
    }
}

package java.lang;
/**
 * @author imlgw.top
 * @date 2019/4/18 12:01
 */
public class String {
    static {
        System.out.println("i am init");
    }
    public int getVal(){
        return  250;
    }
}

 public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        SimpleClassLoader simpleClassLoader = new SimpleClassLoader();
        Class<?> aClass = simpleClassLoader.loadClass("java.lang.String");
        System.out.println(aClass.getClassLoader());
    }

java.lang.SecurityException: Prohibited package name: java.lang
	at java.lang.ClassLoader.preDefineClass(ClassLoader.java:662)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:761)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:642)
	at classloader_study.break_parent.SimpleClassLoader.findClass(SimpleClassLoader.java:52)
	at classloader_study.break_parent.SimpleClassLoader.loadClass(SimpleClassLoader.java:77)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	at classloader_study.break_parent.SimpleClassLoaderTest.main(SimpleClassLoaderTest.java:7)

protected Class<?> findClass(String name) throws ClassNotFoundException {
        Unsafe unsafe=UnsafeTest.getUnsafe();
        String classPath = name.replace(".", "/");
        File classFile = new File(dir, classPath + ".class");
        if (!classFile.exists()) {
            throw new ClassNotFoundException("The class " + name + " found under " + dir);
        }

        byte[] classBytes = loadClassBytes(classFile);
        if (null == classBytes || classBytes.length == 0)
            throw new ClassNotFoundException("load the class " + name + " failed");

        return unsafe.defineClass(null,classBytes,0,classBytes.length,SimpleClassLoader.this,null);
}

java.lang.SecurityException: Prohibited package name: java.lang
	at sun.misc.Unsafe.defineClass(Native Method)
	at classloader_study.break_parent.SimpleClassLoader.findClass(SimpleClassLoader.java:57)
	at classloader_study.break_parent.SimpleClassLoader.loadClass(SimpleClassLoader.java:83)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	at classloader_study.break_parent.SimpleClassLoaderTest.main(SimpleClassLoaderTest.java:7)
Exception in thread "main" java.lang.NullPointerException
	at classloader_study.break_parent.SimpleClassLoaderTest.main(SimpleClassLoaderTest.java:8)

public class MyClassLoaderTest2 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, ClassNotFoundException {
        //注意这里的 ClassLoader 要么利用前面的打破了双亲委托机制的，要么把 classpath 里面字节码的删掉。
        MyClassLoader loader1=new MyClassLoader("Resolmi1");
        MyClassLoader loader2=new MyClassLoader("Resolmi2");
        Class<?> aClass2 = loader2.loadClass("classloader_study.myClassLoader.MyObject");
        Class<?> aClass1 = loader1.loadClass("classloader_study.myClassLoader.MyObject");
        //两个不同的加载器（没有父子关系）加载同一个类加载出来的不是同一个
        System.out.println(aClass1.hashCode()); //2133927002
        System.out.println(aClass2.hashCode()); //1836019240
     }
}

public class ClassLoaderTest {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //使用上面自定义的 ClassLoader
        MyClassLoader loader=new MyClassLoader("Resolmi");
        Class<?> aClass = loader.loadClass("classloader_study.myClassLoader.Parent");
        //创建实例
        aClass.newInstance();
    }
}

public class Parent {
    public Parent() {
        System.out.println("Parent is load by" + this.getClass().getClassLoader());
        Hello();
    }

    public void Hello() {
        //父加载器访问子加载器加载的类
        System.out.println("Parent can see the " + Sub.class);
    }
}

public class Sub {
    public Sub(){
        System.out.println("Sub is load by"+this.getClass().getClassLoader());
        new Parent(); //构造 Parent 类
    }
}

Sub is load byclassloader_study.myClassLoader.MyClassLoader@74a14482
Parent is load bysun.misc.Launcher$AppClassLoader@18b4aac2
Exception in thread "main" java.lang.NoClassDefFoundError: classloader_study/myClassLoader/Sub
	at classloader_study.myClassLoader.Parent.Hello(Parent.java:15)
	at classloader_study.myClassLoader.Parent.<init>(Parent.java:10)
	at classloader_study.myClassLoader.Sub.<init>(Sub.java:10)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at java.lang.Class.newInstance(Class.java:442)
	at classloader_study.myClassLoader.ClassLoaderTest.main(ClassLoaderTest.java:14)
Caused by: java.lang.ClassNotFoundException: classloader_study.myClassLoader.Sub
	at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	... 9 more

public class Parent {
    public Parent() {
        System.out.println("Parent is load by" + this.getClass().getClassLoader());
        //Hello();
    }

    public void Hello() {
        //父加载器访问子加载器加载的类
        System.out.println("Parent can see the " + Sub.class);
    }
}

public class Sub {
    public Sub(){
        System.out.println("Sub is load by"+this.getClass().getClassLoader());
        new Parent(); //构造 Sub 类
        //访问父加载器加载的类
        System.out.println("Sub can see "+Parent.class);
    }
}

findclass is invoke MyClassLoader is loadclassloader_study.myClassLoader.Sub
Sub is load byclassloader_study.myClassLoader.MyClassLoader@74a14482
Parent is load bysun.misc.Launcher$AppClassLoader@18b4aac2
Sub can see class classloader_study.myClassLoader.Parent

Process finished with exit code 0

private static void loadInitialDrivers() {
    String drivers;
    try {
        drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
            public String run() {
                return System.getProperty("jdbc.drivers");
            }
        });
    } catch (Exception ex) {
        drivers = null;
    }
    // If the driver is packaged as a Service Provider, load it.
    // Get all the drivers through the classloader
    // exposed as a java.sql.Driver.class service.
    // ServiceLoader.load() replaces the sun.misc.Providers()
	// 如果驱动正确打包为 jar 就会用 ServiceLoader 去加载它
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
            /****************************************************/
			/*ServiceLoad 工具类，注意这个 ServiceLoad 的加载器，默认就是 TCCL*/
            ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
            /****************************************************/
            /*在这里会获取到一个 Drivers 的迭代器，但是其实还没有开始加载类*/
            Iterator<Driver> driversIterator = loadedDrivers.iterator();

            /* Load these drivers, so that they can be instantiated.
             * It may be the case that the driver class may not be there
             * i.e. there may be a packaged driver with the service class
             * as implementation of java.sql.Driver but the actual class
             * may be missing. In that case a java.util.ServiceConfigurationError
             * will be thrown at runtime by the VM trying to locate
             * and load the service.
             *
             * Adding a try catch block to catch those runtime errors
             * if driver not available in classpath but it's
             * packaged as service and that service is there in classpath.
             */
            try{
                while(driversIterator.hasNext()) {
                    //迭代的过程中通过 next 反射加载并初始化这个驱动字节码
                    //没有接收返回的数据库驱动实例
                    driversIterator.next();
                }
            } catch(Throwable t) {
            // Do nothing
            }
            return null;
        }
    });

    println("DriverManager.initialize: jdbc.drivers = " + drivers);
	//加载 Jdk 中的驱动实例（虽然我并不知道是什么）总之我们第三方的驱动已经加载好了
    if (drivers == null || drivers.equals("")) {
        return;
    }
    String[] driversList = drivers.split(":");
    println("number of Drivers:" + driversList.length);
    for (String aDriver : driversList) {
        try {
            println("DriverManager.Initialize: loading " + aDriver);
            Class.forName(aDriver, true,
                    ClassLoader.getSystemClassLoader());
        } catch (Exception ex) {
            println("DriverManager.Initialize: load failed: " + ex);
        }
    }
}

public final class ServiceLoader<S> implements Iterable<S> {
	//目录前缀就是从这里来的
    private static final String PREFIX = "META-INF/services/";

    //实现类 Service
    private final Class<S> service;

    // The class loader used to locate, load, and instantiate providers
    private final ClassLoader loader;

    // The access control context taken when the ServiceLoader is created
    private final AccessControlContext acc;

    // Cached providers, in instantiation order
    // 按照实例的顺序，来缓存服务提供者避免重复的加载，具体可以看下面的 iterator 方法
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

    // The current lazy-lookup iterator
    private LazyIterator lookupIterator;

    public void reload() {
        providers.clear();
        //初始化懒加载迭代器
        lookupIterator = new LazyIterator(service, loader);
    }
	
    //构造器
    private ServiceLoader(Class<S> svc, ClassLoader cl) {
        service = Objects.requireNonNull(svc, "Service interface cannot be null");
        loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
        acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
        reload();
    }

    private static void fail(Class<?> service, String msg, Throwable cause)
        throws ServiceConfigurationError
    {
        throw new ServiceConfigurationError(service.getName() + ": " + msg,
                                            cause);
    }

    private static void fail(Class<?> service, String msg)
        throws ServiceConfigurationError
    {
        throw new ServiceConfigurationError(service.getName() + ": " + msg);
    }

    private static void fail(Class<?> service, URL u, int line, String msg)
        throws ServiceConfigurationError
    {
        fail(service, u + ":" + line + ": " + msg);
    }

    // Parse a single line from the given configuration file, adding the name
    // on the line to the names list.
    //
    private int parseLine(Class<?> service, URL u, BufferedReader r, int lc,
                          List<String> names)
        throws IOException, ServiceConfigurationError
    {
        String ln = r.readLine();
        if (ln == null) {
            return -1;
        }
        int ci = ln.indexOf('#');
        if (ci >= 0) ln = ln.substring(0, ci);
        ln = ln.trim();
        int n = ln.length();
        if (n != 0) {
            if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
                fail(service, u, lc, "Illegal configuration-file syntax");
            int cp = ln.codePointAt(0);
            if (!Character.isJavaIdentifierStart(cp))
                fail(service, u, lc, "Illegal provider-class name: " + ln);
            for (int i = Character.charCount(cp); i < n; i += Character.charCount(cp)) {
                cp = ln.codePointAt(i);
                if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))
                    fail(service, u, lc, "Illegal provider-class name: " + ln);
            }
            if (!providers.containsKey(ln) && !names.contains(ln))
                names.add(ln);
        }
        return lc + 1;
    }

    private Iterator<String> parse(Class<?> service, URL u)
        throws ServiceConfigurationError
    {
        InputStream in = null;
        BufferedReader r = null;
        ArrayList<String> names = new ArrayList<>();
        try {
            in = u.openStream();
            r = new BufferedReader(new InputStreamReader(in, "utf-8"));
            int lc = 1;
            while ((lc = parseLine(service, u, r, lc, names)) >= 0);
        } catch (IOException x) {
            fail(service, "Error reading configuration file", x);
        } finally {
            try {
                if (r != null) r.close();
                if (in != null) in.close();
            } catch (IOException y) {
                fail(service, "Error closing configuration file", y);
            }
        }
        return names.iterator();
    }

    // Private inner class implementing fully-lazy provider lookup
    // 看名字就知道了，懒迭代器，在迭代的时候才真正的加载
    private class LazyIterator
        implements Iterator<S>
    {

        Class<S> service;
        ClassLoader loader;
        Enumeration<URL> configs = null;
        Iterator<String> pending = null;
        String nextName = null;

        private LazyIterator(Class<S> service, ClassLoader loader) {
            this.service = service;
            this.loader = loader;
        }

        private boolean hasNextService() {
            if (nextName != null) {
                return true;
            }
            if (configs == null) {
                try {
                    String fullName = PREFIX + service.getName();
                    if (loader == null)
                        configs = ClassLoader.getSystemResources(fullName);
                    else
                        configs = loader.getResources(fullName);
                } catch (IOException x) {
                    fail(service, "Error locating configuration files", x);
                }
            }
            while ((pending == null) || !pending.hasNext()) {
                if (!configs.hasMoreElements()) {
                    return false;
                }
                pending = parse(service, configs.nextElement());
            }
            nextName = pending.next();
            return true;
        }
        
		//迭代器的 next
        private S nextService() {
            if (!hasNextService())
                throw new NoSuchElementException();
            String cn = nextName;
            nextName = null;
            Class<?> c = null;
            try {
                //利用 TCCL 加载实现类，但是不初始化
                c = Class.forName(cn, false, loader);
            } catch (ClassNotFoundException x) {
                fail(service,
                     "Provider " + cn + " not found");
            }
            if (!service.isAssignableFrom(c)) {
                fail(service,
                     "Provider " + cn  + " not a subtype");
            }
            try {
                //newInstance() 初始化了对应的实现类
                S p = service.cast(c.newInstance());
                //放到 providers 中
                providers.put(cn, p);
                return p;
            } catch (Throwable x) {
                fail(service,
                     "Provider " + cn + " could not be instantiated",
                     x);
            }
            throw new Error();          // This cannot happen
        }

        public boolean hasNext() {
            if (acc == null) {
                return hasNextService();
            } else {
                PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
                    public Boolean run() { return hasNextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }

        public S next() {
            if (acc == null) {
                return nextService();
            } else {
                PrivilegedAction<S> action = new PrivilegedAction<S>() {
                    public S run() { return nextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

    }

    /**
     * Lazily loads the available providers of this loader's service.
     * @return  An iterator that lazily loads providers for this loader's
     *          service
     */
    public Iterator<S> iterator() {
        return new Iterator<S>() {

            Iterator<Map.Entry<String,S>> knownProviders
                = providers.entrySet().iterator();

            public boolean hasNext() {
                if (knownProviders.hasNext())
                    return true;
                return lookupIterator.hasNext();
            }

            public S next() {
                if (knownProviders.hasNext())
                    return knownProviders.next().getValue();
                return lookupIterator.next();
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }

        };
    }

    /* 重载的 ServiceLoad */
    public static <S> ServiceLoader<S> load(Class<S> service,
                                            ClassLoader loader)
    {
        return new ServiceLoader<>(service, loader);
    }

	//DriverManage 里面就是调用的这个方法
    public static <S> ServiceLoader<S> load(Class<S> service) {
        //拿到了 TCCL
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        //调用上面重载的 ServiceLoad 方法
        return ServiceLoader.load(service, cl);
    }

    public static <S> ServiceLoader<S> loadInstalled(Class<S> service) {
        ClassLoader cl = ClassLoader.getSystemClassLoader();
        ClassLoader prev = null;
        while (cl != null) {
            prev = cl;
            cl = cl.getParent();
        }
        return ServiceLoader.load(service, prev);
    }

    public String toString() {
        return "java.util.ServiceLoader[" + service.getName() + "]";
    }

}