java面经

一、Java基础

Java和C语言有什么区别？Java好在哪里？

内存管理：Java中不需要考虑内存的问题，如果想用一个对象，new一个就可以，当不再使用这个对象后，JVM会自动进行回收。而C需要使用malloc之类的方法申请内存，然后不想用了需要使用free去释放内存。

面向对象：Java是一门面向对象的编程语言，而C语言主要是面向过程的

解释与编译共存：Java是一门解释与编译并存的语言，而C语言是编译型语言。

Java程序从源代码到运行的过程是这样的：.java文件—>javac编译—>.class文件—>解释器和JIT即时编译器—>机器码—>OS

.class—>机器码这一步JVM加载器首先加载字节码文件，然后通过解释器逐行解释运行，但这种方式执行速度相对较慢。而且很多方法和代码块是被频繁调用的（热点代码），所以后面引进了JIT编译器，而JIT属于运行时编译，当JIT编译器完成第一次编译后，会将字节码对应的机器码保存下来，下次直接使用（也就是说热点代码基本上已经被编译成机器码保存了下来，而其他的代码可以通过解释器执行，这样就大大提高了程序运行效率）。JVM 会根据代码每次被执行的情况收集信息并相应地做出一些优化，因此执行的次数越多，它的速度就越快。

一次编译到处运行：Java是先从.java文件通过javac编译成字节码文件，然后这个字节码文件可以在任何操作系统的JVM上运行。当然其他语言编译成字节码文件后也可以在JVM上运行。因此Java的开发效率比较高。

开发效率高：C语言主要面向底层，像内存、CPU等；而Java不需要，虚拟机已经帮助解决很多底层方面的问题。

指针：Java 不提供指针来直接访问内存，程序内存更加安全

为什么Java要经过中间步骤转换为字节码，然后再用JVM执行Java字节码，而不能一步到位，直接从原始代码到执行结果？

每次重新执行同样的代码都必须重新经过从源代码到机器语言之间的编译过程，而Java可以在编译成字节码后，在多平台运行。

怎么理解Java的跨平台性，一次编译到处运行？

简单地说就是编译后的Java程序可直接在不同的平台上的虚拟机运行，而不用重新编译。

面向对象和面向过程的区别？

​ 面向过程是直接将解决问题的步骤分析出来，然后用函数把步骤一步一步实现，再依次调用就可以了；而面向对象是将构成问题的事物，分解成若干个对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个事物在解决问题过程中的行为。面向过程思想偏向于我们做一件事的流程，首先做什么，其次做什么，最后做什么。面向对象思想偏向于了解一个人，这个人的性格、特长是怎么样的，有没有遗传到什么能力，有没有家族病史。

​ 面向过程的性能比面向对象高，因为类调用需要实例化，开销比较大，比较消耗资源。如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，因为在它们看来性能是最重要的因素。而面向对象易维护、易扩展（封装、继承和多态，容易设计高内聚低耦合的系统结构）、开发效率高（接近日常生活和自然的思考方式）

如何理解面向对象三大特性：封装、继承、多态？

封装：将类成员属性（数据）和类的方法（对数据的操作）捆绑到一起，形成对外界的隐藏，同时提供外界可以操作的接口。封装的意义在于保护或者防止代码被我们无形破坏，保护成员属性，不让类以外的程序直接访问和修改，隐藏方法细节。

继承：继承是在已有的类中派生出新的类，新的类能够吸收原有类的属性和行为，并能够扩展新的能力。继承能够反映现实生活中的真实关系，减少了代码冗余，对父类的代码和属性进行重写。子类不可以选择性的继承父类的属性和方法，而是要全部继承。（父类中的静态方法可以被继承但是不能被重写）

多态：父类引用指向不同子类实例对象。Java实现多态需要三个必要条件：继承、重写、向上转型。继承：在多态中必须存在有继承关系的子类和父类。重写：子类对父类中的某些方法进行重新定义，那么在调用方法时就会执行子类中的方法。向上转型：需要将子类的引用赋给父类对象，只有这样该引用才既能调用父类的方法，又能调用子类的方法。

类继承会有什么问题吗，一般什么情况下才会去用继承？

a：子类只能继承父类所有非私有的成员(成员方法和成员变量)。但是可以通过暴力反射来获取。

b：子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。

类继承打破了封装性，这迫使开发者要去了解超类的实现细节，导致了子类和超类的耦合，当父类改变时可能要相应地对子类做出改变。子类从父类继承的方法在编译时就确定下来了，所以无法在运行期间改变从父类继承的方法的行为。

继承是 is-a 的关系

为什么重写equals方法还要重写hashcode方法？

需要保证重写后的equals方法认定相同的对象的hashcode相等。

深克隆和浅克隆

浅拷贝：在拷贝对象时，只对基本数据类型进行了拷贝，对于引用数据类型只是进行了引用地址的传递，而没有创建一个新的对象，这就是浅拷贝；

深拷贝：相应地，对于引用数据类型进行拷贝时，创建了一个新的对象，并且复制了其内的成员变量，就叫做深拷贝。（深拷贝实现：1. 继续利用clone方法 2. 序列化这个对象）

反射相关

反射指在运行状态时，对于任意一个类，都可以获取到这个类的全部属性和方法。对于任意一个对象，都能够调用它的任意方法和属性，并且可以改变它的属性，这种动态获取信息以及动态调用对象的方法的功能称为Java语言的反射机制。

注解的实现原理

注解的作用：

1 生成文档。这是最常见的，也是Java 最早提供的注解。常用的有@param @return 等； 2 跟踪代码依赖性，实现替代配置文件功能。比如Dagger 2 依赖注入，未来java 开发，将大量注解配置，具有很大用处; 3 在编译时进行格式检查。如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出。

注解的原理：

注解本质是一个继承了Annotation 的特殊接口，在调用getDeclaredAnnotations()方法（通过反射方法获取）的时候，返回一个代理$Proxy对象，这个代理对象是由jdk动态代理创建，使用Proxy的newProxyInstance方法，传入接口和InvocationHandler的一个实例(也就是 AnotationInvocationHandler) ，最后返回一个实例。期间，在创建代理对象之前解析注解的时候，从该注解类的常量池中取出注解的信息，包括之前写到注解中的参数，然后将这些信息在创建 AnnotationInvocationHandler 时候，传入进去作为构造函数的参数。

1
2
3
4
5
6
static class AnnotationInvocationHandler implements InvocationHandler{
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   //处理注解的解析
    }    
  }
1
2
3
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)

newProxyInstance，方法有三个参数：
loader: 用哪个类加载器去加载代理对象
interfaces: 动态代理类需要实现的接口
h: 动态代理方法在执行时，会调用h里面的invoke方法去执行

Lambda表达式的优缺点？

优点：

  • 简洁。

  • 非常容易并行计算。

  • 结合 hashmap 的 computeIfAbsent 方法，递归运算非常快。java有针对递归的专门优化。

缺点：

  • 若不用并行计算，很多时候计算速度没有比传统的 for 循环快。（并行计算有时需要预热才显示出效率优势，并行计算目前对 Collection 类型支持的好，对其他类型支持的一般）
  • 不容易调试。
  • 若其他程序员没有学过 lambda 表达式，代码不容易让其他语言的程序员看懂。
  • 在 lambda 语句中强制类型转换貌似不方便，一定要搞清楚到底是 map 还是 mapToDouble 还是 mapToInt
Stream流式编程的好处？终止方法和延迟方法的区别是？终止方法存在的意义是什么？

二、Java集合

HashMap底层实现

JDK1.7使用数组+链表；JDK1.8使用数组+链表+红黑树

链表会转化为红黑树的两个条件：
①链表的长度达到8；
②HashMap底层使用的table数组长度length达到64（当HashMap底层使用的table数组长度达到64时，链表的长度达到8这种情况不满足泊松分布，即出现的概率非常非常小，一般是存在恶意攻击，就是一直存入同样的值，因此此时将链表转换为红黑树）；
注：如果不满足后者，将会触发扩容方法

链表长度大于8转化为红黑树，小于6红黑树转化为链表；为什么不直接设置成大于8转化成红黑树，小于8转化成链表；（中间有个差值7进行过渡是为了避免链表和树频繁转换，如果一个HashMap不停的插入、删除元素，链表个数在8左右徘徊，就会频繁的发生树转链表、链表转树，效率会很低）

HashMap为什么要引进红黑树？为什么不用其他的平衡二叉树之类的？红黑树的优势在哪里？

  1. 红黑树的五大特征：
    a. 节点要么全为红色，要么为黑色
    b. 根节点为黑色
    c. 叶子节点为黑色
    d. 从根节点到叶子节点不存在两个相邻的红色节点
    e. 从任意节点到其每个叶子节点的所有路径包含相同数目的黑色节点
  2. 根据红黑树的特征可知
    a. 红黑树不追求“完全平衡”，它只要求部分地达到平衡要求，降低了对旋转的要求，从而提高了性能。红黑树的算法时间复杂度与平衡查找树相同，但统计性能比平衡二叉树更高
    b.

