热加载的原理是开启一个后台线程，检查文件变化，变化就重新加载类。
```java




// ContainerBackgroundProcessor实现Runnable接口,负责后台处理
protected class ContainerBackgroundProcessor implements Runnable {

        @Override
        // run方法是主处理逻辑
        public void run() {
            
            // 定义变量保存可能出现的异常
            Throwable t = null;
            
            // 定义变量保存线程意外死亡的日志信息
            String unexpectedDeathMessage = sm.getString("containerBase.backgroundProcess.unexpectedThreadDeath",
                    Thread.currentThread().getName());
            
            try {
                
                // 循环处理,直到线程结束
                while (!threadDone) {
                    
                    try {
                        // 每隔一定时间睡眠
                        Thread.sleep(backgroundProcessorDelay * 1000L); 
                    } catch (InterruptedException e) {
                        // 忽略中断异常
                    }
                    
                    if (!threadDone) {
                        // 调用processChildren方法处理子容器
                        processChildren(ContainerBase.this);
                    }
                }
                
            } catch (RuntimeException | Error e) {
                // 如果发生异常,保存到t变量并抛出
                t = e;
                throw e;
                
            } finally {
                
                if (!threadDone) {
                    // 线程意外死亡打印日志
                    log.error(unexpectedDeathMessage, t);
                }
            }
        }

        // 处理子容器
        protected void processChildren(Container container) {

            // 保存当前类加载器
            ClassLoader originalClassLoader = null;

            try {
                
                if (container instanceof Context) {
                    
                    // Context实例获取类加载器
                    Loader loader = ((Context) container).getLoader();
                    
                    // Loader可能为null,忽略
                    if (loader == null) {
                        return; 
                    }

                    // 使用Context的类加载器
                    originalClassLoader = ((Context) container).bind(false, null);
                }
                
                // 处理当前容器
                container.backgroundProcess();
                
                // 获取子容器
                Container[] children = container.findChildren();
                
                for (Container child : children) {

                    if (child.getBackgroundProcessorDelay() <= 0) {
                        // 处理子容器
                        processChildren(child);
                    }
                }
                
            } catch (Throwable t) {
                
                // 处理异常
                ExceptionUtils.handleThrowable(t);
                log.error(sm.getString("containerBase.backgroundProcess.error"), t);
                
            } finally {
                
                if (container instanceof Context) {
                    // 恢复类加载器
                    ((Context) container).unbind(false, originalClassLoader);
                }
            }
        }
    }



```

```java
public void backgroundProcess() {
 
    //1. 执行容器中 Cluster 组件的周期性任务
    Cluster cluster = getClusterInternal();
    if (cluster != null) {
        cluster.backgroundProcess();
    }
    
    //2. 执行容器中 Realm 组件的周期性任务
    Realm realm = getRealmInternal();
    if (realm != null) {
        realm.backgroundProcess();
   }
   
   //3. 执行容器中 Valve 组件的周期性任务
    Valve current = pipeline.getFirst();
    while (current != null) {
       current.backgroundProcess();
       current = current.getNext();
    }
    
    //4. 触发容器的 " 周期事件 "，Host 容器的监听器 HostConfig 就靠它来调用
    fireLifecycleEvent(Lifecycle.PERIODIC_EVENT, null);
}
```

Tomcat源码学习21 --热加载源码分析

差点忘记备份镜像了
![image.png](/static/img/9d87450a60d1bd6e26ea9da2b9aac6f8.image.webp)

备份一下镜像

硬链接和软连接是 Linux 下两种常见的链接类型,下面详细介绍它们之间的区别:

硬链接(hard link):



- 目录下可以有多个物理指向同一个 inode 的文件(硬链接文件)。 

- 所有硬链接文件共享同一个 inode,对任意一个文件的修改都会影响其他硬链接文件。

- 删除最后一个硬链接文件时,该文件才真正被删除,数据一直占用磁盘空间。

- 不能对目录建立硬链接,一个目录只能有一个名称。

软连接(symbolic link):

- 软链接本身占用独立的 inode,内部存储指向原文件/目录的路径。

- 软连接像窗口指向原文件,删除软连接不影响原文件,但原文件删除后软连接失效。

- 可以对文件和目录建立软连接,向用户暴露为另一个文件/目录路径。

- 软连接可以指向不同文件系统下的文件,跨设备的软链接需要支持列出的文件系统。

区别:

- 硬链接操作对象为 inode,软连接操作对象为路径名。
- 删除硬链接文件不删除数据,删除软连接不影响原文件。
- 只能为文件建硬链接,目录只能建软连接。

硬链接在磁盘上共享数据块,软连接像指针引用其他路径。

