mirror of
https://github.com/Snailclimb/JavaGuide
synced 2025-06-16 18:10:13 +08:00
董宗磊
GitHub
commit
d3c780a448
@ -210,6 +210,7 @@
|
|||||||
|
|
||||||
- [5面阿里,终获offer(2018年秋招)](docs/essential-content-for-interview/BATJrealInterviewExperience/5面阿里,终获offer.md)
|
- [5面阿里,终获offer(2018年秋招)](docs/essential-content-for-interview/BATJrealInterviewExperience/5面阿里,终获offer.md)
|
||||||
- [蚂蚁金服2019实习生面经总结(已拿口头offer)](docs/essential-content-for-interview/BATJrealInterviewExperience/蚂蚁金服实习生面经总结(已拿口头offer).md)
|
- [蚂蚁金服2019实习生面经总结(已拿口头offer)](docs/essential-content-for-interview/BATJrealInterviewExperience/蚂蚁金服实习生面经总结(已拿口头offer).md)
|
||||||
|
- [2019年蚂蚁金服、头条、拼多多的面试总结](docs/essential-content-for-interview/BATJrealInterviewExperience/2019alipay-pinduoduo-toutiao.md)
|
||||||
|
|
||||||
## 工具
|
## 工具
|
||||||
|
|
||||||
|
|||||||
@ -0,0 +1,294 @@
|
|||||||
|
作者： rhwayfun,原文地址：https://mp.weixin.qq.com/s/msYty4vjjC0PvrwasRH5Bw ,JavaGuide 已经获得作者授权并对原文进行了重新排版。
|
||||||
|
<!-- TOC -->
|
||||||
|
|
||||||
|
- [写在2019年后的蚂蚁、头条、拼多多的面试总结](#写在2019年后的蚂蚁头条拼多多的面试总结)
|
||||||
|
- [准备过程](#准备过程)
|
||||||
|
- [蚂蚁金服](#蚂蚁金服)
|
||||||
|
- [一面](#一面)
|
||||||
|
- [二面](#二面)
|
||||||
|
- [三面](#三面)
|
||||||
|
- [四面](#四面)
|
||||||
|
- [五面](#五面)
|
||||||
|
- [小结](#小结)
|
||||||
|
- [拼多多](#拼多多)
|
||||||
|
- [面试前](#面试前)
|
||||||
|
- [一面](#一面-1)
|
||||||
|
- [二面](#二面-1)
|
||||||
|
- [三面](#三面-1)
|
||||||
|
- [小结](#小结-1)
|
||||||
|
- [字节跳动](#字节跳动)
|
||||||
|
- [面试前](#面试前-1)
|
||||||
|
- [一面](#一面-2)
|
||||||
|
- [二面](#二面-2)
|
||||||
|
- [小结](#小结-2)
|
||||||
|
- [总结](#总结)
|
||||||
|
|
||||||
|
<!-- /TOC -->
|
||||||
|
|
||||||
|
# 2019年蚂蚁金服、头条、拼多多的面试总结
|
||||||
|
|
||||||
|
文章有点长，请耐心看完，绝对有收获！不想听我BB直接进入面试分享：
|
||||||
|
|
||||||
|
- 准备过程
|
||||||
|
- 蚂蚁金服面试分享
|
||||||
|
- 拼多多面试分享
|
||||||
|
- 字节跳动面试分享
|
||||||
|
- 总结
|
||||||
|
|
||||||
|
说起来开始进行面试是年前倒数第二周，上午9点，我还在去公司的公交上，突然收到蚂蚁的面试电话，其实算不上真正的面试。面试官只是和我聊了下他们在做的事情（主要是做双十一这里大促的稳定性保障，偏中间件吧），说的很详细，然后和我沟通了下是否有兴趣，我表示有兴趣，后面就收到正式面试的通知，最后没选择去蚂蚁表示抱歉。
|
||||||
|
|
||||||
|
当时我自己也准备出去看看机会，顺便看看自己的实力。当时我其实挺纠结的，一方面现在部门也正需要我，还是可以有一番作为的，另一方面觉得近一年来进步缓慢，没有以前飞速进步的成就感了，而且业务和技术偏于稳定，加上自己也属于那种比较懒散的人，骨子里还是希望能够突破现状，持续在技术上有所精进。
|
||||||
|
|
||||||
|
在开始正式的总结之前，还是希望各位同仁能否听我继续发泄一会，抱拳！
|
||||||
|
|
||||||
|
我翻开自己2018年初立的flag，觉得甚是惭愧。其中就有一条是保持一周写一篇博客，奈何中间因为各种原因没能坚持下去。细细想来，主要是自己没能真正静下来心认真投入到技术的研究和学习，那么为什么会这样？说白了还是因为没有确定目标或者目标不明确，没有目标或者目标不明确都可能导致行动的失败。
|
||||||
|
|
||||||
|
那么问题来了，目标是啥？就我而言，短期目标是深入研究某一项技术，比如最近在研究mysql，那么深入研究一定要动手实践并且有所产出，这就够了么？还需要我们能够举一反三，结合实际开发场景想一想日常开发要注意什么，这中间有没有什么坑？可以看出，要进步真的不是一件简单的事，这种反人类的行为需要我们克服自我的弱点，逐渐形成习惯。真正牛逼的人，从不觉得认真学习是一件多么难的事，因为这已经形成了他的习惯，就喝早上起床刷牙洗脸那么自然简单。
|
||||||
|
|
||||||
|
扯了那么多，开始进入正题，先后进行了蚂蚁、拼多多和字节跳动的面试。
|
||||||
|
|
||||||
|
## 准备过程
|
||||||
|
|
||||||
|
先说说我自己的情况，我2016先在蚂蚁实习了将近三个月，然后去了我现在的老东家，2.5年工作经验，可以说毕业后就一直老老实实在老东家打怪升级，虽说有蚂蚁的实习经历，但是因为时间太短，还是有点虚的。所以面试官看到我简历第一个问题绝对是这样的。
|
||||||
|
|
||||||
|
“哇，你在蚂蚁待过，不错啊”，面试官笑嘻嘻地问到。“是的，还好”，我说。“为啥才三个月？”，面试官脸色一沉问到。“哗啦啦解释一通。。。”，我解释道。“哦，原来如此，那我们开始面试吧”，面试官一本正经说到。
|
||||||
|
|
||||||
|
尼玛，早知道不写蚂蚁的实习经历了，后面仔细一想，当初写上蚂蚁不就给简历加点料嘛。
|
||||||
|
|
||||||
|
言归正传，准备过程其实很早开始了（当然这不是说我工作时老想着跳槽，因为我明白现在的老东家并不是终点，我还需要不断提升），具体可追溯到从蚂蚁离职的时候，当时出来也面了很多公司，没啥大公司，面了大概5家公司，都拿到offer了。
|
||||||
|
|
||||||
|
工作之余常常会去额外研究自己感兴趣的技术以及工作用到的技术，力求把原理搞明白，并且会自己实践一把。此外，买了N多书，基本有时间就会去看，补补基础，什么操作系统、数据结构与算法、MySQL、JDK之类的源码，基本都好好温习了（文末会列一下自己看过的书和一些好的资料）。**我深知基础就像“木桶效应”的短板，决定了能装多少水。**
|
||||||
|
|
||||||
|
此外，在正式决定看机会之前，我给自己列了一个提纲，主要包括Java要掌握的核心要点，有不懂的就查资料搞懂。我给自己定位还是Java工程师，所以Java体系是一定要做到心中有数的，很多东西没有常年的积累面试的时候很容易露馅，学习要对得起自己，不要骗人。
|
||||||
|
|
||||||
|
剩下的就是找平台和内推了，除了蚂蚁，头条和拼多多都是找人内推的，感谢蚂蚁面试官对我的欣赏，以后说不定会去蚂蚁咯😄。
|
||||||
|
|
||||||
|
平台：脉脉、GitHub、v2
|
||||||
|
|
||||||
|
## 蚂蚁金服
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
- 一面
|
||||||
|
- 二面
|
||||||
|
- 三面
|
||||||
|
- 四面
|
||||||
|
- 五面
|
||||||
|
- 小结
|
||||||
|
|
||||||
|
### 一面
|
||||||
|
|
||||||
|
一面就做了一道算法题，要求两小时内完成，给了长度为N的有重复元素的数组，要求输出第10大的数。典型的TopK问题，快排算法搞定。
|
||||||
|
|
||||||
|
算法题要注意的是合法性校验、边界条件以及异常的处理。另外，如果要写测试用例，一定要保证测试覆盖场景尽可能全。加上平时刷刷算法题，这种考核应该没问题的。
|
||||||
|
|
||||||
|
### 二面
|
||||||
|
|
||||||
|
- 自我介绍下呗
|
||||||
|
- 开源项目贡献过代码么？（Dubbo提过一个打印accesslog的bug算么）
|
||||||
|
- 目前在部门做什么，业务简单介绍下，内部有哪些系统，作用和交互过程说下
|
||||||
|
- Dubbo踩过哪些坑，分别是怎么解决的？（说了异常处理时业务异常捕获的问题，自定义了一个异常拦截器）
|
||||||
|
- 开始进入正题，说下你对线程安全的理解（多线程访问同一个对象，如果不需要考虑额外的同步，调用对象的行为就可以获得正确的结果就是线程安全）
|
||||||
|
- 事务有哪些特性？（ACID）
|
||||||
|
- 怎么理解原子性？（同一个事务下，多个操作要么成功要么失败，不存在部分成功或者部分失败的情况）
|
||||||
|
- 乐观锁和悲观锁的区别？（悲观锁假定会发生冲突，访问的时候都要先获得锁，保证同一个时刻只有线程获得锁，读读也会阻塞；乐观锁假设不会发生冲突，只有在提交操作的时候检查是否有冲突）这两种锁在Java和MySQL分别是怎么实现的？（Java乐观锁通过CAS实现，悲观锁通过synchronize实现。mysql乐观锁通过MVCC，也就是版本实现，悲观锁可以通过select... for update加上排它锁）
|
||||||
|
- HashMap为什么不是线程安全的？（多线程操作无并发控制，顺便说了在扩容的时候多线程访问时会造成死锁，会形成一个环，不过扩容时多线程操作形成环的问题再JDK1.8已经解决，但多线程下使用HashMap还会有一些其他问题比如数据丢失，所以多线程下不应该使用HashMap，而应该使用ConcurrentHashMap）怎么让HashMap变得线程安全？(Collections的synchronize方法包装一个线程安全的Map，或者直接用ConcurrentHashMap)两者的区别是什么？（前者直接在put和get方法加了synchronize同步，后者采用了分段锁以及CAS支持更高的并发）
|
||||||
|
- jdk1.8对ConcurrentHashMap做了哪些优化？（插入的时候如果数组元素使用了红黑树，取消了分段锁设计，synchronize替代了Lock锁）为什么这样优化？（避免冲突严重时链表多长，提高查询效率，时间复杂度从O(N)提高到O(logN)）
|
||||||
|
- redis主从机制了解么？怎么实现的？
|
||||||
|
- 有过GC调优的经历么？（有点虚，答得不是很好）
|
||||||
|
- 有什么想问的么？
|
||||||
|
|
||||||
|
### 三面
|
||||||
|
|
||||||
|
- 简单自我介绍下
|
||||||
|
- 监控系统怎么做的，分为哪些模块，模块之间怎么交互的？用的什么数据库？（MySQL）使用什么存储引擎，为什么使用InnnoDB？(支持事务、聚簇索引、MVCC)
|
||||||
|
- 订单表有做拆分么，怎么拆的？(垂直拆分和水平拆分)
|
||||||
|
- 水平拆分后查询过程描述下
|
||||||
|
- 如果落到某个分片的数据很大怎么办？(按照某种规则，比如哈希取模、range，将单张表拆分为多张表)
|
||||||
|
- 哈希取模会有什么问题么？(有的，数据分布不均，扩容缩容相对复杂 )
|
||||||
|
- 分库分表后怎么解决读写压力？(一主多从、多主多从)
|
||||||
|
- 拆分后主键怎么保证惟一？(UUID、Snowflake算法)
|
||||||
|
- Snowflake生成的ID是全局递增唯一么？(不是，只是全局唯一，单机递增)
|
||||||
|
- 怎么实现全局递增的唯一ID？(讲了TDDL的一次取一批ID，然后再本地慢慢分配的做法)
|
||||||
|
- Mysql的索引结构说下(说了B+树，B+树可以对叶子结点顺序查找，因为叶子结点存放了数据结点且有序)
|
||||||
|
- 主键索引和普通索引的区别(主键索引的叶子结点存放了整行记录，普通索引的叶子结点存放了主键ID，查询的时候需要做一次回表查询)一定要回表查询么？(不一定，当查询的字段刚好是索引的字段或者索引的一部分，就可以不用回表，这也是索引覆盖的原理)
|
||||||
|
- 你们系统目前的瓶颈在哪里？
|
||||||
|
- 你打算怎么优化？简要说下你的优化思路
|
||||||
|
- 有什么想问我么？
|
||||||
|
|
||||||
|
### 四面
|
||||||
|
|
||||||
|
- 介绍下自己
|
||||||
|
- 为什么要做逆向？
|
||||||
|
- 怎么理解微服务？
|
||||||
|
- 服务治理怎么实现的？(说了限流、压测、监控等模块的实现)
|
||||||
|
- 这个不是中间件做的事么，为什么你们部门做？(当时没有单独的中间件团队，微服务刚搞不久，需要进行监控和性能优化)
|
||||||
|
- 说说Spring的生命周期吧
|
||||||
|
- 说说GC的过程(说了young gc和full gc的触发条件和回收过程以及对象创建的过程)
|
||||||
|
- CMS GC有什么问题？(并发清除算法，浮动垃圾，短暂停顿)
|
||||||
|
- 怎么避免产生浮动垃圾？(记得有个VM参数设置可以让扫描新生代之前进行一次young gc，但是因为gc是虚拟机自动调度的，所以不保证一定执行。但是还有参数可以让虚拟机强制执行一次young gc)
|
||||||
|
- 强制young gc会有什么问题？(STW停顿时间变长)
|
||||||
|
- 知道G1么？(了解一点 )
|
||||||
|
- 回收过程是怎么样的？(young gc、并发阶段、混合阶段、full gc，说了Remember Set)
|
||||||
|
- 你提到的Remember Set底层是怎么实现的？
|
||||||
|
- 有什么想问的么？
|
||||||
|
|
||||||
|
### 五面
|
||||||
|
|
||||||
|
五面是HRBP面的，和我提前预约了时间，主要聊了之前在蚂蚁的实习经历、部门在做的事情、职业发展、福利待遇等。阿里面试官确实是具有一票否决权的，很看重你的价值观是否match，一般都比较喜欢皮实的候选人。HR面一定要诚实，不要说谎，只要你说谎HR都会去证实，直接cut了。
|
||||||
|
|
||||||
|
- 之前蚂蚁实习三个月怎么不留下来？
|
||||||
|
- 实习的时候主管是谁？
|
||||||
|
- 实习做了哪些事情？（尼玛这种也问？）
|
||||||
|
- 你对技术怎么看？平时使用什么技术栈？（阿里HR真的是既当爹又当妈，😂）
|
||||||
|
- 最近有在研究什么东西么
|
||||||
|
- 你对SRE怎么看
|
||||||
|
- 对待遇有什么预期么
|
||||||
|
|
||||||
|
最后HR还对我说目前稳定性保障部挺缺人的，希望我尽快回复。
|
||||||
|
|
||||||
|
### 小结
|
||||||
|
|
||||||
|
蚂蚁面试比较重视基础，所以Java那些基本功一定要扎实。蚂蚁的工作环境还是挺赞的，因为我面的是稳定性保障部门，还有许多单独的小组，什么三年1班，很有青春的感觉。面试官基本水平都比较高，基本都P7以上，除了基础还问了不少架构设计方面的问题，收获还是挺大的。
|
||||||
|
|
||||||
|
## 拼多多
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
- 面试前
|
||||||
|
- 一面
|
||||||
|
- 二面
|
||||||
|
- 三面
|
||||||
|
- 小结
|
||||||
|
|
||||||
|
### 面试前
|
||||||
|
|
||||||
|
面完蚂蚁后，早就听闻拼多多这个独角兽，决定也去面一把。首先我在脉脉找了一个拼多多的HR，加了微信聊了下，发了简历便开始我的拼多多面试之旅。这里要非常感谢拼多多HR小姐姐，从面试内推到offer确认一直都在帮我，人真的很nice。
|
||||||
|
|
||||||
|
### 一面
|
||||||
|
|
||||||
|
- 为啥蚂蚁只待了三个月？没转正？(转正了，解释了一通。。。)
|
||||||
|
- Java中的HashMap、TreeMap解释下？(TreeMap红黑树，有序，HashMap无序，数组+链表)
|
||||||
|
- TreeMap查询写入的时间复杂度多少？(O(logN))
|
||||||
|
- HashMap多线程有什么问题？(线程安全，死锁)怎么解决？( jdk1.8用了synchronize + CAS，扩容的时候通过CAS检查是否有修改，是则重试)重试会有什么问题么？(CAS（Compare And Swap）是比较和交换，不会导致线程阻塞，但是因为重试是通过自旋实现的，所以仍然会占用CPU时间，还有ABA的问题)怎么解决？(超时，限定自旋的次数，ABA可以通过原理变量AtomicStampedReference解决，原理利用版本号进行比较)超过重试次数如果仍然失败怎么办？(synchronize互斥锁)
|
||||||
|
- CAS和synchronize有什么区别？都用synchronize不行么？(CAS是乐观锁，不需要阻塞，硬件级别实现的原子性；synchronize会阻塞，JVM级别实现的原子性。使用场景不同，线程冲突严重时CAS会造成CPU压力过大，导致吞吐量下降，synchronize的原理是先自旋然后阻塞，线程冲突严重仍然有较高的吞吐量，因为线程都被阻塞了，不会占用CPU
|
||||||
|
)
|
||||||
|
- 如果要保证线程安全怎么办？(ConcurrentHashMap)
|
||||||
|
- ConcurrentHashMap怎么实现线程安全的？(分段锁)
|
||||||
|
- get需要加锁么，为什么？(不用，volatile关键字)
|
||||||
|
- volatile的作用是什么？(保证内存可见性)
|
||||||
|
- 底层怎么实现的？(说了主内存和工作内存，读写内存屏障，happen-before，并在纸上画了线程交互图)
|
||||||
|
- 在多核CPU下，可见性怎么保证？(思考了一会，总线嗅探技术)
|
||||||
|
- 聊项目，系统之间是怎么交互的？
|
||||||
|
- 系统并发多少，怎么优化？
|
||||||
|
- 给我一张纸，画了一个九方格，都填了数字，给一个M*N矩阵，从1开始逆时针打印这M*N个数，要求时间复杂度尽可能低（内心OS：之前貌似碰到过这题，最优解是怎么实现来着）思考中。。。
|
||||||
|
- 可以先说下你的思路(想起来了，说了什么时候要变换方向的条件，向右、向下、向左、向上，依此循环)
|
||||||
|
- 有什么想问我的？
|
||||||
|
|
||||||
|
### 二面
|
||||||
|
|
||||||
|
- 自我介绍下
|
||||||
|
- 手上还有其他offer么？(拿了蚂蚁的offer)
|
||||||
|
- 部门组织结构是怎样的？(这轮不是技术面么，不过还是老老实实说了)
|
||||||
|
- 系统有哪些模块，每个模块用了哪些技术，数据怎么流转的？（面试官有点秃顶，一看级别就很高）给了我一张纸，我在上面简单画了下系统之间的流转情况
|
||||||
|
- 链路追踪的信息是怎么传递的？(RpcContext的attachment，说了Span的结构:parentSpanId + curSpanId)
|
||||||
|
- SpanId怎么保证唯一性？(UUID，说了下内部的定制改动)
|
||||||
|
- RpcContext是在什么维度传递的？(线程)
|
||||||
|
- Dubbo的远程调用怎么实现的？(讲了读取配置、拼装url、创建Invoker、服务导出、服务注册以及消费者通过动态代理、filter、获取Invoker列表、负载均衡等过程（哗啦啦讲了10多分钟），我可以喝口水么)
|
||||||
|
- Spring的单例是怎么实现的？(单例注册表)
|
||||||
|
- 为什么要单独实现一个服务治理框架？(说了下内部刚搞微服务不久，主要对服务进行一些监控和性能优化)
|
||||||
|
- 谁主导的？内部还在使用么？
|
||||||
|
- 逆向有想过怎么做成通用么？
|
||||||
|
- 有什么想问的么？
|
||||||
|
|
||||||
|
### 三面
|
||||||
|
|
||||||
|
二面老大面完后就直接HR面了，主要问了些职业发展、是否有其他offer、以及入职意向等问题，顺便说了下公司的福利待遇等，都比较常规啦。不过要说的是手上有其他offer或者大厂经历会有一定加分。
|
||||||
|
|
||||||
|
### 小结
|
||||||
|
|
||||||
|
拼多多的面试流程就简单许多，毕竟是一个成立三年多的公司。面试难度中规中矩，只要基础扎实应该不是问题。但不得不说工作强度很大，开始面试前HR就提前和我确认能否接受这样强度的工作，想来的老铁还是要做好准备
|
||||||
|
|
||||||
|
## 字节跳动
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
- 面试前
|
||||||
|
- 一面
|
||||||
|
- 二面
|
||||||
|
- 小结
|
||||||
|
|
||||||
|
### 面试前
|
||||||
|
|
||||||
|
头条的面试是三家里最专业的，每次面试前有专门的HR和你约时间，确定OK后再进行面试。每次都是通过视频面试，因为都是之前都是电话面或现场面，所以视频面试还是有点不自然。也有人觉得视频面试体验很赞，当然萝卜青菜各有所爱。最坑的二面的时候对方面试官的网络老是掉线，最后很冤枉的挂了（当然有一些点答得不好也是原因之一）。所以还是有点遗憾的。
|
||||||
|
|
||||||
|
### 一面
|
||||||
|
|
||||||
|
- 先自我介绍下
|
||||||
|
- 聊项目，逆向系统是什么意思
|
||||||
|
- 聊项目，逆向系统用了哪些技术
|
||||||
|
- 线程池的线程数怎么确定？
|
||||||
|
- 如果是IO操作为主怎么确定？
|
||||||
|
- 如果计算型操作又怎么确定？
|
||||||
|
- Redis熟悉么，了解哪些数据结构?(说了zset) zset底层怎么实现的?(跳表)
|
||||||
|
- 跳表的查询过程是怎么样的，查询和插入的时间复杂度?(说了先从第一层查找，不满足就下沉到第二层找，因为每一层都是有序的，写入和插入的时间复杂度都是O(logN))
|
||||||
|
- 红黑树了解么，时间复杂度?(说了是N叉平衡树，O(logN))
|
||||||
|
- 既然两个数据结构时间复杂度都是O(logN)，zset为什么不用红黑树(跳表实现简单，踩坑成本低，红黑树每次插入都要通过旋转以维持平衡，实现复杂)
|
||||||
|
- 点了点头，说下Dubbo的原理?(说了服务注册与发布以及消费者调用的过程)踩过什么坑没有？（说了dubbo异常处理的和打印accesslog的问题）
|
||||||
|
- CAS了解么？（说了CAS的实现）还了解其他同步机制么？（说了synchronize以及两者的区别，一个乐观锁，一个悲观锁）
|
||||||
|
- 那我们做一道题吧，数组A，2*n个元素，n个奇数、n个偶数，设计一个算法，使得数组奇数下标位置放置的都是奇数，偶数下标位置放置的都是偶数
|
||||||
|
- 先说下你的思路（从0下标开始遍历，如果是奇数下标判断该元素是否奇数，是则跳过，否则从该位置寻找下一个奇数）
|
||||||
|
- 下一个奇数？怎么找？（有点懵逼，思考中。。）
|
||||||
|
- 有思路么？（仍然是先遍历一次数组，并对下标进行判断，如果下标属性和该位置元素不匹配从当前下标的下一个遍历数组元素，然后替换）
|
||||||
|
- 你这样时间复杂度有点高，如果要求O(N)要怎么做（思考一会，答道“定义两个指针，分别从下标0和1开始遍历，遇见奇数位是是偶数和偶数位是奇数就停下，交换内容”）
|
||||||
|
- 时间差不多了，先到这吧。你有什么想问我的？
|
||||||
|
|
||||||
|
### 二面
|
||||||
|
|
||||||
|
- 面试官和蔼很多，你先介绍下自己吧
|
||||||
|
- 你对服务治理怎么理解的？
|
||||||
|
- 项目中的限流怎么实现的？（Guava ratelimiter，令牌桶算法）
|
||||||
|
- 具体怎么实现的？（要点是固定速率且令牌数有限）
|
||||||
|
- 如果突然很多线程同时请求令牌，有什么问题？（导致很多请求积压，线程阻塞）
|
||||||
|
- 怎么解决呢？（可以把积压的请求放到消息队列，然后异步处理）
|
||||||
|
- 如果不用消息队列怎么解决？（说了RateLimiter预消费的策略）
|
||||||
|
- 分布式追踪的上下文是怎么存储和传递的？（ThreadLocal + spanId，当前节点的spanId作为下个节点的父spanId）
|
||||||
|
- Dubbo的RpcContext是怎么传递的？（ThreadLocal）主线程的ThreadLocal怎么传递到线程池？（说了先在主线程通过ThreadLocal的get方法拿到上下文信息，在线程池创建新的ThreadLocal并把之前获取的上下文信息设置到ThreadLocal中。这里要注意的线程池创建的ThreadLocal要在finally中手动remove，不然会有内存泄漏的问题）
|
||||||
|
- 你说的内存泄漏具体是怎么产生的？（说了ThreadLocal的结构，主要分两种场景：主线程仍然对ThreadLocal有引用和主线程不存在对ThreadLocal的引用。第一种场景因为主线程仍然在运行，所以还是有对ThreadLocal的引用，那么ThreadLocal变量的引用和value是不会被回收的。第二种场景虽然主线程不存在对ThreadLocal的引用，且该引用是弱引用，所以会在gc的时候被回收，但是对用的value不是弱引用，不会被内存回收，仍然会造成内存泄漏）
|
||||||
|
- 线程池的线程是不是必须手动remove才可以回收value？（是的，因为线程池的核心线程是一直存在的，如果不清理，那么核心线程的threadLocals变量会一直持有ThreadLocal变量）
|
||||||
|
- 那你说的内存泄漏是指主线程还是线程池？（主线程 ）
|
||||||
|
- 可是主线程不是都退出了，引用的对象不应该会主动回收么？（面试官和内存泄漏杠上了），沉默了一会。。。
|
||||||
|
- 那你说下SpringMVC不同用户登录的信息怎么保证线程安全的？（刚才解释的有点懵逼，一下没反应过来，居然回答成锁了。大脑有点晕了，此时已经一个小时过去了，感觉情况不妙。。。）
|
||||||
|
- 这个直接用ThreadLocal不就可以么，你见过SpringMVC有锁实现的代码么？（有点晕菜。。。）
|
||||||
|
- 我们聊聊mysql吧，说下索引结构（说了B+树）
|
||||||
|
- 为什么使用B+树？（ 说了查询效率高，O(logN)，可以充分利用磁盘预读的特性，多叉树，深度小，叶子结点有序且存储数据）
|
||||||
|
- 什么是索引覆盖？（忘记了。。。 ）
|
||||||
|
- Java为什么要设计双亲委派模型？
|
||||||
|
- 什么时候需要自定义类加载器？
|
||||||
|
- 我们做一道题吧，手写一个对象池
|
||||||
|
- 有什么想问我的么？（感觉我很多点都没答好，是不是挂了（结果真的是） ）
|
||||||
|
|
||||||
|
### 小结
|
||||||
|
|
||||||
|
头条的面试确实很专业，每次面试官会提前给你发一个视频链接，然后准点开始面试，而且考察的点都比较全。
|
||||||
|
|
||||||
|
面试官都有一个特点，会抓住一个值得深入的点或者你没说清楚的点深入下去直到你把这个点讲清楚，不然面试官会觉得你并没有真正理解。二面面试官给了我一点建议，研究技术的时候一定要去研究产生的背景，弄明白在什么场景解决什么特定的问题，其实很多技术内部都是相通的。很诚恳，还是很感谢这位面试官大大。
|
||||||
|
|
||||||
|
## 总结
|
||||||
|
|
||||||
|
从年前开始面试到头条面完大概一个多月的时间，真的有点身心俱疲的感觉。最后拿到了拼多多、蚂蚁的offer，还是蛮幸运的。头条的面试对我帮助很大，再次感谢面试官对我的诚恳建议，以及拼多多的HR对我的啰嗦的问题详细解答。
|
||||||
|
|
||||||
|
这里要说的是面试前要做好两件事：简历和自我介绍，简历要好好回顾下自己做的一些项目，然后挑几个亮点项目。自我介绍基本每轮面试都有，所以最好提前自己练习下，想好要讲哪些东西，分别怎么讲。此外，简历提到的技术一定是自己深入研究过的，没有深入研究也最好找点资料预热下，不打无准备的仗。
|
||||||
|
|
||||||
|
**这些年看过的书**：
|
||||||
|
|
||||||
|
《Effective Java》、《现代操作系统》、《TCP/IP详解：卷一》、《代码整洁之道》、《重构》、《Java程序性能优化》、《Spring实战》、《Zookeeper》、《高性能MySQL》、《亿级网站架构核心技术》、《可伸缩服务架构》、《Java编程思想》
|
||||||
|
|
||||||
|
说实话这些书很多只看了一部分，我通常会带着问题看书，不然看着看着就睡着了，简直是催眠良药😅。
|
||||||
|
|
||||||
|
|
||||||
|
最后，附一张自己面试前准备的脑图：
|
||||||
|
|
||||||
|
链接:https://pan.baidu.com/s/1o2l1tuRakBEP0InKEh4Hzw 密码:300d
|
||||||
|
|
||||||
|
全文完。
|
||||||
@ -186,7 +186,7 @@ Thread类中包含的成员变量代表了线程的某些优先级。如**Thread
|
|||||||
这是另一个非常经典的java多线程面试问题，而且在面试中会经常被问到。很简单，但是很多人都会答不上来！
|
这是另一个非常经典的java多线程面试问题，而且在面试中会经常被问到。很简单，但是很多人都会答不上来！
|
||||||
|
|
||||||
new一个Thread，线程进入了新建状态;调用start()方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。
|
new一个Thread，线程进入了新建状态;调用start()方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。
|
||||||
start()会执行线程的相应准备工作，然后自动执行run()方法的内容，这是真正的多线程工作。 而直接执行run()方法，会把run方法当成一个mian线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。
|
start()会执行线程的相应准备工作，然后自动执行run()方法的内容，这是真正的多线程工作。 而直接执行run()方法，会把run方法当成一个main线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。
|
||||||
|
|
||||||
**总结： 调用start方法方可启动线程并使线程进入就绪状态，而run方法只是thread的一个普通方法调用，还是在主线程里执行。**
|
**总结： 调用start方法方可启动线程并使线程进入就绪状态，而run方法只是thread的一个普通方法调用，还是在主线程里执行。**
|
||||||
|
|
||||||
|
|||||||
@ -1,39 +1,60 @@
|
|||||||
# 程序员的简历就该这样写
|
<!-- TOC -->
|
||||||
|
|
||||||
### 1 前言
|
- [程序员简历就该这样写](#程序员简历就该这样写)
|
||||||
<font color="red">一份好的简历可以在整个申请面试以及面试过程中起到非常好的作用。</font> 在不夸大自己能力的情况下，写出一份好的简历也是一项很棒的能力。
|
- [为什么说简历很重要？](#为什么说简历很重要)
|
||||||
|
- [先从面试前来说](#先从面试前来说)
|
||||||
|
- [再从面试中来说](#再从面试中来说)
|
||||||
|
- [下面这几点你必须知道](#下面这几点你必须知道)
|
||||||
|
- [必须了解的两大法则](#必须了解的两大法则)
|
||||||
|
- [STAR法则（Situation Task Action Result）](#star法则situation-task-action-result)
|
||||||
|
- [FAB 法则（Feature Advantage Benefit）](#fab-法则feature-advantage-benefit)
|
||||||
|
- [项目经历怎么写？](#项目经历怎么写)
|
||||||
|
- [专业技能该怎么写？](#专业技能该怎么写)
|
||||||
|
- [排版注意事项](#排版注意事项)
|
||||||
|
- [其他的一些小tips](#其他的一些小tips)
|
||||||
|
- [推荐的工具/网站](#推荐的工具网站)
|
||||||
|
|
||||||
### 2 为什么说简历很重要？
|
<!-- /TOC -->
|
||||||
|
|
||||||
#### 2.1 先从面试前来说
|
# 程序员简历就该这样写
|
||||||
|
|
||||||
假如你是网申，你的简历必然会经过HR的筛选，一张简历HR可能也就花费10秒钟看一下，然后HR就会决定你这一关是Fail还是Pass。
|
本篇文章除了教大家用Markdown如何写一份程序员专属的简历，后面还会给大家推荐一些不错的用来写Markdown简历的软件或者网站，以及如何优雅的将Markdown格式转变为PDF格式或者其他格式。
|
||||||
|
|
||||||
假如你是内推，如果你的简历没有什么优势的话，就算是内推你的人再用心，也无能为力。
|
推荐大家使用Markdown语法写简历，然后再将Markdown格式转换为PDF格式后进行简历投递。
|
||||||
|
|
||||||
|
如果你对Markdown语法不太了解的话，可以花半个小时简单看一下Markdown语法说明: http://www.markdown.cn 。
|
||||||
|
|
||||||
|
## 为什么说简历很重要？
|
||||||
|
|
||||||
|
一份好的简历可以在整个申请面试以及面试过程中起到非常好的作用。 在不夸大自己能力的情况下，写出一份好的简历也是一项很棒的能力。为什么说简历很重要呢?
|
||||||
|
|
||||||
|
### 先从面试前来说
|
||||||
|
|
||||||
|
- 假如你是网申，你的简历必然会经过HR的筛选，一张简历HR可能也就花费10秒钟看一下，然后HR就会决定你这一关是Fail还是Pass。
|
||||||
|
- 假如你是内推，如果你的简历没有什么优势的话，就算是内推你的人再用心，也无能为力。
|
||||||
|
|
||||||
另外，就算你通过了筛选，后面的面试中，面试官也会根据你的简历来判断你究竟是否值得他花费很多时间去面试。
|
另外，就算你通过了筛选，后面的面试中，面试官也会根据你的简历来判断你究竟是否值得他花费很多时间去面试。
|
||||||
|
|
||||||
所以，简历就像是我们的一个门面一样，它在很大程度上决定了你能否进入到下一轮的面试中。
|
所以，简历就像是我们的一个门面一样，它在很大程度上决定了你能否进入到下一轮的面试中。
|
||||||
|
|
||||||
#### 2.2 再从面试中来说
|
### 再从面试中来说
|
||||||
|
|
||||||
我发现大家比较喜欢看面经 ，这点无可厚非，但是大部分面经都没告诉你很多问题都是在特定条件下才问的。举个简单的例子：一般情况下你的简历上注明你会的东西才会被问到（Java、数据结构、网络、算法这些基础是每个人必问的），比如写了你会 redis，那面试官就很大概率会问你 redis 的一些问题。比如：redis的常见数据类型及应用场景、redis是单线程为什么还这么快、 redis 和 memcached 的区别、redis 内存淘汰机制等等。
|
我发现大家比较喜欢看面经 ，这点无可厚非，但是大部分面经都没告诉你很多问题都是在特定条件下才问的。举个简单的例子：一般情况下你的简历上注明你会的东西才会被问到（Java、数据结构、网络、算法这些基础是每个人必问的），比如写了你会 redis,那面试官就很大概率会问你 redis 的一些问题。比如：redis的常见数据类型及应用场景、redis是单线程为什么还这么快、 redis 和 memcached 的区别、redis 内存淘汰机制等等。
|
||||||
|
|
||||||
所以，首先，你要明确的一点是：**你不会的东西就不要写在简历上**。另外，**你要考虑你该如何才能让你的亮点在简历中凸显出来**，比如：你在某某项目做了什么事情解决了什么问题（只要有项目就一定有要解决的问题）、你的某一个项目里使用了什么技术后整体性能和并发量提升了很多等等。
|
所以，首先，你要明确的一点是：**你不会的东西就不要写在简历上**。另外，**你要考虑你该如何才能让你的亮点在简历中凸显出来**，比如：你在某某项目做了什么事情解决了什么问题（只要有项目就一定有要解决的问题）、你的某一个项目里使用了什么技术后整体性能和并发量提升了很多等等。
|
||||||
|
|
||||||
面试和工作是两回事，聪明的人会把面试官往自己擅长的领域领，其他人则被面试官牵着鼻子走。虽说面试和工作是两回事，但是你要想要获得自己满意的 offer ，你自身的实力必须要强。
|
面试和工作是两回事，聪明的人会把面试官往自己擅长的领域领，其他人则被面试官牵着鼻子走。虽说面试和工作是两回事，但是你要想要获得自己满意的 offer ，你自身的实力必须要强。
|
||||||
|
|
||||||
### 3 下面这几点你必须知道
|
## 下面这几点你必须知道
|
||||||
|
|
||||||
1. 大部分公司的HR都说我们不看重学历（骗你的！），但是如果你的学校不出众的话，很难在一堆简历中脱颖而出，除非你的简历上有特别的亮点，比如：某某大厂的实习经历、获得了某某大赛的奖等等。
|
1. 大部分公司的HR都说我们不看重学历（骗你的！），但是如果你的学校不出众的话，很难在一堆简历中脱颖而出，除非你的简历上有特别的亮点，比如：某某大厂的实习经历、获得了某某大赛的奖等等。
|
||||||
2. **大部分应届生找工作的硬伤是没有工作经验或实习经历，所以如果你是应届生就不要错过秋招和春招。一旦错过，你后面就极大可能会面临社招，这个时候没有工作经验的你可能就会面临各种碰壁，导致找不到一个好的工作**
|
2. **大部分应届生找工作的硬伤是没有工作经验或实习经历，所以如果你是应届生就不要错过秋招和春招。一旦错过，你后面就极大可能会面临社招，这个时候没有工作经验的你可能就会面临各种碰壁，导致找不到一个好的工作**
|
||||||
3. **写在简历上的东西一定要慎重，这是面试官大量提问的地方；**
|
3. **写在简历上的东西一定要慎重，这是面试官大量提问的地方；**
|
||||||
4. **将自己的项目经历完美的展示出来非常重要。**
|
4. **将自己的项目经历完美的展示出来非常重要。**
|
||||||
|
|
||||||
### 4 必须了解的两大法则
|
## 必须了解的两大法则
|
||||||
|
|
||||||
|
### STAR法则（Situation Task Action Result）
|
||||||
**①STAR法则（Situation Task Action Result）：**
|
|
||||||
|
|
||||||
- **Situation：** 事情是在什么情况下发生；
|
- **Situation：** 事情是在什么情况下发生；
|
||||||
- **Task:：** 你是如何明确你的任务的；
|
- **Task:：** 你是如何明确你的任务的；
|
||||||
@ -42,14 +63,7 @@
|
|||||||
|
|
||||||
简而言之，STAR法则，就是一种讲述自己故事的方式，或者说，是一个清晰、条理的作文模板。不管是什么，合理熟练运用此法则，可以轻松的对面试官描述事物的逻辑方式，表现出自己分析阐述问题的清晰性、条理性和逻辑性。
|
简而言之，STAR法则，就是一种讲述自己故事的方式，或者说，是一个清晰、条理的作文模板。不管是什么，合理熟练运用此法则，可以轻松的对面试官描述事物的逻辑方式，表现出自己分析阐述问题的清晰性、条理性和逻辑性。
|
||||||
|
|
||||||
下面这段内容摘自百度百科，我觉得写的非常不错：
|
### FAB 法则（Feature Advantage Benefit）
|
||||||
|
|
||||||
> STAR法则，500强面试题回答时的技巧法则，备受面试者成功者和500强HR的推崇。
|
|
||||||
由于这个法则被广泛应用于面试问题的回答，尽管我们还在写简历阶段，但是，写简历时能把面试的问题就想好，会使自己更加主动和自信，做到简历，面试关联性，逻辑性强，不至于在一个月后去面试，却把简历里的东西都忘掉了（更何况有些朋友会稍微夸大简历内容）
|
|
||||||
在我们写简历时，每个人都要写上自己的工作经历，活动经历，想必每一个同学，都会起码花上半天甚至更长的时间去搜寻脑海里所有有关的经历，争取找出最好的东西写在简历上。
|
|
||||||
但是此时，我们要注意了，简历上的任何一个信息点都有可能成为日后面试时的重点提问对象，所以说，不能只管写上让自己感觉最牛的经历就完事了，要想到今后，在面试中，你所写的经历万一被面试官问到，你真的能回答得流利，顺畅，且能通过这段经历，证明自己正是适合这个职位的人吗？
|
|
||||||
|
|
||||||
**②FAB 法则（Feature Advantage Benefit）：**
|
|
||||||
|
|
||||||
- **Feature：** 是什么；
|
- **Feature：** 是什么；
|
||||||
- **Advantage：** 比别人好在哪些地方；
|
- **Advantage：** 比别人好在哪些地方；
|
||||||
@ -57,16 +71,17 @@
|
|||||||
|
|
||||||
简单来说，这个法则主要是让你的面试官知道你的优势、招了你之后对公司有什么帮助。
|
简单来说，这个法则主要是让你的面试官知道你的优势、招了你之后对公司有什么帮助。
|
||||||
|
|
||||||
### 5 项目经历怎么写？
|
## 项目经历怎么写？
|
||||||
|
|
||||||
简历上有一两个项目经历很正常，但是真正能把项目经历很好的展示给面试官的非常少。对于项目经历大家可以考虑从如下几点来写：
|
简历上有一两个项目经历很正常，但是真正能把项目经历很好的展示给面试官的非常少。对于项目经历大家可以考虑从如下几点来写：
|
||||||
|
|
||||||
1. 对项目整体设计的一个感受
|
1. 对项目整体设计的一个感受
|
||||||
2. 在这个项目中你负责了什么、做了什么、担任了什么角色
|
2. 在这个项目中你负责了什么、做了什么、担任了什么角色
|
||||||
3. 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用
|
3. 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用
|
||||||
4. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如：用 redis 做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。
|
4. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如:用redis做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。
|
||||||
|
|
||||||
|
## 专业技能该怎么写？
|
||||||
|
|
||||||
### 6 专业技能该怎么写？
|
|
||||||
先问一下你自己会什么，然后看看你意向的公司需要什么。一般HR可能并不太懂技术，所以他在筛选简历的时候可能就盯着你专业技能的关键词来看。对于公司有要求而你不会的技能，你可以花几天时间学习一下，然后在简历上可以写上自己了解这个技能。比如你可以这样写(下面这部分内容摘自我的简历，大家可以根据自己的情况做一些修改和完善)：
|
先问一下你自己会什么，然后看看你意向的公司需要什么。一般HR可能并不太懂技术，所以他在筛选简历的时候可能就盯着你专业技能的关键词来看。对于公司有要求而你不会的技能，你可以花几天时间学习一下，然后在简历上可以写上自己了解这个技能。比如你可以这样写(下面这部分内容摘自我的简历，大家可以根据自己的情况做一些修改和完善)：
|
||||||
|
|
||||||
- 计算机网络、数据结构、算法、操作系统等课内基础知识：掌握
|
- 计算机网络、数据结构、算法、操作系统等课内基础知识：掌握
|
||||||
@ -79,28 +94,28 @@
|
|||||||
- Zookeeper: 掌握
|
- Zookeeper: 掌握
|
||||||
- 常见消息队列: 掌握
|
- 常见消息队列: 掌握
|
||||||
- Linux：掌握
|
- Linux：掌握
|
||||||
- MySQL常见优化手段：掌握
|
- MySQL常见优化手段：掌握
|
||||||
- Spring Boot +Spring Cloud +Docker:了解
|
- Spring Boot +Spring Cloud +Docker:了解
|
||||||
- Hadoop 生态相关技术中的 HDFS、Storm、MapReduce、Hive、Hbase ：了解
|
- Hadoop 生态相关技术中的 HDFS、Storm、MapReduce、Hive、Hbase ：了解
|
||||||
- Python 基础、一些常见第三方库比如OpenCV、wxpy、wordcloud、matplotlib：熟悉
|
- Python 基础、一些常见第三方库比如OpenCV、wxpy、wordcloud、matplotlib：熟悉
|
||||||
|
|
||||||
### 7 开源程序员Markdown格式简历模板分享
|
## 排版注意事项
|
||||||
|
|
||||||
分享一个Github上开源的程序员简历模板。包括PHP程序员简历模板、iOS程序员简历模板、Android程序员简历模板、Web前端程序员简历模板、Java程序员简历模板、C/C++程序员简历模板、NodeJS程序员简历模板、架构师简历模板以及通用程序员简历模板 。
|
1. 尽量简洁，不要太花里胡哨；
|
||||||
Github地址：[https://github.com/geekcompany/ResumeSample](https://github.com/geekcompany/ResumeSample)
|
2. 一些技术名词不要弄错了大小写比如MySQL不要写成mysql，Java不要写成Java。这个在我看来还是比较忌讳的，所以一定要注意这个细节；
|
||||||
|
3. 中文和数字英文之间加上空格的话看起来会舒服一点；
|
||||||
|
|
||||||
|
## 其他的一些小tips
|
||||||
我的下面这篇文章讲了如何写一份Markdown格式的简历，另外，文中还提到了一种实现 Markdown 格式到PDF、HTML、JPEG这几种格式的转换方法。
|
|
||||||
|
|
||||||
[手把手教你用Markdown写一份高质量的简历](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484347&idx=1&sn=a986ea7e199871999a5257bd3ed78be1&chksm=fd9855dacaefdccc2c5d5f8f79c4aa1b608ad5b42936bccaefb99a850a2e6e8e2e910e1b3153&token=719595858&lang=zh_CN#rd)
|
|
||||||
|
|
||||||
### 8 其他的一些小tips
|
|
||||||
|
|
||||||
1. 尽量避免主观表述，少一点语义模糊的形容词，尽量要简洁明了，逻辑结构清晰。
|
1. 尽量避免主观表述，少一点语义模糊的形容词，尽量要简洁明了，逻辑结构清晰。
|
||||||
2. 注意排版（不需要花花绿绿的），尽量使用Markdown语法。
|
2. 如果自己有博客或者个人技术栈点的话，写上去会为你加分很多。
|
||||||
3. 如果自己有博客或者个人技术栈点的话，写上去会为你加分很多。
|
3. 如果自己的Github比较活跃的话，写上去也会为你加分很多。
|
||||||
4. 如果自己的Github比较活跃的话，写上去也会为你加分很多。
|
4. 注意简历真实性，一定不要写自己不会的东西，或者带有欺骗性的内容
|
||||||
5. 注意简历真实性，一定不要写自己不会的东西，或者带有欺骗性的内容
|
5. 项目经历建议以时间倒序排序，另外项目经历不在于多，而在于有亮点。
|
||||||
6. 项目经历建议以时间倒序排序，另外项目经历不在于多，而在于有亮点。
|
6. 如果内容过多的话，不需要非把内容压缩到一页，保持排版干净整洁就可以了。
|
||||||
7. 如果内容过多的话，不需要非把内容压缩到一页，保持排版干净整洁就可以了。
|
7. 简历最后最好能加上：“感谢您花时间阅读我的简历，期待能有机会和您共事。”这句话，显的你会很有礼貌。
|
||||||
8. 简历最后最好能加上：“感谢您花时间阅读我的简历，期待能有机会和您共事。”这句话，显的你会很有礼貌。
|
|
||||||
|
## 推荐的工具/网站
|
||||||
|
|
||||||
|
- 冷熊简历(MarkDown在线简历工具，可在线预览、编辑和生成PDF):<http://cv.ftqq.com/>
|
||||||
|
- Typora+[Java程序员简历模板](https://github.com/geekcompany/ResumeSample/blob/master/java.md)
|
||||||
|
|||||||
406
docs/java/Multithread/1并发编程基础知识.md
Normal file
406
docs/java/Multithread/1并发编程基础知识.md
Normal file
@ -0,0 +1,406 @@
|
|||||||
|
# Java 并发基础知识
|
||||||
|
|
||||||
|
Java 并发的基础知识，可能会在笔试中遇到，技术面试中也可能以并发知识环节提问的第一个问题出现。比如面试官可能会问你：“谈谈自己对于进程和线程的理解，两者的区别是什么？”
|
||||||
|
|
||||||
|
**本节思维导图：**
|
||||||
|
|
||||||
|
## 一 进程和线程
|
||||||
|
|
||||||
|
进程和线程的对比这一知识点由于过于基础，所以在面试中很少碰到，但是极有可能会在笔试题中碰到。
|
||||||
|
|
||||||
|
常见的提问形式是这样的：**“什么是线程和进程?，请简要描述线程与进程的关系、区别及优缺点？ ”**。
|
||||||
|
|
||||||
|
### 1.1. 何为进程?
|
||||||
|
|
||||||
|
进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。
|
||||||
|
|
||||||
|
在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。
|
||||||
|
|
||||||
|
如下图所示，在 windows 中通过查看任务管理器的方式，我们就可以清楚看到 window 当前运行的进程（.exe 文件的运行）。
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
### 1.2 何为线程?
|
||||||
|
|
||||||
|
线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的**堆**和**方法区**资源，但每个线程有自己的**程序计数器**、**虚拟机栈**和**本地方法栈**，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
|
||||||
|
|
||||||
|
Java 程序天生就是多线程程序，我们可以通过 JMX 来看一下一个普通的 Java 程序有哪些线程，代码如下。
|
||||||
|
|
||||||
|
```java
|
||||||
|
public class MultiThread {
|
||||||
|
public static void main(String[] args) {
|
||||||
|
// 获取 Java 线程管理 MXBean
|
||||||
|
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
|
||||||
|
// 不需要获取同步的 monitor 和 synchronizer 信息，仅获取线程和线程堆栈信息
|
||||||
|
ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
|
||||||
|
// 遍历线程信息，仅打印线程 ID 和线程名称信息
|
||||||
|
for (ThreadInfo threadInfo : threadInfos) {
|
||||||
|
System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
上述程序输出如下（输出内容可能不同，不用太纠结下面每个线程的作用，只用知道 main 线程执行 main 方法即可）：
|
||||||
|
|
||||||
|
```
|
||||||
|
[5] Attach Listener //添加事件
|
||||||
|
[4] Signal Dispatcher // 分发处理给 JVM 信号的线程
|
||||||
|
[3] Finalizer //调用对象 finalize 方法的线程
|
||||||
|
[2] Reference Handler //清除 reference 线程
|
||||||
|
[1] main //main 线程,程序入口
|
||||||
|
```
|
||||||
|
|
||||||
|
从上面的输出内容可以看出：**一个 Java 程序的运行是 main 线程和多个其他线程同时运行**。
|
||||||
|
|
||||||
|
### 1.3 从 JVM 角度说进程和线程之间的关系（重要）
|
||||||
|
|
||||||
|
#### 1.3.1 图解进程和线程的关系
|
||||||
|
|
||||||
|
下图是 Java 内存区域，通过下图我们从 JVM 的角度来说一下线程和进程之间的关系。如果你对 Java 内存区域 (运行时数据区) 这部分知识不太了解的话可以阅读一下我的这篇文章：[《可能是把 Java 内存区域讲的最清楚的一篇文章》](https://github.com/Snailclimb/JavaGuide/blob/master/Java 相关/可能是把 Java 内存区域讲的最清楚的一篇文章.md)
|
||||||
|
|
||||||
|
<div align="center">
|
||||||
|
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3Java 运行时数据区域 JDK1.8.png" width="600px"/>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
从上图可以看出：一个进程中可以有多个线程，多个线程共享进程的**堆**和**方法区 (JDK1.8 之后的元空间)**资源，但是每个线程有自己的**程序计数器**、**虚拟机栈** 和 **本地方法栈**。
|
||||||
|
|
||||||
|
下面来思考这样一个问题：为什么**程序计数器**、**虚拟机栈**和**本地方法栈**是线程私有的呢？为什么堆和方法区是线程共享的呢？
|
||||||
|
|
||||||
|
#### 1.3.2 程序计数器为什么是私有的?
|
||||||
|
|
||||||
|
程序计数器主要有下面两个作用：
|
||||||
|
|
||||||
|
1. 字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理。
|
||||||
|
2. 在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。
|
||||||
|
|
||||||
|
需要注意的是，如果执行的是 native 方法，那么程序计数器记录的是 undefined 地址，只有执行的是 Java 代码时程序计数器记录的才是下一条指令的地址。
|
||||||
|
|
||||||
|
所以，程序计数器私有主要是为了**线程切换后能恢复到正确的执行位置**。
|
||||||
|
|
||||||
|
#### 1.3.3 虚拟机栈和本地方法栈为什么是私有的?
|
||||||
|
|
||||||
|
- **虚拟机栈：**每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
|
||||||
|
- **本地方法栈：**和虚拟机栈所发挥的作用非常相似，区别是： **虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务。** 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。
|
||||||
|
|
||||||
|
所以，为了**保证线程中的局部变量不被别的线程访问到**，虚拟机栈和本地方法栈是线程私有的。
|
||||||
|
|
||||||
|
#### 1.3.4 一句话简单了解堆和方法区
|
||||||
|
|
||||||
|
堆和方法区是所有线程共享的资源，其中堆是进程中最大的一块内存，主要用于存放新创建的对象 (所有对象都在这里分配内存)，方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
|
||||||
|
|
||||||
|
## 二 多线程并发编程
|
||||||
|
|
||||||
|
### 2.1 并发与并行概念解读
|
||||||
|
|
||||||
|
- **并发：** 同一时间段，多个任务都在执行 (单位时间内不一定同时执行)；
|
||||||
|
- **并行：**单位时间内，多个任务同时执行。
|
||||||
|
|
||||||
|
### 2.2 为什么要使用多线程?
|
||||||
|
|
||||||
|
先从总体上来说：
|
||||||
|
|
||||||
|
- **从计算机底层来说：**线程可以比作是轻量级的进程，是程序执行的最小单位,线程间的切换和调度的成本远远小于进程。另外，多核 CPU 时代意味着多个线程可以同时运行，这减少了线程上下文切换的开销。
|
||||||
|
- **从当代互联网发展趋势来说：**现在的系统动不动就要求百万级甚至千万级的并发量，而多线程并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能。
|
||||||
|
|
||||||
|
再深入到计算机底层来探讨：
|
||||||
|
|
||||||
|
- **单核时代：** 在单核时代多线程主要是为了提高 CPU 和 IO 设备的综合利用率。举个例子：当只有一个线程的时候会导致 CPU 计算时，IO 设备空闲；进行 IO 操作时，CPU 空闲。我们可以简单地说这两者的利用率目前都是 50%左右。但是当有两个线程的时候就不一样了，当一个线程执行 CPU 计算时，另外一个线程可以进行 IO 操作，这样两个的利用率就可以在理想情况下达到 100%了。
|
||||||
|
- **多核时代:** 多核时代多线程主要是为了提高 CPU 利用率。举个例子：假如我们要计算一个复杂的任务，我们只用一个线程的话，CPU 只会一个 CPU 核心被利用到，而创建多个线程就可以让多个 CPU 核心被利用到，这样就提高了 CPU 的利用率。
|
||||||
|
|
||||||
|
### 2.3 使用多线程可能带来的问题
|
||||||
|
|
||||||
|
并发编程的目的就是为了能提高程序的执行效率提高程序运行速度，但是并发编程并不总是能提高程序运行速度的，而且并发编程可能会遇到很多问题，比如：内存泄漏、上下文切换、死锁还有受限于硬件和软件的资源闲置问题。
|
||||||
|
|
||||||
|
## 三 线程的创建与运行
|
||||||
|
|
||||||
|
前两种实际上很少使用，一般都是用线程池的方式比较多一点。
|
||||||
|
|
||||||
|
### 3.1 继承 Thread 类的方式
|
||||||
|
|
||||||
|
|
||||||
|
```java
|
||||||
|
public class MyThread extends Thread {
|
||||||
|
@Override
|
||||||
|
public void run() {
|
||||||
|
super.run();
|
||||||
|
System.out.println("MyThread");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
```
|
||||||
|
Run.java
|
||||||
|
|
||||||
|
```java
|
||||||
|
public class Run {
|
||||||
|
|
||||||
|
public static void main(String[] args) {
|
||||||
|
MyThread mythread = new MyThread();
|
||||||
|
mythread.start();
|
||||||
|
System.out.println("运行结束");
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
```
|
||||||
|
运行结果：
|
||||||
|
|
||||||
|
|
||||||
|
从上面的运行结果可以看出：线程是一个子任务，CPU 以不确定的方式，或者说是以随机的时间来调用线程中的 run 方法。
|
||||||
|
|
||||||
|
### 3.2 实现 Runnable 接口的方式
|
||||||
|
|
||||||
|
推荐实现 Runnable 接口方式开发多线程，因为 Java 单继承但是可以实现多个接口。
|
||||||
|
|
||||||
|
MyRunnable.java
|
||||||
|
|
||||||
|
```java
|
||||||
|
public class MyRunnable implements Runnable {
|
||||||
|
@Override
|
||||||
|
public void run() {
|
||||||
|
System.out.println("MyRunnable");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
Run.java
|
||||||
|
|
||||||
|
```java
|
||||||
|
public class Run {
|
||||||
|
|
||||||
|
public static void main(String[] args) {
|
||||||
|
Runnable runnable=new MyRunnable();
|
||||||
|
Thread thread=new Thread(runnable);
|
||||||
|
thread.start();
|
||||||
|
System.out.println("运行结束！");
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
```
|
||||||
|
运行结果：
|
||||||
|
|
||||||
|
|
||||||
|
### 3.3 使用线程池的方式
|
||||||
|
|
||||||
|
使用线程池的方式也是最推荐的一种方式，另外，《阿里巴巴 Java 开发手册》在第一章第六节并发处理这一部分也强调到“线程资源必须通过线程池提供，不允许在应用中自行显示创建线程”。这里就不给大家演示代码了，线程池这一节会详细介绍到这部分内容。
|
||||||
|
|
||||||
|
## 四 线程的生命周期和状态
|
||||||
|
|
||||||
|
Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态（图源《Java 并发编程艺术》4.1.4 节）。
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示（图源《Java 并发编程艺术》4.1.4 节）：
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
由上图可以看出：线程创建之后它将处于 **NEW（新建）** 状态，调用 `start()` 方法后开始运行，线程这时候处于 **READY（可运行）** 状态。可运行状态的线程获得了 CPU 时间片（timeslice）后就处于 **RUNNING（运行）** 状态。
|
||||||
|
|
||||||
|
> 操作系统隐藏 Java 虚拟机（JVM）中的 RUNNABLE 和 RUNNING 状态，它只能看到 RUNNABLE 状态（图源：[HowToDoInJava](https://howtodoinjava.com/)：[Java Thread Life Cycle and Thread States](https://howtodoinjava.com/java/multi-threading/java-thread-life-cycle-and-thread-states/)），所以 Java 系统一般将这两个状态统称为 **RUNNABLE（运行中）** 状态 。
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
当线程执行 `wait()`方法之后，线程进入 **WAITING（等待）**状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 **TIME_WAITING(超时等待)** 状态相当于在等待状态的基础上增加了超时限制，比如通过 `sleep（long millis）`方法或 `wait（long millis）`方法可以将 Java 线程置于 TIMED WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 **BLOCKED（阻塞）** 状态。线程在执行 Runnable 的` run() `方法之后将会进入到 **TERMINATED（终止）** 状态。
|
||||||
|
|
||||||
|
## 五 线程优先级
|
||||||
|
|
||||||
|
**理论上**来说系统会根据优先级来决定首先使哪个线程进入运行状态。当 CPU 比较闲的时候，设置线程优先级几乎不会有任何作用，而且很多操作系统压根不会不会理会你设置的线程优先级，所以不要让业务过度依赖于线程的优先级。
|
||||||
|
|
||||||
|
另外，**线程优先级具有继承特性**比如 A 线程启动 B 线程，则 B 线程的优先级和 A 是一样的。**线程优先级还具有随机性** 也就是说线程优先级高的不一定每一次都先执行完。
|
||||||
|
|
||||||
|
Thread 类中包含的成员变量代表了线程的某些优先级。如**Thread.MIN_PRIORITY（常数 1）**，**Thread.NORM_PRIORITY（常数 5）**,**Thread.MAX_PRIORITY（常数 10）**。其中每个线程的优先级都在**1** 到**10** 之间，在默认情况下优先级都是**Thread.NORM_PRIORITY（常数 5）**。
|
||||||
|
|
||||||
|
**一般情况下，不会对线程设定优先级别，更不会让某些业务严重地依赖线程的优先级别，比如权重，借助优先级设定某个任务的权重，这种方式是不可取的，一般定义线程的时候使用默认的优先级就好了。**
|
||||||
|
|
||||||
|
**相关方法：**
|
||||||
|
|
||||||
|
```java
|
||||||
|
public final void setPriority(int newPriority) //为线程设定优先级
|
||||||
|
public final int getPriority() //获取线程的优先级
|
||||||
|
```
|
||||||
|
**设置线程优先级方法源码：**
|
||||||
|
|
||||||
|
```java
|
||||||
|
public final void setPriority(int newPriority) {
|
||||||
|
ThreadGroup g;
|
||||||
|
checkAccess();
|
||||||
|
//线程游戏优先级不能小于 1 也不能大于 10，否则会抛出异常
|
||||||
|
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
|
||||||
|
throw new IllegalArgumentException();
|
||||||
|
}
|
||||||
|
//如果指定的线程优先级大于该线程所在线程组的最大优先级，那么该线程的优先级将设为线程组的最大优先级
|
||||||
|
if((g = getThreadGroup()) != null) {
|
||||||
|
if (newPriority > g.getMaxPriority()) {
|
||||||
|
newPriority = g.getMaxPriority();
|
||||||
|
}
|
||||||
|
setPriority0(priority = newPriority);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
```
|
||||||
|
|
||||||
|
## 六 守护线程和用户线程
|
||||||
|
|
||||||
|
**守护线程和用户线程简介:**
|
||||||
|
|
||||||
|
- **用户 (User) 线程：**运行在前台，执行具体的任务，如程序的主线程、连接网络的子线程等都是用户线程
|
||||||
|
- **守护 (Daemon) 线程：**运行在后台，为其他前台线程服务.也可以说守护线程是 JVM 中非守护线程的 **“佣人”**。一旦所有用户线程都结束运行，守护线程会随 JVM 一起结束工作.
|
||||||
|
|
||||||
|
main 函数所在的线程就是一个用户线程啊，main 函数启动的同时在 JVM 内部同时还启动了好多守护线程，比如垃圾回收线程。
|
||||||
|
|
||||||
|
**那么守护线程和用户线程有什么区别呢？**
|
||||||
|
|
||||||
|
比较明显的区别之一是用户线程结束，JVM 退出，不管这个时候有没有守护线程运行。而守护线程不会影响 JVM 的退出。
|
||||||
|
|
||||||
|
**注意事项：**
|
||||||
|
|
||||||
|
1. `setDaemon(true)`必须在`start（）`方法前执行，否则会抛出 `IllegalThreadStateException` 异常
|
||||||
|
2. 在守护线程中产生的新线程也是守护线程
|
||||||
|
3. 不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑
|
||||||
|
4. 守护 (Daemon) 线程中不能依靠 finally 块的内容来确保执行关闭或清理资源的逻辑。因为我们上面也说过了一旦所有用户线程都结束运行，守护线程会随 JVM 一起结束工作，所以守护 (Daemon) 线程中的 finally 语句块可能无法被执行。
|
||||||
|
|
||||||
|
## 七 上下文切换
|
||||||
|
|
||||||
|
多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。
|
||||||
|
|
||||||
|
概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换会这个任务时，可以再加载这个任务的状态。**任务从保存到再加载的过程就是一次上下文切换**。
|
||||||
|
|
||||||
|
上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。
|
||||||
|
|
||||||
|
Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。
|
||||||
|
|
||||||
|
## 八 线程死锁
|
||||||
|
|
||||||
|
### 认识线程死锁
|
||||||
|
|
||||||
|
多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
|
||||||
|
|
||||||
|
如下图所示，线程 A 持有资源 2，线程 B 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
下面通过一个例子来说明线程死锁,代码模拟了上图的死锁的情况 (代码来源于《并发编程之美》)：
|
||||||
|
|
||||||
|
```java
|
||||||
|
public class DeadLockDemo {
|
||||||
|
private static Object resource1 = new Object();//资源 1
|
||||||
|
private static Object resource2 = new Object();//资源 2
|
||||||
|
|
||||||
|
public static void main(String[] args) {
|
||||||
|
new Thread(() -> {
|
||||||
|
synchronized (resource1) {
|
||||||
|
System.out.println(Thread.currentThread() + "get resource1");
|
||||||
|
try {
|
||||||
|
Thread.sleep(1000);
|
||||||
|
} catch (InterruptedException e) {
|
||||||
|
e.printStackTrace();
|
||||||
|
}
|
||||||
|
System.out.println(Thread.currentThread() + "waiting get resource2");
|
||||||
|
synchronized (resource2) {
|
||||||
|
System.out.println(Thread.currentThread() + "get resource2");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}, "线程 1").start();
|
||||||
|
|
||||||
|
new Thread(() -> {
|
||||||
|
synchronized (resource2) {
|
||||||
|
System.out.println(Thread.currentThread() + "get resource2");
|
||||||
|
try {
|
||||||
|
Thread.sleep(1000);
|
||||||
|
} catch (InterruptedException e) {
|
||||||
|
e.printStackTrace();
|
||||||
|
}
|
||||||
|
System.out.println(Thread.currentThread() + "waiting get resource1");
|
||||||
|
synchronized (resource1) {
|
||||||
|
System.out.println(Thread.currentThread() + "get resource1");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}, "线程 2").start();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
Output
|
||||||
|
|
||||||
|
```
|
||||||
|
Thread[线程 1,5,main]get resource1
|
||||||
|
Thread[线程 2,5,main]get resource2
|
||||||
|
Thread[线程 1,5,main]waiting get resource2
|
||||||
|
Thread[线程 2,5,main]waiting get resource1
|
||||||
|
```
|
||||||
|
|
||||||
|
线程 A 通过 synchronized (resource1) 获得 resource1 的监视器锁，然后通过` Thread.sleep(1000);`让线程 A 休眠 1s 为的是让线程 B 得到执行然后获取到 resource2 的监视器锁。线程 A 和线程 B 休眠结束了都开始企图请求获取对方的资源，然后这两个线程就会陷入互相等待的状态，这也就产生了死锁。上面的例子符合产生死锁的四个必要条件。
|
||||||
|
|
||||||
|
学过操作系统的朋友都知道产生死锁必须具备以下四个条件：
|
||||||
|
|
||||||
|
1. 互斥条件：该资源任意一个时刻只由一个线程占用。
|
||||||
|
1. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
|
||||||
|
1. 不剥夺条件:线程已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
|
||||||
|
1. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
|
||||||
|
|
||||||
|
### 如何避免线程死锁?
|
||||||
|
|
||||||
|
我们只要破坏产生死锁的四个条件中的其中一个就可以了。
|
||||||
|
|
||||||
|
**破坏互斥条件**
|
||||||
|
|
||||||
|
这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。
|
||||||
|
|
||||||
|
**破坏请求与保持条件**
|
||||||
|
|
||||||
|
一次性申请所有的资源。
|
||||||
|
|
||||||
|
**破坏不剥夺条件**
|
||||||
|
|
||||||
|
占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
|
||||||
|
|
||||||
|
**破坏循环等待条件**
|
||||||
|
|
||||||
|
靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。
|
||||||
|
|
||||||
|
我们对线程 2 的代码修改成下面这样就不会产生死锁了。
|
||||||
|
|
||||||
|
```java
|
||||||
|
new Thread(() -> {
|
||||||
|
synchronized (resource1) {
|
||||||
|
System.out.println(Thread.currentThread() + "get resource1");
|
||||||
|
try {
|
||||||
|
Thread.sleep(1000);
|
||||||
|
} catch (InterruptedException e) {
|
||||||
|
e.printStackTrace();
|
||||||
|
}
|
||||||
|
System.out.println(Thread.currentThread() + "waiting get resource2");
|
||||||
|
synchronized (resource2) {
|
||||||
|
System.out.println(Thread.currentThread() + "get resource2");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}, "线程 2").start();
|
||||||
|
```
|
||||||
|
|
||||||
|
Output
|
||||||
|
|
||||||
|
```
|
||||||
|
Thread[线程 1,5,main]get resource1
|
||||||
|
Thread[线程 1,5,main]waiting get resource2
|
||||||
|
Thread[线程 1,5,main]get resource2
|
||||||
|
Thread[线程 2,5,main]get resource1
|
||||||
|
Thread[线程 2,5,main]waiting get resource2
|
||||||
|
Thread[线程 2,5,main]get resource2
|
||||||
|
|
||||||
|
Process finished with exit code 0
|
||||||
|
```
|
||||||
|
|
||||||
|
我们分析一下上面的代码为什么避免了死锁的发生?
|
||||||
|
|
||||||
|
线程 1 首先获得到 resource1 的监视器锁,这时候线程 2 就获取不到了。然后线程 1 再去获取 resource2 的监视器锁，可以获取到。然后线程 1 释放了对 resource1、resource2 的监视器锁的占用，线程 2 获取到就可以执行了。这样就破坏了破坏循环等待条件，因此避免了死锁。
|
||||||
|
|
||||||
|
## 参考
|
||||||
|
|
||||||
|
- 《Java 并发编程之美》
|
||||||
|
|
||||||
|
- 《Java 并发编程的艺术》
|
||||||
|
|
||||||
|
- https://howtodoinjava.com/java/multi-threading/java-thread-life-cycle-and-thread-states/
|
||||||
|
|
||||||
|
|
||||||
@ -1,269 +0,0 @@
|
|||||||
# Java 并发基础知识
|
|
||||||
|
|
||||||
Java 并发的基础知识，可能会在笔试中遇到，技术面试中也可能以并发知识环节提问的第一个问题出现。比如面试官可能会问你：“谈谈自己对于进程和线程的理解，两者的区别是什么？”
|
|
||||||
|
|
||||||
**本节思维导图：**
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
## 一 进程和线程
|
|
||||||
|
|
||||||
进程和线程的对比这一知识点由于过于基础，所以在面试中很少碰到，但是极有可能会在笔试题中碰到。
|
|
||||||
|
|
||||||
常见的提问形式是这样的：**“什么是线程和进程?，请简要描述线程与进程的关系、区别及优缺点？ ”**。
|
|
||||||
|
|
||||||
### 1.1. 何为进程?
|
|
||||||
|
|
||||||
进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。
|
|
||||||
|
|
||||||
在Java中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。
|
|
||||||
|
|
||||||
如下图所示，在 windows 中通过查看任务管理器的方式，我们就可以清楚看到 window 当前运行的进程（.exe文件的运行）。
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
### 1.2 何为线程?
|
|
||||||
|
|
||||||
线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的**堆**和**方法区**资源，但每个线程有自己的**程序计数器**、**虚拟机栈**和**本地方法栈**，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
|
|
||||||
|
|
||||||
Java 程序天生就是多线程程序，我们可以通过 JMX 来看一下一个普通的 Java 程序有哪些线程，代码如下。
|
|
||||||
|
|
||||||
```java
|
|
||||||
public class MultiThread {
|
|
||||||
public static void main(String[] args) {
|
|
||||||
// 获取Java线程管理MXBean
|
|
||||||
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
|
|
||||||
// 不需要获取同步的monitor和synchronizer信息，仅获取线程和线程堆栈信息
|
|
||||||
ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
|
|
||||||
// 遍历线程信息，仅打印线程ID和线程名称信息
|
|
||||||
for (ThreadInfo threadInfo : threadInfos) {
|
|
||||||
System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
上述程序输出如下（输出内容可能不同，不用太纠结下面每个线程的作用，只用知道 main 线程执行main方法即可）：
|
|
||||||
|
|
||||||
```
|
|
||||||
[5] Attach Listener //添加事件
|
|
||||||
[4] Signal Dispatcher // 分发处理给JVM信号的线程
|
|
||||||
[3] Finalizer //调用对象finalize方法的线程
|
|
||||||
[2] Reference Handler //清除reference线程
|
|
||||||
[1] main //main线程,程序入口
|
|
||||||
```
|
|
||||||
|
|
||||||
从上面的输出内容可以看出：**一个 Java 程序的运行是 main 线程和多个其他线程同时运行**。
|
|
||||||
|
|
||||||
### 1.3 从 JVM 角度说进程和线程之间的关系（重要）
|
|
||||||
|
|
||||||
#### 1.3.1 图解进程和线程的关系
|
|
||||||
|
|
||||||
下图是 Java 内存区域，通过下图我们从 JVM 的角度来说一下线程和进程之间的关系。如果你对 Java 内存区域(运行时数据区)这部分知识不太了解的话可以阅读一下我的这篇文章：[《可能是把Java内存区域讲的最清楚的一篇文章》](https://github.com/Snailclimb/JavaGuide/blob/master/Java相关/可能是把Java内存区域讲的最清楚的一篇文章.md)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
从上图可以看出：一个进程中可以有多个线程，多个线程共享进程的**堆**和**方法区**资源，但是每个线程有自己的**程序计数器**、**虚拟机栈** 和 **本地方法栈**。
|
|
||||||
|
|
||||||
下面来思考这样一个问题：为什么**程序计数器**、**虚拟机栈**和**本地方法栈**是线程私有的呢？为什么堆和方法区是线程共享的呢？
|
|
||||||
|
|
||||||
#### 1.3.2 程序计数器为什么是私有的?
|
|
||||||
|
|
||||||
程序计数器主要有下面两个作用：
|
|
||||||
|
|
||||||
1. 字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理。
|
|
||||||
2. 在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。
|
|
||||||
|
|
||||||
需要注意的是，如果执行的是native方法，那么程序计数器记录的是undefined地址，只有执行的是Java代码时程序计数器记录的才是下一条指令的地址。
|
|
||||||
|
|
||||||
所以，程序计数器私有主要是为了**线程切换后能恢复到正确的执行位置**。
|
|
||||||
|
|
||||||
#### 1.3.3 虚拟机栈和本地方法栈为什么是私有的?
|
|
||||||
|
|
||||||
- **虚拟机栈：**每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
|
|
||||||
- **本地方法栈：**和虚拟机栈所发挥的作用非常相似，区别是： **虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务。** 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。
|
|
||||||
|
|
||||||
所以，为了**保证线程中的局部变量不被别的线程访问到**，虚拟机栈和本地方法栈是线程私有的。
|
|
||||||
|
|
||||||
#### 1.3.4 一句话简单了解堆和方法区
|
|
||||||
|
|
||||||
堆和方法区是所有线程共享的资源，其中堆是进程中最大的一块内存，主要用于存放新创建的对象(所有对象都在这里分配内存)，方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
|
|
||||||
|
|
||||||
## 二 多线程并发编程
|
|
||||||
|
|
||||||
### 2.1 并发与并行
|
|
||||||
|
|
||||||
- **并发：** 同一时间段，多个任务都在执行(单位时间内不一定同时执行)；
|
|
||||||
- **并行：**单位时间内，多个任务同时执行。
|
|
||||||
|
|
||||||
### 2.1 多线程并发编程详解
|
|
||||||
|
|
||||||
单CPU时代多个任务共享一个CPU，某一特定时刻只能有一个任务被执行，CPU会分配时间片给当前要执行的任务。当一个任务占用CPU时，其他任务就会被挂起。当占用CPU的任务的时间片用完后，才会由 CPU 选择下一个需要执行的任务。所以说，在单核CPU时代，多线程编程没有太大意义，反而会因为线程间频繁的上下文切换而带来额外开销。
|
|
||||||
|
|
||||||
但现在 CPU 一般都是多核，如果这个CPU是多核的话，那么进程中的不同线程可以使用不同核心，实现了真正意义上的并行运行。**那为什么我们不直接叫做多线程并行编程呢？**
|
|
||||||
|
|
||||||
**这是因为多线程在实际开发使用中，线程的个数往往多于CPU的个数，所以一般都称多线程并发编程而不是多线程并行编程。`**
|
|
||||||
|
|
||||||
### 2.2 为什么要多线程并发编程?
|
|
||||||
|
|
||||||
- **从计算机底层来说：**线程可以比作是轻量级的进程，是程序执行的最小单位,线程间的切换和调度的成本远远小于进程。另外，多核 CPU 时代意味着多个线程可以同时运行，这减少了线程上下文切换的开销。
|
|
||||||
|
|
||||||
- **从当代互联网发展趋势来说：**现在的系统动不动就要求百万级甚至千万级的并发量，而多线程并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能。
|
|
||||||
|
|
||||||
## 三 线程的创建与运行
|
|
||||||
|
|
||||||
前两种实际上很少使用，一般都是用线程池的方式比较多一点。
|
|
||||||
|
|
||||||
### 3.1 继承 Thread 类的方式
|
|
||||||
|
|
||||||
|
|
||||||
```java
|
|
||||||
public class MyThread extends Thread {
|
|
||||||
@Override
|
|
||||||
public void run() {
|
|
||||||
super.run();
|
|
||||||
System.out.println("MyThread");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
```
|
|
||||||
Run.java
|
|
||||||
|
|
||||||
```java
|
|
||||||
public class Run {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
MyThread mythread = new MyThread();
|
|
||||||
mythread.start();
|
|
||||||
System.out.println("运行结束");
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
```
|
|
||||||
运行结果：
|
|
||||||
|
|
||||||
|
|
||||||
从上面的运行结果可以看出：线程是一个子任务，CPU以不确定的方式，或者说是以随机的时间来调用线程中的run方法。
|
|
||||||
|
|
||||||
### 3.2 实现Runnable接口的方式
|
|
||||||
|
|
||||||
推荐实现Runnable接口方式开发多线程，因为Java单继承但是可以实现多个接口。
|
|
||||||
|
|
||||||
MyRunnable.java
|
|
||||||
|
|
||||||
```java
|
|
||||||
public class MyRunnable implements Runnable {
|
|
||||||
@Override
|
|
||||||
public void run() {
|
|
||||||
System.out.println("MyRunnable");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
Run.java
|
|
||||||
|
|
||||||
```java
|
|
||||||
public class Run {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
Runnable runnable=new MyRunnable();
|
|
||||||
Thread thread=new Thread(runnable);
|
|
||||||
thread.start();
|
|
||||||
System.out.println("运行结束！");
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
```
|
|
||||||
运行结果：
|
|
||||||
|
|
||||||
|
|
||||||
### 3.3 使用线程池的方式
|
|
||||||
|
|
||||||
使用线程池的方式也是最推荐的一种方式，另外，《阿里巴巴Java开发手册》在第一章第六节并发处理这一部分也强调到“线程资源必须通过线程池提供，不允许在应用中自行显示创建线程”。这里就不给大家演示代码了，线程池这一节会详细介绍到这部分内容。
|
|
||||||
|
|
||||||
## 四 线程的生命周期和状态
|
|
||||||
|
|
||||||
Java 线程在运行的生命周期中的指定时刻只可能处于下面6种不同状态的其中一个状态（图源《Java 并发编程艺术》4.1.4节）。
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示（图源《Java 并发编程艺术》4.1.4节）：
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
由上图可以看出：
|
|
||||||
|
|
||||||
线程创建之后它将处于 **NEW（新建）** 状态，调用 `start()` 方法后开始运行，线程这时候处于 **READY（可运行）** 状态。可运行状态的线程获得了 cpu 时间片（timeslice）后就处于 **RUNNING（运行）** 状态。
|
|
||||||
|
|
||||||
> 操作系统隐藏 Java虚拟机（JVM）中的 RUNNABLE 和 RUNNING 状态，它只能看到 RUNNABLE 状态（图源：[HowToDoInJava](https://howtodoinjava.com/)：[Java Thread Life Cycle and Thread States](https://howtodoinjava.com/java/multi-threading/java-thread-life-cycle-and-thread-states/)），所以 Java 系统一般将这两个状态统称为 **RUNNABLE（运行中）** 状态 。
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
当线程执行 `wait()`方法之后，线程进入 **WAITING（等待）**状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 **TIME_WAITING(超时等待)** 状态相当于在等待状态的基础上增加了超时限制，比如通过 `sleep（long millis）`方法或 `wait（long millis）`方法可以将 Java 线程置于 TIMED WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 **BLOCKED（阻塞）** 状态。线程在执行 Runnable 的` run() `方法之后将会进入到 **TERMINATED（终止）** 状态。
|
|
||||||
|
|
||||||
## 五 线程优先级
|
|
||||||
|
|
||||||
**理论上**来说系统会根据优先级来决定首先使哪个线程进入运行状态。当 CPU 比较闲的时候，设置线程优先级几乎不会有任何作用，而且很多操作系统压根不会不会理会你设置的线程优先级，所以不要让业务过度依赖于线程的优先级。
|
|
||||||
|
|
||||||
另外，**线程优先级具有继承特性**比如A线程启动B线程，则B线程的优先级和A是一样的。**线程优先级还具有随机性** 也就是说线程优先级高的不一定每一次都先执行完。
|
|
||||||
|
|
||||||
Thread类中包含的成员变量代表了线程的某些优先级。如**Thread.MIN_PRIORITY（常数1）**，**Thread.NORM_PRIORITY（常数5）**,**Thread.MAX_PRIORITY（常数10）**。其中每个线程的优先级都在**1** 到**10** 之间，在默认情况下优先级都是**Thread.NORM_PRIORITY（常数5）**。
|
|
||||||
|
|
||||||
**一般情况下，不会对线程设定优先级别，更不会让某些业务严重地依赖线程的优先级别，比如权重，借助优先级设定某个任务的权重，这种方式是不可取的，一般定义线程的时候使用默认的优先级就好了。**
|
|
||||||
|
|
||||||
**相关方法：**
|
|
||||||
|
|
||||||
```java
|
|
||||||
public final void setPriority(int newPriority) //为线程设定优先级
|
|
||||||
public final int getPriority() //获取线程的优先级
|
|
||||||
```
|
|
||||||
**设置线程优先级方法源码：**
|
|
||||||
|
|
||||||
```java
|
|
||||||
public final void setPriority(int newPriority) {
|
|
||||||
ThreadGroup g;
|
|
||||||
checkAccess();
|
|
||||||
//线程游戏优先级不能小于1也不能大于10，否则会抛出异常
|
|
||||||
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
|
|
||||||
throw new IllegalArgumentException();
|
|
||||||
}
|
|
||||||
//如果指定的线程优先级大于该线程所在线程组的最大优先级，那么该线程的优先级将设为线程组的最大优先级
|
|
||||||
if((g = getThreadGroup()) != null) {
|
|
||||||
if (newPriority > g.getMaxPriority()) {
|
|
||||||
newPriority = g.getMaxPriority();
|
|
||||||
}
|
|
||||||
setPriority0(priority = newPriority);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
```
|
|
||||||
|
|
||||||
## 六 守护线程和用户线程
|
|
||||||
|
|
||||||
**守护线程和用户线程简介:**
|
|
||||||
|
|
||||||
- **用户(User)线程：**运行在前台，执行具体的任务，如程序的主线程、连接网络的子线程等都是用户线程
|
|
||||||
- **守护(Daemon)线程：**运行在后台，为其他前台线程服务.也可以说守护线程是JVM中非守护线程的 **“佣人”**。一旦所有用户线程都结束运行，守护线程会随JVM一起结束工作.
|
|
||||||
|
|
||||||
main 函数所在的线程就是一个用户线程啊，main函数启动的同时在JVM内部同时还启动了好多守护线程，比如垃圾回收线程。
|
|
||||||
|
|
||||||
**那么守护线程和用户线程有什么区别呢？**
|
|
||||||
|
|
||||||
比较明显的区别之一是用户线程结束，JVM退出，不管这个时候有没有守护线程运行。而守护线程不会影响 JVM 的退出。
|
|
||||||
|
|
||||||
**注意事项：**
|
|
||||||
|
|
||||||
1. `setDaemon(true)`必须在`start（）`方法前执行，否则会抛出 `IllegalThreadStateException` 异常
|
|
||||||
2. 在守护线程中产生的新线程也是守护线程
|
|
||||||
3. 不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑
|
|
||||||
4. 守护(Daemon)线程中不能依靠 finally 块的内容来确保执行关闭或清理资源的逻辑。因为我们上面也说过了一旦所有用户线程都结束运行，守护线程会随JVM一起结束工作，所以守护(Daemon)线程中的finally语句块可能无法被执行。
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
## 参考
|
|
||||||
|
|
||||||
- 《Java并发编程之美》
|
|
||||||
- 《Java并发编程的艺术》
|
|
||||||
- https://howtodoinjava.com/java/multi-threading/java-thread-life-cycle-and-thread-states/
|
|
||||||
Loading…
x
Reference in New Issue
Block a user