（AVL树的旋转比红黑树的旋转更加难以平衡和调试，需要更高的旋转次数）
HashMap扩容机制，即resize方法？（JDK 1.7 会重新计算每个元素的哈希值，JDK1.8是通过高位运算（e.hash & oldCap）来确定元素是否需要移动，如果运算结果值为0，那么元素扩容后位置不变，结果值为1表示元素在扩容时位置发生了变化，新的下标位置等于原下标位置 + 原数组长度）
HashMap添加元素的步骤（put方法）、计算集合元素个数（size方法）
HashMap为什么是线程不安全的？（同时新增元素、同时扩容导致数据丢失，jdk1.7头部倒序插入出现死循环导致CPU占用100%）
HashMap默认的加载因子是0.75，为什么不设置成1或者0.5（从容量和性能考虑）
HashMap发生哈希冲突，新节点是插入到链表头部还是链表的尾部，头部倒序插入死循环是怎么产生的？（jdk1.7采用头部倒序插入，会导致死循环；jdk1.8使用尾部正序插入）
Hashtable怎么控制key value 不能为null？（当调用put方法时，首先会判断value是否为null，为null的话直接抛出空指针异常；对于key，由于Hashtable计算hash值是int hash = key.hashCode();直接取对象的hashcode，key为null就会报空指针异常；而HashMap计算hash值是return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16)，key为null则hash值为0）
ConcurrentHashMap底层采用的结构（分jdk1.7和jdk1.8），jdk1.7和jdk1.8分别采用什么方式实现线程安全？（jdk1.7采用分段锁，也就是为每一个segment加上ReentrantLock锁；jdk1.8使用的是CAS机制加上synchronized锁）
ConcurrentMap中的size方法是如何实现的？多线程操作下，如果一个线程在查size方法，一个线程在执行put方法，底层是如何控制每次计算出来的值是正确的？（https://blog.csdn.net/chenyiminnanjing/article/details/82716180）
HashSet的底层实现？（基于HashMap来实现的，new 一个 HashSet对象底层实际就是new了一个HashMap，并且使用默认的初始容量16和默认的加载因子0.75；当我们往HashSet里面添加一个元素其实就是往HashMap里面put了一个元素，并且是以key存在的，HashMap的value值都是一样的，是一个静态常量PRESENT，源码为：private static final Object PRESENT = new Object(); ）
BlockingQueue（阻塞队列）如何实现生产者消费者模型？
线程安全的List有哪些？（Vector、CopyOnWriteArrayList、还可以使用Collections类的synchronizedList方法将线程不安全的List转为线程安全的）
为什么ArrayList查询速度快？（ArrayList底层是基于数组实现，可以根据元素下标进行查询，查询方式为（数组首地址+元素长度*下标，基于这个位置读取相应的字节数就可以了），如果数组存的是对象，怎么根据下标定位元素所在位置？（对象数组每个元素存放的是对象的引用，而引用类型如果开启指针压缩占用4字节，不开启则占用8字节，所以对象数组同样适用上面的公式）
ArrayList的扩容？（ArrayList底层是基于数组实现，所以创建ArrayList会给数组指定一个初始容量，默认值为10，因为必须指明数组的长度才能给数组分配空间；由于数组的特性，ArrayList扩容是创建一个更大的数组，然后将原来的元素拷贝到更大的数组中，扩容的核心方法是Arrays.copyOf方法）
ArrayList和LinkedList的区别，添加一个元素的时间复杂度各是多少，既然ArrayList添加元素效率没有LinkedList高，为什么我们平时用的比较多的还是ArrayList？
一般什么情况下会用ArrayList，什么情况用LinkedList？（如果只是普通的存取元素多用ArrayList，LinkedList一般用作栈、队列）
将一个Map集合变成栈，如何实现？（我的思路是用TreeMap去实现，key存的是要入栈的元素，value存的是可以记录他们入栈的一个先后顺序的，例如时间戳，然后重写Comparator比较器，根据value进行排序，遍历Map时，先进的后面出）
Map集合有迭代器吗？遍历输出Map中所有元素有哪些方法？

三、多线程和Java锁

线程池的三大方法、七大参数、四种拒绝策略（可以顺带谈一下阿里巴巴开发手册对于线程池使用的规范）
创建线程的多种方式
最大线程数如何定义？（从CPU密集型和IO密集型考虑）
线程池的五种状态（Running、Shutdown、Stop、Tidying、Terminated）
线程池的任务执行流程、excute方法和 submit方法的区别？
Synchronized锁和Lock锁的区别
Java线程虚假唤醒（线程本应该处于wait状态却被唤醒了，解决方案是wait方法应该用while循环包裹，不用if）
JMM的三种特性（原子性、可见性、有序性）、主内存和线程工作内存的八种交互动作
volatile如何保证可见性（MESI缓存一致性协议）
volatile如何保证有序性（内存屏障——lock前缀指令）
synchronized和volatile的区别（volatile是一种非锁机制，这种机制可以避免锁机制引起的线程上下文切换和调度问题。因此，volatile的执行成本比synchronized更低；volatile只能保证可见性有序性；synchronized可以保证原子性可见性有序性）
JUC包中的原子类如何保证原子性？（CAS机制和自旋锁）
CAS机制，会引发什么问题，如何解决ABA问题？（CAS会导致ABA问题，解决ABA问题是使用版本号机制）
悲观锁和乐观锁的区别，应用？（java中的Synchronized关键字和lock锁使用的都是悲观锁；CAS机制是乐观锁的一种实现方式）
公平锁和非公平锁（公平锁按照先来先服务，不会出现饥饿；非公平锁会导致饥饿，但是效率更高，默认的锁都是非公平的）
自旋锁和互斥锁，自旋锁的优缺点？（优点：减少上下文切换和用户态内核态的切换带来的开销；缺点：循环等待消耗CPU）
可重入锁和不可重入锁（不可重入锁容易导致死锁发生，大多数锁都是可重入的，例如Synchronized锁和ReentrantLock）
JDK1.6 Synchronized锁升级（偏向锁—轻量级锁—重量级锁）
Synchronized锁的底层实现，锁的是什么，其它线程如何判断该锁已经被占用了？
死锁产生的四个必要条件以及死锁的处理策略

四、Mysql

Myisam和InnoDB存储引擎的区别？（Myisam不支持外键也不支持事务，支持的是表锁，当执行select操作时，自动给涉及的表加表锁，当执行增删改操作，自动给涉及的表加写锁；InnoDB支持外键也支持事务，支持的是行锁，当执行select操作时，不加任何锁，当执行增删改操作，自动给涉及的行加写锁）
间隙锁是什么？行锁升级为表锁的情况？
InnoDB的行锁有哪些？锁住的是行还是索引？（Record Lock、Gap Lock、Next-Key Lock；锁住的是索引，而不是行）
为什么可重复读隔离级别也可以解决幻读？（通过Next-Key Lock可以消除幻读）
并发事务处理带来的四种问题和事务的隔离级别（丢失更新、脏读、不可重复读、幻读；读未提交、读已提交、可重复读、串行化）
如何理解Mysql默认的事务隔离级别可重复读？
事务的ACID属性是如何实现的？（原子性通过回滚日志undo log实现；持久性通过重做日志redo log实现；隔离性通过锁和MVCC实现；而一致性则是通过原子性、隔离性、持久性来实现，只有满足这三个特性，才能实现事务的一致性）
聚簇索引、非聚簇索引、回表查询、覆盖索引；
索引失效的情况？（违反最左前缀法则、范围查询右边的列索引失效、字符串不加单引号、对索引列进行运算、头部模糊匹配、使用不等于！=或者<>）
explain分析执行计划、SQL语句的优化
mysql三大范式（1NF即原子性，2NF即消除部分依赖，3NF即消除传递依赖）
mysql索引的底层实现，为什么用B+树不用B树？（B+树IO次数更少、更适合范围查询、查询效率更加稳定）
哈希表查找速度不是更快吗，为什么不直接使用哈希表来做索引的底层数据结构？（哈希表不支持范围查找）

五、Redis

Redis五种基本数据类型的使用场景
缓存穿透、缓存击穿、缓存雪崩
Redis的过期策略和内存淘汰机制
Redis的zset底层数据结构，为什么用跳跃表而不用红黑树

六、框架相关

Spring AOP的实现原理？（基于动态代理模式，如果目标类实现了接口，那么使用基于接口的动态代理，否则使用基于子类/cglib的动态代理）
Spring AOP 的具体加载步骤？
AOP和OOP的区别，分别适用什么场景？
Spring Bean的作用域，Spring Bean的生命周期（Bean的实例化—初始化Bean—使用Bean—Bean的销毁）
Spring容器创建对象的两种时机，各有什么优缺点？（一是Spring容器启动时创建Bean，二是调用getBean方法时创建）
SpringMVC的执行流程（可以顺带讲一下适配器模式）
Mybatis的一级缓存和二级缓存？
Mybatis中#和$的区别？
Mybatis如何实现批量插入？
Mybatis的xml文件中，sql语句可以使用直接使用大于号小于号吗？应该用什么符号代替？

七、设计模式

代理模式（应用：一是创建多线程的方式之使用Runnable接口应用了静态代理；二是Spring AOP应用了动态代理）
参考文章：https://blog.csdn.net/can_chen/article/details/107827629

适配器模式（应用：一是创建多线程的方式之使用Callable接口；二是SpringMVC中的HandleAdapter）
参考文章：https://blog.csdn.net/can_chen/article/details/106968769

工厂模式（应用：一是Spring IOC；二是Mybatis中的SqlSessionFactory就用到了简单工厂模式）
参考文章：https://blog.csdn.net/can_chen/article/details/105924115

