话说类加载过程第二篇

原创

木子的昼夜

修改于 2021-04-06 11:14:18

3810

修改于 2021-04-06 11:14:18

文章被收录于专栏：互联网底层的我们互联网底层的我们

上一篇说了类加载器、双亲委派机制、自定义类加载器

一、问题ask

1. 自定义类加载器的上一层也就是父类加载器是谁

System.out.println(new MyClassLoader().getParent());
输出结果：sun.misc.Launcher$AppClassLoader@18b4aac2

2. 我没有指定parent呀为什么不是null呢

我们自定义类加载器继承了ClassLoader,new MyClassLoader()的时候会先走类加载器的构造

// 无参构造  调用了2个参数的构造 
protected ClassLoader() {
        this(checkCreateClassLoader(), getSystemClassLoader());
}
// 这里指定了parent  parent从哪儿来 看getSystemClassLoader()
private ClassLoader(Void unused, ClassLoader parent) {
        // 指定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;
        }
}

@CallerSensitive
public static ClassLoader getSystemClassLoader() {
    // 返回的scl 看scl怎么初始化的
    initSystemClassLoader();
    if (scl == null) {
        return null;
    }
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkClassLoaderPermission(scl, Reflection.getCallerClass());
    }
    return scl;
}

 private static synchronized void initSystemClassLoader() {
        if (!sclSet) {
            if (scl != null)
                throw new IllegalStateException("recursive invocation");
            sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
            if (l != null) {	
                Throwable oops = null;
                // 获取classLoader
                scl = l.getClassLoader();
                try {
                    scl = AccessController.doPrivileged(
                        new SystemClassLoaderAction(scl));
                } catch (PrivilegedActionException pae) {
                    oops = pae.getCause();
                    if (oops instanceof InvocationTargetException) {
                        oops = oops.getCause();
                    }
                }
                if (oops != null) {
                    if (oops instanceof Error) {
                        throw (Error) oops;
                    } else {
                        // wrap the exception
                        throw new Error(oops);
                    }
                }
            }
            sclSet = true;
        }
}
// 直接返回了loader  loader 是怎么来的  
public ClassLoader getClassLoader() {
        return this.loader;
}

// Launcher类初始化的时候 构造方法里初始化了load 默认是appclassloader
this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);

3. 直接获取系统类加载器

ClassLoader.getSystemClassLoader(); -> appClassLoader

4. 可以自己指定parent

// 写一个有参的构造 传入一个你想认的爹  然后调用super 把parent传进去就行了
public MyClassLoader(ClassLoader parent) {
        super(parent);
}

5. 打破双亲委派？看一眼不理解没关系我也不理解从别的地方抄过来的

重写LoadClass方法undefined因为双亲委派是在loadClass里边的逻辑指定的
什么时候打破？
1. JDK1.2之前没有findClass 必须重写loadClass
2. ThreadCotextClassLoader 可以实现基础类调用实现类代码，通过thread.setContentClassLoader 指定
3. 热启动热部署 osgi 、tomcat 都有自己的模块指定classloader (可以加载同一类库不同版本) 比如两个WebApplication加载不同版本的同一个类

二、Linking

verification 对文件格式进行校验
preparation 给静态变量赋默认值
resolution
将类、方法、属性等符号引用解析为直接引用

  常量池中的各种符号引用解析为指针、偏移量等内存地址的直接引用。

 比如java.lang.Object  他是个符号引用

 如果想找他真是的内存数据 需要根据java.lang.Object先去常量池找见这个符号，然后再根据符号找对应的类型，这个就太绕了 ，直接把符号引用解析为直接引用的话 java.lang.Object 就变为0x00012 内存地址 ，直接根据这个地址找类型就可以了

三、Initializing

调用初始化代码 <clinit> 给静态成员赋初始值

1. 面试题输出结果是多少

/**
 * @author 木子的昼夜
 */
public class Mr {
    public static void main(String[] args) {
        System.out.println(T.count);
    }
}

class T{
    // 成员变量
    public static int count = 10;
    public static T t = new T();
    // 构造
    private T(){
        count++;
    }
}

结果：11

如果赋值和new 对象换一下位置呢

/**
 * @author 木子的昼夜
 */
public class Mr {
    public static void main(String[] args) {
        System.out.println(T.count);
    }
}

class T{
    // 成员变量
    public static T t = new T();
    public static int count = 10;
    // 构造
    private T(){
        count++;
    }
}
结果： 10

自己想下这个过程想不通可以公众号留言我再进行解答应该都可以想的通。。

2. 也就是

静态属性： load->默认值->初始值
成员属性： new -> 申请内存->默认值->初始值

3. 这里有个面试题单例双重校验

	/**
 * @author 木子的昼夜
 */
public class Sig {
    private  static T03 t03;
    public static T03 getInstance(){
        // 先校验是否是null
        if (t03 == null) {
            // 等锁
            synchronized (T03.class){
                // 接着校验是否是null 因为可能多个人等锁
                if (t03 == null){
                    t03 = new T03();
                }
            }
        }
        return t03;
    }
}

class T03{
}

这个单例模式有什么问题吗？

