小工具知识网

当前位置: 首页 > 行业知识 > Java重点原理精炼

行业知识

Java重点原理精炼

2026-11-17 14:28:57 来源:互联网转载

Java重点原理精炼

作者���介:大家好,我是 枫度柚子,Java摆烂选手,很高兴认识大家

CSDN/掘金/B站: 枫吹过的柚

合作伙伴B站: 爱敲代码的小黄

实时更新地址: https://blog.csdn.net/qq_41804775/article/details/136355802

如果感觉博主的文章还不错的话,请三连支持一下博主哦

微信群: 加微信 QaQ-linv 或 hls1793929520

QQ群: 995832569

更新时间: 2024-03-08

适用年限: 3年~5年

目录

文章目录

  • Java重点原理精炼
    • 目录
    • 简历JD参考
    • Java基础
      • 面向过程与面向对象的区别
      • 什么是值传递和引用传递
      • String为什么是不可变的
      • String、StringBuilder、StringBuffer的区别
      • 深拷贝和浅拷贝
      • equals和==的区别
      • 两个对象的hashcode相同,equals一定相同吗
      • final、finally、finalize的区别
      • 集合
        • 集合引入
        • ArrayList和LinkedList的区别
        • 快速失败(fast fail)
        • CopyOnWriteArrayList底层实现原理
        • HashMap在JDK 7和JDK 8的区别
        • HashMap的put流程
        • HashMap的get流程
        • HashMap的扩容流程
        • ConcurrentHashMap在JDK 7和JDK 8的区别
        • ConcurrentHashMap的put流程
        • ConcurrentHashMap扩容机制
        • ConcurrentHashMap的size方法
        • 多线程
          • 多线程引入
          • 线程、进程、协程的区别
          • 线程的生命周期
          • 什么是上下文切换
          • 什么是并发线程安全问题
          • run和start的区别
          • 线程常用方法
          • 什么是线程中断
          • 线程的创建方式有哪些
          • 为什么要使用线程池
          • 线程池的核心参数
          • 线程池的工作流程
          • 常见的阻塞队列
          • 线程池的类型有哪些
          • 线程池调优
          • ThreadLocal实现原理
          • 锁机制
            • 锁机制引入
            • 乐观锁和悲观锁的区别
            • ***锁、活锁、饥饿的区别
            • Java***锁如何避免
            • 常见的原子类
            • 什么是CAS
            • 谈一下volatile
            • Monitor机制
            • 管程是如何保证同步和互斥的
            • 管程中的Mesa模型和Hoare模型
            • 谈一下synchronized
            • synchronized的锁变化
            • synchronized锁粗化、锁消除
            • 什么是AQS
            • JUC可重入锁ReentrantLock
            • JUC共享锁Semaphore
            • JUC闭锁CountDownLatch
            • JUC循环屏障CyclicBarrier
            • JUC读写锁ReentrantReadWriteLock
            • 保证三个线程同时执行
            • 并发情况下三个线程依次执行
            • 三个线程有序交错执行
            • 两个线程交替打印奇偶数
            • JMM
              • 谈一下Java的共享内存模型JMM
              • JVM
                • JVM引入
                • 类加载器有哪些
                • 什么是双亲委派机制
                • 为什么要有双亲委派机制
                • 如何打破双亲委派机制
                • Tomcat为什么要打破双亲委派机制
                • JVM类加载过程
                • JVM的重要组成部分和作用
                • 对象的创建过程
                • 什么是栈上分配
                • 垃圾收集算法有哪些
                • 什么是STW
                • 为什么要进行STW
                • 对象的分配策略
                • 如何判断对象是否存活/如何判断对象可以被回收
                • 什么情况下类会被卸载
                • 引用类型有哪几种
                • 常见的垃圾收集器
                • JVM如何处理跨代引用
                • JVM常用调参
                • JVM故障分析
                • Arthas常用指令
                • 内存溢出和内存泄露的区别
                • 常量池的分类
                • 类实例化的顺序
                • MySQL
                  • MySQL引入
                  • 事务的四大特性(ACID)
                  • 脏写、脏读、不可重复读、幻读
                  • 事务的隔离级别
                  • 常见的索引结构
                  • MySQL的索引数据结构
                  • 为什么MySQL要用B+Tree而不用跳表
                  • 聚簇索引和非聚簇索引
                  • InnoDB和MylSAM的区别
                  • 为什么非主键索引的叶子节点的数据存储的是主键ID
                  • 为什么建议InnoDB必须设置主键
                  • 为什么推荐使用自增整型作为主键而不是UUID
                  • MySQL的执行计划怎么看
                  • 索引什么时候会失效
                  • 索引优化原则
                  • SQL的执行流程
                  • MySQL的三个日志
                  • Undo的MVCC机制
                  • InnoDB的BufferPool缓存机制
                  • 线上百万数据如何添加索引
                  • MySQL中的锁有哪些
                  • 分库分表
                  • Oracle
                    • Oracle的执行计划怎么看
                    • Redis
                      • Redis的数据类型
                      • 谈一下布隆过滤器
                      • Redis为什么这么快
                      • Redis为什么要引入多线程
                      • 什么是IO多路复用
                      • Redis的Reactor模型
                      • Redis如何获取所有key
                      • Redis持久化有哪几种方式
                      • Redis持久化方式如何选择
                      • Redis主从复制(同步)原理
                      • Redis怎么实现高可用
                      • 哨兵选主过程
                      • Redis Cluster主从选举过程
                      • 主从选举的脑裂问题
                      • 缓存雪崩、缓存击穿、缓存穿透
                      • 热点缓存并发重建
                      • 数据库和缓存双写不一致
                      • Redis分布式锁实现
                      • 过期键的删除策略
                      • 内存淘汰策略有哪些
                      • Netty
                        • 同步和异步的区别
                        • 阻塞和非阻塞的区别
                        • TCP粘包/拆包
                        • 常见的IO模型
                        • Netty有哪些核心组件
                        • 谈谈你对Netty中Pipeline工作原理理解
                        • Netty中提供了哪些线程模型
                        • Netty是如何实现零拷贝的
                        • Zookeeper
                          • Zookeeper的节点类型
                          • Zookeeper分布式锁实现
                          • Zookeeper的Watcher机制
                          • Zookeeper的leader选举过程
                          • Zookeeper主备之间的数据同步是同步还是异步的
                          • 谈一下ZAB协议(原子广播协议)
                          • ZAB和Paxos算法的联系与区别
                          • RabbitMQ
                            • RabbitMQ引入
                            • RabbitMQ的工作队列模式
                            • RabbitMQ的***信队列和延迟队列
                            • RabbitMQ如何避免消息重复消费(RabbitMQ如何保证消息幂等性)
                            • RabbitMQ如何保证消息有序
                            • RabbitMQ如何处理消息堆积
                            • RabbitMQ如何保证消息不丢失
                            • RabbitMQ如何保证消息可靠性传输
                            • Kafka
                              • Kafka引入
                              • Kafka的设计
                              • Kafka高性能的原因(Kafka为什么这么快)
                              • Kafka主备之间采用的是同步复制还是异步复制
                              • Kafka的Broker持久化机制
                              • Kafka什么情况会丢消息
                              • Kafka生产端的发送模式
                              • Kafka消费端的消费模式
                              • Kafka的消费乱序
                              • Kafka副本Leader选举机制
                              • Kafka消费者的重平衡(Rebalance)机制
                              • 分区故障恢复机制
                              • Kafka的消息幂等性3种语义的实现
                              • Kafka如何保证消息不丢失
                              • Kafka如何保证消息有序
                              • Kafka如何处理消息堆积
                              • 谈谈对Kafka零拷贝的理解
                              • Kafka的延迟消息
                              • Kafka生产端发多条消息,一半成功一半失败怎么办
                              • Kafka的事务
                              • RocketMQ
                                • RocketMQ引入
                                • RocketMQ的设计
                                • RocketMQ为什么要放弃Zookeeper
                                • RocketMQ的消息模型
                                • 谈谈你对RocketMQ分布式事务原理的理解
                                • RocketMQ生产端的发送模式
                                • RocketMQ消费端的消费模式
                                • RocketMQ的消息确认机制
                                • RocketMQ的持久化机制
                                • RocketMQ的过期文件删除机制
                                • RocketMQ的数据刷盘机制
                                • RocketMQ的主从复制原理
                                • RocketMQ如何保证消息不丢失
                                • NameServer挂了如何保证消息不丢失
                                • RocketMQ如何保证消息有序
                                • RocketMQ如何处理消息堆积
                                • 谈谈对RocketMQ零拷贝的理解
                                • Spring
                                  • 谈一下IOC
                                  • 谈一下AOP
                                  • ApplicationContext和BeanFactory的区别
                                  • Spring启动流程
                                  • Bean的生命周期
                                  • Bean的作用域
                                  • Bean如何保证线程安全
                                  • 循环依赖如何解决
                                  • 事务传播行为
                                  • Spring如何处理事务
                                  • 谈一下Spring事务机制
                                  • @Transactional事务失效
                                  • Spring中的设计模式有哪些
                                  • @Autowired和@Resource的区别
                                  • Spring MVC
                                    • Spring MVC请求流程
                                    • Spring和Spring MVC为什么需要父子容器
                                    • 是否可以把所有Bean都通过Spring容器来管理
                                    • 是否可以把我们所需的Bean都放入Spring MVC子容器里面来管理
                                    • Spring Boot
                                      • Spring Boot常用注解
                                      • Spring Boot自动装配原理
                                      • Jar启动流程
                                      • 如何自定义Starter
                                      • SpringBoot是如何启动Tomcat的
                                      • Spring Cloud
                                        • CAP理论
                                        • Base理论
                                        • Spring Cloud核心组件以及作用
                                        • Eureka的数据同步原理
                                        • 谈一下分布式事务
                                        • 谈谈对Seata的理解
                                        • 场景题
                                          • 网络调用,串行是10s,修改为并行后能压缩到1s,此时CPU飙升,如何平衡这个点,线程池是怎么设置,qps高的情况下,线程数少就会导致排队出现io爆炸
                                          • 网站首页公告,假设公告id是连续,不间断的,要求使用Redis存储,并且根据评论的时间排序,而且还有分页的功能,请给出你的解决方式,从存储方式和查询方式分析,以及分页怎么获得总数据数,分页怎么分
                                          • 某个文章的评论,要求使用Redis存储,并且根据评论的时间排序,而且还有分页的功能,请给出你的解决方式,从存储方式和查询方式分析,以及分页怎么获得总数据数,分页怎么分

                                            简历JD参考

                                            • 深入理解volatile、synchronized、Lock、ConcurrentHashMap、线程池等并发编程技术;
                                            • 深入理解JVM、JMM,熟悉内存模型、类加载、垃圾收集器、GC算法等、具有生产JVM调优经验;
                                            • 熟练使用Redis,熟悉其数据类型、持久化、主从复制、集群、缓存一致性等,对分布式锁实现有一定的理解;
                                            • 熟练使用MySQL,熟悉底层数据结构、索引、事务、日志等,具有生产慢SQL调优经验;
                                            • 熟悉Zookeeper,熟悉节点类型、ZAB协议以及分布式锁实现等;
                                            • 熟悉Netty,对Rceator模型、零拷贝、粘/拆包具有一定的理解;
                                            • 熟练使用RabbitMQ、Kafka、RocketMQ,熟悉基础架构、副本同步机制、持久化机制、零拷贝以及常见问题解决方案;
                                            • 熟悉Spring,对IOC、AOP、Bean生命周期、循环依赖等;
                                            • 熟悉Spring Boot,对常用注解、自动装配原理、Jar启动流程、自定义Starter有一定的理解;
                                            • 熟练使用Spring Cloud,对常用组件、分布式事务具有一定的理解;
                                            • 熟悉常规的设计模式,熟悉责任链、工厂、策略等,具有项目落地实践经历;

                                              Java基础

                                              面向过程与面向对象的区别

                                              • 面向过程可以理解为按步骤处理问题
                                              • 面向对象可以理解为将具体事务存在的属性、行为抽象出来,然后去进行实现

                                                什么是值传递和引用传递

                                                • 值传递是对基本数据类型而言,只进行值的拷贝,不会影响原变量
                                                • 引用传递是对对象而言,不是传递对象的值,而是传递对象的地址,如果副本改变会影响到原对象

                                                  String为什么是不可变的

                                                  • String内部维护的是private final char/byte数组,不可变线程安全
                                                    • 好处
                                                      • 防止被恶意篡改
                                                      • 作为HashMap的key可以保证不可变性
                                                      • 可以实现字符串常量池,在Java中,创建字符串对象的方式
                                                        • 通过字符串常量进行创建
                                                          • 在字符串常量池判断是否存在,如果存在就返回,不存在就在字符串常量池创建后返回
                                                          • 通过new字符串对象进行创建
                                                            • 在字符串常量池中判断是否存在,如果不存在就创建,再判断堆中是否存在,如果不存在就创建,然后返回该对象,总之要保证字符串常量池和堆中都有该对象

                                                              String、StringBuilder、StringBuffer的区别

                                                              • String内部维护的是private final char/byte数组,不可变线程安全
                                                              • StringBuilder可变,线程不安全,可以使用append进行拼接字符串
                                                              • StringBuffer可变,通过synchronized来保证线程安全,操作和StringBuilder一样
                                                                • synchronized对于出现在循环中会进行锁粗化,会将锁的范围扩展到整个操作,从而避免频繁进行锁操作造成性能开销

                                                                  深拷贝和浅拷贝

                                                                  • 浅拷贝就是副本对象和原对象都指向同一块内存空间,副本对象的改变会影响到原对象
                                                                  • 深拷贝就是副本对象和原对象不指向通一块内存空间,会重新开辟一块内存空间给副本对象进行指向

                                                                    equals和==的区别

                                                                    • ==对于基本类型比较的是值,但是引用类型比较的是内存地址
                                                                    • equals取决于子类是否重写,默认和==等价

                                                                      两个对象的hashcode相同,equals一定相同吗

                                                                      • 一般推荐重写equals方法的同时也要重写hashcode方法
                                                                        • 两个对象的hashcode相同,equals可能相同
                                                                        • 两个对象equals相同,hashcode一定相同

                                                                          final、finally、finalize的区别

                                                                          • final修饰的类不能被继承、属性是常量而且必须初始化、修饰的方法不能被重写
                                                                          • finally用于异常处理,finally代码块中的内容一定会执行
                                                                          • finalize是Object类的一个方法,当我们调用system.gc()时会调用,也可以使用它在GC时自救一次
                                                                            • 重写finalize方法的对象会被加入到一个unfinalized链表中,首次GC时不会回收该对象,调用完finalize后,然后从unfinalized链表剔除,此时对象可以进行自救,将自己重新加入到引用链上,下一次GC时会进行回收

                                                                              集合

                                                                              集合引入

                                                                              • 概念前提
                                                                                • ArrayList的数组默认长度10,1.5倍数组扩容,扩容通过开辟新数组进行转移老数组元素
                                                                                • HashMap、ConcurrentHashMap的数组默认长度16,2倍数组扩容,扩容通过开辟新数组进行转移老数组元素
                                                                                • 核心思想
                                                                                  • 读写分离
                                                                                    • CopyOnWriteArrayList底层实现、处理快速失败
                                                                                    • 分散热点
                                                                                      • ConcurrentHashMap底层addCount计算
                                                                                      • 索引优化
                                                                                        • HashMap/ConcurrentHashMap 从数组->链表->红黑树
                                                                                        • 考察重点
                                                                                          • 集合底层实现以及设计思想
                                                                                          • 注意点
                                                                                            • 对于存放大量元素到ArrayList 或 HashMap中时,建议提前初始化好容量避免扩容导致性能损耗

                                                                                              ArrayList和LinkedList的区别

                                                                                              • ArrayList基于数组实现,LinkedList基于链表实现

                                                                                              • ArryList适合随机查找,LinkedList适合增删,时间复杂度不同

                                                                                              • ArrayList和LinkedList都是基于List接口实现的,LinkedList还实现了Deque接口,可以当做队列使用

                                                                                                快速失败(fast fail)

                                                                                                • 快速失败是Java基于多线程操作同一集合的保护机制
                                                                                                • 解决办法
                                                                                                  • 可以使用Colletions.synchronizedList方法处理集合 或 在修改集合的地方用synchronized进行修饰,但是性能较低
                                                                                                  • 使用CopyOnWriteArrayList代替List,采用读写分离的方式,写时会新拷贝一份数组,对新数组进行操作,操作完之后,再将引用指向新数组

                                                                                                    CopyOnWriteArrayList底层实现原理

                                                                                                    • CopyOnWriteArrayList是基于数组实现的,采用多写分离的方式来应对多线程的读写操作,当对内部数组进行操作时,会拷贝一份出来用于写,写操作时会进行加锁避免并发写入导致数据丢失,而读依旧在旧数组进行,当操作完之后,再将引用重新指向新数组完成整个操作
                                                                                                    • CopyOnWriteArrayList适合读多写少的场景,但是比较吃内存,并且对于实时性要求很高场景不太适用因为可能读到旧数据

                                                                                                      HashMap在JDK 7和JDK 8的区别

                                                                                                      • HashMap在JDK 7采用的是 数组 + 链表 的方式,由于HashMap的key是基于hash值计算后放到对应的数组槽位的,可能会出现hash碰撞,所以在每个槽位采用链表头插法进行存放元素,如果容量不足会先扩容
                                                                                                      • HashMap在JDK 8采用的是 数组 + 链表/红黑树 的方式,基于JDK 7的基础上为了解决链表过长导致查询效率降低以及头插法导致循环链表从而***循环造成CPU满载的问题,所以JDK 8采用了尾插法

                                                                                                        HashMap的put流程

                                                                                                        • 首先基于hash值计算得到数组下标
                                                                                                        • 如果下标元素为空,在JDK 7下会将K-V封装成Entry对象,在JDK 8下会封装成Node对象,然后放到数组对应的槽位
                                                                                                        • 如果下标元素不为空
                                                                                                          • 在JDK 7下会先判断是否需要扩容,如果需要就优先扩容,然后采用头插法插入当前槽位的链表上,如果Key相同就更新Value
                                                                                                          • 在JDK 8下不会先判断是否需要扩容,而是先判断节点是链表节点还是红黑树节点,最后再看扩容
                                                                                                            • 如果是链表节点,将K-V封装成链表节点,采用尾插法插入当前槽位的链表上,如果Key相同就更新Value,当数组长度达到64且链表长度达到8就会将链表转化为红黑树来提升查询速度
                                                                                                            • 如果是红黑树节点,将K-V封装成红黑树节点放到红黑树上,如果Key相同就更新Value,当红黑树节点数达到6时会退化成链表

                                                                                                              HashMap的get流程

                                                                                                              • 基于hash值计算得到数组的下标,然后遍历每个槽位(链表/红黑树)通过equals方法进行查找Key相同的元素

                                                                                                                HashMap的扩容流程

                                                                                                                • HashMap的扩容实质上就是数组的扩容,会重新开辟一份2倍原数组容量的数组将老数组的元素转移过来
                                                                                                                  • 在JDK 7下会将老数组中的元素重新进行hash值计算得到新数组的下标,然后放到对应数组的槽位的链表上,扩容的目的主要是为了解决链表过长的问题
                                                                                                                  • 在JDK 8下也会将老数组中元素的数组下标重新计算
                                                                                                                    • 如果是红黑树对应的槽位,会通过低位和高位(依旧是老位置的元素和新位置的元素)拆分成两个子链表存放到不同的槽位,当数组长度达到64且链表长度达到8时转化为红黑树
                                                                                                                    • 如果是链表对应的槽位,操作和JDK 7的一样

                                                                                                                      ConcurrentHashMap在JDK 7和JDK 8的区别

                                                                                                                      • 在JDK 7下,采用分段锁的方式来保证线程安全,内部维护了一个segment数组,每个segment都包含了一个HashEntry数组,相当于一个小的HashMap提供了get、put方法,并且segment都实现了ReentrantLock,put元素时通过ReentrantLock加锁
                                                                                                                      • 在JDK 8下,采用synchronized来保证线程安全的,内部维护一个Node数组,put元素时对Node节点进行加锁,相当于JDK 7减小了锁的粒度并且节省了内存

                                                                                                                        ConcurrentHashMap的put流程

                                                                                                                        • 详概

                                                                                                                          • 在JDK 7下

                                                                                                                            • 基于hash值计算得到数组对应的segment,如果当前segment不存在锁就进行加锁,然后在对应的HashEntry数组中进行put操作,操作完之后进行释放锁
                                                                                                                            • 在JDK 8下

                                                                                                                            • 基于hash值计算得到数组对应的槽位

                                                                                                                              • 判断数组是否已经初始化,如果没有初始化,会Thread.yield保证数组先初始化
                                                                                                                              • 如果数组的槽位不存在元素就通过 CAS + 自旋 保证元素插入成功

                                                                                                                                • 判断需要扩容,如果需要就进行扩容
                                                                                                                                • 如果在无需数组初始化、扩容而是存在hash冲突的情况下采用synchronized对Node节点加锁进行put,对应的槽位可能是链表或红黑树,如果链表长度达到8会转化为红黑树

                                                                                                                                • 简概

                                                                                                                                  • 在JDK 7,基于segment数组,segment继承于ReentrantLock,每次put加锁,保证元素存入
                                                                                                                                  • 在JDK 8,数组槽位为空时,采用 CAS + 自旋 保证存入,如果出现hash冲突,采用synchronized对Node加锁保证链表节点/红黑树节点存入

                                                                                                                                    ConcurrentHashMap扩容机制

                                                                                                                                    • ConcurrentHashMap的扩容实质上也是数组的扩容,会重新开辟一份2倍原数组容量的数组将老数组的元素转移过来

                                                                                                                                    • 在JDK 7下基于分段锁实现的,每个segment都维护了一个小HashMap,所以每个segment内部会进行扩容,操作和HashMap扩容一样

                                                                                                                                    • 在JDK 8下倒序遍历数组的槽位,每经过一个槽位就通过synchronized对Node节点进行加锁,根据不同槽位类型(链表/红黑树)执行拷贝方法,对于红黑树会通过低位和高位(依旧是老位置的元素和新位置的元素)拆分成两个子链表存放到不同的槽位

                                                                                                                                      ConcurrentHashMap的size方法

                                                                                                                                      • 对于ConcurrentHashMap不能在put元素时进行加锁统计元素,这样会影响put的效率
                                                                                                                                      • ConcurrentHashMap的size方法通过 baseCount + CountCell数组 的方式进行统计
                                                                                                                                        • 多个线程会先通过CAS去进行baseCount累加,如果其中一个线程累加失败,会将其热点值的计算打散到CountCell数组l的各个槽位,每个线程对应一个槽位进行累加即可,最终结果 = baseCount + CountCell数组各个槽位值
                                                                                                                                        • 站在size计算的角度上看是线程安全的,但是从全局角度看并不是,因为put方法和size方法之间的数据并不是一致的

                                                                                                                                          多线程

                                                                                                                                          多线程引入

                                                                                                                                          • 考察重点
                                                                                                                                            • 线程的使用以及线程池调优

                                                                                                                                              线程、进程、协程的区别

                                                                                                                                              • 进程是操作系统资源分配的最小单位
                                                                                                                                                • 进程的通信方式
                                                                                                                                                  • 管道
                                                                                                                                                    • 管道分为匿名管道与命名管道,匿名管道用于父子进程通信,命名管道支持各种进程通信
                                                                                                                                                    • 信号
                                                                                                                                                      • 信号是软件层面对中断机制的模拟
                                                                                                                                                      • 消息队列
                                                                                                                                                        • 克服信号量有限的弊端,具有读、写能力
                                                                                                                                                        • 共享内存
                                                                                                                                                          • 通过多个进程读取公共内存进行通信,比如分布式锁
                                                                                                                                                          • socket
                                                                                                                                                            • 用于网络中不同机器的进程通信
                                                                                                                                                            • 线程是操作系统任务调度和执行的最小单位,归属于进程
                                                                                                                                                              • 线程的通信方式
                                                                                                                                                                • 通过volatile来保证可见性,但是volatile常用于单写多读的场景
                                                                                                                                                                • 协程是存在于用户态轻量级线程,通过减少上下文切换频率提升并发性能

                                                                                                                                                                  线程的生命周期

                                                                                                                                                                  • 新建(new)
                                                                                                                                                                    • new一个线程对象
                                                                                                                                                                    • 可运行(runnable)
                                                                                                                                                                      • 当线程调用start方法
                                                                                                                                                                      • 运行(running)
                                                                                                                                                                        • 处于可运行状态下的线程获取到时间片执行
                                                                                                                                                                        • 阻塞(blocked)
                                                                                                                                                                          • 线程因为某些原因进入阻塞状态,必须等待条件满足才会继续执行
                                                                                                                                                                          • 终止(terminated)
                                                                                                                                                                            • 线程执行结束或异常退出

                                                                                                                                                                              什么是上下文切换

                                                                                                                                                                              • 上下文切换主要是CPU从一个线程切换到另外一个线程,切换前会保存上一个线程的操作状态以便于下次继续使用
                                                                                                                                                                              • 上下文切换发生于内核态,频繁的从用户态切换到内核态会耗费性能

                                                                                                                                                                                什么是并发线程安全问题

                                                                                                                                                                                • 多个线程操作共享资源但是由于缺少同步措施导致达不到预期结果
                                                                                                                                                                                  • 如何保证线程安全
                                                                                                                                                                                    • 可以使用JVM内置锁synchronzied、JUC提供的Lock

                                                                                                                                                                                      run和start的区别

                                                                                                                                                                                      • run方法只是对象的方法,并不会去创建线程
                                                                                                                                                                                      • start方法会从用户态切换到内核态进行创建线程,创建完成后回调run方法

                                                                                                                                                                                        线程常用方法

                                                                                                                                                                                        • sleep
                                                                                                                                                                                          • 可以指定时间,让线程短暂休眠,通过interrupt可以打断休眠状态,如果抛出中断异常会清除中断标志
                                                                                                                                                                                          • sleep(0) 等价于 yield
                                                                                                                                                                                          • yield
                                                                                                                                                                                            • 上下文切换,会让出CPU资源
                                                                                                                                                                                            • join
                                                                                                                                                                                              • 会让join线程先执行,主线程暂停
                                                                                                                                                                                              • join底层会一直检查join线程是否存活,如果存活会让其他线程继续等待
                                                                                                                                                                                              • stop
                                                                                                                                                                                                • stop不推荐使用,因为会强制终止未执行完的线程

                                                                                                                                                                                                  什么是线程中断

                                                                                                                                                                                                  • 线程中断就是通过中断信号去告诉线程你可以停止,但是线程并不会立刻停止,如果收到了信号,可以自定义终止逻辑,相对于stop直接强制线程终止优雅很多
                                                                                                                                                                                                    • 线程中断的方法
                                                                                                                                                                                                      • interrupt
                                                                                                                                                                                                        • 给线程加上中断标志,不会终止线程
                                                                                                                                                                                                        • interrupted
                                                                                                                                                                                                          • 判断是否有中断标志,有会清除
                                                                                                                                                                                                          • isInterrupted
                                                                                                                                                                                                            • 判断是否有中断标志,但不会清除
                                                                                                                                                                                                            • 可以通过while循环判断isInterrupted和共享变量来处理中断,但是要注意如果有用sleep可以通过interrupt把中断标志位加上

                                                                                                                                                                                                              线程的创建方式有哪些

                                                                                                                                                                                                              • 线程创建的方式实际只有一种,都是通过new Thread创建,然后通过调用start方法去内核态创建线程,完成后回调run方法
                                                                                                                                                                                                              • 通常说的创建方式
                                                                                                                                                                                                                • 继承Thread类,重写run方法
                                                                                                                                                                                                                • 实现Runnable接口,重写run方法
                                                                                                                                                                                                                • 实现Callable接口,重写call方法,通过FutureTask创建来获取执行的结果
                                                                                                                                                                                                                • 通过线程池创建

                                                                                                                                                                                                                  为什么要使用线程池

                                                                                                                                                                                                                  • 线程的创建和销毁都需要进行用户态和内核态的切换,当new Thread时会通过start去内核态创建线程,完成后回调run方法,使用线程池可以减少切换频率
                                                                                                                                                                                                                  • 线程池的使用方便管理线程,通过复用线程减少性能开销,以及提高执行任务的响应速度

                                                                                                                                                                                                                    线程池的核心参数

                                                                                                                                                                                                                    • 核心线程数、最大线程数、最大空闲时间、最大空闲时间单位、阻塞队列、线程工厂、拒绝策略
                                                                                                                                                                                                                      • 核心线程数 就是 线程池中保持活动状态的最小线程数,即使这些线程处于空闲状态,它们也不会被回收
                                                                                                                                                                                                                      • 最大线程数 就是 线程池中允许存在的最大线程数,当任务数量超过核心线程数且任务队列已满时,线程池会创建新的线程来处理任务,直到达到最大线程数

                                                                                                                                                                                                                        线程池的工作流程

                                                                                                                                                                                                                        • 当任务到达时,线程池首先会先创建核心线程去执行任务,如果核心线程创建满了,会先复用空闲的核心线程,如果核心线程都在跑任务,此时新的任务会被安排进入到阻塞队列中等待,如果阻塞队列也满了,就会创建非核心线程去执行任务,直到达到最大线程数,如果三者都满了,就会走拒绝策略
                                                                                                                                                                                                                          • 拒绝策略
                                                                                                                                                                                                                            • 拒绝执行,抛异常(AbortPoliy)
                                                                                                                                                                                                                            • 拒绝执行(DiscardPolicy)
                                                                                                                                                                                                                            • 使用主线程执行任务(CallerRunsPolicy)
                                                                                                                                                                                                                            • 丢弃队列中最老任务,尝试执行新任务(DiscardOldestPolicy)

                                                                                                                                                                                                                              常见的阻塞队列

                                                                                                                                                                                                                              • ArrayBlockingQueue
                                                                                                                                                                                                                                • 基于环形数组实现的有界阻塞队列,不需指定初始容量,按照先进先出的顺存储元素,并且在队列满时会阻塞写入操作,直到有空间可用,同样在队列为空时,读取操作会被阻塞,直到有元素可用
                                                                                                                                                                                                                                • LinkedBlockingQueue
                                                                                                                                                                                                                                  • 基链表实现的可选有界或无界塞队列,它与ArrayBlockingQueue类似,但是没有固定的容量限制,当队列为空时,读取操作会被阻塞,直到有元素可用,当队列满时,写入操作会被阻塞,直到有空间可用
                                                                                                                                                                                                                                  • SynchronousQueue
                                                                                                                                                                                                                                    • 一个特殊的阻塞队列,它不存储元素,它的每个插入操作必须等待另一个线程的对应移除操作,反之亦然,SynchronousQueue可以用于线程间的数据交换
                                                                                                                                                                                                                                    • PriorityBlockingQueue
                                                                                                                                                                                                                                      • 基于优先级堆实现的无界阻塞队列,它可以按照元素的优先级进行排序,并且在插入和移除操作时保持有序,当队列为空时,读取操作会被阻塞,直到有元素可用
                                                                                                                                                                                                                                      • DelayQueue
                                                                                                                                                                                                                                        • 基于优先级堆实现的延迟阻塞队列,它可以存储实现了Delayed接口的元素,每个元素都有一个过期时间,只有在元素过期后,才能从队列中取出。当队列为空时,读取操作会被阻塞,直到有元素过期

                                                                                                                                                                                                                                          线程池的类型有哪些

                                                                                                                                                                                                                                          • 常见的线程池
                                                                                                                                                                                                                                            • SingleThreadPool
                                                                                                                                                                                                                                              • 核心线程与最大线程数为1,非核心线程存活时间为0,采用LinkedBlockingQueue作为阻塞队列
                                                                                                                                                                                                                                              • 比较适合单线程串行任务
                                                                                                                                                                                                                                              • FixedThreadPool
                                                                                                                                                                                                                                                • 核心线程与最大线程数为n,非核心线程存活时间为0,采用LinkedBlockingQueue作为阻塞队列
                                                                                                                                                                                                                                                • 比较适合CPU密集型任务
                                                                                                                                                                                                                                                • CachedThreadPool
                                                                                                                                                                                                                                                  • 核心线程数为0,最大线程数为n,非核心线程存活时间为60s,采用SynchronousQueue作为阻塞队列
                                                                                                                                                                                                                                                  • 比较适合传递性任务
                                                                                                                                                                                                                                                  • ScheduledThreadPool
                                                                                                                                                                                                                                                    • 用来定期执行任务

                                                                                                                                                                                                                                                      线程池调优

                                                                                                                                                                                                                                                      • 参数说明

                                                                                                                                                                                                                                                        • QPS是每秒的访问数
                                                                                                                                                                                                                                                        • TP99是99%网络请求需要的最低耗时
                                                                                                                                                                                                                                                        • Buffer是还能给到的线程数
                                                                                                                                                                                                                                                        • 调优思路

                                                                                                                                                                                                                                                          • 线程池调优主要要根据实际业务场景去进行调整,一般调整参数主要是核心线程数、最大线程数、阻塞队列以及拒绝策略
                                                                                                                                                                                                                                                            • 如何设置核心线程数,可以从响应时间和吞吐量敏感度考虑
                                                                                                                                                                                                                                                              • 对于C端场景需要考虑响应时间,对于批量调用下游服务的场景,可以合理配置核心线程数让任务尽早的执行完

    上一篇:如何安全下载视频教程

    下一篇:方舟官方服务器怎么传送?