单例模式（一般会需要手撕单例模式的代码，主要谈DCL模式关于指令重排的问题，以及反射可以破坏除枚举以外的几种方式；单例模式的应用有：一是Spring Bean的作用域默认就是使用单例模式；二是Mybatis中的ErrorContext类也使用了单例模式，这个类用于记录线程执行环境的错误信息）
参考文章：https://blog.csdn.net/can_chen/article/details/105049999

装饰器模式（应用：JAVA的IO流就用到了装饰器模式）
参考文章：https://blog.csdn.net/can_chen/article/details/105786680

装饰器模式和代理模式的区别？
参考文章：https://www.cnblogs.com/yanggb/p/10952843.html

策略模式（应用：Arrays类的sort方法就用到了策略模式，Comparator接口就是一个策略接口，将排序方法定义成一个策略，用户可以自定义排序策略，可以是升序也可以是降序）
参考文章：https://blog.csdn.net/can_chen/article/details/106745298

观察者模式与发布订阅模式的区别？（JDK源码已经为我们提供好了一套观察者模式，Observer就是观察者接口，Observable类是被观察者，是一个具体类，提供了一个存放所有观察者角色的集合，并且也提供了添加观察者、移除观察者、通知观察者等方法）
参考文章： https://blog.csdn.net/hf872914334/article/details/88899326

八、网络

TCP三次握手和四次挥手的过程，每次发送的包的内容，客户端和服务端的状态？

TCP三次握手可以携带数据吗？TCP协议运行时阶段？

为什么是三次握手，可以四次握手或者两次握手吗？

为什么握手是三次，而挥手要四次？

TCP四次挥手为什么需要TIME-WAIT阶段等待2MSL，是哪一方有TIME-WAIT阶段？（主动释放释放连接的那端）

TCP的长连接和短连接（http://blog.sina.com.cn/s/blog_6d39b5be0101k6v4.html）

半连接队列和全连接队列，什么是syn flood攻击，如何应对syn flood攻击？（https://www.jianshu.com/p/ff26312e67a9）