面试官会疯狂的暗示你加volatile .

接着会问volatile的作用： 禁止指令重排 保证可见性

这里就是因为我们说的 new T03() 的时候先分配内存再赋初始值再赋默认值

如果内存分配好了另一个线程 if(t03 == null) 就是false了

然后就返回了如果用t03.count 那他还是0呢

当然概率很低但是这是会出现的

让我们看一下T03 t03 = new T03();的过程

public class T03 {
    public int count =8;
}
public class Test {
    public static void main(String[] args) {
        T03 t03 = new T03();
    }
}

注意：这里需要使用 idea的一个工具->jclasslib ByteCode Viewer 直接搜索安装即可

先运行一下main方法生成class文件
选中Test文件
view 视图找 Show ByteCode By jclasslib

看生成过程

0 new #2 <T03>   // （1）这句话就是在内存开辟一块空间  count = 0 
3 dup 
4 invokespecial #3 <T03.<init>> // （2）这句话就是初始化count值 count = 8 
7 astore_1 //（3） 这句话 就是把内存空间 地址引用  赋值给t03变量  
8 retur

正常情况下按照(1) (2) (3)的顺序执行是没有任何问题的但是指令可能重排

可能会出现 (1) (3)(2) 这种情况就是我们上边说的出现问题的情况所以要禁止指令重排 volatile

4. JMM 不是接妹妹是 Java Memory Model

1. 先来一个存储器的层次结构图来开开胃

2. 为什么会出现数据不一致？

假设线程1使用cpu1 把数据 x 读到了L0、L1、L2中的任何一个地方这是cpu独享的

线程2 使用cpu2 把数据x 也读到了 cpu2的 L0 、L1、L2的任何一个地方

这时候就是一个数据在内存中存储着2份了其中一份修改了那另一份没改是不是就有问题了

3.硬件层面怎么来解决这个问题 -- 总线锁

在cpu 读取数据 L3-->L2 都要过总线

在cpu1读取x的时候给总线上一把锁这时候cpu2不允许读

缺点：总线锁是锁总线，也就是我cpu2不访问x 我cpu2去访问y 也不能访问这样不是很合理吧

大家去洗脚了，你找了小丽，然后在门口上了一把锁，凭什么不让我去找小兰。。。

4.硬件层面怎么来解决这个问题 -- 一致性协议（各种各样）MESI 、MSI MOSI 、Synaose 、Firefly 、Dragon 等

一般大家聊的时候是MESI -- intel CPU 实现协议

what is MESI ? is this !

数据存储在缓存行上缓存行用额外两位two bit 来标记状态，这里需要注意，如果数据夸缓存行了，那就很难用这种方式标记了，就需要使用总线锁了，呀呼嘿嘿
这个很难表达我试着说一下子

 1.我是cpu1, 我从主从读取了x ,这时候只有我读没有其他cpu读，我会标记位Exclusive

如果我读的时候，还有别的cpu在读，那我就标记位Shared
如果我读回来，我做了修改，那我就标记位Modified ，这个时候别人就会变成Invalid
如果我读回来，别的cpu不要脸的进行了修改（为啥我修改就不是不要懒哈哈），那我就标记为Invalid ，这时候如果我要用这个数计算的时候，我会重新从内存读取一下

至于这些状态都是在什么时候变化的，这个学问就大了去了，主板上各种逻辑单元，我也不知道是什么高科技实现的。

5. 再叙--缓存行

上边说了缓存行的2bit标记状态那什么是缓存行呢？

cpu这个家伙呀，在读取数据的时候，是以缓存行为最小单位读取的

比如int x =666； cpu在读取x的时候不会只读取这四个字节，他会读取x及x以后的N个字节

这些个字节总的就叫缓存行，一般缓存行是64字节

缓存行问题：

我是cpu1, 我读取x的时候，会把整个缓存行读取了

我修改了x ，我把缓存行状态改为invalid，其实我没有

修改y z w j 但是如果别的cpu在使用y z w j的话

就需要重新加载一遍

这个问题叫：伪共享：位于同一缓存行的两个不同数据被两个CPU锁定，产生互相影响。

这里有一个缓存行对齐的例子：

public class CacheLineTest01 {
    static T[] arr = new T[2];
    static{
        arr[0] = new T();
        arr[1] = new T();
    }
    public static void main(String[] args) throws InterruptedException {
        final CountDownLatch cdl = new CountDownLatch(2);
        final long count = 1_0000_0000L;
        long start = System.currentTimeMillis();
        // 起两个线程 分别修改arr[0] arr[1] 对应对象T的属性 
        // 这个arr很大概率上会在一个缓存行 因为就2个T对象 每个对象就一个Long类型属性 总共不够64字节
        new Thread(()->{
            for (long i = 0; i <count; i++) {
                arr[0].x = i;
            }
            cdl.countDown();
        }).start();
        new Thread(()->{
            for (int i = 0; i < count; i++) {
                arr[1].x = i;
            }
            cdl.countDown();
        }).start();

        cdl.await();
        long end = System.currentTimeMillis();
        System.out.println((end-start)/100);

    }
}
class T{
    public volatile long x=0L;
 }