软连接和硬链接

inode存储了文件在磁盘中的索引，并且一个文件在磁盘中存储不一定是连续的。





1. inode是文件系统中的一个数据结构，用于存储文件的元信息，包括文件的大小、权限、时间戳等信息。每个文件都有一个唯一的inode节点与之对应[[1]](https://zhuanlan.zhihu.com/p/430293714)。

2. inode中存储了文件在磁盘中的索引信息，即文件数据在磁盘上的位置。通过inode，文件系统可以将文件的逻辑结构与物理结构进行转换[[1]](https://zhuanlan.zhihu.com/p/430293714)。

3. 一个文件在磁盘中存储的数据不一定是连续的。文件系统会将文件的数据分散存放在磁盘上的不同位置，然后通过inode中的磁盘地址表将这些分散的数据块连接起来，形成文件的逻辑结构[[1]](https://zhuanlan.zhihu.com/p/430293714)。

4. 文件系统在打开一个文件时，会通过文件名找到对应的inode号，然后通过inode中的磁盘地址表将分散存放的文件数据块连接起来，以读取文件的内容[[1]](https://zhuanlan.zhihu.com/p/430293714)。

综上所述，inode存储了文件在磁盘中的索引信息，而一个文件在磁盘中存储的数据不一定是连续的。

---
Learn more:
1. [inode：linux的文件存储方式 - 知乎](https://zhuanlan.zhihu.com/p/430293714)
2. [一口气搞懂「文件系统」，就靠这 25 张图了-腾讯云开发者社区-腾讯云](https://cloud.tencent.com/developer/article/1681429)
3. [一次由iNode 引发的惨案，爆肝四小时终于理解了iNode - 掘金](https://juejin.cn/post/7058177122749120548)

inode结构

CR3寄存器是x86架构中的一个控制寄存器，用于存储页目录表的物理地址。它在操作系统中起着重要的作用，与内存管理单元（MMU）和转换查找缓冲区（TLB）密切相关。






## 1. CR3寄存器的功能
- CR3寄存器用于存储页目录表的物理地址，也被称为页目录基址寄存器（PDBR）[[1]](https://blog.csdn.net/SweeNeil/article/details/106171361)。
- 在64位机器上，CR3寄存器从32位扩展为64位，用于存储页目录表的物理内存基地址[[1]](https://blog.csdn.net/SweeNeil/article/details/106171361)。
- 每当进程切换时，操作系统会将下一个要运行的进程的页目录表物理内存基地址等信息存储到CR3寄存器中[[1]](https://blog.csdn.net/SweeNeil/article/details/106171361)。

## 2. CR3寄存器与TLB的关系
- TLB（转换查找缓冲区）是一个硬件缓存，用于存储最近访问的页表项，以加速地址转换过程[[1]](https://blog.csdn.net/SweeNeil/article/details/106171361)。
- 当TLB中不包含所需的页表项时，需要额外的总线周期从内存中读取页表项[[1]](https://blog.csdn.net/SweeNeil/article/details/106171361)。
- 当CR3寄存器的值发生改变时，TLB会被刷新，即TLB中的所有页表项都会失效，需要重新加载[[2]](https://blog.csdn.net/weixin_41430055/article/details/125299709)。

## 3. CR3寄存器与操作系统的交互
- 每当进程切换时，操作系统需要修改CR3寄存器的内容[[1]](https://blog.csdn.net/SweeNeil/article/details/106171361)。
- 在x86架构下，当切换到一个新的进程时，操作系统会将新进程的页目录表物理内存基地址加载到CR3寄存器中[[1]](https://blog.csdn.net/SweeNeil/article/details/106171361)。
- 这样做的目的是切换页全局目录以安装一个新的地址空间，并切换内核态堆栈和硬件上下文[[1]](https://blog.csdn.net/SweeNeil/article/details/106171361)。

总结：
CR3寄存器是x86架构中的一个控制寄存器，用于存储页目录表的物理地址。它与TLB密切相关，当CR3寄存器的值发生改变时，TLB会被刷新。操作系统在进程切换时需要修改CR3寄存器的内容，以切换页全局目录和硬件上下文。

---
Learn more:
1. [X86_64 CR3控制寄存器详解_cr3和pgd的关系-CSDN博客](https://blog.csdn.net/SweeNeil/article/details/106171361)
2. [【精选】X86_64 CR3详解_cr3寄存器-CSDN博客](https://blog.csdn.net/weixin_41430055/article/details/125299709)
3. [[转载] 控制寄存器(CR0,CR1,CR2,CR3,CR4) - 舒方小院 - 博客园](https://www.cnblogs.com/iamfy/archive/2012/05/10/2495044.html)