在浏览器中输入一个网址回车后发生了什么？(https://www.cnblogs.com/tisikcci/p/5866753.html)

域名解析过程的递归查询和迭代查询（https://blog.csdn.net/weixin_42061048/article/details/80170991）

浏览器输入一个网址之后，按照TP/IP参考模型，从应用层到网络层各使用了哪些协议？

（应用层：HTTP、DNS；传输层：TCP、UDP；网络层：IP、ICMP、ARP）

ICMP协议的两个应用——Ping和Traceroute（https://www.jianshu.com/p/32bc2749a831）

IP地址和MAC地址有什么区别？

http和https的区别 （https://www.php.cn/faq/418162.html）

网站为什么要使用cookie和session；cookie和session有什么区别？

get请求和post请求的区别？

TCP和UDP的区别以及各自的应用场景？

epoll和select的区别？

客户端和服务端通信大致分为四个步骤：①打开一个TCP连接 ②发送一个http报文 ③读取服务端返回的报文 ④关闭连接或者为后续请求重用连接

CT92J.png

请求报文由以下元素组成：

  • 一个 HTTP 的method，经常是由一个动词像GET, POST 或者一个名词像OPTIONS，HEAD来定义客户端的动作行为。通常客户端的操作都是获取资源（GET 方法）或者发送HTML form表单（POST 方法），虽然在一些情况下也会有其他操作。
  • 要获取的资源的路径，通常是上下文中就很明显的元素资源的 URL，它没有protocol（http://），domain（developer.mozilla.org），或是 TCP 的port (en-US)（HTTP 一般在 80 端口）。
  • HTTP 协议版本号。
  • 为服务端表达其他信息的可选头部headers。请求头
  • 对于一些像 POST 这样的方法，报文的 body 就包含了发送的资源，这与响应报文的 body 类似。请求体

CTfJy.png

响应报文包含了下面的元素：

  • HTTP 协议版本号。
  • 一个状态码（status code），来告知对应请求执行成功或失败，以及失败的原因。
  • 一个状态信息，这个信息是非权威的状态码描述信息，可以由服务端自行设定。
  • HTTP headers，与请求头部类似。
  • 可选项，比起请求报文，响应报文中更常见地包含获取的资源 body。

http流水线

九、JVM

  1. JVM是运行Java字节码的虚拟机。JVM有针对不同操作系统的不同实现，目的是采用相同的字节码，都会给出相同的结果。字节码和不同系统的JVM是实现“一次编译，到处运行”的关键。
  2. JVM内存模型（程序计数器、虚拟机栈、本地方法栈、堆、方法区）

JDK1.8做了哪些变化？（JDK1.7已经将原本位于永久代的字符串常量池移到堆中了，但是永久代的概念还存在，JDK1.8才彻底废除永久代，进而用元空间代替）

永久代和元空间，JDK1.8为什么要使用元空间代替永久代？

元空间溢出？（元空间不属于Java虚拟机，使用的是本地内存，存放的是类及方法的一些信息，动态加载类或者频繁加载类信息，但是没有及时卸载，会导致元空间溢出）

对象创建的两种方式（指针碰撞、空闲列表）、对象访问定位的两种方式（使用句柄、直接指针）

栈上分配与逃逸分析（JVM层面进行java性能优化的技巧）

判断对象是否存活的两种方式，引用计数法的缺点？（引用计数法、可达性分析法）

关于Object类的finalize()方法（jvm自动执行，无需手动调用，只能执行一次）.

java的四种引用（强引用、软引用、弱引用、虚引用）

三种垃圾回收算法，各自的优缺点（标记-清除法、标记-复制法、标记-整理法）

Minor GC 和 Full GC 的区别，触发条件，以及空间分配担保策略？

内存溢出和内存泄露（内存泄露的堆积会导致内存溢出）

JVM参数调优（-Xms、-Xmx、-Xss、-XX:NewRatio、-XX:SurvivorRatio、-XX：+PrintGCDetails、-HeapDumpOnOutOfMemory）

发生OOM如何解决（首先尝试通过JVM参数调优扩大堆内存空间；再者dump出堆内存存储快照，使用JProfile工具进行分析）

垃圾收集器（CMS问的居多，另外，如果谈及发生gc会给用户带来什么不好的体验，可以谈谈Stop the World）

类加载机制的过程，准备阶段做了哪些工作？（准备阶段会给类的静态变量分配内存（方法区）并赋初值，如果类的静态变量被final修饰，那么初始化的值就不是零值，而是声明的值）

类的双亲委派模型定义，双亲委派模型的好处？如何破坏类的双亲委派模型？

十、操作系统

linux的僵尸进程和孤儿进程的区别，如何清理僵尸进程？（kill僵尸进程的父进程）
如何查看僵尸进程信息？如何统计僵尸进程数量？（ps - ef | grep defunct；ps -ef | grep defunct | wc - l）
并发和并行的区别？
进程和线程的区别？
进程通信的方式有哪些？（管道、消息队列、共享内存、信号量、套接字Socket）

展开全文 >>

Nginx简述

Nginx 简述

Nginx是一款轻量级的Web服务器、反向代理服务器，由于它的内存占用少，启动极快，高并发能力强，在互联网项目中广泛应用。

代理服务器和VPN

代理服务器

​ 所谓代理服务器，是一个“中间人”的角色，在你和服务器之间传递数据。相当大比例的代理服务器可以以网站的形式存在，你只需打开代理服务器的网站，然后输入你希望访问的链接，就可以像平时浏览网页一样操作了。代理的工作原理是：由代理服务器自己去访问你的目标网站，并加载它的内容，然后再把这些加载过的内容传递到你的窗口上。这样就相当于你在浏览目标网站了。因此代理经常被叫做“梯子”或者“桥”。

​ 使用代理的好处是，你不需要直接链接到目标网站，因此目标网站就无法获取你的IP地址，取而代之获取的是代理服务器的IP地址。这样你就可以隐藏你的位置信息了。 当你访问大多数代理服务的时候，他们通常会要求你选择一个代理服务器所在的国家。你可以通过对应国家的代理服务器访问目标网站，这样目标网站就会认为你是在对应国家进行访问的。 比如，如果你想要访问的网站屏蔽了你所在的国家，那么你可以用代理服务器换上其他国家的IP，只要代理服务器所在的位置不在屏蔽范围之内，你就可以通过代理服务器实现访问了。

VPN

​ VPN英文全称是“Virtual Private Network”，翻译过来就是“虚拟专用网络”。它可以通过特殊的加密的通讯协议在连接在Internet上的位于不同地方的两个或多个企业内部网之间建立一条专有的通讯线路，就好比是架设了一条专线一样，但是它并不需要真正的去铺设光缆之类的物理线路。

正向代理和反向代理

正向代理（代理服务器相当于客户端）（内网访问外网）

5jUFv.png

​ 正向代理类似一个跳板机，代理访问外部资源。比如我们国内访问谷歌，直接访问访问不到，我们可以通过一个正向代理服务器，请求发到代理服务器，代理服务器能够访问谷歌，这样由代理去谷歌取到返回数据，再返回给我们，这样我们就能访问谷歌了。

为什么使用正向代理
  • 一是出于安全审计及控制方面的一些考虑。 在一些组织内，web 相关的端口如 80 及 443 是被封禁的，你在里面直接是根本上不去网的，这时你要想上网，就只能配置组织为你指定的一台内网的代理服务器了；
  • 还有一些原因则是出于加速或节省带宽等的考虑。因为有的代理服务器它不仅能转发，还能对网页以及其它一些资源进行缓存；
  • 由于国家已经决定，有些国外的技术网站是访问不了的，而我们又想上去查阅资料解决手中的 bug，这时就需要一些科学的手段，直接访问不行，就必须通过代理来”曲径通幽”了。
反向代理（代理服务器相当于服务器）

​ 反向代理（Reverse Proxy）实际运行方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个服务器。

5juG0.png

为什么要使用反向代理（Nginx功能）
  • 最重要的：负载均衡

​ 可以利用反向代理可以作为内部 负载均衡(load balance) 的手段。举个例子来说, 假如我现在开发了一个 java web 的应用作为我的网站后台，我直接部署它到 tomcat 服务器上，让 tomcat 监听 80 端口，直接对外服务。一开始访问量也不大，所以这样也是没有问题的，如下图所示：

5jD47.png

​ 但过一段时间之后，访问量可能上来了，一个 tomcat 进程处理不过来，那怎么办呢？于是我打算再起一个新的 tomcat 进程，但这样就面临一个问题，只有一个 80 端口，它已经被第一个 tomcat 进程占用，如果还要再起另外一个，则只能选用其它的端口，比如 8080。

​ 当使用另外一个端口时，确实可以启动两个 tomcat 的进程，但用户想访问到第二个 tomcat 进程的服务，却要这样去访问: http://xiaogd.net:8080。显然，这样的方案是有问题的，用户根本不知道 8080 端口上服务的存在，就算你有办法告诉用户，用户也可能不太理解，用户同时也很怕麻烦的，为啥要我输入一个冒号加 8080 呢？此外，就算有些用户愿意如你所说转向访问 8080 端口，你还是不能很好的控制把访问量平均地分配在两个 tomcat 上，毕竟这是用户随机决定的，也许很多用户又突然涌过来了 8080 端口的应用上，造成了这边的拥挤。又或者只有很少的用户愿意听从你的劝告转到新的 8080 端口上，访问还是集中在旧的 80 端口上的，这样旧的应用上响应还是很缓慢，而新的应用却因为没几个用户访问而显得空闲，没有得到充分的使用。

​ 那么，在这种情况下，反向代理的好处就体现出来了，具体的操作是这样的，让 Nginx 作为一个前置的反向代理，监听在 80 端口上；而第一个 tomcat 则躲到幕后，同时它也不再监听 80 端口(需要让给 Nginx)，而改为监听一个其它没有被使用的端口，比如 8081，然后让 Nginx 转发请求给它处理。此时，如果同时涌入了很多请求，Nginx 会把一半的请求交给 8080 端口上的 tomcat，另一半的请求交给 8081 端口上的 tomcat，如下图所示：

5jsaO.png

​ 对外来看，所有请求还是 Nginx 来处理，用户不需要去做选择，也不需要知道什么 8080、8081 端口上应用的存在，他们还是继续访问原来的网址 http://xiaogd.net 即可，无需做任何改变。如果你在云上有好几台主机，甚至还可以将其组成一个内网，然后将 tomcat 部署在不同的主机上。比如有三台主机的话，一台运行 Nginx 监听 80 端口，其余两台运行 tomcat，分别监听 8080 和 8081 端口，同时接受并处理 Nginx 反向代理过来的请求，如下图所示：

5jR4P.png

​ 还可以通过tomcat主机的性能调整负载的比例。在这种反向代理的模式中，同样的，生成网页这个重任交到了隐藏在背后的 tomcat，生成一个复杂的动态网页可能需要经过一些复杂的计算，要查询数据库，要拼凑各个页面组件，可能会比较耗时，但这些请求被两个 tomcat 应用并发地处理了，因此响应的速度还是得到了保证，而这些就是反向代理能给我们带来的好处。

  • 也可以提高响应速度，反向代理服务器也可以提供缓存服务
  • 正向代理可以隐藏客户端IP，反向代理可以隐藏服务器的IP
  • 反向代理服务器可以作为应用层防火墙，为网站提供防护功能。还可以有一些特殊的处理，比如为后端服务器统一提供加密、HTTP访问认证等。

展开全文 >>

Spring 知识点

Spring知识点

IOC

控制反转，就是创建对象的控制权交给Spring框架，不再由用户使用类的构造方法来new一个对象，IOC的主要实现方式是依赖注入，Spring依赖注入的方式主要有两种，手动注入和自动注入

  • 手动注入（使用配置文件）

    a. set方法注入

    b. 构造方法注入

  • 自动注入

    a. xml （set 和 构造方法）

    b. 注解 @Autowired（可以写在1.属性 2.构造方法 3.普通方法）

BeanFactory 和 ApplicationContext的区别

BeanFactory和ApplicationContext是Spring的两大核心接口，都可以当做Spring的容器。其中ApplicationContext是BeanFactory的子接口。

  • BeanFactory：是Spring里面最底层的接口，包含了各种Bean的定义，读取bean配置文档，管理bean的加载、实例化，控制bean的生命周期，维护bean之间的依赖关系。ApplicationContext接口作为BeanFactory的派生，除了提供BeanFactory所具有的功能外，还提供了更完整的框架功能：
    a. 继承MessageSource，因此支持国际化。
    b. 统一的资源文件访问方式。
    c. 提供在监听器中注册bean的事件。
    d. 同时加载多个配置文件。
    e. 载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次，比如应用的web层。

  • BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化。这样，我们就不能发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入，BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常。
    而ApplicationContext，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误，这样有利于检查所依赖属性是否注入。ApplicationContext启动后预载入所有的单实例Bean，通过预载入单实例bean ,确保当你需要的时候，你就不用等待，因为它们已经创建好了。相对于基本的BeanFactory，ApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时，程序启动较慢。

  • BeanFactory通常以编程的方式被创建，ApplicationContext还能以声明的方式创建，如使用ContextLoader。

  • BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，而ApplicationContext则是自动注册。

AOP

AOP：面向切面编程，是面向对象编程（OOP）的一种延续。

OOP 编程思想可以解决大部分的代码重复问题。但是有一些问题是处理不了的。比如在父类 Animal 中的多个方法的相同位置出现了重复的代码，OOP就解决不了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 动物父类 
public class Animal {
	// 身高
	private String height;	
	// 体重
	private double weight;
	public void eat() {
	    // 性能监控代码
	    long start = System.currentTimeMillis();
	    // 业务逻辑代码
	    System.out.println("I can eat...");	
	    // 性能监控代码
	    System.out.println("执行时长：" + (System.currentTimeMillis() - start)/1000f + 			"s");
	}
	public void run() {
	    // 性能监控代码
	    long start = System.currentTimeMillis();	
	    // 业务逻辑代码
	    System.out.println("I can run...");	
	    // 性能监控代码
	    System.out.println("执行时长：" + (System.currentTimeMillis() - start)/1000f + "s");
	}
}

上面的性能监测代码需要在不同的函数体中进行重复书写，这部分重复的代码，一般统称为横切逻辑代码（多个纵向（顺序）流程中出现的相同子流程代码，一般称之为横切逻辑代码），横切逻辑代码的使用场景很有限，一般是事务控制、权限校验、日志等。

横切逻辑代码存在的问题：

  • 代码重复问题

  • 横切逻辑代码和业务代码混在一起，代码臃肿，不易于维护。

AOP就是用来解决这些问题的，提出横向抽取机制，将横切逻辑代码与业务逻辑代码分离。

l6DRS.png

代码拆分比较容易，但问题在于如何在不改变原有业务逻辑的情况下，悄无声息的将横向逻辑代码应用到原有的业务逻辑中，达到和原来一样的效果。

通过上面的分析可以发现，AOP 主要用来解决：在不改变原有业务逻辑的情况下，增强横切逻辑代码，根本上解耦合，避免横切逻辑代码重复。

AOP 为什么叫面向切面编程

切 ：指的是横切逻辑，原有业务逻辑代码不动，只能操作横切逻辑代码，所以面向横切逻辑

面 ：横切逻辑代码往往要影响的是很多个方法，每个方法如同一个点，多个点构成一个面。这里有一个面的概念

AOP使用到的代理模式

静态代理

静态代理代表为AspectJ，所谓静态代理，就是AOP框架会在编译阶段生成AOP代理类，因此也称为编译时增强，他会在编译阶段将AspectJ(切面)加入到Java字节码中，运行的时候就是增强后的AOP对象。

静态代理. (如果有多个对象要找代理，那么就需要实现很多个对象的代理类，用户体验差；如果被代理的方法过多，每个方法都要增强，代码不整洁)

1
2
3
4
//原始接口
public interface Person{
	void eat();
}
1
2
3
4
5
6
7
//原始对象
public class Student implements Person{
	@Override
	public void eat(){
		System.out.println("--------student eat----------");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
//代理对象
public class ProxyStudent implements Person{
	private Student s;
	public ProxyStudent(){
		this.s = new Student();
	}
	@Override
	public void eat(){
		System.out.println("--------proxystudent before----------");
		s.eat();
		System.out.println("--------proxystudent after----------");
	}
}
1
2
3
4
5
6
7
public class TestProxy{
	@Test
	public void proxyTest(){
		ProxyStudent ps = new ProxyStudent();
		ps.eat();
	}
}
动态代理

Spring AOP是由动态代理实现的。动态代理是指AOP框架不会去修改字节码，而是在运行的过程中生成一个临时的代理对象，这个AOP对象包含了目标对象的全部方法，并且在特定切点处进行了增强处理，并回调原对象的方法（原有的业务逻辑是由原始对象调用的）。主要分为JDK动态代理和Cglib动态代理。

JDK动态代理

核心：InvocationHandler接口和Proxy类

Proxy类利用InvocationHandler动态创建一个符合某一接口的实例（Proxy.newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)）， 当代理对象调用真实对象的方法时，会自动的跳转到代理对象关联的handler对象的invoke方法进行调用，动态地将横切逻辑和业务编织在一起。代理类创建真实对象时

//JDK动态代理（创建一个JdkProxy类，用于统一代理）
public class JdkProxy implements InvocationHandler {
    private Object bean;
    public JdkProxy(Object bean) { //传入原始bean，否则后面调用method.invoke()方法会陷入死循环
        this.bean = bean;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        if (methodName.equals("wakeup")){
            System.out.println("早安~~~");
        }else if(methodName.equals("sleep")){
            System.out.println("晚安~~~");
        }
        return method.invoke(bean, args); //使用原始bean调用原有的业务逻辑
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static void main(String[] args) {
    JdkProxy proxy = new JdkProxy(new Student("张三")); 
    Person student = (Person) Proxy.newProxyInstance(proxy.getClass().getClassLoader(), new Class[]{Person.class}, proxy);
    student.wakeup();
    student.sleep();

    proxy = new JdkProxy(new Doctor("王教授"));
    Person doctor = (Person) Proxy.newProxyInstance(proxy.getClass().getClassLoader(), new Class[]{Person.class}, proxy);
    doctor.wakeup();
    doctor.sleep();

    proxy = new JdkProxy(new Dog("旺旺"));
    Animal dog = (Animal) Proxy.newProxyInstance(proxy.getClass().getClassLoader(), new Class[]{Animal.class}, proxy);
    dog.wakeup();
    dog.sleep();

    proxy = new JdkProxy(new Cat("咪咪"));
    Animal cat = (Animal) Proxy.newProxyInstance(proxy.getClass().getClassLoader(), new Class[]{Animal.class}, proxy);
    cat.wakeup();
    cat.sleep();
}
Cglib动态代理

Spring从5.x开始，开始默认使用Cglib来作为动态代理实现。

Cglib是一个开源项目，它的底层是字节码处理框架ASM，Cglib提供了比jdk更为强大的动态代理。主要相比jdk动态代理的优势有：

  • jdk动态代理只能基于接口，代理生成的对象只能赋值给接口变量，而Cglib就不存在这个问题，Cglib是通过生成子类来实现的，代理对象既可以赋值给实现类，又可以赋值给接口。
  • Cglib速度比jdk动态代理更快，性能更好。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class CglibProxy implements MethodInterceptor {
    private Enhancer enhancer = new Enhancer();
    private Object bean;
    public CglibProxy(Object bean) {
        this.bean = bean;
    }
    public Object getProxy(){
        //设置需要创建子类的类
        enhancer.setSuperclass(bean.getClass());
        enhancer.setCallback(this);
        //通过字节码技术动态创建子类实例
        return enhancer.create();
        //可以看到，Cglib"凭空"的创造了一个原bean的子类，并把Callback指向了this，也就是当前对象，也就是这个proxy对象。从而会调用intercept方法。而在intercept方法里，进行了附加功能的执行，最后还是调用了原始bean的相应方法。
    }   
    //实现MethodInterceptor接口方法
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        String methodName = method.getName();
        if (methodName.equals("wakeup")){
            System.out.println("早安~~~");
        }else if(methodName.equals("sleep")){
            System.out.println("晚安~~~");
        }
        //调用原bean的方法
        return method.invoke(bean,args);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static void main(String[] args) {
    CglibProxy proxy = new CglibProxy(new Student("张三"));
    Student student = (Student) proxy.getProxy();
    student.wakeup();
    student.sleep();

    proxy = new CglibProxy(new Doctor("王教授"));
    Doctor doctor = (Doctor) proxy.getProxy();
    doctor.wakeup();
    doctor.sleep();

    proxy = new CglibProxy(new Dog("旺旺"));
    Dog dog = (Dog) proxy.getProxy();
    dog.wakeup();
    dog.sleep();

    proxy = new CglibProxy(new Cat("咪咪"));
    Cat cat = (Cat) proxy.getProxy();
    cat.wakeup();
    cat.sleep();
}

Bean的生命周期

  • 生成BeanDefinition Spring在启动的时候会进行扫描，找到符合条件的类装载进BeanDefinitionMap中
  • 合并BeanDefinition Spring中支持父子BeanDefinition，和Java父子类类似
1
2
<bean id="parent" class="com.zhouyu.service.Parent" scope="prototype"/>
<bean id="child" class="com.zhouyu.service.Child"/>

这么定义的情况下，child是单例Bean。

1
2
<bean id="parent" class="com.zhouyu.service.Parent" scope="prototype"/>
<bean id="child" class="com.zhouyu.service.Child" parent="parent"/>

但这种情况下，child是原型Bean。因为child的父BeanDefinition是parent，所以会继承parent上所定义的scope属性。而在根据child来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition。

  • 加载类 BeanDefinition合并之后，就可以去创建Bean对象了，而创建Bean就必须实例化对象，而实例化就必须先加载当前BeanDefinition所对应的class

  • 实例化 推断构造方法，根据BeanDefinition创建对象

  • 设置对象属性 此处会处理@Autowired(byType)、@Resourse(byName)、@Value等注解，并注入所有的属性。

  • 执行Aware 完成了属性赋值之后，Spring会执行一些回调（回调的作用是让bean具有意识，让它知道自己是一个bean，比如说让它拥有beanName属性，并且可以按照自己的意愿进行修改这些属性），包括：

    a. BeanNameAware：回传beanName给bean对象。

    b. BeanClassLoaderAware：回传classLoader给bean对象。

    c. BeanFactoryAware：回传beanFactory给对象。

  • 初始化前 初始化前调用**BeanPostProcessor.postProcessBeforeInitialization()**（BeanPostProcessor接口中的方法）

  • 初始化

    a. 查看当前Bean对象是否实现了InitializingBean接口，如果实现了就调用其afterPropertiesSet()方法

    b. 执行BeanDefinition中指定的初始化方法

  • 初始化后 初始化后调用BeanPostProcessor.postProcessAfterInitialization()。可以在这个步骤中，对Bean最终进行处理，Spring中的AOP就是基于初始化后实现的，初始化后返回的对象才是最终的Bean对象

  • 使用Bean 经过流程9后，就可以正式使用Bean了，对于Scope为singleton的Bean，Spring的ioc容器中会缓存一份该bean的实例，而对于scope为prototype的Bean，每次调用都会new一个新的对象，其生命周期交给调用方管理，而不是Spring容器进行管理。

  • 关闭容器 如果Bean实现了DisposableBean接口，则会回调该接口的destroy()方法。如果Bean配置了destroy-method方法，就会执行destroy-method配置的方法。至此整个Bean的生命周期结束。

Spring事务

事务：要么一起成功，要么一起失败

隔离级别：读未提交，读已提交，可重复读，串行化

脏读、不可重复读、幻读

事务丢失：

  • 第一类事务丢失（回滚丢失）

对于第一类事务丢失，就是比如A和B同时在执行一个数据，然后B事务已经提交了，然后A事务回滚了，这样B事务的操作就因为A事务回滚而丢失了。（举例，账户上一共有100块钱，然后A事务转出50块，这个时候B事务往账户里转入50块，A事务此时回滚，B事务的操作就因为A事务回滚而丢失了）

  • 第二类事务丢失（提交覆盖丢失）

对于第二类事务丢失，也称为覆盖丢失，就是A和B一起执行一个数据，两个同时取到一个数据，然后B事务首先提交，但是A事务接下来又提交，就覆盖了B事务。

编程式事务

主要两种用法：

  • 通过PlatformTransactionManager控制事务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@Test
    public void test1() throws Exception {
        //定义一个数据源
        DataSource dataSource = new DataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/int?characterEncoding=UTF-8&serverTimezone=UTC");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        dataSource.setInitialSize(5);
        //定义一个JdbcTemplate，用来方便执行数据库增删改查
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        //1.定义事务管理器，给其指定一个数据源（可以把事务管理器想象为一个人，这个人来负责事务的控制操作）
        PlatformTransactionManager platformTransactionManager = new DataSourceTransactionManager(dataSource);
        //2.定义事务属性：TransactionDefinition，
        // TransactionDefinition可以用来配置事务的属性信息，比如事务隔离级别、事务超时时间、事务传播方式、是否是只读事务等等。
        TransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
        //3.开启事务：调用platformTransactionManager.getTransaction开启事务操作，得到事务状态(TransactionStatus)对象
        TransactionStatus transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);
        //4.执行业务操作，下面就执行2个插入操作
        try {
            System.out.println("before:" + jdbcTemplate.queryForList("SELECT * from t_user"));
            jdbcTemplate.update("insert into t_user (name) values (?)", "test1-1");
            jdbcTemplate.update("insert into t_user (name) values (?)", "test1-2");
            //5.提交事务：platformTransactionManager.commit
            platformTransactionManager.commit(transactionStatus);
        } catch (Exception e) {
            //6.回滚事务：platformTransactionManager.rollback
            platformTransactionManager.rollback(transactionStatus);
        }
        System.out.println("after:" + jdbcTemplate.queryForList("SELECT * from t_user"));
    }

上述代码主要有5个步骤

a. 定义事务管理器PlatformTransactionManager。事务管理器相当于一个管理员，这个管理员就是用来帮你控制事务的，比如开启事务，提交事务，回滚事务等等。spring中使用PlatformTransactionManager这个接口来表示事务管理器

b. 定义事务属性TransactionDefinition。定义事务属性，比如事务隔离级别、事务超时时间、事务传播方式、是否是只读事务等等。spring中使用TransactionDefinition接口来表示事务的定义信息，有个子类比较常用：DefaultTransactionDefinition。

c. 开启事务。调用事务管理器的getTransaction方法，即可以开启一个事务。这个方法会返回一个TransactionStatus表示事务状态的一个对象，通过TransactionStatus提供的一些方法可以用来控制事务的一些状态，比如事务最终是需要回滚还是需要提交。在getTransaction之后，spring内部会执行一些操作，大致流程如下：

1
2
3
4
5
6
7
8
9
10
11
/有一个全局共享的threadLocal对象 resources
static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal<>("Transactional resources");
//获取一个db的连接
DataSource datasource = platformTransactionManager.getDataSource();
Connection connection = datasource.getConnection();
//设置手动提交事务
connection.setAutoCommit(false);
Map<Object, Object> map = new HashMap<>();
map.put(datasource,connection);
resources.set(map);

上面代码，将数据源datasource和connection映射起来放在了ThreadLocal中，ThreadLocal大家应该比较熟悉，用于在同一个线程中共享数据；后面我们可以通过resources这个ThreadLocal获取datasource其对应的connection对象。

d. 执行业务操作 我们使用jdbcTemplate插入了2条记录。大家看一下创建JdbcTemplate的代码，需要指定一个datasource

1
2
3
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

PlatformTransactionManager platformTransactionManager = new DataSourceTransactionManager(dataSource);

上述代码中两者用到的dataSource是同一个。事务管理器开启事务的时候，会创建一个连接，将datasource和connection映射之后丢在了ThreadLocal中，而JdbcTemplate内部执行db操作的时候，也需要获取连接，JdbcTemplate会以自己内部的datasource去上面的threadlocal中找有没有关联的连接，如果有直接拿来用，若没找到将重新创建一个连接，而此时是可以找到的，那么JdbcTemplate就参与到spring的事务中了。

e. 提交或回滚

  • TransactionTemplate

方式1中部分代码是可以重用的，所以spring对其进行了优化，采用模板方法模式就其进行封装，主要省去了提交或者回滚事务的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
@Test
    public void test2() throws Exception {
        //定义一个数据源
        DataSource dataSource = new DataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/int?characterEncoding=UTF-8&serverTimezone=UTC");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        dataSource.setInitialSize(5);
        //定义一个JdbcTemplate，用来方便执行数据库增删改查
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        //1.定义事务管理器，给其指定一个数据源（可以把事务管理器想象为一个人，这个人来负责事务的控制操作）
        PlatformTransactionManager platformTransactionManager = new DataSourceTransactionManager(dataSource);
        //2.定义事务属性：TransactionDefinition，TransactionDefinition可以用来配置事务的属性信息，比如事务隔离级别、事务超时时间、事务传播方式、是否是只读事务等等。
        DefaultTransactionDefinition  transactionDefinition = new DefaultTransactionDefinition();
        transactionDefinition.setTimeout(10);
        //3.创建TransactionTemplate对象
        TransactionTemplate transactionTemplate = new TransactionTemplate(platformTransactionManager,transactionDefinition);/**
         * 4.通过TransactionTemplate提供的方法执行业务操作
         * 主要有2个方法：
         * （1）.executeWithoutResult(Consumer<TransactionStatus> action)：没有返回值的，需传递一个Consumer对象，在accept方法中做业务操作
         * （2）.<T> T execute(TransactionCallback<T> action)：有返回值的，需要传递一个TransactionCallback对象，在doInTransaction方法中做业务操作
         * 调用execute方法或者executeWithoutResult方法执行完毕之后，事务管理器会自动提交事务或者回滚事务。
         * 那么什么时候事务会回滚，有2种方式：
         * （1）transactionStatus.setRollbackOnly();将事务状态标注为回滚状态
         * （2）execute方法或者executeWithoutResult方法内部抛出异常
         * 什么时候事务会提交？
         * 方法没有异常 && 未调用过transactionStatus.setRollbackOnly();
         */
        transactionTemplate.executeWithoutResult(new Consumer<TransactionStatus>() {
            @Override
            public void accept(TransactionStatus transactionStatus) {
                jdbcTemplate.update("insert into t_user (name) values (?)", "transactionTemplate-1");
                jdbcTemplate.update("insert into t_user (name) values (?)", "transactionTemplate-2");
            }
        });
        System.out.println("after:" + jdbcTemplate.queryForList("SELECT * from t_user"));
    }

TransactionTemplate,主要有2个方法：

executeWithoutResult：无返回值场景，需传递一个Consumer对象，在accept方法中做业务操作

1
2
3
4
5
6
transactionTemplate.executeWithoutResult(new Consumer<TransactionStatus>() {
    @Override
    public void accept(TransactionStatus transactionStatus) {
        //执行业务操作
    }
});

execute：有返回值场景，需要传递一个TransactionCallback对象，在doInTransaction方法中做业务操作

1
2
3
4
5
6
7
Integer result = transactionTemplate.execute(new TransactionCallback<Integer>() {
    @Nullable
    @Override
    public Integer doInTransaction(TransactionStatus status) {
        return jdbcTemplate.update("insert into t_user (name) values (?)", "executeWithoutResult-3");
    }
});
声明式事务

将事务管理代码从业务代码中抽离出来，以声明的方式来实现事务管理。将事务管理作为横切关注点，通过AOP方式模块化。

导入tx约束

1
2
3
4
xmlns:tx="http://www.springframework.org/schema/tx"
 
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">

导入事务管理器依赖

1
2
3
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
 </bean>

事务通知配置

1
2
3
4
5
6
7
8
9
10
11
12
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!--配置哪些方法使用什么样的事务,配置事务的传播特性-->
        <tx:method name="add" propagation="REQUIRED"/>
        <tx:method name="delete" propagation="REQUIRED"/>
        <tx:method name="update" propagation="REQUIRED"/>
        <tx:method name="search*" propagation="REQUIRED"/>
        <tx:method name="get" read-only="true"/>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

AOP配置

1
2
3
4
5
<!--配置aop织入事务-->
<aop:config>
    <aop:pointcut id="txPointcut" expression="execution(* com.kuang.dao.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
</aop:config>
1
2
3
4
5
6
7
@Test
public void test2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    UserMapper mapper = (UserMapper) context.getBean("userDao");
    List<User> user = mapper.selectUser();
    System.out.println(user);
}

循环依赖与三级缓存

第一级缓存，单例池： SingletonObjects

第二级缓存（earlySingletonObjects）：

三级缓存（singletonFactories）：Map<beanName : 原始对象> AOP的时候会用到原始对象、beandefinition、beanName，实际上三级缓存的Map存的是一个lambda表达式 Map<beanName : lambda(beanName, bd, 原始对象)>，采用工厂方式（为什么采用工厂方式，是因为有些Bean是需要被代理的（AOP），总不能把代理前的暴露出去那就毫无意义了）

过程（找的顺序，先找一级，再找二级，最后找三级，三级如果有生成二级，删除三级）

  1. 假设情景A依赖于B，B依赖于A，在创建A的bean时，实例化后，A bean的原始对象构造成ObjectFactory添加三级依赖singletonFactories中，这个ObjectFactory是一个函数式接口，所以支持lambda表达式：**() ->getEarlyBeanReference(beanName, mbd, bean)**
  2. 属性填充阶段检测到需要依赖B Bean，缓存检测下来发现容器中还没有B Bean，这时创建B Bean，同样将B Bean的Bean工厂添加到三级缓存。
  3. B Bean实例化后，在属性填充时发现需要A Bean，就从缓存中检查中是否有A Bean，因为在过程1中已经将A Bean的ObjectFactory添加进了三级缓存singletonFactories。所以能够找到A Bean的原始对象。
  4. 执行三级缓存中的A Bean的原始对象ObjectFactory后，将A Bean的原始对象从三级缓存移到二级缓存，同时移除三级缓存中的对象。
  5. 三级缓存中的lambda表达式会进行AOP的增强，创建代理类，因此二级缓存earlySingletonObjects存放的有可能是经过AOP增强的代理对象。
  6. 在AOP增强的时候会用到缓存earlyProxyReferences，这样后面A Bean再自己走到AOP增强的时候会检测是否已经增强。
  7. 这时B填充完A属性，完成B Bean的创建，便会进入单例池
  8. A Bean在单例池中取出创建好的Bean完成创建
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				singletonObject = this.earlySingletonObjects.get(beanName);
				if (singletonObject == null && allowEarlyReference) {
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}

首先A通过getBean调到doCreateBean（Spring通过getBean方法获取bean），初步实例化即调用createBeanInstance()方法后，属性注入之前进入到下边代码中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {        
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {
        //省略前面的部分代码       
        // even when triggered by lifecycle interfaces like BeanFactoryAware.
        // 7.判断是否需要提早曝光实例：单例 && 允许循环依赖 && 当前bean正在创建中
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isTraceEnabled()) {
                logger.trace("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            // 8.提前曝光beanName的ObjectFactory，用于解决循环引用
            // 8.1 应用后置处理器SmartInstantiationAwareBeanPostProcessor，允许返回指定bean的早期引用，若没有则直接返回bean
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }
        // Initialize the bean instance.
        // 初始化bean实例。
        Object exposedObject = bean;
        try {
            // 9.对bean进行属性填充；其中，可能存在依赖于其他bean的属性，则会递归初始化依赖的bean实例
            populateBean(beanName, mbd, instanceWrapper);
            // 10.对bean进行初始化
            //初始化bean，过程如下：
            //1：判断是否实现了BeanNameAware，BeanClassLoaderAware，
            //   BeanFactoryAware方法，如果有，则设置相关的属性
            //2: 调用bean初始化的前置（BeanPostProcessor）操作
            //3: 执行初始化的方法。
            //  如果有initializingBean，则调用afterPropertiesSet
            //  如果有InitMethod，则调用初始方法
            //4: 调用bean初始化的后置（BeanPostProcessor）操作
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }       
        //省略中间的部分代码        
        // 13.完成创建并返回
        return exposedObject;
    }
}

属性注入之前Spring将Bean包装成一个工厂添加进了三级缓存中，即调用addSingletonFactory()方法。

当A开始属性注入，B开始实例化时，同样会通过getBean，同样会跟A一样属性注入，再次实例化A，此时再次实例化A时，getBean经过getSingleton会从三级缓存中拿出ObjectFactory，调用getObject会拿到A的对象。

到此为止，循环依赖被解决。解决循环依赖后，会在doCreateBean()方法中调用populateBean()方法填充属性，完成对bean的依赖属性进行注入。

即在AbstractBeanFactory类中：

  • 通过 getBean(String name)方法、调用doGetBean()方法、在doGetBean()方法内部调用Object sharedInstance = getSingleton(beanName);代码，在getSingleton()方法中会从三级缓存中拿出ObjectFactory
  • 通过ObjectFactory单例对象工厂创建的单例对象，放到早期单例对象缓存中即二级缓存earlySingletonObjects，并在三级缓存中移除beanName对应的单例对象工厂

5HRag.png

手写Spring框架

扫描过程中每个bean生成一个beandefinition，这个beandefinition保存bean的很多信息，例如bean.class，scope，bean是否懒加载，bean的依赖关系等等，然后将beandefinition放入beandefinitionmap中作为value，key为beanname

围绕bean的生命周期实现了一个简单的Spring框架，简单流程如下：

① 创建一个ApplicationContext类，传入一个config类，该配置类中用@ComponentScan注解声明了扫描路径

1
2
3
@ComponentScan("com.zhouyu.user")
public class AppConfig {
}

② 实现ApplicationContext类的基本逻辑：

​ a. 扫描配置类 scan(configClass) 判断配置类是否有@ComponentScan的注解，如果有取出注解后面标注的值，也就是要扫描的路径。取到扫描路径下的所有文件，然后判断文件中的类是否有@Component注解，如果有，创建一个BeanDefinition对象，设置该类的clazz类、scope值等记录到beanDefinition对象中，并以beanName作为键，beanDefinition作为值存放到beanDefinitionMap中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
private void scan(Class configClass) {
    // 获取要扫描的包路径
    if (configClass.isAnnotationPresent(ComponentScan.class)) {
        ComponentScan annotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
        String path = annotation.value();

        path = path.replace(".", "/");

        ClassLoader classLoader = this.getClass().getClassLoader();
        URL resource = classLoader.getResource(path);
        File file = new File(resource.getFile());

        List<File> classFile = new ArrayList<>();
        if (file.isDirectory()) {
            for (File f : file.listFiles()) {
                if (f.isDirectory()) {
                    for (File f1 : f.listFiles()) {
                        if (!f1.isDirectory()) {
                            classFile.add(f1);
                        }
                    }
                } else {
                    classFile.add(f);
                }

            }
        }

        for (File cFile : classFile) {
            String absolutePath = cFile.getAbsolutePath();
            String className = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"))
                    .replace("\\", ".");

            try {
                Class<?> clazz = classLoader.loadClass(className);

                if (clazz.isAnnotationPresent(Component.class)) {
                    BeanDefinition beanDefinition = new BeanDefinition();
                    beanDefinition.setType(clazz);
                    beanDefinition.setLazy(clazz.isAnnotationPresent(Lazy.class));
                    if (clazz.isAnnotationPresent(Scope.class)) {
                        beanDefinition.setScope(clazz.getAnnotation(Scope.class).value());
                    } else {
                        beanDefinition.setScope("singleton");
                    }

                    String beanName = clazz.getAnnotation(Component.class).value();
                    if (beanName.isEmpty()) {
                        beanName = Introspector.decapitalize(clazz.getSimpleName());
                    }

                    beanDefinitionMap.put(beanName, beanDefinition);

                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }

        }

    }
}

​ b. 遍历beanDefinitionMap，判断Scope类型为”singleton”的beandefinition，创建单例Bean实例，对有@Autowired注解标注的类进行依赖注入，对实现Aware接口的类进行设置，对有@Transcational 注解的类将实例对象放到单例池中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
for (String beanName : beanDefinitionMap.keySet()) {
    BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
    if (beanDefinition.getScope().equals("singleton") && !beanDefinition.isLazy()) {
        Object bean = createBean(beanName, beanDefinition);
        singletonObjects.put(beanName, bean);
    }
}
private Object createBean(String beanName, BeanDefinition beanDefinition){

        Class clazz = beanDefinition.getType();

        try {
            Object o = clazz.newInstance();

            for (Field field : clazz.getDeclaredFields()) {
                if (field.isAnnotationPresent(Autowired.class)) {
                    Object bean = getBean(field.getName());
                    field.setAccessible(true);
                    field.set(o, bean);
                }
            }

            if (o instanceof BeanNameAware) {
                ((BeanNameAware)o).setBeanName(beanName);
            }

            if (o instanceof ApplicationContextAware) {
                ((ApplicationContextAware)o).setApplicationContext(this);
            }

            if (clazz.isAnnotationPresent(Transactional.class)) {
                Enhancer enhancer = new Enhancer();
                enhancer.setSuperclass(clazz);
                Object target = o;
                enhancer.setCallback(new MethodInterceptor() {
                    @Override
                    public Object intercept(Object proxy, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                        System.out.println("开启事务");
                        Object result = method.invoke(target, objects);
                        System.out.println("提交事务");
                        return result;
                    }
                });
                o = enhancer.create();
            }

            return o;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return null;
    }

Spring 源码

1.

  1. bean的加载 doGetBean()

    我们知道了 Spring 在容器刷新的后期，通过调用AbstractApplicationContext#finishBeanFactoryInitialization 方法来实例化了所有的非惰性bean。在这里面就通过 beanFactory.preInstantiateSingletons(); 调用了一个非常关键的方法 AbstractBeanFactory#getBean(java.lang.String)，而其实际上调用的是 AbstractBeanFactory#doGetBean 方法。doGetBean 完成了单例Bean的完整创建过程，包括bean的创建，BeanPostProcessor 的方法调用、init-method等方法的调用、Aware 等接口的实现。

    接下来分析AbstractBeanFactory的子类DefaultListableBeanFactory，该子类中重写了doGetBean方法；而且该类继承了DefaultSingletonBeanRegistry接口。

    DefaultSingletonBeanRegistry接口中有一些列的集合类型来保存Bean的相关信息。此处指出其中比较重要的几个：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    /** Cache of singleton objects: bean name to bean instance. */
    //	用于保存BeanName和创建bean实例之间的关系，即缓存bean。 beanname -> instance 一级缓存
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    /** Cache of singleton factories: bean name to ObjectFactory. */
    // 用于保存BeanName和常见bean的工厂之间的关系。beanname-> ObjectFactory  三级缓存
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    /** Cache of early singleton objects: bean name to bean instance. */
    // 也是保存BeanName和创建bean实例之间的关系，与singletonObjects 不同的是，如果一个单例bean被保存在此，则当bean还在创建过程中(比如 A类中有B类属性，当创建A类时发现需要先创建B类，这时候Spring又跑去创建B类，A类就会添加到该集合中，表示正在创建)，就可以通过getBean方法获取到了，其目的是用来检测循环引用。   二级缓存
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
    /** Set of registered singletons, containing the bean names in registration order. */
    // 用来保存当前所有已经注册的bean
    private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

    下面挑出来几个关键缓存集合来描述：

    singletonObjects ：ConcurrentHashMap。最简单最重要的缓存Map。保存关系是 beanName ：bean实例关系。单例的bean在创建完成后都会保存在 singletonObjects 中，后续使用直接从singletonObjects 中获取。
    singletonFactories ：HashMap。这是为了解决循环依赖问题，用于提前暴露对象，保存形式是 beanName : ObjectFactory<?>。
    earlySingletonObjects ：HashMap。这也是为了解决循环依赖问题。和 singletonFactories 互斥。因为 singletonFactories 保存的是 ObjectFactory。而earlySingletonObjects 个人认为是 singletonFactories 更进一步的缓存，保存的是 ObjectFactory#getObject的结果。
    registeredSingletons ：LinkedHashSet，用于保存注册过的beanName

    img

展开全文 >>

操作系统线程与Java线程的区别

操作系统线程与Java线程的区别

用户态线程

第一阶段:

操作系统在最开始的时候没有线程的概念，刚开始只有进程，操作系统分配资源的最小单位是进程，进程与进程之间是隔离的，每个进程都有自己的内存空间。CPU调度以进程作为最小调度单元。

第二阶段:

初期的多线程，线程是在用户空间下实现的。

我们都知道内存分用户空间和系统空间，系统空间是给操作系统使用的，用户空间是应用程序使用的，应用程序如果需要访问系统空间，需要进行系统调用，从用户态切换到内核态。

那怎么在用户空间实现的多线程呢？

实际上是操作系统按进程维度来调度，操作系统是不去管你用户线程的切换的，应用程序自己在用户空间实现线程的创建、维护和调度。模型如下图:
DuqU4.png

当线程在用户空间下实现时，操作系统对线程的存在一无所知，操作系统只能看到进程，而不能看到线程。所有的线程都是在用户空间实现。在操作系统看来，每一个进程只有一个线程。

这种方式的好处之一就是即使操作系统不支持线程，也可以通过库函数来支持线程。在JDK1.1中，就用的绿色线程，而不是原始线程。

这种模式的优点和缺点都非常明显:

缺点: 因为操作系统不知道线程的存在，CPU的时间片切换是以进程为维度的，如果进程中有某个线程进行了某些耗时长的操作，会阻塞整个进程。另外当一个进程中的某一个线程(绿色线程)进行系统调用时，比如网络IO、缺页中断等操作而导致线程阻塞，操作系统也会阻塞整个进程，即使这个进程中其它线程还在工作。

优点: 使用库函数来实现的线程切换，就免去了用户态到内核态的切换，Go的协程就有借鉴了一部分这个思想。

内核态线程

内核线程就是直接由操作系统内核（Kernel）支持的线程，这种线程由内核来完成线程切换，内核通过操纵调度器（Scheduler）对线程进行调度，并负责将线程的任务映射到各个处理器上。每个内核线程可以视为内核的一个分身，这样操作系统就有能力同时处理多件事情，支持多线程的内核就叫做多线程内核（Multi-Threads Kernel）。通俗的讲就是，程序员直接使用操作系统中已经实现的线程，而线程的创建、销毁、调度和维护，都是靠操作系统（准确的说是内核）来实现，程序员只需要使用系统调用，而不需要自己设计线程的调度算法和线程对CPU资源的抢占使用。

Java线程

Java线程在JDK1.2之前，是基于称为“绿色线程”（Green Threads）的用户线程实现的，而在JDK1.2中，线程模型替换为基于操作系统原生线程模型来实现。因此，在目前的JDK版本中，操作系统支持怎样的线程模型，在很大程度上决定了Java虚拟机的线程是怎样映射的，这点在不同的平台上没有办法达成一致，虚拟机规范中也并未限定Java线程需要使用哪种线程模型来实现。线程模型只对线程的并发规模和操作成本产生影响，对Java程序的编码和运行过程来说，这些差异都是透明的。
也就说JDK1.2之前，程序员们为JVM开发了自己的一个线程调度内核，到操作系统层面就是用户空间内的线程实现。而到了JDK1.2及以后，JVM选择了更加稳健且方便使用的操作系统原生的线程模型，通过系统调用，将程序的线程交给了操作系统内核进行调度。也就是说，现在的Java中线程的本质，其实就是操作系统中的线程，Linux下是基于pthread库实现的轻量级进程，```Windows下是原生的系统``Win32 API提供系统调用从而实现多线程。

操作系统中线程和Java线程状态的关系

Du3jm.png

DuknR.png

从实际意义上来讲，操作系统中的线程除去new和terminated状态，一个线程真实存在的状态，只有：

ready：表示线程已经被创建，正在等待系统调度分配CPU使用权。
running：表示线程获得了CPU使用权，正在进行运算
waiting：表示线程等待（或者说挂起），让出CPU资源给其他线程使用对于Java中的线程状态：

无论是Timed Waiting ，Waiting还是Blocked，对应的都是操作系统线程的**waiting（等待**）状态。
而Runnable状态，则对应了操作系统中的ready和running状态。

展开全文 >>

类加载的几种方式

类加载的几种方式

​ Java虚拟机团队有意把类加载阶段中的 “通过一个类的全限定名来获取描述该类的二进制字节流” 这个动作放到Java虚拟机外部去实现，以便让应用程序自己决定如何去获取所需的类。实现这个动作的代码被称为“类加载器”。

​ 在我们使用一个类之前，JVM需要先将该类的字节码文件（.class文件）从磁盘、网络或其他来源加载到内存中，并对字节码进行解析生成对应的Class对象，这就是类加载器的功能。我们可以利用类加载器，实现类的动态加载。

加载方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
隐式加载
1、由new关键字创建一个类的实例
   在由运行时刻用 new 方法载入
   例：Person person = new Person();

显式加载
2、使用 Class.forName()  除了将类的class文件加载到JVM中之外，还会对类进行解释，执行类中的static块
   通过反射加载类型，并创建对象实例
   例：Class clazz ＝ Class.forName("Person");
      Object person ＝ clazz.newInstance();
3、使用某个ClassLoader实例的loadClass()方法 只会进行加载，在进行newInstance时才会执行static块
   通过该 ClassLoader 实例的 loadClass() 方法载入。应用程序可以通过继承 ClassLoader 实现自己的类装载器。
   例：Class clazz ＝ classLoader.loadClass("Person");
      Object person ＝ clazz.newInstance();

类加载过程

  1. 加载
  2. 验证
  3. 准备
  4. 解析
  5. 初始化

展开全文 >>

面经

面经

美团一面：

项目相关：

  1. 项目中的难点，简要介绍生产者消费者模型，异步处理事件和多线程处理的区别。
  2. 简要介绍solr。使用solr和数据库中直接使用%like%有什么区别

Java基础：

1. 简要介绍static关键字，static方法的继承算重写吗，类继承时实现多态是走的父类static方法还是子类static方法。
 2. 介绍泛型，说一下泛型的好处
 3. 说一下Java7 HashMap是线程安全的吗？不安全怎么办？
 4. 简述 JVM 的内存区域  对象的引用放在栈中
 5. 数据库联合索引 最左前缀 ACID特性  数据库发现读写比较慢，那我怎么优化
 6. 线程池的参数
 7. 计算机网络 TCP UDP TCP怎么保证可靠连接的 说一下拥塞控制
 8. Linux 现在发现CPU占用的很多，我怎么找到最占用CPU的那条语句

链表求和

展开全文 >>

为什么Redis底层用跳表而不是红黑树或者B+树

为什么Redis底层用跳表而不是红黑树或者B+树？

zset为什么不用红黑树？

插入、删除、查找以及迭代输出有序序列这几个操作红黑树也可以完成，且时间复杂度跟跳表一样。但按照区间来查找数据这个操作红黑树的效率没有跳表高， 跳表可以做到 $\ O(log_2N)$ 的时间复杂度定位区间的起点，再在原始链表中顺序往后遍历，非常高效。

其他原因还有跳表更容易代码实现；跳表更加灵活，它可以通过改变索引构建策略，有效平衡执行效率和内存消耗。
Tips： 跳表不能完全替代红黑树，红黑树比跳表的出现要早一些( Hashmap 和 TreeMap 是1.2就有了的)，很多编程语言中的 Map 类型都是通过红黑树来实现，做业务开发时可以直接拿来用，不用费劲自己去实现，但跳表没有现成的实现，所以在开发中如果想使用跳表必须要自己实现。在1.6中，有了跳表实现的Map，即ConcurrentSkipListMap，但仿佛跳表实现的Map不如HashMap稳定。

zset为什么不用B+树？

B+树的原理是叶子节点存储数据，非叶子节点存储索引，B+树的每个节点可以存储多个关键字，它将节点大小设置为磁盘页的大小，充分利用了磁盘预读的功能。每次读取磁盘页时就会读取一整个节点,每个叶子节点还有指向前后节点的指针，为的是最大限度的降低磁盘的IO；因为数据在内存中读取耗费的时间是从磁盘的IO读取的百万分之一。而Redis是内存中读取数据，不涉及IO，因此使用了跳表；

为什么Redis使用单线程读取速度还这么块？

因为Redis不涉及I/O操作，而多线程更适合用于I/O操作多的情况。
Tips：1.CPU在切换线程的时候有上下文切换时间，上下文切换时间非常耗时；但I/O操作更耗时，所以在需要频繁进行I/O操作时，应当优先考虑多线程。2.Redis的性能和CPU无关，其性能瓶颈在：a.机器内存大小，内存大小关系到Redis存储的数据量；b.网络带宽，Redis的客户端和服务端可能部署在不同的机器上，但就近部署降低往返时间RTT，提高性能。

原文链接：https://blog.csdn.net/ellie_chen/article/details/119139963

展开全文 >>

二叉树的最近公共祖先

二叉树的最近公共祖先

定义 $\ f_x$ 表示$\ x$ 节点的子树中是否包含$\ p$节点或$\ q$节点，如果包含为true，否则为false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class Solution {

​    TreeNode ans;

​    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {

​        ans = null;

​        DFS(root, p, q);

​        return ans;

​    }

​    public boolean DFS(TreeNode root, TreeNode p, TreeNode q){

​        if(root == null) return false;

​        boolean lson = DFS(root.left, p, q);

​        boolean rson = DFS(root.right, p, q);

​        if((lson&&rson)||(lson||rson)&&(root.val==p.val||root.val==q.val)){

​            ans = root;

​        }

​        return lson||rson||root.val==p.val||root.val==q.val;

​    }

}

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

永远热爱生活的<br><br>一个程序员