执行多次输出结果：
    30、29、23、26、27、30

public class CacheLineTest02 {
    static T006[] arr = new T006[2];
    static{
        arr[0] = new T006();
        arr[1] = new T006();
    }

    public static void main(String[] args) throws InterruptedException {
        final CountDownLatch cdl = new CountDownLatch(2);
        long start = System.currentTimeMillis();
        final long count = 1_0000_0000L;
        new Thread(()->{
            for (long i = 0; i < count; i++) {
                arr[0].x = i;
            }
            cdl.countDown();
        }).start();
        new Thread(()->{
            for (int i = 0; i <count; i++) {
                arr[1].x = i;
            }
            cdl.countDown();
        }).start();

        cdl.await();
        long end = System.currentTimeMillis();
        System.out.println((end-start)/100);
    }
}
// 加了一个对齐 也就是Padding 这样new2个T006之后  绝对不在一个缓存行 
// 所以两个cpu修改属性 不会相互影响
class T006 extends  Padding{
    public volatile long x=0L;
}
class Padding{
    long a,b,c,d,e,f,g;
}
执行多次结果：
    14、16、16、14、17、14、15

很明显，第二段代码的执行时间更快这就是缓存行对齐对程序效率提升的作用

可以看图：第一段代码会走invalid 每次都会去内存拿数据再进行修改，而第二段代码会走Modified不需要去内存再一次拿数据

6. 乱序执行 01

用一句话总结：cpu为了提高执行效率，会在一条指令准备数据过程中，执行另一条不依赖于前一条指令的指令

可以看一个例子：cpu在执行指令1的时候，指令1 需要去内存拿数据，大家知道内存读取数据耗时至少是cpu的100倍起步，这个时间cpu等着吗？不能呀！那你电脑不卡成狗了吗。

这个时间cpu会接着去判断下一条指令2，看指令2是否依赖指令1的执行结果，如果依赖，接着看指令3，如果不依赖就执行，依次往下执行，直到指令1拿回来数据为止

举个例子：

小强做饭，第一道菜是土豆炖牛腩，第二道菜是拍黄瓜

如果是你，你会怎么做？

最容易些想到的是这样：

准备土豆->准备牛腩->放锅里->看着它炖熟了->盛出来->准备黄瓜->拍黄瓜->倒酱汁->拍黄瓜做好了

但是我们一般不会这么做，我们跟cpu一样聪明：

我们会这样做：

准备土豆->准备牛腩->放锅里->判断拍黄瓜这道菜要不要等土豆牛腩好了才能做？->不是->准备黄瓜->拍黄瓜->倒酱汁->拍黄瓜做好了->在做拍黄瓜的过程中你肯定会看着土豆牛腩，防止干锅，如果拍黄瓜过程中土豆牛腩好了，你会先停止拍黄瓜，先去把牛腩捞出来（不然土豆块成土豆汤了），然后再去拍黄瓜

7.乱序执行 02

合并写的概念：

拿生活中的例子就是，小强的土豆炖牛肉好了，可以放上桌让别人吃了，但是他觉得，这顿饭拍黄瓜跟土豆炖牛肉一起吃才能称之为“一顿饭”，注意这里一顿饭在cpu中可以对应一个数据。然后他就俩都做好了，拿一个大托盘，把2道菜合成了“一顿饭” 放上桌，大家吃的不亦乐乎。

学术上的概念大概意思就是：多个程序对同一个数据x进行操作，cpu执行x=x+1; 准备把结果写回L3内存，但是他“自作聪明”的发现，后边好像还有一句 x = x+10;所以他就等着x=x+10;这句执行完之后再把一个最终结果写回L3内存，而不是写2次。

合并写的缓冲区WCbuffer 很小很小只有4个字节

8.乱序执行证明小程序

import java.util.concurrent.CountDownLatch;

public class TestOrder {
    private static int a=0,b=0,x=0,y=0;

    public static void main(String[] args) throws InterruptedException {
       long count = 0;
       for (;;){
           count++;
           CountDownLatch cdl = new CountDownLatch(1);
           CountDownLatch cdlres = new CountDownLatch(2);
           // 默认值
           a=0;b=0;x=0;y=0;
           new Thread(()->{
               try {
                   cdl.await();
                   a = 1;
                   x = b;
               } catch (InterruptedException e) { }finally {
                   cdlres.countDown();
               }
           }).start();
           new Thread(()->{
               try {
                   cdl.await();
                   b = 1;
                   y = a;
               } catch (InterruptedException e) { }finally {
                   cdlres.countDown();
               }
           }).start();
           cdl.countDown();
           cdlres.await();
           if (x==0&&y==0){
               System.out.println("存在乱序"+"，一共执行："+count+ " 次");
               break;
           }
       }
    }
}

如果不重排出现的结果应该是：

如果出现x==0 && y == 0 的情况说明指令重拍了

想要证明，你就拿着这个程序，跑吧，跑一会儿，要有耐心

看看我执行的次数：40多万次

9.有序性保证

待续。。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java

登录后参与评论

0 条评论

热度