diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000000..853f53da406 --- /dev/null +++ b/.gitignore @@ -0,0 +1,34 @@ +.gradle +/build/ +/**/build/ + +### STS ### +.apt_generated +.classpath +.factorypath +.project +.settings +.springBeans +.sts4-cache + +### IntelliJ IDEA ### +.idea +*.iws +*.iml +*.ipr +/out/ +/**/out/ +.shelf/ +.ideaDataSources/ +dataSources/ + +### NetBeans ### +/nbproject/private/ +/nbbuild/ +/dist/ +/nbdist/ +/.nb-gradle/ +/node_modules/ + +### OS ### +.DS_Store diff --git a/docs/.nojekyll b/.nojekyll similarity index 100% rename from docs/.nojekyll rename to .nojekyll diff --git a/HomePage.md b/HomePage.md new file mode 100644 index 00000000000..43a338951fc --- /dev/null +++ b/HomePage.md @@ -0,0 +1,236 @@ +点击订阅[Java面试进阶指南](https://xiaozhuanlan.com/javainterview?rel=javaguide)(专为Java面试方向准备)。[为什么要弄这个专栏?](https://shimo.im/./9BJjNsNg7S4dCnz3/) + +

Java 学习/面试指南

+

+ + + + +## 目录 + +- [Java](#java) + - [基础](#基础) + - [容器](#容器) + - [并发](#并发) + - [JVM](#jvm) + - [I/O](#io) + - [Java 8](#java-8) + - [编程规范](#编程规范) +- [网络](#网络) +- [操作系统](#操作系统) + - [Linux相关](#linux相关) +- [数据结构与算法](#数据结构与算法) + - [数据结构](#数据结构) + - [算法](#算法) +- [数据库](#数据库) + - [MySQL](#mysql) + - [Redis](#redis) +- [系统设计](#系统设计) + - [设计模式(工厂模式、单例模式 ... )](#设计模式) + - [常用框架(Spring、Zookeeper ... )](#常用框架) + - [数据通信(消息队列、Dubbo ... )](#数据通信) + - [网站架构](#网站架构) +- [面试指南](#面试指南) + - [备战面试](#备战面试) + - [常见面试题总结](#常见面试题总结) + - [面经](#面经) +- [工具](#工具) + - [Git](#git) + - [Docker](#Docker) +- [资料](#资料) + - [书单](#书单) + - [Github榜单](#Github榜单) +- [待办](#待办) +- [说明](#说明) + +## Java + +### 基础 + +* [Java 基础知识回顾](java/Java基础知识.md) +* [Java 基础知识疑难点总结](java/Java疑难点.md) +* [J2EE 基础知识回顾](java/J2EE基础知识.md) + +### 容器 + +* [Java容器常见面试题/知识点总结](java/collection/Java集合框架常见面试题.md) +* [ArrayList 源码学习](java/collection/ArrayList.md) +* [LinkedList 源码学习](java/collection/LinkedList.md) +* [HashMap(JDK1.8)源码学习](java/collection/HashMap.md) + +### 并发 + +* [Java 并发基础常见面试题总结](java/Multithread/JavaConcurrencyBasicsCommonInterviewQuestionsSummary.md) +* [Java 并发进阶常见面试题总结](java/Multithread/JavaConcurrencyAdvancedCommonInterviewQuestions.md) +* [并发容器总结](java/Multithread/并发容器总结.md) +* [乐观锁与悲观锁](essential-content-for-interview/面试必备之乐观锁与悲观锁.md) +* [JUC 中的 Atomic 原子类总结](java/Multithread/Atomic.md) +* [AQS 原理以及 AQS 同步组件总结](java/Multithread/AQS.md) + +### JVM +* [一 Java内存区域](java/jvm/Java内存区域.md) +* [二 JVM垃圾回收](java/jvm/JVM垃圾回收.md) +* [三 JDK 监控和故障处理工具](java/jvm/JDK监控和故障处理工具总结.md) +* [四 类文件结构](java/jvm/类文件结构.md) +* [五 类加载过程](java/jvm/类加载过程.md) +* [六 类加载器](java/jvm/类加载器.md) + +### I/O + +* [BIO,NIO,AIO 总结 ](java/BIO-NIO-AIO.md) +* [Java IO 与 NIO系列文章](java/Java%20IO与NIO.md) + +### Java 8 + +* [Java 8 新特性总结](java/What's%20New%20in%20JDK8/Java8Tutorial.md) +* [Java 8 学习资源推荐](java/What's%20New%20in%20JDK8/Java8教程推荐.md) + +### 编程规范 + +- [Java 编程规范](java/Java编程规范.md) + +## 网络 + +* [计算机网络常见面试题](network/计算机网络.md) +* [计算机网络基础知识总结](network/干货：计算机网络知识总结.md) +* [HTTPS中的TLS](network/HTTPS中的TLS.md) + +## 操作系统 + +### Linux相关 + +* [后端程序员必备的 Linux 基础知识](operating-system/后端程序员必备的Linux基础知识.md) +* [Shell 编程入门](operating-system/Shell.md) + +## 数据结构与算法 + +### 数据结构 + +- [数据结构知识学习与面试](dataStructures-algorithms/数据结构.md) + +### 算法 + +- [算法学习资源推荐](dataStructures-algorithms/算法学习资源推荐.md) +- [几道常见的字符串算法题总结 ](dataStructures-algorithms/几道常见的子符串算法题.md) +- [几道常见的链表算法题总结 ](dataStructures-algorithms/几道常见的链表算法题.md) +- [剑指offer部分编程题](dataStructures-algorithms/剑指offer部分编程题.md) +- [公司真题](dataStructures-algorithms/公司真题.md) +- [回溯算法经典案例之N皇后问题](dataStructures-algorithms/Backtracking-NQueens.md) + +## 数据库 + +### MySQL + +* [MySQL 学习与面试](database/MySQL.md) +* [一千行MySQL学习笔记](database/一千行MySQL命令.md) +* [MySQL高性能优化规范建议](database/MySQL高性能优化规范建议.md) +* [数据库索引总结](database/MySQL%20Index.md) +* [事务隔离级别(图文详解)](database/事务隔离级别(图文详解).md) +* [一条SQL语句在MySQL中如何执行的](database/一条sql语句在mysql中如何执行的.md) + +### Redis + +* [Redis 总结](database/Redis/Redis.md) +* [Redlock分布式锁](database/Redis/Redlock分布式锁.md) +* [如何做可靠的分布式锁，Redlock真的可行么](database/Redis/如何做可靠的分布式锁，Redlock真的可行么.md) + +## 系统设计 + +### 设计模式 + +- [设计模式系列文章](system-design/设计模式.md) + +### 常用框架 + +#### Spring + +- [Spring 学习与面试](system-design/framework/spring/Spring.md) +- [Spring 常见问题总结](system-design/framework/spring/SpringInterviewQuestions.md) +- [Spring中bean的作用域与生命周期](system-design/framework/spring/SpringBean.md) +- [SpringMVC 工作原理详解](system-design/framework/spring/SpringMVC-Principle.md) +- [Spring中都用到了那些设计模式?](system-design/framework/spring/Spring-Design-Patterns.md) + +#### ZooKeeper + +- [ZooKeeper 相关概念总结](system-design/framework/ZooKeeper.md) +- [ZooKeeper 数据模型和常见命令](system-design/framework/ZooKeeper数据模型和常见命令.md) + +### 数据通信 + +- [数据通信(RESTful、RPC、消息队列)相关知识点总结](system-design/data-communication/summary.md) +- [Dubbo 总结：关于 Dubbo 的重要知识点](system-design/data-communication/dubbo.md) +- [消息队列总结](system-design/data-communication/message-queue.md) +- [RabbitMQ 入门](system-design/data-communication/rabbitmq.md) +- [RocketMQ的几个简单问题与答案](system-design/data-communication/RocketMQ-Questions.md) + +### 网站架构 + +- [一文读懂分布式应该学什么](system-design/website-architecture/分布式.md) +- [8 张图读懂大型网站技术架构](system-design/website-architecture/8%20张图读懂大型网站技术架构.md) +- [【面试精选】关于大型网站系统架构你不得不懂的10个问题](system-design/website-architecture/【面试精选】关于大型网站系统架构你不得不懂的10个问题.md) + +## 面试指南 + +### 备战面试 + +* [【备战面试1】程序员的简历就该这样写](essential-content-for-interview/PreparingForInterview/程序员的简历之道.md) +* [【备战面试2】初出茅庐的程序员该如何准备面试？](essential-content-for-interview/PreparingForInterview/interviewPrepare.md) +* [【备战面试3】7个大部分程序员在面试前很关心的问题](essential-content-for-interview/PreparingForInterview/JavaProgrammerNeedKnow.md) +* [【备战面试4】Github上开源的Java面试/学习相关的仓库推荐](essential-content-for-interview/PreparingForInterview/JavaInterviewLibrary.md) +* [【备战面试5】如果面试官问你“你有什么问题问我吗？”时，你该如何回答](essential-content-for-interview/PreparingForInterview/如果面试官问你“你有什么问题问我吗？”时，你该如何回答.md) +* [【备战面试6】美团面试常见问题总结（附详解答案）](essential-content-for-interview/PreparingForInterview/美团面试常见问题总结.md) + +### 常见面试题总结 + +* [第一周（2018-8-7）](essential-content-for-interview/MostCommonJavaInterviewQuestions/第一周（2018-8-7）.md) (为什么 Java 中只有值传递、==与equals、 hashCode与equals) +* [第二周（2018-8-13）](essential-content-for-interview/MostCommonJavaInterviewQuestions/第二周(2018-8-13).md)(String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的？、什么是反射机制？反射机制的应用场景有哪些？......) +* [第三周（2018-08-22）](java/collection/Java集合框架常见面试题.md) （Arraylist 与 LinkedList 异同、ArrayList 与 Vector 区别、HashMap的底层实现、HashMap 和 Hashtable 的区别、HashMap 的长度为什么是2的幂次方、HashSet 和 HashMap 区别、ConcurrentHashMap 和 Hashtable 的区别、ConcurrentHashMap线程安全的具体实现方式/底层具体实现、集合框架底层数据结构总结） +* [第四周(2018-8-30).md](essential-content-for-interview/MostCommonJavaInterviewQuestions/第四周(2018-8-30).md) （主要内容是几道面试常问的多线程基础题。） + +### 面经 + +- [5面阿里,终获offer(2018年秋招)](essential-content-for-interview/BATJrealInterviewExperience/5面阿里,终获offer.md) +- [蚂蚁金服2019实习生面经总结(已拿口头offer)](essential-content-for-interview/BATJrealInterviewExperience/蚂蚁金服实习生面经总结(已拿口头offer).md) +- [2019年蚂蚁金服、头条、拼多多的面试总结](essential-content-for-interview/BATJrealInterviewExperience/2019alipay-pinduoduo-toutiao.md) + +## 工具 + +### Git + +* [Git入门](tools/Git.md) + +### Docker + +* [Docker 入门](tools/Docker.md) +* [一文搞懂 Docker 镜像的常用操作！](tools/Docker-Image.md) + +## 资料 + +### 书单 + +- [Java程序员必备书单](data/java-recommended-books.md) + +### Github榜单 + +- [Java 项目月榜单](github-trending/JavaGithubTrending.md) + +*** + +## 待办 + +- [x] [Java 8 新特性总结](./java/What's%20New%20in%20JDK8/Java8Tutorial.md) +- [x] [Java 8 新特性详解](./java/What's%20New%20in%20JDK8/Java8教程推荐.md) +- [ ] Java 多线程类别知识重构(---正在进行中---) +- [x] [BIO,NIO,AIO 总结 ](./java/BIO-NIO-AIO.md) +- [ ] Netty 总结(---正在进行中---) +- [ ] 数据结构总结重构(---正在进行中---) + +## 公众号 + +- 如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 +- 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本公众号后台回复 **"Java面试突击"** 即可免费领取！ +- 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 + +

+ +

diff --git a/README.md b/README.md index 976fc0c0067..993a9f0ad2d 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,5 @@ -

Java 学习/面试指南

+点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 +

@@ -11,18 +12,17 @@ 公众号 公众号 投稿 -

Special Sponsors

+ 投稿

+

Sponsor

- - - + + +

-由于对文件目录结构进行了大幅度修改，所以如果遇到文章中有 Github 404 链接请 [联系我](#联系我) - -推荐使用 在线阅读(访问速度慢的话，请使用 )，在线阅读内容本仓库同步一致。这种方式阅读的优势在于：有侧边栏阅读体验更好，Gitee pages 的访问速度相对来说也比较快。 +推荐使用 https://snailclimb.github.io/JavaGuide/ 在线阅读(访问速度慢的话，请使用 https://snailclimb.gitee.io/javaguide )，在线阅读内容本仓库同步一致。这种方式阅读的优势在于：有侧边栏阅读体验更好，Gitee pages 的访问速度相对来说也比较快。 ## 目录 @@ -33,7 +33,7 @@ - [JVM](#jvm) - [I/O](#io) - [Java 8](#java-8) - - [编程规范](#编程规范) + - [优雅 Java 代码必备实践(Java编程规范)](#优雅-java-代码必备实践java编程规范) - [网络](#网络) - [操作系统](#操作系统) - [Linux相关](#linux相关) @@ -43,19 +43,27 @@ - [数据库](#数据库) - [MySQL](#mysql) - [Redis](#redis) + - [数据库扩展](#数据库扩展) - [系统设计](#系统设计) - - [设计模式](#设计模式) - - [常用框架](#常用框架) - - [数据通信](#数据通信) - - [网站架构](#网站架构) + - [常用框架(Spring/SpringBoot、Zookeeper ... )](#常用框架) + - [数据通信/中间件(消息队列、RPC ... )](#数据通信中间件) + - [权限认证](#权限认证) + - [分布式 & 微服务](#分布式--微服务) + - [API 网关](#api-网关) + - [配置中心](#配置中心) + - [唯一 id 生成](#唯一-id-生成) + - [服务治理：服务注册与发现、服务路由控制](#服务治理服务注册与发现服务路由控制) + - [架构](#架构) + - [设计模式(工厂模式、单例模式 ... )](#设计模式) - [面试指南](#面试指南) - [备战面试](#备战面试) - [常见面试题总结](#常见面试题总结) - [面经](#面经) +- [Java学习常见问题汇总](#java学习常见问题汇总) - [工具](#工具) - [Git](#git) - [Docker](#Docker) -- [资料](#资料) +- [资源](#资源) - [书单](#书单) - [Github榜单](#Github榜单) - [待办](#待办) @@ -65,36 +73,36 @@ ### 基础 -* [Java 基础知识回顾](docs/java/Java基础知识.md) +* **[Java 基础知识回顾](docs/java/Java基础知识.md)** +* **[Java 基础知识疑难点/易错点](docs/java/Java疑难点.md)** +* **[一些重要的Java程序设计题](docs/java/Java程序设计题.md)** * [J2EE 基础知识回顾](docs/java/J2EE基础知识.md) -* [Collections 工具类和 Arrays 工具类常见方法](docs/java/Basis/Arrays%2CCollectionsCommonMethods.md) -* [Java常见关键字总结：static、final、this、super](docs/java/Basis/final、static、this、super.md) ### 容器 -* **常见问题总结：** - * [这几道Java集合框架面试题几乎必问](docs/java/这几道Java集合框架面试题几乎必问.md) - * [Java 集合框架常见面试题总结](docs/java/Java集合框架常见面试题总结.md) -* **源码分析：** - * [ArrayList 源码学习](docs/java/ArrayList.md) - * [【面试必备】透过源码角度一步一步带你分析 ArrayList 扩容机制](docs/java/ArrayList-Grow.md) - * [LinkedList 源码学习](docs/java/LinkedList.md) - * [HashMap(JDK1.8)源码学习](docs/java/HashMap.md) +* **[Java容器常见面试题/知识点总结](docs/java/collection/Java集合框架常见面试题.md)** +* [ArrayList 源码学习](docs/java/collection/ArrayList.md) +* [LinkedList 源码学习](docs/java/collection/LinkedList.md) +* [HashMap(JDK1.8)源码学习](docs/java/collection/HashMap.md) ### 并发 -* [并发编程面试必备：synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及 和ReenTrantLock 的对比](docs/java/synchronized.md) -* [并发编程面试必备：乐观锁与悲观锁](docs/essential-content-for-interview/面试必备之乐观锁与悲观锁.md) -* [并发编程面试必备：JUC 中的 Atomic 原子类总结](docs/java/Multithread/Atomic.md) -* [并发编程面试必备：AQS 原理以及 AQS 同步组件总结](docs/java/Multithread/AQS.md) -* [BATJ都爱问的多线程面试题](docs/java/Multithread/BATJ都爱问的多线程面试题.md) +* **[Java 并发基础常见面试题总结](docs/java/Multithread/JavaConcurrencyBasicsCommonInterviewQuestionsSummary.md)** +* **[Java 并发进阶常见面试题总结](docs/java/Multithread/JavaConcurrencyAdvancedCommonInterviewQuestions.md)** * [并发容器总结](docs/java/Multithread/并发容器总结.md) +* **[Java线程池学习总结](./docs/java/Multithread/java线程池学习总结.md)** +* [乐观锁与悲观锁](docs/essential-content-for-interview/面试必备之乐观锁与悲观锁.md) +* [JUC 中的 Atomic 原子类总结](docs/java/Multithread/Atomic.md) +* [AQS 原理以及 AQS 同步组件总结](docs/java/Multithread/AQS.md) ### JVM -* [可能是把Java内存区域讲的最清楚的一篇文章](docs/java/可能是把Java内存区域讲的最清楚的一篇文章.md) -* [搞定JVM垃圾回收就是这么简单](docs/java/搞定JVM垃圾回收就是这么简单.md) -* [《深入理解Java虚拟机》第2版学习笔记](docs/java/Java虚拟机（jvm）.md) +* **[一 Java内存区域](docs/java/jvm/Java内存区域.md)** +* **[二 JVM垃圾回收](docs/java/jvm/JVM垃圾回收.md)** +* [三 JDK 监控和故障处理工具](docs/java/jvm/JDK监控和故障处理工具总结.md) +* [四 类文件结构](docs/java/jvm/类文件结构.md) +* **[五 类加载过程](docs/java/jvm/类加载过程.md)** +* [六 类加载器](docs/java/jvm/类加载器.md) ### I/O @@ -105,10 +113,11 @@ * [Java 8 新特性总结](docs/java/What's%20New%20in%20JDK8/Java8Tutorial.md) * [Java 8 学习资源推荐](docs/java/What's%20New%20in%20JDK8/Java8教程推荐.md) +* [Java8 forEach 指南](docs/java/What's%20New%20in%20JDK8/Java8foreach指南.md) -### 编程规范 +### 优雅 Java 代码必备实践(Java编程规范) -- [Java 编程规范](docs/java/Java编程规范.md) +* [Java 编程规范以及优雅 Java 代码实践总结](docs/java/Java编程规范.md) ## 网络 @@ -121,7 +130,7 @@ ### Linux相关 * [后端程序员必备的 Linux 基础知识](docs/operating-system/后端程序员必备的Linux基础知识.md) -* [Shell 编程入门](docs/operating-system/Shell.md) +* [Shell 编程入门](docs/operating-system/Shell.md) ## 数据结构与算法 @@ -132,82 +141,137 @@ ### 算法 - [算法学习资源推荐](docs/dataStructures-algorithms/算法学习资源推荐.md) -- [算法总结——几道常见的子符串算法题 ](docs/dataStructures-algorithms/几道常见的子符串算法题.md) -- [算法总结——几道常见的链表算法题 ](docs/dataStructures-algorithms/几道常见的链表算法题.md) +- [几道常见的字符串算法题总结 ](docs/dataStructures-algorithms/几道常见的子符串算法题.md) +- [几道常见的链表算法题总结 ](docs/dataStructures-algorithms/几道常见的链表算法题.md) - [剑指offer部分编程题](docs/dataStructures-algorithms/剑指offer部分编程题.md) - [公司真题](docs/dataStructures-algorithms/公司真题.md) -- [回溯算法经典案例之N皇后问题](./dataStructures-algorithms/Backtracking-NQueens.md) +- [回溯算法经典案例之N皇后问题](docs/dataStructures-algorithms/Backtracking-NQueens.md) ## 数据库 ### MySQL -* [MySQL 学习与面试](docs/database/MySQL.md) -* [一千行MySQL学习笔记](docs/database/一千行MySQL命令.md) -* [【思维导图-索引篇】搞定数据库索引就是这么简单](docs/database/MySQL%20Index.md) +* **[【推荐】MySQL/数据库 知识点总结](docs/database/MySQL.md)** +* **[阿里巴巴开发手册数据库部分的一些最佳实践](docs/database/阿里巴巴开发手册数据库部分的一些最佳实践.md)** +* **[一千行MySQL学习笔记](docs/database/一千行MySQL命令.md)** +* [MySQL高性能优化规范建议](docs/database/MySQL高性能优化规范建议.md) +* [数据库索引总结](docs/database/MySQL%20Index.md) * [事务隔离级别(图文详解)](docs/database/事务隔离级别(图文详解).md) -* [一条sql语句在MySQL中如何执行的](docs/database/一条sql语句在mysql中如何执行的.md) +* [一条SQL语句在MySQL中如何执行的](docs/database/一条sql语句在mysql中如何执行的.md) ### Redis * [Redis 总结](docs/database/Redis/Redis.md) * [Redlock分布式锁](docs/database/Redis/Redlock分布式锁.md) * [如何做可靠的分布式锁，Redlock真的可行么](docs/database/Redis/如何做可靠的分布式锁，Redlock真的可行么.md) +* [几种常见的 Redis 集群以及使用场景](docs/database/Redis/redis集群以及应用场景.md) -## 系统设计 +### 数据库扩展 -### 设计模式 +代办...... -- [设计模式系列文章](docs/system-design/设计模式.md) +## 系统设计 ### 常用框架 -#### Spring +#### Spring/SpringBoot -- [Spring 学习与面试](docs/system-design/framework/Spring学习与面试.md) -- [Spring中bean的作用域与生命周期](docs/system-design/framework/SpringBean.md) -- [SpringMVC 工作原理详解](docs/system-design/framework/SpringMVC%20%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86%E8%AF%A6%E8%A7%A3.md) +- [Spring 学习与面试](docs/system-design/framework/spring/Spring.md) +- **[Spring 常见问题总结](docs/system-design/framework/spring/SpringInterviewQuestions.md)** +- **[SpringBoot 指南/常见面试题总结](https://github.com/Snailclimb/springboot-guide)** +- [Spring中bean的作用域与生命周期](docs/system-design/framework/spring/SpringBean.md) +- [SpringMVC 工作原理详解](docs/system-design/framework/spring/SpringMVC-Principle.md) +- [Spring中都用到了那些设计模式?](docs/system-design/framework/spring/Spring-Design-Patterns.md) #### ZooKeeper -- [可能是把 ZooKeeper 概念讲的最清楚的一篇文章](docs/system-design/framework/ZooKeeper.md) -- [ZooKeeper 数据模型和常见命令了解一下，速度收藏！](docs/system-design/framework/ZooKeeper数据模型和常见命令.md) +- [ZooKeeper 相关概念总结](docs/system-design/framework/ZooKeeper.md) +- [ZooKeeper 数据模型和常见命令](docs/system-design/framework/ZooKeeper数据模型和常见命令.md) -### 数据通信 +### 数据通信/中间件 + +- [数据通信(RESTful、RPC、消息队列)相关知识点总结](docs/system-design/data-communication/summary.md) + +#### RPC -- [数据通信(RESTful、RPC、消息队列)相关知识点总结](docs/system-design/data-communication/数据通信(RESTful、RPC、消息队列).md) - [Dubbo 总结：关于 Dubbo 的重要知识点](docs/system-design/data-communication/dubbo.md) -- [消息队列总结：新手也能看懂，消息队列其实很简单](docs/system-design/data-communication/message-queue.md) -- [一文搞懂 RabbitMQ 的重要概念以及安装](docs/system-design/data-communication/rabbitmq.md) +- [服务之间的调用为啥不直接用 HTTP 而用 RPC？](docs/system-design/data-communication/why-use-rpc.md) + +#### 消息队列 + +- [消息队列总结](docs/system-design/data-communication/message-queue.md) +- [RabbitMQ 入门](docs/system-design/data-communication/rabbitmq.md) +- [RocketMQ的几个简单问题与答案](docs/system-design/data-communication/RocketMQ-Questions.md) +- [Kafka入门看这一篇就够了](docs/system-design/data-communication/Kafka入门看这一篇就够了.md) +- [Kafka系统设计开篇-面试看这篇就够了](docs/system-design/data-communication/Kafka系统设计开篇-面试看这篇就够了.md) + +### 权限认证 + +- **[权限认证基础:区分Authentication,Authorization以及Cookie、Session、Token](docs/system-design/authority-certification/basis-of-authority-certification.md)** +- **[JWT 优缺点分析以及常见问题解决方案](docs/system-design/authority-certification/JWT-advantages-and-disadvantages.md)** +- **[适合初学者入门 Spring Security With JWT 的 Demo](https://github.com/Snailclimb/spring-security-jwt-guide)** + +### 分布式 & 微服务 + +- [分布式应该学什么](docs/system-design/website-architecture/分布式.md) + +#### API 网关 + +网关主要用于请求转发、安全认证、协议转换、容灾。 + +- [浅析如何设计一个亿级网关(API Gateway)](docs/system-design/micro-service/API网关.md) + +#### 配置中心 + +代办...... + +#### 唯一 id 生成 + + [分布式id生成方案总结](docs/system-design/micro-service/分布式id生成方案总结.md) + +#### 服务治理：服务注册与发现、服务路由控制 + +代办...... -### 网站架构 +### 架构 -- [一文读懂分布式应该学什么](docs/system-design/website-architecture/分布式.md) - [8 张图读懂大型网站技术架构](docs/system-design/website-architecture/8%20张图读懂大型网站技术架构.md) -- [【面试精选】关于大型网站系统架构你不得不懂的10个问题](docs/system-design/website-architecture/【面试精选】关于大型网站系统架构你不得不懂的10个问题.md) +- [【面试精选】关于大型网站系统架构你不得不懂的10个问题](docs/system-design/website-architecture/关于大型网站系统架构你不得不懂的10个问题.md) + +### 设计模式 + +- [设计模式系列文章](docs/system-design/设计模式.md) ## 面试指南 ### 备战面试 -* [【备战面试1】程序员的简历就该这样写](docs/essential-content-for-interview/PreparingForInterview/程序员的简历之道.md) -* [【备战面试2】初出茅庐的程序员该如何准备面试？](docs/essential-content-for-interview/PreparingForInterview/interviewPrepare.md) -* [【备战面试3】7个大部分程序员在面试前很关心的问题](docs/essential-content-for-interview/PreparingForInterview/JavaProgrammerNeedKnow.md) -* [【备战面试4】Java程序员必备书单](docs/essential-content-for-interview/PreparingForInterview/books.md) -* [【备战面试5】Github上开源的Java面试/学习相关的仓库推荐](docs/essential-content-for-interview/PreparingForInterview/JavaInterviewLibrary.md) -* [【备战面试6】如果面试官问你“你有什么问题问我吗？”时，你该如何回答](docs/essential-content-for-interview/PreparingForInterview/如果面试官问你“你有什么问题问我吗？”时，你该如何回答.md) -* [【备战面试7】美团面试常见问题总结（附详解答案）](docs/essential-content-for-interview/PreparingForInterview/美团面试常见问题总结.md) +* **[【备战面试1】程序员的简历就该这样写](docs/essential-content-for-interview/PreparingForInterview/程序员的简历之道.md)** +* **[【备战面试2】初出茅庐的程序员该如何准备面试？](docs/essential-content-for-interview/PreparingForInterview/interviewPrepare.md)** +* **[【备战面试3】7个大部分程序员在面试前很关心的问题](docs/essential-content-for-interview/PreparingForInterview/JavaProgrammerNeedKnow.md)** +* **[【备战面试4】Github上开源的Java面试/学习相关的仓库推荐](docs/essential-content-for-interview/PreparingForInterview/JavaInterviewLibrary.md)** +* **[【备战面试5】如果面试官问你“你有什么问题问我吗？”时，你该如何回答](docs/essential-content-for-interview/PreparingForInterview/面试官-你有什么问题要问我.md)** +* **[【备战面试6】美团面试常见问题总结（附详解答案）](docs/essential-content-for-interview/PreparingForInterview/美团面试常见问题总结.md)** +* **[【备战面试7】一些刁难的面试问题总结](https://xiaozhuanlan.com/topic/9056431872)** ### 常见面试题总结 * [第一周（2018-8-7）](docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/第一周（2018-8-7）.md) (为什么 Java 中只有值传递、==与equals、 hashCode与equals) * [第二周（2018-8-13）](docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/第二周(2018-8-13).md)(String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的？、什么是反射机制？反射机制的应用场景有哪些？......) -* [第三周（2018-08-22）](docs/java/这几道Java集合框架面试题几乎必问.md) （Arraylist 与 LinkedList 异同、ArrayList 与 Vector 区别、HashMap的底层实现、HashMap 和 Hashtable 的区别、HashMap 的长度为什么是2的幂次方、HashSet 和 HashMap 区别、ConcurrentHashMap 和 Hashtable 的区别、ConcurrentHashMap线程安全的具体实现方式/底层具体实现、集合框架底层数据结构总结） +* [第三周（2018-08-22）](docs/java/collection/Java集合框架常见面试题.md) （Arraylist 与 LinkedList 异同、ArrayList 与 Vector 区别、HashMap的底层实现、HashMap 和 Hashtable 的区别、HashMap 的长度为什么是2的幂次方、HashSet 和 HashMap 区别、ConcurrentHashMap 和 Hashtable 的区别、ConcurrentHashMap线程安全的具体实现方式/底层具体实现、集合框架底层数据结构总结） * [第四周(2018-8-30).md](docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/第四周(2018-8-30).md) （主要内容是几道面试常问的多线程基础题。） ### 面经 - [5面阿里,终获offer(2018年秋招)](docs/essential-content-for-interview/BATJrealInterviewExperience/5面阿里,终获offer.md) +- [蚂蚁金服2019实习生面经总结(已拿口头offer)](docs/essential-content-for-interview/BATJrealInterviewExperience/蚂蚁金服实习生面经总结(已拿口头offer).md) +- [2019年蚂蚁金服、头条、拼多多的面试总结](docs/essential-content-for-interview/BATJrealInterviewExperience/2019alipay-pinduoduo-toutiao.md) + +## Java学习常见问题汇总 + +- [Java学习路线和方法推荐](docs/questions/java-learning-path-and-methods.md) +- [Java培训四个月能学会吗？](docs/questions/java-training-4-month.md) +- [新手学习Java，有哪些Java相关的博客，专栏，和技术学习网站推荐？](docs/questions/java-learning-website-blog.md) ## 工具 @@ -217,15 +281,24 @@ ### Docker -* [Docker 入门](docs/tools/Docker.md) +* [Docker 基本概念解读](docs/tools/Docker.md) +* [一文搞懂 Docker 镜像的常用操作！](docs/tools/Docker-Image.md) -## 资料 +### 其他 + +- [阿里云服务器使用经验](docs/tools/阿里云服务器使用经验.md) + +## 资源 ### 书单 -- [Java程序员必备书单](docs/essential-content-for-interview/PreparingForInterview/books.md) +- [Java程序员必备书单](docs/data/java-recommended-books.md) + +### 实战项目推荐 -### Github榜单 +- [Github 上热门的 Spring Boot 项目实战推荐](docs/data/spring-boot-practical-projects.md) + +### Github 历史榜单 - [Java 项目月榜单](docs/github-trending/JavaGithubTrending.md) @@ -233,16 +306,13 @@ ## 待办 -- [x] [Java 8 新特性总结](docs/java/What's%20New%20in%20JDK8/Java8Tutorial.md) -- [x] [Java 8 新特性详解](docs/java/What's%20New%20in%20JDK8/Java8教程推荐.md) -- [ ] Java 多线程类别知识重构(---正在进行中---) -- [x] [BIO,NIO,AIO 总结 ](docs/java/BIO-NIO-AIO.md) +- [x] Java 多线程类别知识重构 - [ ] Netty 总结(---正在进行中---) - [ ] 数据结构总结重构(---正在进行中---) ## 说明 -### 介绍 +### JavaGuide介绍 * **对于 Java 初学者来说：** 本文档倾向于给你提供一个比较详细的学习路径，让你对于Java整体的知识体系有一个初步认识。另外，本文的一些文章 也是你学习和复习 Java 知识不错的实践； @@ -252,6 +322,12 @@ Markdown 格式参考：[Github Markdown格式](https://guides.github.com/featur 利用 docsify 生成文档部署在 Github pages: [docsify 官网介绍](https://docsify.js.org/#/) +### 作者的其他开源项目推荐 + +1. [springboot-guide](https://github.com/Snailclimb/springboot-guide) : 适合新手入门以及有经验的开发人员查阅的 Spring Boot 教程（业余时间维护中，欢迎一起维护）。 +2. [programmer-advancement](https://github.com/Snailclimb/programmer-advancement) : 我觉得技术人员应该有的一些好习惯！ +3. [spring-security-jwt-guide](https://github.com/Snailclimb/spring-security-jwt-guide) :从零入门 ！Spring Security With JWT（含权限验证）后端部分代码。 + ### 关于转载 如果你需要转载本仓库的一些文章到自己的博客的话，记得注明原文地址就可以了。 @@ -274,20 +350,28 @@ Markdown 格式参考：[Github Markdown格式](https://guides.github.com/featur 添加我的微信备注“Github”,回复关键字 **“加群”** 即可入群。 -![我的微信](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-2/JavaGuide.jpg) +![个人微信](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-7/wechat3.jpeg) ### Contributor 下面是笔主收集的一些对本仓库提过有价值的pr或者issue的朋友，人数较多，如果你也对本仓库提过不错的pr或者issue的话，你可以加我的微信与我联系。下面的排名不分先后！ - - - + + + + + + + + + + + @@ -315,6 +399,12 @@ Markdown 格式参考：[Github Markdown格式](https://guides.github.com/featur + + + + + + ### 公众号 @@ -322,6 +412,6 @@ Markdown 格式参考：[Github Markdown格式](https://guides.github.com/featur **《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！ -**Java工程师必备学习资源:** 一些Java工程师常用学习资源[公众号](#公众号)后台回复关键字 **“1”** 即可免费无套路获取。 +**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 -![我的公众号](https://user-gold-cdn.xitu.io/2018/11/28/167598cd2e17b8ec?w=258&h=258&f=jpeg&s=27334) +![我的公众号](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/167598cd2e17b8ec.png) diff --git a/docs/_coverpage.md b/_coverpage.md similarity index 81% rename from docs/_coverpage.md rename to _coverpage.md index 612cd2160ec..9e45fbab3cf 100644 --- a/docs/_coverpage.md +++ b/_coverpage.md @@ -8,3 +8,6 @@ [GitHub]() [开始阅读](#java) +![](./media/pictures/rostyslav-savchyn-5joK905gcGc-unsplash.jpg) + + diff --git a/code/java/ThreadPoolExecutorDemo/.idea/.gitignore b/code/java/ThreadPoolExecutorDemo/.idea/.gitignore new file mode 100644 index 00000000000..5c98b428844 --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/.idea/.gitignore @@ -0,0 +1,2 @@ +# Default ignored files +/workspace.xml \ No newline at end of file diff --git a/code/java/ThreadPoolExecutorDemo/.idea/checkstyle-idea.xml b/code/java/ThreadPoolExecutorDemo/.idea/checkstyle-idea.xml new file mode 100644 index 00000000000..e61c523d5e2 --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/.idea/checkstyle-idea.xml @@ -0,0 +1,16 @@ + + + + + + \ No newline at end of file diff --git a/code/java/ThreadPoolExecutorDemo/.idea/inspectionProfiles/Project_Default.xml b/code/java/ThreadPoolExecutorDemo/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 00000000000..6560a98983e --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,36 @@ + + + + \ No newline at end of file diff --git a/code/java/ThreadPoolExecutorDemo/.idea/misc.xml b/code/java/ThreadPoolExecutorDemo/.idea/misc.xml new file mode 100644 index 00000000000..05483570e04 --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/code/java/ThreadPoolExecutorDemo/.idea/modules.xml b/code/java/ThreadPoolExecutorDemo/.idea/modules.xml new file mode 100644 index 00000000000..864cd10eaf7 --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/code/java/ThreadPoolExecutorDemo/.idea/uiDesigner.xml b/code/java/ThreadPoolExecutorDemo/.idea/uiDesigner.xml new file mode 100644 index 00000000000..e96534fb27b --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/code/java/ThreadPoolExecutorDemo/.idea/vcs.xml b/code/java/ThreadPoolExecutorDemo/.idea/vcs.xml new file mode 100644 index 00000000000..c2365ab11f9 --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/code/java/ThreadPoolExecutorDemo/ThreadPoolExecutorDemo.iml b/code/java/ThreadPoolExecutorDemo/ThreadPoolExecutorDemo.iml new file mode 100644 index 00000000000..c90834f2d60 --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/ThreadPoolExecutorDemo.iml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/META-INF/ThreadPoolExecutorDemo.kotlin_module b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/META-INF/ThreadPoolExecutorDemo.kotlin_module new file mode 100644 index 00000000000..2983af70661 Binary files /dev/null and b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/META-INF/ThreadPoolExecutorDemo.kotlin_module differ diff --git a/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/callable/CallableDemo.class b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/callable/CallableDemo.class new file mode 100644 index 00000000000..70861e733a4 Binary files /dev/null and b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/callable/CallableDemo.class differ diff --git a/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/callable/MyCallable.class b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/callable/MyCallable.class new file mode 100644 index 00000000000..283e340bdcf Binary files /dev/null and b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/callable/MyCallable.class differ diff --git a/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/common/ThreadPoolConstants.class b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/common/ThreadPoolConstants.class new file mode 100644 index 00000000000..07214fc7233 Binary files /dev/null and b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/common/ThreadPoolConstants.class differ diff --git a/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/scheduledThreadPoolExecutor/ScheduledThreadPoolExecutorDemo.class b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/scheduledThreadPoolExecutor/ScheduledThreadPoolExecutorDemo.class new file mode 100644 index 00000000000..dc98bc8f2fe Binary files /dev/null and b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/scheduledThreadPoolExecutor/ScheduledThreadPoolExecutorDemo.class differ diff --git a/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/scheduledThreadPoolExecutor/Task.class b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/scheduledThreadPoolExecutor/Task.class new file mode 100644 index 00000000000..9920a634de1 Binary files /dev/null and b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/scheduledThreadPoolExecutor/Task.class differ diff --git a/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/threadPoolExecutor/MyRunnable.class b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/threadPoolExecutor/MyRunnable.class new file mode 100644 index 00000000000..c1cf37ca4ad Binary files /dev/null and b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/threadPoolExecutor/MyRunnable.class differ diff --git a/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/threadPoolExecutor/ThreadPoolExecutorDemo.class b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/threadPoolExecutor/ThreadPoolExecutorDemo.class new file mode 100644 index 00000000000..80c34f4d66e Binary files /dev/null and b/code/java/ThreadPoolExecutorDemo/out/production/ThreadPoolExecutorDemo/threadPoolExecutor/ThreadPoolExecutorDemo.class differ diff --git a/code/java/ThreadPoolExecutorDemo/src/callable/CallableDemo.java b/code/java/ThreadPoolExecutorDemo/src/callable/CallableDemo.java new file mode 100644 index 00000000000..be762bda262 --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/src/callable/CallableDemo.java @@ -0,0 +1,49 @@ +package callable; + +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +import static common.ThreadPoolConstants.CORE_POOL_SIZE; +import static common.ThreadPoolConstants.KEEP_ALIVE_TIME; +import static common.ThreadPoolConstants.MAX_POOL_SIZE; +import static common.ThreadPoolConstants.QUEUE_CAPACITY; + +public class CallableDemo { + public static void main(String[] args) { + //使用阿里巴巴推荐的创建线程池的方式 + //通过ThreadPoolExecutor构造函数自定义参数创建 + ThreadPoolExecutor executor = new ThreadPoolExecutor( + CORE_POOL_SIZE, + MAX_POOL_SIZE, + KEEP_ALIVE_TIME, + TimeUnit.SECONDS, + new ArrayBlockingQueue<>(QUEUE_CAPACITY), + new ThreadPoolExecutor.CallerRunsPolicy()); + + List> futureList = new ArrayList<>(); + Callable callable = new MyCallable(); + for (int i = 0; i < 10; i++) { + //提交任务到线程池 + Future future = executor.submit(callable); + //将返回值 future 添加到 list，我们可以通过 future 获得 执行 Callable 得到的返回值 + futureList.add(future); + } + for (Future fut : futureList) { + try { + System.out.println(new Date() + "::" + fut.get()); + } catch (InterruptedException | ExecutionException e) { + e.printStackTrace(); + } + } + //关闭线程池 + executor.shutdown(); + } +} + diff --git a/code/java/ThreadPoolExecutorDemo/src/callable/MyCallable.java b/code/java/ThreadPoolExecutorDemo/src/callable/MyCallable.java new file mode 100644 index 00000000000..53d540fb75c --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/src/callable/MyCallable.java @@ -0,0 +1,13 @@ +package callable; + +import java.util.concurrent.Callable; + +public class MyCallable implements Callable { + + @Override + public String call() throws Exception { + Thread.sleep(1000); + //返回执行当前 Callable 的线程名字 + return Thread.currentThread().getName(); + } +} diff --git a/code/java/ThreadPoolExecutorDemo/src/common/ThreadPoolConstants.java b/code/java/ThreadPoolExecutorDemo/src/common/ThreadPoolConstants.java new file mode 100644 index 00000000000..2018e86f6c7 --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/src/common/ThreadPoolConstants.java @@ -0,0 +1,11 @@ +package common; + +public class ThreadPoolConstants { + public static final int CORE_POOL_SIZE = 5; + public static final int MAX_POOL_SIZE = 10; + public static final int QUEUE_CAPACITY = 100; + public static final Long KEEP_ALIVE_TIME = 1L; + private ThreadPoolConstants(){ + + } +} diff --git a/code/java/ThreadPoolExecutorDemo/src/threadPoolExecutor/MyRunnable.java b/code/java/ThreadPoolExecutorDemo/src/threadPoolExecutor/MyRunnable.java new file mode 100644 index 00000000000..4ebf2dcbce7 --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/src/threadPoolExecutor/MyRunnable.java @@ -0,0 +1,36 @@ +package threadPoolExecutor; + +import java.util.Date; + +/** + * 这是一个简单的Runnable类，需要大约5秒钟来执行其任务。 + * @author shuang.kou + */ +public class MyRunnable implements Runnable { + + private String command; + + public MyRunnable(String s) { + this.command = s; + } + + @Override + public void run() { + System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date()); + processCommand(); + System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date()); + } + + private void processCommand() { + try { + Thread.sleep(5000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + @Override + public String toString() { + return this.command; + } +} diff --git a/code/java/ThreadPoolExecutorDemo/src/threadPoolExecutor/ThreadPoolExecutorDemo.java b/code/java/ThreadPoolExecutorDemo/src/threadPoolExecutor/ThreadPoolExecutorDemo.java new file mode 100644 index 00000000000..2e510cd6562 --- /dev/null +++ b/code/java/ThreadPoolExecutorDemo/src/threadPoolExecutor/ThreadPoolExecutorDemo.java @@ -0,0 +1,39 @@ +package threadPoolExecutor; + +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +import static common.ThreadPoolConstants.CORE_POOL_SIZE; +import static common.ThreadPoolConstants.KEEP_ALIVE_TIME; +import static common.ThreadPoolConstants.MAX_POOL_SIZE; +import static common.ThreadPoolConstants.QUEUE_CAPACITY; + + +public class ThreadPoolExecutorDemo { + + public static void main(String[] args) { + + //使用阿里巴巴推荐的创建线程池的方式 + //通过ThreadPoolExecutor构造函数自定义参数创建 + ThreadPoolExecutor executor = new ThreadPoolExecutor( + CORE_POOL_SIZE, + MAX_POOL_SIZE, + KEEP_ALIVE_TIME, + TimeUnit.SECONDS, + new ArrayBlockingQueue<>(QUEUE_CAPACITY), + new ThreadPoolExecutor.CallerRunsPolicy()); + + for (int i = 0; i < 10; i++) { + //创建WorkerThread对象（WorkerThread类实现了Runnable 接口） + Runnable worker = new MyRunnable("" + i); + //执行Runnable + executor.execute(worker); + } + //终止线程池 + executor.shutdown(); + while (!executor.isTerminated()) { + } + System.out.println("Finished all threads"); + } +} diff --git a/docs/HomePage.md b/docs/HomePage.md deleted file mode 100644 index ace3fd8a412..00000000000 --- a/docs/HomePage.md +++ /dev/null @@ -1,202 +0,0 @@ -

Java 学习/面试指南

-

- - - -

-

Special Sponsors

-

- - - -

- - -## Java - -### 基础 - -* [Java 基础知识回顾](./java/Java基础知识.md) -* [J2EE 基础知识回顾](./java/J2EE基础知识.md) -* [Collections 工具类和 Arrays 工具类常见方法](./java/Basis/Arrays%2CCollectionsCommonMethods.md) -* [Java常见关键字总结：static、final、this、super](./java/Basis/final、static、this、super.md) - -### 容器 - -* **常见问题总结：** - * [这几道Java集合框架面试题几乎必问](./java/这几道Java集合框架面试题几乎必问.md) - * [Java 集合框架常见面试题总结](./java/Java集合框架常见面试题总结.md) -* **源码分析：** - * [ArrayList 源码学习](./java/ArrayList.md) - * [【面试必备】透过源码角度一步一步带你分析 ArrayList 扩容机制](./java/ArrayList-Grow.md) - * [LinkedList 源码学习](./java/LinkedList.md) - * [HashMap(JDK1.8)源码学习](./java/HashMap.md) - -### 并发 - -* [并发编程面试必备：synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及 和ReenTrantLock 的对比](./java/synchronized.md) -* [并发编程面试必备：乐观锁与悲观锁](./essential-content-for-interview/面试必备之乐观锁与悲观锁.md) -* [并发编程面试必备：JUC 中的 Atomic 原子类总结](./java/Multithread/Atomic.md) -* [并发编程面试必备：AQS 原理以及 AQS 同步组件总结](./java/Multithread/AQS.md) -* [BATJ都爱问的多线程面试题](./java/Multithread/BATJ都爱问的多线程面试题.md) -* [并发容器总结](./java/Multithread/并发容器总结.md) - -### JVM - -* [可能是把Java内存区域讲的最清楚的一篇文章](./java/可能是把Java内存区域讲的最清楚的一篇文章.md) -* [搞定JVM垃圾回收就是这么简单](./java/搞定JVM垃圾回收就是这么简单.md) -* [《深入理解Java虚拟机》第2版学习笔记](./java/Java虚拟机（jvm）.md) - -### I/O - -* [BIO,NIO,AIO 总结 ](./java/BIO-NIO-AIO.md) -* [Java IO 与 NIO系列文章](./java/Java%20IO与NIO.md) - -### Java 8 - -* [Java 8 新特性总结](./java/What's%20New%20in%20JDK8/Java8Tutorial.md) -* [Java 8 学习资源推荐](./java/What's%20New%20in%20JDK8/Java8教程推荐.md) - -### 编程规范 - -- [Java 编程规范](./java/Java编程规范.md) - -## 网络 - -* [计算机网络常见面试题](./network/计算机网络.md) -* [计算机网络基础知识总结](./network/干货：计算机网络知识总结.md) -* [HTTPS中的TLS](./network/HTTPS中的TLS.md) - -## 操作系统 - -### Linux相关 - -* [后端程序员必备的 Linux 基础知识](./operating-system/后端程序员必备的Linux基础知识.md) -* [Shell 编程入门](./operating-system/Shell.md) - -## 数据结构与算法 - -### 数据结构 - -- [数据结构知识学习与面试](./dataStructures-algorithms/数据结构.md) - -### 算法 - -- [算法学习资源推荐](./dataStructures-algorithms/算法学习资源推荐.md) -- [算法总结——几道常见的子符串算法题 ](./dataStructures-algorithms/几道常见的子符串算法题.md) -- [算法总结——几道常见的链表算法题 ](./dataStructures-algorithms/几道常见的链表算法题.md) -- [剑指offer部分编程题](./dataStructures-algorithms/剑指offer部分编程题.md) -- [公司真题](./dataStructures-algorithms/公司真题.md) -- [回溯算法经典案例之N皇后问题](./dataStructures-algorithms/Backtracking-NQueens.md) - -## 数据库 - -### MySQL - -* [MySQL 学习与面试](./database/MySQL.md) -* [一千行MySQL学习笔记](./database/一千行MySQL命令.md) -* [【思维导图-索引篇】搞定数据库索引就是这么简单](./database/MySQL%20Index.md) -* [事务隔离级别(图文详解)](./database/事务隔离级别(图文详解).md) -* [一条sql语句在MySQL中如何执行的](./database/一条sql语句在mysql中如何执行的.md) - -### Redis - -* [Redis 总结](./database/Redis/Redis.md) -* [Redlock分布式锁](./database/Redis/Redlock分布式锁.md) -* [如何做可靠的分布式锁，Redlock真的可行么](./database/Redis/如何做可靠的分布式锁，Redlock真的可行么.md) - -## 系统设计 - -### 设计模式 - -- [设计模式系列文章](./system-design/设计模式.md) - -### 常用框架 - -#### Spring - -- [Spring 学习与面试](./system-design/framework/Spring学习与面试.md) -- [Spring中bean的作用域与生命周期](./system-design/framework/SpringBean.md) -- [SpringMVC 工作原理详解](./system-design/framework/SpringMVC%20%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86%E8%AF%A6%E8%A7%A3.md) - -#### ZooKeeper - -- [可能是把 ZooKeeper 概念讲的最清楚的一篇文章](./system-design/framework/ZooKeeper.md) -- [ZooKeeper 数据模型和常见命令了解一下，速度收藏！](./system-design/framework/ZooKeeper数据模型和常见命令.md) - -### 数据通信 - -- [数据通信(RESTful、RPC、消息队列)相关知识点总结](./system-design/data-communication/数据通信(RESTful、RPC、消息队列).md) -- [Dubbo 总结：关于 Dubbo 的重要知识点](./system-design/data-communication/dubbo.md) -- [消息队列总结：新手也能看懂，消息队列其实很简单](./system-design/data-communication/message-queue.md) -- [一文搞懂 RabbitMQ 的重要概念以及安装](./system-design/data-communication/rabbitmq.md) - -### 网站架构 - -- [一文读懂分布式应该学什么](./system-design/website-architecture/分布式.md) -- [8 张图读懂大型网站技术架构](./system-design/website-architecture/8%20张图读懂大型网站技术架构.md) -- [【面试精选】关于大型网站系统架构你不得不懂的10个问题](./system-design/website-architecture/【面试精选】关于大型网站系统架构你不得不懂的10个问题.md) - -## 面试指南 - -### 备战面试 - -* [【备战面试1】程序员的简历就该这样写](./essential-content-for-interview/PreparingForInterview/程序员的简历之道.md) -* [【备战面试2】初出茅庐的程序员该如何准备面试？](./essential-content-for-interview/PreparingForInterview/interviewPrepare.md) -* [【备战面试3】7个大部分程序员在面试前很关心的问题](./essential-content-for-interview/PreparingForInterview/JavaProgrammerNeedKnow.md) -* [【备战面试4】Java程序员必备书单](./essential-content-for-interview/PreparingForInterview/books.md) -* [【备战面试5】Github上开源的Java面试/学习相关的仓库推荐](./essential-content-for-interview/PreparingForInterview/JavaInterviewLibrary.md) -* [【备战面试6】如果面试官问你“你有什么问题问我吗？”时，你该如何回答](./essential-content-for-interview/PreparingForInterview/如果面试官问你“你有什么问题问我吗？”时，你该如何回答.md) -* [【备战面试7】美团面试常见问题总结（附详解答案）](./essential-content-for-interview/PreparingForInterview/美团面试常见问题总结.md) - -### 常见面试题总结 - -* [第一周（2018-8-7）](./essential-content-for-interview/MostCommonJavaInterviewQuestions/第一周（2018-8-7）.md) (为什么 Java 中只有值传递、==与equals、 hashCode与equals) -* [第二周（2018-8-13）](./essential-content-for-interview/MostCommonJavaInterviewQuestions/第二周(2018-8-13).md)(String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的？、什么是反射机制？反射机制的应用场景有哪些？......) -* [第三周（2018-08-22）](./java/这几道Java集合框架面试题几乎必问.md) （Arraylist 与 LinkedList 异同、ArrayList 与 Vector 区别、HashMap的底层实现、HashMap 和 Hashtable 的区别、HashMap 的长度为什么是2的幂次方、HashSet 和 HashMap 区别、ConcurrentHashMap 和 Hashtable 的区别、ConcurrentHashMap线程安全的具体实现方式/底层具体实现、集合框架底层数据结构总结） -* [第四周(2018-8-30).md](./essential-content-for-interview/MostCommonJavaInterviewQuestions/第四周(2018-8-30).md) （主要内容是几道面试常问的多线程基础题。） - -### 面经 - -- [5面阿里,终获offer(2018年秋招)](./essential-content-for-interview/BATJrealInterviewExperience/5面阿里,终获offer.md) - -## 工具 - -### Git - -* [Git入门](./tools/Git.md) - -### Docker - -* [Docker 入门](./tools/Docker.md) - -## 资料 - -### 书单 - -- [Java程序员必备书单](./essential-content-for-interview/PreparingForInterview/books.md) - -### Github榜单 - -- [Java 项目月榜单](./github-trending/JavaGithubTrending.md) - -*** - -## 待办 - -- [x] [Java 8 新特性总结](./java/What's%20New%20in%20JDK8/Java8Tutorial.md) -- [x] [Java 8 新特性详解](./java/What's%20New%20in%20JDK8/Java8教程推荐.md) -- [ ] Java 多线程类别知识重构(---正在进行中---) -- [x] [BIO,NIO,AIO 总结 ](./java/BIO-NIO-AIO.md) -- [ ] Netty 总结(---正在进行中---) -- [ ] 数据结构总结重构(---正在进行中---) - -## 公众号 - -- 如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 -- 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本公众号后台回复 **"Java面试突击"** 即可免费领取！ -- 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 - -

- -

diff --git "a/docs/chat/2018 \347\247\213\346\213\233.md" "b/docs/chat/2018 \347\247\213\346\213\233.md" deleted file mode 100644 index a2b47de8eee..00000000000 --- "a/docs/chat/2018 \347\247\213\346\213\233.md" +++ /dev/null @@ -1,93 +0,0 @@ - - -# 秋招历程流水账总结 - -笔主大四准毕业生，在秋招末流比较幸运地进入了一家自己非常喜欢一家公司——ThoughtWorks. - -![今天去签约在门外拍的照片](https://images.gitbook.cn/1433af10-d5f7-11e8-841a-4f0b0cc7be7b) - -从9-6号投递出去第一份简历，到10-18号左右拿到第一份 offer ，中间差不多有 1 个半月的时间了。可能自己比较随缘，而且自己所在的大学所处的位置并不是互联网比较发达的城市的原因。所以，很少会有公司愿意跑到我们学校那边来宣讲，来的公司也大多是一些自己没听过或者不太喜欢的公司。所以，在前期，我仅仅能够通过网上投递简历的方式来找工作。 - -零零总总算了一下，自己在网上投了大概有 10 份左右的简历，都是些自己还算喜欢的公司。简单说一下自己投递的一些公司：网上投递的公司有：ThoughtWorks、网易、小米、携程、爱奇艺、知乎、小红书、搜狐、欢聚时代、京东；直接邮箱投递的有：烽火、中电数据、蚂蚁金服花呗部门、今日头条；线下宣讲会投递的有：玄武科技。 - -网上投递的大部分简历都是在做完笔试之后就没有了下文了，即使有几场笔试自我感觉做的很不错的情况下，还是没有收到后续的面试邀请。还有些邮箱投递的简历，后面也都没了回应。所以，我总共也只参加了3个公司的面试，ThoughtWorks、玄武科技和中电数据，都算是拿到了 offer。拿到 ThoughtWorks 的 offer之后，后面的一些笔试和少部分面试都拒了。决定去 ThoughtWorks 了，春招的大部队会没有我的存在。 - - -我个人对 ThoughtWorks 最有好感，ThoughtWorks 也是我自己之前很想去的一家公司。不光是因为我投递简历的时候可以不用重新填一遍表格可以直接发送我已经编辑好的PDF格式简历的友好，这个公司的文化也让我很喜欢。每次投递一家公司几乎都要重新填写一遍简历真的很让人头疼，即使是用牛客网的简历助手也还是有很多东西需要自己重新填写。 - -说句实话，自己在拿到第一份 offer 之前心里还是比较空的，虽然说对自己还是比较自信。包括自己当时来到武汉的原因，也是因为自己没有 offer ，就感觉心里空空的，我相信很多人在这个时候与我也有一样的感觉。然后，我就想到武汉参加一下别的学校宣讲会。现在看来，这个决定也是不必要的，因为我最后去的公司 ThoughtWorks，虽然就在我租的房子的附近，但之前投递的时候，选择的还是远程面试。来到武汉，简单的修整了一下之后，我就去参加了玄武科技在武理工的宣讲会，顺便做了笔试，然后接着就是技术面、HR面、高管面。总体来说，玄武科技的 HR 真的很热情，为他们点个赞，虽然自己最后没能去玄武科技，然后就是技术面非常简单，HR面和高管面也都还好，不会有压抑的感觉，总体聊得很愉快。需要注意的是 玄武科技和很多公司一样都有笔试中有逻辑题，我之前没有做过类似的题，所以当时第一次做有点懵逼。高管面的时候，高管还专门在我做的逻辑题上聊了一会，让我重新做了一些做错的题，并且给他讲一些题的思路，可以看出高层对于应聘者的这项能力还是比较看重的。 - - - -中电数据的技术面试是电话进行的，花了1个多小时一点，个人感觉问的还是比较深的，感觉自己总体回答的还是比较不错的。 - -这里我着重说一下 ThoughtWorks，也算是给想去 ThoughtWorks 的同学一点小小的提示。我是 9.11 号在官网：https://join.thoughtworks.cn/ 投递的简历，9.20 日邮件通知官网下载作业，作业总体来说不难，9.21 号花了半天多的时间做完，然后就直接在9.21 号下午提交了。然后等了挺长时间的，可能是因为 ThoughtWorks 在管理方面比较扁平化的原因，所以总体来说效率可能不算高。因为我选的是远程面试，所以直接下载好 zoom 之后，等HR打电话过来告诉你一个房间号，你就可以直接进去面试就好，一般技术面试有几个人看着你。技术面试的内容，首先就是在面试官让你在你之前做的作业的基础上新增加一个或者两个功能（20分钟）。所以，你在技术面试之前一定要保证你的程序的扩展性是不错的，另外就是你在技术面试之前最好能重构一下自己写的程序。重构本身就是你自己对你写的程序的理解加强很好的一种方式，另外重构也能让你发现你的程序的一些小问题。然后，这一步完成之后，面试官可能会问你一些基础问题，比较简单，所以我觉得 ThoughtWorks 可能更看重你的代码质量。ThoughtWorks 的 HR 面和其他公司的唯一不同可能在于，他会让你用英语介绍一下自己或者说自己的技术栈啊这些。 - -![思特沃克可爱的招聘官网](https://images.gitbook.cn/83f765e0-d5f6-11e8-9c1a-919e09988420) - - -# 关于面试一些重要的问题总结 -另外，再给大家总结一些我个人想到一些关于面试非常重要的一些问题。 - -### 面试前 - -**如何准备** - - -运筹帷幄之后，决胜千里之外！不打毫无准备的仗，我觉得大家可以先从下面几个方面来准备面试： - -1. 自我介绍。（你可千万这样介绍：“我叫某某，性别，来自哪里，学校是那个，自己爱干什么”，记住：多说点简历上没有的，多说点自己哪里比别人强！） -2. 自己面试中可能涉及哪些知识点、那些知识点是重点。 -3. 面试中哪些问题会被经常问到、面试中自己改如何回答。(强烈不推荐背题，第一：通过背这种方式你能记住多少？能记住多久？第二：背题的方式的学习很难坚持下去！) -4. 自己的简历该如何写。 - - - -另外，如果你想去类似阿里巴巴、腾讯这种比较大的互联网公司的话，一定要尽早做打算。像阿里巴巴在7月份左右就开始了提前批招聘，到了9月份差不多就已经招聘完毕了。所以，秋招没有参加到阿里的面试还是很遗憾的，毕竟面试即使失败了，也能从阿里难度Max的面试中学到很多东西。 - -**关于着装** - -穿西装、打领带、小皮鞋？NO！NO！NO！这是互联网公司面试又不是去走红毯，所以你只需要穿的简单大方就好，不需要太正式。 - -**关于自我介绍** - -如果你简历上写的基本信息就不要说了，比如性别、年龄、学校。另外，你也不要一上来就说自己爱好什么这方面内容。因为，面试官根本不关心这些东西。你直接挑和你岗位相关的重要经历和自己最突出的特点讲就好了。 - - - -**提前准备** - -面试之前可以在网上找找有没有你要面试的公司的面经。在我面试 ThoughtWorks 的前几天我就在网上找了一些关于 ThoughtWorks 的技术面的一些文章。然后知道了 ThoughtWorks 的技术面会让我们在之前做的作业的基础上增加一个或两个功能，所以我提前一天就把我之前做的程序重新重构了一下。然后在技术面的时候，简单的改了几行代码之后写个测试就完事了。如果没有提前准备，我觉得 20 分钟我很大几率会完不成这项任务。 - - -### 面试中 - -面试的时候一定要自信，千万不要怕自己哪里会答不出来，或者说某个问题自己忘记怎么回答了。面试过程中，很多问题可能是你之前没有碰到过的，这个时候你就要通过自己构建的知识体系来思考这些问题。如果某些问题你回答不上来，你也可以让面试官给你简单的提示一下。总之，你要自信，你自信的前提是自己要做好充分的准备。下面给大家总结一些面试非常常见的问题： - -- SpringMVC 工作原理 -- 说一下自己对 IOC 、AOP 的理解 -- Spring 中用到了那些设计模式，讲一下自己对于这些设计模式的理解 -- Spring Bean 的作用域和生命周期了解吗 -- Spring 事务中的隔离级别 -- Spring 事务中的事务传播行为 -- 手写一个 LRU 算法 -- 知道那些排序算法，简单介绍一下快排的原理，能不能手写一下快排 -- String 为什么是不可变的？String为啥要设计为不可变的？ -- Arraylist 与 LinkedList 异同 -- HashMap的底层实现 -- HashMap 的长度为什么是2的幂次方 -- ConcurrentHashMap 和 Hashtable 的区别 -- ConcurrentHashMap线程安全的具体实现方式/底层具体实现 -- 如果你的简历写了redis 、dubbo、zookeeper、docker的话，面试官还会问一下这些东西。比如redis可能会问你：为什么要用 redis、为什么要用 redis 而不用 map/guava 做缓存、redis 常见数据结构以及使用场景分析、 redis 设置过期时间、redis 内存淘汰机制、 redis 持久化机制、 缓存雪崩和缓存穿透问题、如何解决 Redis 的并发竞争 Key 问题、如何保证缓存与数据库双写时的数据一致性。 -- 一些简单的 Linux 命令。 -- 为什么要用 消息队列 -- 关于 Java多线程，在面试的时候，问的比较多的就是①悲观锁和乐观锁②synchronized 和 ReenTrantLock 区别以及 volatile 和 synchronized 的区别，③可重入锁与非可重入锁的区别、④多线程是解决什么问题的、⑤线程池解决什么问题，为什么要用线程池 ⑥Synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及 ReenTrantLock 对比；⑦线程池使用时的注意事项、⑧AQS 原理以及 AQS 同步组件：Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock、⑨ReentranLock源码，设计原理，整体过程 等等问题。 -- 关于 Java 虚拟机问的比较多的是：①Java内存区域、②虚拟机垃圾算法、③虚拟机垃圾收集器、④JVM内存管理、⑤JVM调优这些问题。 - - -### 面试后 - -如果失败，不要灰心；如果通过，切勿狂喜。面试和工作实际上是两回事，可能很多面试未通过的人，工作能力比你强的多，反之亦然。我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！ - - - diff --git "a/docs/chat/\344\270\252\344\272\272\351\230\205\350\257\273\344\271\246\347\261\215\346\270\205\345\215\225.md" "b/docs/chat/\344\270\252\344\272\272\351\230\205\350\257\273\344\271\246\347\261\215\346\270\205\345\215\225.md" deleted file mode 100644 index f14ee33a211..00000000000 --- "a/docs/chat/\344\270\252\344\272\272\351\230\205\350\257\273\344\271\246\347\261\215\346\270\205\345\215\225.md" +++ /dev/null @@ -1,89 +0,0 @@ -下面是个人阅读书籍的部分清单，我比较建议阅读的书籍前都加上了:thumbsup: 表情。 -> ### 核心基础知识 - -- :thumbsup: [《图解HTTP》](https://book.douban.com/subject/25863515/) - - 讲漫画一样的讲HTTP，很有意思，不会觉得枯燥，大概也涵盖也HTTP常见的知识点。因为篇幅问题，内容可能不太全面。不过，如果不是专门做网络方向研究的小伙伴想研究HTTP相关知识的话，读这本书的话应该来说就差不多了。 - -> ### Java相关 - -- :thumbsup: [《Head First Java.第二版》](https://book.douban.com/subject/2000732/) - - 可以说是我的Java启蒙书籍了，特别适合新手读当然也适合我们用来温故Java知识点。 - -- [《Java多线程编程核心技术》](https://book.douban.com/subject/26555197/) - - Java多线程入门级书籍还不错，但是说实话，质量不是很高，很快就可以阅读完。 - -- [《JAVA网络编程 第4版》](https://book.douban.com/subject/26259017/) - - 可以系统的学习一下网络的一些概念以及网络编程在Java中的使用。 - -- :thumbsup: [《Java核心技术卷1+卷2》](https://book.douban.com/subject/25762168/) - - 很棒的两本书，建议有点Java基础之后再读，介绍的还是比较深入的，非常推荐。这两本书我一般也会用来巩固知识点，是两本适合放在自己身边的好书。 - -- :thumbsup: [《Java编程思想(第4版)》](https://book.douban.com/subject/2130190/) - - 这本书要常读，初学者可以快速概览，中等程序员可以深入看看java，老鸟还可以用之回顾java的体系。这本书之所以厉害，因为它在无形中整合了设计模式，这本书之所以难读，也恰恰在于他对设计模式的整合是无形的。 - -- :thumbsup: [《Java并发编程的艺术》](https://book.douban.com/subject/26591326/) - - 这本书不是很适合作为Java并发入门书籍，需要具备一定的JVM基础。我感觉有些东西讲的还是挺深入的，推荐阅读。 -- :thumbsup: [《实战Java高并发程序设计》](https://book.douban.com/subject/26663605/) - - 豆瓣评分 8.3 ，书的质量没的说，推荐大家好好看一下。 - -- [《Java程序员修炼之道》](https://book.douban.com/subject/24841235/) - - 很杂，我只看了前面几章，不太推荐阅读。 - -- :thumbsup: [《深入理解Java虚拟机（第2版）周志明》](https://book.douban.com/subject/24722612/) - - 神书！神书！神书！建议多刷几遍，书中的所有知识点可以通过JAVA运行时区域和JAVA的内存模型与线程两个大模块罗列完全。 - -> ### JavaWeb相关 - -- :thumbsup: [《深入分析Java Web技术内幕》](https://book.douban.com/subject/25953851/) - - 感觉还行，涉及的东西也蛮多，推荐阅读。 - -- :thumbsup: [《Spring实战（第4版）》](https://book.douban.com/subject/26767354/) - - 不建议当做入门书籍读，入门的话可以找点国人的书或者视频看。这本定位就相当于是关于Spring的新华字典，只有一些基本概念的介绍和示例，涵盖了Spring的各个方面，但都不够深入。就像作者在最后一页写的那样：“学习Spring，这才刚刚开始”。 - -- [《Java Web整合开发王者归来》](https://book.douban.com/subject/4189495/) - - 当时刚开始学的时候就是开的这本书，基本上是完完整整的看完了。不过，我不是很推荐大家看。这本书比较老了，里面很多东西都已经算是过时了。不过，这本书的一个很大优点是：基础知识点概括全面。 - -- :thumbsup: [《Redis实战》](https://book.douban.com/subject/26612779/) - - 如果你想了解Redis的一些概念性知识的话，这本书真的非常不错。 - -> ### 架构相关 - -- :thumbsup: [《大型网站技术架构：核心原理与案例分析+李智慧》](https://book.douban.com/subject/25723064/) - - 这本书我读过，基本不需要你有什么基础啊~读起来特别轻松，但是却可以学到很多东西，非常推荐了。另外我写过这本书的思维导图，关注我的微信公众号：“Java面试通关手册”回复“大型网站技术架构”即可领取思维导图。 - -- [《架构解密从分布式到微服务（Leaderus著）》](https://book.douban.com/subject/27081188/) - - 很一般的书籍，我就是当做课后图书来阅读的。 - -> ### 代码优化 - -- :thumbsup: [《重构_改善既有代码的设计》](https://book.douban.com/subject/4262627/) - - 豆瓣 9.1 分，重构书籍的开山鼻祖。 -> ### linux操作系统相关 -- :thumbsup:[<>](https://book.douban.com/subject/25900403/) :thumbsup: [<>](https://book.douban.com/subject/1500149/) - - 对于理解linux操作系统原理非常有用，同时可以打好个人的基本功力，面试中很多公司也会问到linux知识。 -> ### 课外书籍 - -《技术奇点》 :thumbsup:《追风筝的人》 :thumbsup:《穆斯林的葬礼》 :thumbsup:《三体》 《人工智能——李开复》 -:thumbsup:《活着——余华》 - - - - diff --git "a/docs/chat/\345\246\202\344\275\225\346\217\220\351\227\256.md" "b/docs/chat/\345\246\202\344\275\225\346\217\220\351\227\256.md" deleted file mode 100644 index f860839bd47..00000000000 --- "a/docs/chat/\345\246\202\344\275\225\346\217\220\351\227\256.md" +++ /dev/null @@ -1,53 +0,0 @@ -上几周公司例会培训有一个讲座是关于 **“如何提问”** 的，听完讲座再联想到自己的一些实际经历，我觉得学会提问对一个来说真的太特么重要了。 - -就拿我自己平时的情况来说，随着我自己业余写的一些文章被越来越人看到，越来越多人认识和了解到我。也正因为如此，我每天几乎都面临来自读者至少 10 个以上的问题。我挺高兴有这么多人愿意问我问题的。我看到一些读者的问题，能回答的我都会尽力去好好解决对方的疑惑，我觉得这也算是一种信任，一种陌生人之间建立起来的信任。如果我没及时回答或者忘记回答你的问题的话，可能是我当时比较忙忘记了或者说我自己也不会！我也请各位也对没有按时回答你问题的一些人一些宽容，换句话说也没有人有义务非要去回答你的问题，而且你的的提问方式真的很大影响了别人回答你问题的欲望。所以，大家在提问题之前可以先这样想：“别人如果回答我的问题是情分，如果没能解决我的问题也很正常，如果忘记或者不想回答我的问题也没毛病”。至少我每次问别人问题前都是这样想的，这样别人很久或者没回答我问题，我也不至于纠结半天！**于****我而言，你所提的问题质量，决定了我是否愿意去帮你解答。甚至在某些情况下，你提出了一些很有价值的问题的话，会让我对你产生一种好感，觉得你这个人还挺有见解“**。 - -我遇到过很多让我无语或者头疼的问题，也遇到让我很欢喜想要去耐心解答的问题，总的来说，会提问的人还是太少了。我不知道我是不是一个会提问的人，为此我也查阅了网上的一些相关资料，下面给大家分享一下我对如何提问的看法。**下面只是代表了我个人的看法，欢迎各位在评论区说出自己的见解，我会抽出一位综合起来最好的朋友送一本50元左右的任意书籍。** - -下面我总结了一些经常被问到的一些问题，我暂且将它们分为：“稍微正常”和“不那么好”这两类。 - -**我觉得稍微正常点的问题（还算正常的问题，但提问方式有待改善）：** - -1. 如何学习什么? -2. 什么该如何入门? -3. 什么问题如何解决? -4. 什么内容你能给我解释一下吗? -5. 如何找到一个让自己满意的工作? -6. 简介该如何写? -7. 初学xxx有哪些书籍推荐呢？ -8. ...... - - - -**我觉得觉得不那么好的问题（让人讨厌的问题）：** - -1. 什么软件可以发一下、我能在哪找到 X 程序或 X 资源？（一般被提问者内心OS：难道不会 Google？最不济应该也会百度吧！） -2. 什么环境变量怎么配置啊（ Google？百度？） -3. 随便截个bug图，然后扔下一句话：“这是什么题”（一般被提问者内心OS：我滴个乖乖，你随便截个图问我，我特么哪有闲心思给你解决这种问题，我自己不就是从这个时候过来的吗，是不是应该把 stackoverflow 推荐给他！ -4. 我怎么才能破解 root 帐号/窃取 OP 特权/读别人的邮件呢？(一般被提问者内心OS：想要这样做，说明了你是个卑鄙小人；想找个别人帮你，说明你是个白痴！) -5. ...... - -分享一个这两天遇到的一个典型的例子，当然，之前也遇到了很多这样的例子，我觉得下面这位同学的问题以及提问方式都不太好，至少我自己真的不太喜欢。 - -![null](https://mmbiz.qpic.cn/mmbiz_png/iaIdQfEric9Tw8S29vl6wk6aYibBBia0w2u6LGwcibRkDiaX9NlloSQRUoRtulgnMFqzeohq5LwqJYGQPvVLeFce15Fg/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1) - -前面的聊天的我这里就不贴了，总结来说，我觉得他的提问存在很明显的问题就是：没有把自己的问题描述清楚，问一些过于”低级“的问题，另外，最重要是我觉得他态度也不是那么好。所以，后面我就直接给他说：”这些问题你直接百度/Google 最好“。我是真的讨厌这种问问题方式，我也知道你可能是刚入门，需要别人帮助你回答一些疑问，但是请你问问题之前自己先做下功课可好？ - -说了这么多废话，其实也是自己心里话，不光是想让大家意识到会提问真的很重要，同时也是告诫自己以后要注意自己的提问方式。**下面说一下我觉得比较好的提问方式或者说是高效提问方式：** - -1. 最重要的就是遇到问题之前首先 Google！很多时候你花半个小时到处问问题，你 Google 一下可能 10 分钟就解决了。 -2. 有问题直接问，不要给别人来句“在吗”或者“有时间吗”这类话（我觉得我还算脾气很好的，每天都会遇到这类人，每天都不耐烦的回答，但直接说明自己的问题或者请求不是更好吗？）。 -3. 问别人问题之前自己先做一些功课，不要一上来就问一下很 Low 的问题，让别人对你的印象不好； -4. 问问题的时候尽量添加一些上下文信息，比如说：你为什么问这些问题，这些问题出现在什么情况下等等。 -5. 你可以先说明一下自己对于这些问题的看法，你准备如何解决，你做过哪些尝试，你期待对方给你什么样的回答。 -6. 缩小你的问题的范围，越是范围小而清晰的问题越容易回答。 - - - -最后，再分享一下有些我觉得比较好的提问网站： - -**国内:** segmentfault、知乎 - -**国外：**stackoverflow (感觉和知乎很像，但是 stackoverflow 不光可以给回答打分还可以给问题本身打分，我觉得这点很不错，最重要的是 stackoverflow 主要是程序员问答，你遇到的很多程序问题在这里应该都有其他人遇到过 ) - -更多关于如何提问的内容，详见 github 上开源版『提问的智慧』 diff --git "a/docs/chat/\351\200\211\346\213\251\346\212\200\346\234\257\346\226\271\345\220\221\351\203\275\350\246\201\350\200\203\350\231\221\345\223\252\344\272\233\345\233\240\347\264\240.md" "b/docs/chat/\351\200\211\346\213\251\346\212\200\346\234\257\346\226\271\345\220\221\351\203\275\350\246\201\350\200\203\350\231\221\345\223\252\344\272\233\345\233\240\347\264\240.md" deleted file mode 100644 index fa39c7c1150..00000000000 --- "a/docs/chat/\351\200\211\346\213\251\346\212\200\346\234\257\346\226\271\345\220\221\351\203\275\350\246\201\350\200\203\350\231\221\345\223\252\344\272\233\345\233\240\347\264\240.md" +++ /dev/null @@ -1,63 +0,0 @@ -本文主要是作者读安晓辉老师的《程序员程序员职场进阶 32 讲 》中关于“选择技术方向都要考虑哪些因素”这部分做的一些笔记和自己的思考。在这里分享给各位！ - -### 选择一种技术可能会考虑到的决定因素 - -1. 就业机会 - - 选择一门就业面广的技术还是比较重要的。我的很多学PHP的同学现在都在培训班学Java，真的！！！ -2. 难易程度 - - 我当时是在C/C++语言与Java中选择了Java，因为我感觉Java学起来确实要比C++简单一些。 -3. 个人兴趣 - - 兴趣是你能坚持下来的一个很重要的条件。 -4. 薪资水平 - - 薪资虽然不是人的唯一追求，但是一定是必备的追求。 -5. 发展前景 - - 你肯定不愿意看到这种情况发生：选择了一门技术，结果一年后它就没人用、没市场了。所以我们在选择时就要考虑这一点，做一些预判。 - - 选择技术时存在两种考虑：一种是选择稳定的、经典的技术；一种是卡位将来的市场缺口，选择将来可能需要用到的技术。 -6. 他人推荐 - - 我们在懵懵懂懂的时候，往往最容易听从别人的推荐，然后选择某种技术。 -7. 相近原则 - - 当我们已经掌握了一些技术，要学习新技术时，就可以根据一种新技术是否和自己已经掌握的技术比较接近来判断选择。相近的技术，学起来会更容易上手。 -8. 互补原则 - - 和相近性类似，互补性也常用在拓展我们技术能力的情景下。它指的是，有一些技术可以和你已经掌握的技术互相补充，组合在一起，形成更完整、更系统的技术图谱，给你带来更大的竞争力。关于相近原则与互补原则，我们也会在后面的文章里具体解读。 -9. 团队技术图谱 - - 我觉得这个可能就是团队开发过程中的需要。比如在做一个项目的时候，这个项目需要你去学习一下某个你没有接触过的新技术。 - -### 入行时如何选择技术方向 - - 为了明确自己的求职目标，可以问问自己下面的问题： -- 我想在哪个城市工作？ -- 我想在哪些行业、领域发展？ -- 我想去什么样的公司？ -- 我想做什么样的产品？ - -另外你要知道的是热门技术会有更多机会，相应竞争压力也会更大，并不能保证你找到合适的工作。 -冷门技术，机会相对较少，而且机会相对确定 。 - -### 构建技能树时如何选择技术方向 - -当我们过了专项能力提升的初级阶段之后，就应该开始构建自己的技能体系了。在为搭建技能树而选择技术时，通常考虑下面两个原则： -- 相近原则 -- 互补原则 - -“学习技术时一定要学对自己以后发展有用的技术”是我经常对自己强调的，另外我觉得很误导人同时也很错误的一个思想是：“只要是技术学了就会有用的”，这句话在我刚学编程时经常听到有人对我说。希望大家不要被误导，很多技术过时了就是过时了，没有必要再去花时间学。 - -我觉得相近原则和互补原则互补原则就是你主精和自己技术方向相同的的东西或者对自己技术领域有提升的东西。比如我目前暂时选择了Java为我的主要发展语言，所以我就要求自己大部分时间还是搞和Java相关的东西比如：Spring、SpingBoot、Dubbo、Mybatis等等。但是千万不要被语言所束缚，在业余时间我学的比较多的就是Python以及JS、C/C++/C#也会偶尔接触。因为我经常会接触前端另外我自己偶尔有爬虫需求或者需要用Python的一些第三库解决一些问题，所以我业余学Pyton以及JS就比较多一点，我觉得这两门技术也是对我现有技术的一个补充了。 - - -### 技术转型时的方向选择 - -我觉得对于技术转型主要有一下几点建议 - -- 与自己当前技术栈跨度不太大的领域，比如你做安卓的话转型可以选择做Java后端。 -- 真正适合自己去做的，并不是一味看着这个领域火了（比如人工智能），然后自己就不考虑实际的去转型到这个领域里去。 -- 技术转型方向尽量对自己以后的发展需要有帮助。 diff --git a/docs/data/java-recommended-books.md b/docs/data/java-recommended-books.md new file mode 100644 index 00000000000..7bdadce50be --- /dev/null +++ b/docs/data/java-recommended-books.md @@ -0,0 +1,119 @@ + + + +- [Java](#java) + - [基础](#基础) + - [并发](#并发) + - [JVM](#jvm) + - [Java8 新特性](#java8-新特性) + - [代码优化](#代码优化) +- [网络](#网络) +- [操作系统](#操作系统) +- [数据结构与算法](#数据结构与算法) +- [数据库](#数据库) +- [系统设计](#系统设计) + - [设计模式](#设计模式) + - [常用框架](#常用框架) + - [网站架构](#网站架构) + - [软件底层](#软件底层) +- [其他](#其他) + + +## Java + +### 基础 + +- [《Head First Java》](https://book.douban.com/subject/2000732/)(推荐，豆瓣评分 8.7，1.0K+人评价)： 可以说是我的 Java 启蒙书籍了，特别适合新手读当然也适合我们用来温故 Java 知识点。 +- [《Java 核心技术卷 1+卷 2》](https://book.douban.com/subject/25762168/)（推荐）: 很棒的两本书，建议有点 Java 基础之后再读，介绍的还是比较深入的，非常推荐。这两本书我一般也会用来巩固知识点，是两本适合放在自己身边的好书。 +- [《JAVA 网络编程 第 4 版》](https://book.douban.com/subject/26259017/)： 可以系统的学习一下网络的一些概念以及网络编程在 Java 中的使用。 +- [《Java 编程思想 (第 4 版)》](https://book.douban.com/subject/2130190/)（推荐，豆瓣评分 9.1，3.2K+人评价）：大部分人称之为Java领域的圣经，但我不推荐初学者阅读，有点劝退的味道。稍微有点基础后阅读更好。 +- [《Java性能权威指南》](https://book.douban.com/subject/26740520/)（推荐，豆瓣评分 8.2，0.1K+人评价）：O'Reilly 家族书，性能调优的入门书，我个人觉得性能调优是每个 Java 从业者必备知识，这本书的缺点就是太老了，但是这本书可以作为一个实战书，尤其是 JVM 调优！不适合初学者。前置书籍：《深入理解 Java 虚拟机》 + +### 并发 + +- [《Java 并发编程之美》]() （推荐）：2018 年 10 月出版的一本书，个人感觉非常不错，对每个知识点的讲解都很棒。 +- [《Java 并发编程的艺术》](https://book.douban.com/subject/26591326/)（推荐，豆瓣评分 7.2，0.2K+人评价）： 这本书不是很适合作为 Java 并发入门书籍，需要具备一定的 JVM 基础。我感觉有些东西讲的还是挺深入的，推荐阅读。 +- [《实战 Java 高并发程序设计》](https://book.douban.com/subject/26663605/)（推荐,豆瓣评分 8.3）： 书的质量没的说，推荐大家好好看一下。 +- [《Java 高并发编程详解》](https://book.douban.com/subject/30255689/)（豆瓣评分 7.6）： 2018 年 6 月出版的一本书，内容很详细，但可能又有点过于啰嗦，不过这只是我的感觉。 + +### JVM + +- [《深入理解 Java 虚拟机（第 2 版）周志明》](https://book.douban.com/subject/24722612/)（推荐，豆瓣评分 8.9，1.0K+人评价）：建议多刷几遍，书中的所有知识点可以通过 JAVA 运行时区域和 JAVA 的内存模型与线程两个大模块罗列完全。 +- [《实战 JAVA 虚拟机》](https://book.douban.com/subject/26354292/)（推荐，豆瓣评分 8.0，1.0K+人评价）：作为入门的了解 Java 虚拟机的知识还是不错的。 + +### Java8 新特性 + +- [《Java 8 实战》](https://book.douban.com/subject/26772632/) （推荐，豆瓣评分 9.2 ）：面向 Java 8 的技能升级，包括 Lambdas、流和函数式编程特性。实战系列的一贯风格让自己快速上手应用起来。Java 8 支持的 Lambda 是精简表达在语法上提供的支持。Java 8 提供了 Stream，学习和使用可以建立流式编程的认知。 +- [《Java 8 编程参考官方教程》](https://book.douban.com/subject/26556574/) （推荐，豆瓣评分 9.2）：也还不错吧。 + +### 代码优化 + +- [《重构_改善既有代码的设计》](https://book.douban.com/subject/4262627/)（推荐）：豆瓣 9.1 分，重构书籍的开山鼻祖。 +- [《Effective java 》](https://book.douban.com/subject/3360807/)（推荐，豆瓣评分 9.0，1.4K+人评价）：本书介绍了在 Java 编程中 78 条极具实用价值的经验规则，这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。通过对 Java 平台设计专家所使用的技术的全面描述，揭示了应该做什么，不应该做什么才能产生清晰、健壮和高效的代码。本书中的每条规则都以简短、独立的小文章形式出现，并通过例子代码加以进一步说明。本书内容全面，结构清晰，讲解详细。可作为技术人员的参考用书。 +- [《代码整洁之道》](https://book.douban.com/subject/5442024/)（推荐，豆瓣评分 9.1）：虽然是用 Java 语言作为例子，全篇都是在阐述 Java 面向对象的思想，但是其中大部分内容其它语言也能应用到。 +- **阿里巴巴 Java 开发手册（详尽版）** [https://github.com/alibaba/p3c/blob/master/阿里巴巴 Java 开发手册（详尽版）.pdf](https://github.com/alibaba/p3c/blob/master/%E9%98%BF%E9%87%8C%E5%B7%B4%E5%B7%B4Java%E5%BC%80%E5%8F%91%E6%89%8B%E5%86%8C%EF%BC%88%E8%AF%A6%E5%B0%BD%E7%89%88%EF%BC%89.pdf) +- **Google Java 编程风格指南：** + + +## 网络 + +- [《图解 HTTP》](https://book.douban.com/subject/25863515/)（推荐,豆瓣评分 8.1 , 1.6K+人评价）： 讲漫画一样的讲 HTTP，很有意思，不会觉得枯燥，大概也涵盖也 HTTP 常见的知识点。因为篇幅问题，内容可能不太全面。不过，如果不是专门做网络方向研究的小伙伴想研究 HTTP 相关知识的话，读这本书的话应该来说就差不多了。 +- [《HTTP 权威指南》](https://book.douban.com/subject/10746113/) （推荐,豆瓣评分 8.6）:如果要全面了解 HTTP 非此书不可！ + +## 操作系统 + +- [《鸟哥的 Linux 私房菜》](https://book.douban.com/subject/4889838/)（推荐，，豆瓣评分 9.1，0.3K+人评价）：本书是最具知名度的 Linux 入门书《鸟哥的 Linux 私房菜基础学习篇》的最新版，全面而详细地介绍了 Linux 操作系统。全书分为 5 个部分：第一部分着重说明 Linux 的起源及功能，如何规划和安装 Linux 主机；第二部分介绍 Linux 的文件系统、文件、目录与磁盘的管理；第三部分介绍文字模式接口 shell 和管理系统的好帮手 shell 脚本，另外还介绍了文字编辑器 vi 和 vim 的使用方法；第四部分介绍了对于系统安全非常重要的 Linux 账号的管理，以及主机系统与程序的管理，如查看进程、任务分配和作业管理；第五部分介绍了系统管理员 (root) 的管理事项，如了解系统运行状况、系统服务，针对登录文件进行解析，对系统进行备份以及核心的管理等。 + +## 数据结构与算法 + +- [《大话数据结构》](https://book.douban.com/subject/6424904/)（推荐，豆瓣评分 7.9 , 1K+人评价）：入门类型的书籍，读起来比较浅显易懂，适合没有数据结构基础或者说数据结构没学好的小伙伴用来入门数据结构。 +- [《数据结构与算法分析：C 语言描述》](https://book.douban.com/subject/1139426/)（推荐，豆瓣评分 8.9，1.6K+人评价）:本书是《Data Structures and Algorithm Analysis in C》一书第 2 版的简体中译本。原书曾被评为 20 世纪顶尖的 30 部计算机著作之一，作者 Mark Allen Weiss 在数据结构和算法分析方面卓有建树，他的数据结构和算法分析的著作尤其畅销，并受到广泛好评．已被世界 500 余所大学用作教材。 +- [《算法图解》](https://book.douban.com/subject/26979890/)（推荐，豆瓣评分 8.4，0.6K+人评价）：入门类型的书籍，读起来比较浅显易懂，适合没有算法基础或者说算法没学好的小伙伴用来入门。示例丰富，图文并茂，以让人容易理解的方式阐释了算法.读起来比较快，内容不枯燥！ +- [《算法 第四版》](https://book.douban.com/subject/10432347/)（推荐，豆瓣评分 9.3，0.4K+人评价）：Java 语言描述，算法领域经典的参考书，全面介绍了关于算法和数据结构的必备知识，并特别针对排序、搜索、图处理和字符串处理进行了论述。书的内容非常多，可以说是 Java 程序员的必备书籍之一了。 + +## 数据库 + +- [《高性能 MySQL》](https://book.douban.com/subject/23008813/)（推荐，豆瓣评分 9.3，0.4K+人评价）：mysql 领域的经典之作，拥有广泛的影响力。不但适合数据库管理员（dba）阅读，也适合开发人员参考学习。不管是数据库新手还是专家，相信都能从本书有所收获。 +- [《Redis 实战》](https://book.douban.com/subject/26612779/)：如果你想了解 Redis 的一些概念性知识的话，这本书真的非常不错。 +- [《Redis 设计与实现》](https://book.douban.com/subject/25900156/)（推荐，豆瓣评分 8.5，0.5K+人评价）：也还行吧！ +- [《MySQL 技术内幕-InnoDB 存储引擎》]()（推荐，豆瓣评分 8.7）：了解 InnoDB 存储引擎底层原理必备的一本书，比较深入。 + +## 系统设计 + +### 设计模式 + +- [《设计模式 : 可复用面向对象软件的基础》](https://book.douban.com/subject/1052241/) （推荐，豆瓣评分 9.1）：设计模式的经典！ +- [《Head First 设计模式（中文版）》](https://book.douban.com/subject/2243615/) （推荐，豆瓣评分 9.2）：相当赞的一本设计模式入门书籍。用实际的编程案例讲解算法设计中会遇到的各种问题和需求变更（对的，连需求变更都考虑到了！），并以此逐步推导出良好的设计模式解决办法。 +- [《大话设计模式》](https://book.douban.com/subject/2334288/) （推荐，豆瓣评分 8.3）：本书通篇都是以情景对话的形式，用多个小故事或编程示例来组织讲解GOF(即《设计模式 : 可复用面向对象软件的基础》这本书))，但是不像《设计模式 : 可复用面向对象软件的基础》难懂。但是设计模式只看书是不够的，还是需要在实际项目中运用，结合[设计模式](docs/system-design/设计模式.md)更佳！ + +### 常用框架 + +- [《深入分析 Java Web 技术内幕》](https://book.douban.com/subject/25953851/)： 感觉还行，涉及的东西也蛮多。 +- [《Netty 实战》](https://book.douban.com/subject/27038538/)（推荐，豆瓣评分 7.8，92 人评价）：内容很细，如果想学 Netty 的话，推荐阅读这本书！ +- [《从 Paxos 到 Zookeeper》](https://book.douban.com/subject/26292004/)（推荐，豆瓣评分 7.8，0.3K 人评价）：简要介绍几种典型的分布式一致性协议，以及解决分布式一致性问题的思路，其中重点讲解了 Paxos 和 ZAB 协议。同时，本书深入介绍了分布式一致性问题的工业解决方案——ZooKeeper，并着重向读者展示这一分布式协调框架的使用方法、内部实现及运维技巧，旨在帮助读者全面了解 ZooKeeper，并更好地使用和运维 ZooKeeper。 +- [《Spring 实战（第 4 版）》](https://book.douban.com/subject/26767354/)（推荐，豆瓣评分 8.3，0.3K+人评价）：不建议当做入门书籍读，入门的话可以找点国人的书或者视频看。这本定位就相当于是关于 Spring 的新华字典，只有一些基本概念的介绍和示例，涵盖了 Spring 的各个方面，但都不够深入。就像作者在最后一页写的那样：“学习 Spring，这才刚刚开始”。 +- [《RabbitMQ 实战指南》](https://book.douban.com/subject/27591386/)：《RabbitMQ 实战指南》从消息中间件的概念和 RabbitMQ 的历史切入，主要阐述 RabbitMQ 的安装、使用、配置、管理、运维、原理、扩展等方面的细节。如果你想浅尝 RabbitMQ 的使用，这本书是你最好的选择；如果你想深入 RabbitMQ 的原理，这本书也是你最好的选择；总之，如果你想玩转 RabbitMQ，这本书一定是最值得看的书之一 +- [《Spring Cloud 微服务实战》](https://book.douban.com/subject/27025912/)：从时下流行的微服务架构概念出发，详细介绍了 Spring Cloud 针对微服务架构中几大核心要素的解决方案和基础组件。对于各个组件的介绍，《Spring Cloud 微服务实战》主要以示例与源码结合的方式来帮助读者更好地理解这些组件的使用方法以及运行原理。同时，在介绍的过程中，还包含了作者在实践中所遇到的一些问题和解决思路，可供读者在实践中作为参考。 +- [《第一本 Docker 书》](https://book.douban.com/subject/26780404/)：Docker 入门书籍！ +- [《Spring Boot编程思想（核心篇）》](https://book.douban.com/subject/33390560/)（推荐，豆瓣评分 6.2）：SpringBoot深入书，不适合初学者。书尤其的厚，评分低的的理由是书某些知识过于拖沓，评分高的理由是书中对SpringBoot内部原理讲解很清楚。作者小马哥：Apache Dubbo PMC、Spring Cloud Alibaba项目架构师。B站作者地址：https://space.bilibili.com/327910845?from=search&seid=17095917016893398636。 + +### 网站架构 + +- [《大型网站技术架构：核心原理与案例分析+李智慧》](https://book.douban.com/subject/25723064/)（推荐）:这本书我读过，基本不需要你有什么基础啊~读起来特别轻松，但是却可以学到很多东西，非常推荐了。另外我写过这本书的思维导图，关注我的微信公众号：“Java 面试通关手册”回复“大型网站技术架构”即可领取思维导图。 +- [《亿级流量网站架构核心技术》](https://book.douban.com/subject/26999243/)（推荐）：一书总结并梳理了亿级流量网站高可用和高并发原则，通过实例详细介绍了如何落地这些原则。本书分为四部分：概述、高可用原则、高并发原则、案例实战。从负载均衡、限流、降级、隔离、超时与重试、回滚机制、压测与预案、缓存、池化、异步化、扩容、队列等多方面详细介绍了亿级流量网站的架构核心技术，让读者看后能快速运用到实践项目中。 + +### 软件底层 + +- [《深入剖析 Tomcat》](https://book.douban.com/subject/10426640/)（推荐，豆瓣评分 8.4，0.2K+人评价）：本书深入剖析 Tomcat 4 和 Tomcat 5 中的每个组件，并揭示其内部工作原理。通过学习本书，你将可以自行开发 Tomcat 组件，或者扩展已有的组件。 读完这本书，基本可以摆脱背诵面试题的尴尬。 +- [《深入理解 Nginx（第 2 版）》](https://book.douban.com/subject/26745255/)：作者讲的非常细致，注释都写的都很工整，对于 Nginx 的开发人员非常有帮助。优点是细致，缺点是过于细致，到处都是代码片段，缺少一些抽象。 + +## 其他 + +- [《黑客与画家》](https://read.douban.com/ebook/387525/?dcs=subject-rec&dcm=douban&dct=2243615)：这本书是硅谷创业之父，Y Combinator 创始人 Paul Graham 的文集。之所以叫这个名字，是因为作者认为黑客（并非负面的那个意思）与画家有着极大的相似性，他们都是在创造，而不是完成某个任务。 +- [《图解密码技术》](https://book.douban.com/subject/26265544/)（推荐，豆瓣评分 9.1，0.3K+人评价）：本书以**图配文**的形式，第一部分讲述了密码技术的历史沿革、对称密码、分组密码模式（包括ECB、CBC、CFB、OFB、CTR）、公钥、混合密码系统。第二部分重点介绍了认证方面的内容，涉及单向散列函数、消息认证码、数字签名、证书等。第三部分讲述了密钥、随机数、PGP、SSL/TLS 以及密码技术在现实生活中的应用。关键字：JWT 前置知识、区块链密码技术前置知识。属于密码知识入门书籍。 + + + + + + diff --git a/docs/data/spring-boot-practical-projects.md b/docs/data/spring-boot-practical-projects.md new file mode 100644 index 00000000000..046af88a271 --- /dev/null +++ b/docs/data/spring-boot-practical-projects.md @@ -0,0 +1,66 @@ +最近经常被读者问到有没有 Spring Boot 实战项目可以学习，于是，我就去 Github 上找了 10 个我觉得还不错的实战项目。对于这些实战项目，有部分是比较适合 Spring Boot 刚入门的朋友学习的，还有一部分可能要求你对 Spring Boot 相关技术比较熟悉。需要的朋友可以根据个人实际情况进行选择。如果你对 Spring Boot 不太熟悉的话，可以看我最近开源的 springboot-guide：https://github.com/Snailclimb/springboot-guide 入门（还在持续更新中）。 + +### mall + +- **Github地址**： [https://github.com/macrozheng/mall](https://github.com/macrozheng/mall) +- **star**: 22.9k +- **介绍**: mall项目是一套电商系统，包括前台商城系统及后台管理系统，基于SpringBoot+MyBatis实现。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。 + +### jeecg-boot + +- **Github地址**：[https://github.com/zhangdaiscott/jeecg-boot](https://github.com/zhangdaiscott/jeecg-boot) +- **star**: 6.4k +- **介绍**: 一款基于代码生成器的JAVA快速开发平台！采用最新技术，前后端分离架构：SpringBoot 2.x，Ant Design&Vue，Mybatis，Shiro，JWT。强大的代码生成器让前后端代码一键生成，无需写任何代码，绝对是全栈开发福音！！ JeecgBoot的宗旨是提高UI能力的同时,降低前后分离的开发成本，JeecgBoot还独创在线开发模式，No代码概念，一系列在线智能开发：在线配置表单、在线配置报表、在线设计流程等等。 + +### eladmin + +- **Github地址**：[https://github.com/elunez/eladmin](https://github.com/elunez/eladmin) +- **star**: 3.9k +- **介绍**: 项目基于 Spring Boot 2.1.0 、 Jpa、 Spring Security、redis、Vue的前后端分离的后台管理系统，项目采用分模块开发方式， 权限控制采用 RBAC，支持数据字典与数据权限管理，支持一键生成前后端代码，支持动态路由。 + +### paascloud-master + +- **Github地址**：[https://github.com/paascloud/paascloud-master](https://github.com/paascloud/paascloud-master) +- **star**: 5.9k +- **介绍**: spring cloud + vue + oAuth2.0全家桶实战，前后端分离模拟商城，完整的购物流程、后端运营平台，可以实现快速搭建企业级微服务项目。支持微信登录等三方登录。 + +### vhr + +- **Github地址**：[https://github.com/lenve/vhr](https://github.com/lenve/vhr) +- **star**: 10.6k +- **介绍**: 微人事是一个前后端分离的人力资源管理系统，项目采用SpringBoot+Vue开发。 + +### One mall + +- **Github地址**：[https://github.com/YunaiV/onemall](https://github.com/YunaiV/onemall) +- **star**: 1.2k +- **介绍**: mall 商城，基于微服务的思想，构建在 B2C 电商场景下的项目实战。核心技术栈，是 Spring Boot + Dubbo 。未来，会重构成 Spring Cloud Alibaba 。 + +### Guns + +- **Github地址**：[https://github.com/stylefeng/Guns](https://github.com/stylefeng/Guns) +- **star**: 2.3k +- **介绍**: Guns基于SpringBoot 2，致力于做更简洁的后台管理系统，完美整合springmvc + shiro + mybatis-plus + beetl!Guns项目代码简洁，注释丰富，上手容易，同时Guns包含许多基础模块(用户管理，角色管理，部门管理，字典管理等10个模块)，可以直接作为一个后台管理系统的脚手架! + +### SpringCloud + +- **Github地址**：[https://github.com/YunaiV/onemall](https://github.com/YunaiV/onemall) +- **star**: 1.2k +- **介绍**: mall 商城，基于微服务的思想，构建在 B2C 电商场景下的项目实战。核心技术栈，是 Spring Boot + Dubbo 。未来，会重构成 Spring Cloud Alibaba 。 + +### SpringBoot-Shiro-Vue + +- **Github地址**：[https://github.com/Heeexy/SpringBoot-Shiro-Vue](https://github.com/Heeexy/SpringBoot-Shiro-Vue) +- **star**: 1.8k +- **介绍**: 提供一套基于Spring Boot-Shiro-Vue的权限管理思路.前后端都加以控制,做到按钮/接口级别的权限。 + +### newbee-mall + +最近开源的一个商城项目。 + +- **Github地址**：[https://github.com/newbee-ltd/newbee-mall](https://github.com/newbee-ltd/newbee-mall) +- **star**: 50 +- **介绍**: newbee-mall 项目是一套电商系统，包括 newbee-mall 商城系统及 newbee-mall-admin 商城后台管理系统，基于 Spring Boot 2.X 及相关技术栈开发。 前台商城系统包含首页门户、商品分类、新品上线、首页轮播、商品推荐、商品搜索、商品展示、购物车、订单结算、订单流程、个人订单管理、会员中心、帮助中心等模块。 后台管理系统包含数据面板、轮播图管理、商品管理、订单管理、会员管理、分类管理、设置等模块。 + + + diff --git "a/docs/dataStructures-algorithms/\345\207\240\351\201\223\345\270\270\350\247\201\347\232\204\345\255\220\347\254\246\344\270\262\347\256\227\346\263\225\351\242\230.md" "b/docs/dataStructures-algorithms/\345\207\240\351\201\223\345\270\270\350\247\201\347\232\204\345\255\220\347\254\246\344\270\262\347\256\227\346\263\225\351\242\230.md" index 938f4a48f1a..8489082b2f3 100644 --- "a/docs/dataStructures-algorithms/\345\207\240\351\201\223\345\270\270\350\247\201\347\232\204\345\255\220\347\254\246\344\270\262\347\256\227\346\263\225\351\242\230.md" +++ "b/docs/dataStructures-algorithms/\345\207\240\351\201\223\345\270\270\350\247\201\347\232\204\345\255\220\347\254\246\344\270\262\347\256\227\346\263\225\351\242\230.md" @@ -112,7 +112,7 @@ public class Main { public static String replaceSpace(String[] strs) { // 如果检查值不合法及就返回空串 - if (!chechStrs(strs)) { + if (!checkStrs(strs)) { return ""; } // 数组长度 @@ -137,7 +137,6 @@ public class Main { private static boolean chechStrs(String[] strs) { boolean flag = false; - // 注意：=是赋值，==是判断 if (strs != null) { // 遍历strs检查元素值 for (int i = 0; i < strs.length; i++) { @@ -145,6 +144,7 @@ public class Main { flag = true; } else { flag = false; + break; } } } @@ -463,7 +463,7 @@ public class Main { return 0; } } - return flag == 1 ? res : -res; + return flag != 2 ? res : -res; } diff --git "a/docs/dataStructures-algorithms/\345\207\240\351\201\223\345\270\270\350\247\201\347\232\204\351\223\276\350\241\250\347\256\227\346\263\225\351\242\230.md" "b/docs/dataStructures-algorithms/\345\207\240\351\201\223\345\270\270\350\247\201\347\232\204\351\223\276\350\241\250\347\256\227\346\263\225\351\242\230.md" index 79b74441deb..85e2934e407 100644 --- "a/docs/dataStructures-algorithms/\345\207\240\351\201\223\345\270\270\350\247\201\347\232\204\351\223\276\350\241\250\347\256\227\346\263\225\351\242\230.md" +++ "b/docs/dataStructures-algorithms/\345\207\240\351\201\223\345\270\270\350\247\201\347\232\204\351\223\276\350\241\250\347\256\227\346\263\225\351\242\230.md" @@ -225,7 +225,7 @@ public class Solution { while (node1 != null) { node1 = node1.next; count++; - if (k < 1 && node1 != null) { + if (k < 1) { node2 = node2.next; } k--; diff --git "a/docs/dataStructures-algorithms/\346\225\260\346\215\256\347\273\223\346\236\204.md" "b/docs/dataStructures-algorithms/\346\225\260\346\215\256\347\273\223\346\236\204.md" index 5af7844b228..dfb5bc18586 100644 --- "a/docs/dataStructures-algorithms/\346\225\260\346\215\256\347\273\223\346\236\204.md" +++ "b/docs/dataStructures-algorithms/\346\225\260\346\215\256\347\273\223\346\236\204.md" @@ -47,7 +47,7 @@ Queue 用来存放 等待处理元素 的集合，这种场景一般用于缓冲 ### 什么是 Set Set 继承于 Collection 接口，是一个不允许出现重复元素，并且无序的集合，主要 HashSet 和 TreeSet 两大实现类。 -在判断重复元素的时候，Set 集合会调用 hashCode()和 equal()方法来实现。 +在判断重复元素的时候，HashSet 集合会调用 hashCode()和 equal()方法来实现；TreeSet 集合会调用compareTo方法来实现。 ### 补充：有序集合与无序集合说明 - 有序集合：集合里的元素可以根据 key 或 index 访问 (List、Map) @@ -83,8 +83,8 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且 ### ArrayList 和 LinkedList 源码学习 -- [ArrayList 源码学习](https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/ArrayList.md) -- [LinkedList 源码学习](https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/LinkedList.md) +- [ArrayList 源码学习](https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/ArrayList.md) +- [LinkedList 源码学习](https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/LinkedList.md) ### 推荐阅读 @@ -104,7 +104,7 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且 (1)[完全二叉树](https://baike.baidu.com/item/%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91)——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。 - (2)[满二叉树](https://baike.baidu.com/item/%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91)——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。 + (2)[满二叉树](https://baike.baidu.com/item/%E6%BB%A1%E4%BA%8C%E5%8F%89%E6%A0%91)——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。 (3)[平衡二叉树](https://baike.baidu.com/item/%E5%B9%B3%E8%A1%A1%E4%BA%8C%E5%8F%89%E6%A0%91/10421057)——平衡二叉树又被称为AVL树（区别于AVL算法），它是一棵二叉排序树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 @@ -112,7 +112,7 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且 [完全二叉树](https://baike.baidu.com/item/%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91)（百度百科） - 完全二叉树：叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树 + 完全二叉树：叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树。 * ### 3 满二叉树 [满二叉树](https://baike.baidu.com/item/%E6%BB%A1%E4%BA%8C%E5%8F%89%E6%A0%91)（百度百科，国内外的定义不同） @@ -122,7 +122,7 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且 [数据结构之堆的定义](https://blog.csdn.net/qq_33186366/article/details/51876191) - 堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆 + 堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。 * ### 4 二叉查找树（BST） [浅谈算法和数据结构: 七 二叉查找树](http://www.cnblogs.com/yangecnu/p/Introduce-Binary-Search-Tree.html) @@ -131,7 +131,7 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且 1. 若任意节点的左子树不空，则左子树上所有结点的 值均小于它的根结点的值； 2. 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； - 3. 任意节点的左、右子树也分别为二叉查找树。 + 3. 任意节点的左、右子树也分别为二叉查找树； 4. 没有键值相等的节点（no duplicate nodes）。 * ### 5 平衡二叉树（Self-balancing binary search tree） @@ -144,7 +144,7 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且 2. 根节点总是黑色的； 3. 每个叶子节点都是黑色的空节点（NIL节点）； 4. 如果节点是红色的，则它的子节点必须是黑色的（反之不一定）； - 5. 从根节点到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点（即相同的黑色高度） + 5. 从根节点到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点（即相同的黑色高度）。 - 红黑树的应用： @@ -166,9 +166,9 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且 [《B-树，B+树与B*树的优缺点比较》](https://blog.csdn.net/bigtree_3721/article/details/73632405) - B-树（或B树）是一种平衡的多路查找(又称排序)树，在文件系统中有所应用。主要用作文件的索引。其中的B就表示平衡(Balance) + B-树（或B树）是一种平衡的多路查找（又称排序）树，在文件系统中有所应用。主要用作文件的索引。其中的B就表示平衡(Balance) 1. B+ 树的叶子节点链表结构相比于 B- 树便于扫库，和范围检索。 - 2. B+树支持range-query(区间查询)非常方便，而B树不支持。这是数据库选用B+树的最主要原因。 + 2. B+树支持range-query（区间查询）非常方便，而B树不支持。这是数据库选用B+树的最主要原因。 3. B\*树 是B+树的变体，B\*树分配新结点的概率比B+树要低，空间使用率更高； * ### 8 LSM 树 diff --git a/docs/database/MySQL Index.md b/docs/database/MySQL Index.md index f18b4a077ee..b25589fc7d2 100644 --- a/docs/database/MySQL Index.md +++ b/docs/database/MySQL Index.md @@ -28,8 +28,8 @@ MySQL的基本存储结构是页(记录都存在页里边)： 所以说，如果我们写select * from user where indexname = 'xxx'这样没有进行任何优化的sql语句，默认会这样做： -1. **定位到记录所在的页:需要遍历双向链表，找到所在的页** -2. **从所在的页内中查找相应的记录:由于不是根据主键查询，只能遍历所在页的单链表了** +1. **定位到记录所在的页：需要遍历双向链表，找到所在的页** +2. **从所在的页内中查找相应的记录：由于不是根据主键查询，只能遍历所在页的单链表了** 很明显，在数据量很大的情况下这样查找会很慢！这样的时间复杂度为O（n）。 @@ -60,17 +60,17 @@ MySQL中的索引可以以一定顺序引用多列，这种索引叫作联合索 ``` select * from user where name=xx and city=xx ; ／／可以命中索引 select * from user where name=xx ; // 可以命中索引 -select * from user where city=xx; // 无法命中索引 +select * from user where city=xx ; // 无法命中索引 ``` -这里需要注意的是，查询的时候如果两个条件都用上了，但是顺序不同，如 `city= xx and name ＝xx`，那么现在的查询引擎会自动优化为匹配联合索引的顺序，这样是能够命中索引的. +这里需要注意的是，查询的时候如果两个条件都用上了，但是顺序不同，如 `city= xx and name ＝xx`，那么现在的查询引擎会自动优化为匹配联合索引的顺序，这样是能够命中索引的。 -由于最左前缀原则，在创建联合索引时，索引字段的顺序需要考虑字段值去重之后的个数，较多的放前面。ORDERBY子句也遵循此规则。 +由于最左前缀原则，在创建联合索引时，索引字段的顺序需要考虑字段值去重之后的个数，较多的放前面。ORDER BY子句也遵循此规则。 ### 注意避免冗余索引 冗余索引指的是索引的功能相同，能够命中 就肯定能命中 ，那么 就是冗余索引如（name,city ）和（name ）这两个索引就是冗余索引，能够命中后者的查询肯定是能够命中前者的 在大多数情况下，都应该尽量扩展已有的索引而不是创建新索引。 -MySQLS.7 版本后，可以通过查询 sys 库的 `schema_redundant_indexes` 表来查看冗余索引 +MySQL 5.7 版本后，可以通过查询 sys 库的 `schema_redundant_indexes` 表来查看冗余索引 ### Mysql如何为表字段添加索引？？？ diff --git a/docs/database/MySQL.md b/docs/database/MySQL.md index 44eb02aaa9d..64dfad2fd79 100644 --- a/docs/database/MySQL.md +++ b/docs/database/MySQL.md @@ -1,171 +1,328 @@ +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 + +- [书籍推荐](#书籍推荐) +- [文字教程推荐](#文字教程推荐) +- [视频教程推荐](#视频教程推荐) +- [常见问题总结](#常见问题总结) + - [什么是MySQL?](#什么是mysql) + - [存储引擎](#存储引擎) + - [一些常用命令](#一些常用命令) + - [MyISAM和InnoDB区别](#myisam和innodb区别) + - [字符集及校对规则](#字符集及校对规则) + - [索引](#索引) + - [查询缓存的使用](#查询缓存的使用) + - [什么是事务?](#什么是事务) + - [事物的四大特性(ACID)](#事物的四大特性acid) + - [并发事务带来哪些问题?](#并发事务带来哪些问题) + - [事务隔离级别有哪些?MySQL的默认隔离级别是?](#事务隔离级别有哪些mysql的默认隔离级别是) + - [锁机制与InnoDB锁算法](#锁机制与innodb锁算法) + - [大表优化](#大表优化) + - [1. 限定数据的范围](#1-限定数据的范围) + - [2. 读/写分离](#2-读写分离) + - [3. 垂直分区](#3-垂直分区) + - [4. 水平分区](#4-水平分区) + - [一条SQL语句在MySQL中如何执行的](#一条sql语句在mysql中如何执行的) + - [MySQL高性能优化规范建议](#mysql高性能优化规范建议) + - [一条SQL语句执行得很慢的原因有哪些？](#一条sql语句执行得很慢的原因有哪些) + + + +## 书籍推荐 + +- 《SQL基础教程（第2版）》 （入门级） +- 《高性能MySQL : 第3版》 (进阶) + +## 文字教程推荐 + +- [SQL Tutorial](https://www.w3schools.com/sql/default.asp) （SQL语句学习,英文）、[SQL Tutorial](https://www.w3school.com.cn/sql/index.asp)（SQL语句学习,中文）、[SQL语句在线练习](https://www.w3schools.com/sql/exercise.asp) （非常不错） +- [Github-MySQL入门教程（MySQL tutorial book）](https://github.com/jaywcjlove/mysql-tutorial) （从零开始学习MySQL，主要是面向MySQL数据库管理系统初学者） +- [官方教程](https://dev.mysql.com/doc/refman/5.7/) +- [MySQL 教程（菜鸟教程）](http://www.runoob.com/MySQL/MySQL-tutorial.html) + +## 相关资源推荐 + +- [中国5级行政区域mysql库](https://github.com/kakuilan/china_area_mysql) + +## 视频教程推荐 +**基础入门：** [与MySQL的零距离接触-慕课网](https://www.imooc.com/learn/122) -Java面试通关手册（Java学习指南，欢迎Star，会一直完善下去，欢迎建议和指导）：[https://github.com/Snailclimb/Java_Guide](https://github.com/Snailclimb/Java_Guide) +**MySQL开发技巧：** [MySQL开发技巧（一）](https://www.imooc.com/learn/398)　　[MySQL开发技巧（二）](https://www.imooc.com/learn/427)　　[MySQL开发技巧（三）](https://www.imooc.com/learn/449) -> ## 书籍推荐 +**MySQL5.7新特性及相关优化技巧：** [MySQL5.7版本新特性](https://www.imooc.com/learn/533)　　[性能优化之MySQL优化](https://www.imooc.com/learn/194) -**《高性能MySQL : 第3版》** +[MySQL集群（PXC）入门](https://www.imooc.com/learn/993)　　[MyCAT入门及应用](https://www.imooc.com/learn/951) -> ## 文字教程推荐 +## 常见问题总结 -[MySQL 教程（菜鸟教程）](http://www.runoob.com/mysql/mysql-tutorial.html) +### 什么是MySQL? -[MySQL教程（易百教程）](https://www.yiibai.com/mysql/) +MySQL 是一种关系型数据库，在Java企业级开发中非常常用，因为 MySQL 是开源免费的，并且方便扩展。阿里巴巴数据库系统也大量用到了 MySQL，因此它的稳定性是有保障的。MySQL是开放源代码的，因此任何人都可以在 GPL(General Public License) 的许可下下载并根据个性化的需要对其进行修改。MySQL的默认端口号是**3306**。 -> ## 视频教程推荐 +### 存储引擎 +#### 一些常用命令 -**基础入门：** [与MySQL的零距离接触-慕课网](https://www.imooc.com/learn/122) +**查看MySQL提供的所有存储引擎** -**Mysql开发技巧：** [MySQL开发技巧（一）](https://www.imooc.com/learn/398)　　[MySQL开发技巧（二）](https://www.imooc.com/learn/427)　　[MySQL开发技巧（三）](https://www.imooc.com/learn/449) +```sql +mysql> show engines; +``` -**Mysql5.7新特性及相关优化技巧：** [MySQL5.7版本新特性](https://www.imooc.com/learn/533)　　[性能优化之MySQL优化](https://www.imooc.com/learn/194) +![查看MySQL提供的所有存储引擎](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/mysql-engines.png) -[MySQL集群（PXC）入门](https://www.imooc.com/learn/993)　　[MyCAT入门及应用](https://www.imooc.com/learn/951) +从上图我们可以查看出 MySQL 当前默认的存储引擎是InnoDB,并且在5.7版本所有的存储引擎中只有 InnoDB 是事务性存储引擎，也就是说只有 InnoDB 支持事务。 + +**查看MySQL当前默认的存储引擎** + +我们也可以通过下面的命令查看默认的存储引擎。 + +```sql +mysql> show variables like '%storage_engine%'; +``` + +**查看表的存储引擎** + +```sql +show table status like "table_name" ; +``` + +![查看表的存储引擎](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/查看表的存储引擎.png) + +#### MyISAM和InnoDB区别 + +MyISAM是MySQL的默认数据库引擎（5.5版之前）。虽然性能极佳，而且提供了大量的特性，包括全文索引、压缩、空间函数等，但MyISAM不支持事务和行级锁，而且最大的缺陷就是崩溃后无法安全恢复。不过，5.5版本之后，MySQL引入了InnoDB（事务性数据库引擎），MySQL 5.5版本后默认的存储引擎为InnoDB。 + +大多数时候我们使用的都是 InnoDB 存储引擎，但是在某些情况下使用 MyISAM 也是合适的比如读密集的情况下。（如果你不介意 MyISAM 崩溃恢复问题的话）。 + +**两者的对比：** + +1. **是否支持行级锁** : MyISAM 只有表级锁(table-level locking)，而InnoDB 支持行级锁(row-level locking)和表级锁,默认为行级锁。 +2. **是否支持事务和崩溃后的安全恢复： MyISAM** 强调的是性能，每次查询具有原子性,其执行速度比InnoDB类型更快，但是不提供事务支持。但是**InnoDB** 提供事务支持事务，外部键等高级数据库功能。 具有事务(commit)、回滚(rollback)和崩溃修复能力(crash recovery capabilities)的事务安全(transaction-safe (ACID compliant))型表。 +3. **是否支持外键：** MyISAM不支持，而InnoDB支持。 +4. **是否支持MVCC** ：仅 InnoDB 支持。应对高并发事务, MVCC比单纯的加锁更高效;MVCC只在 `READ COMMITTED` 和 `REPEATABLE READ` 两个隔离级别下工作;MVCC可以使用 乐观(optimistic)锁 和 悲观(pessimistic)锁来实现;各数据库中MVCC实现并不统一。推荐阅读：[MySQL-InnoDB-MVCC多版本并发控制](https://segmentfault.com/a/1190000012650596) +5. ...... + +《MySQL高性能》上面有一句话这样写到: + +> 不要轻易相信“MyISAM比InnoDB快”之类的经验之谈，这个结论往往不是绝对的。在很多我们已知场景中，InnoDB的速度都可以让MyISAM望尘莫及，尤其是用到了聚簇索引，或者需要访问的数据都可以放入内存的应用。 + +一般情况下我们选择 InnoDB 都是没有问题的，但是某些情况下你并不在乎可扩展能力和并发能力，也不需要事务支持，也不在乎崩溃后的安全恢复问题的话，选择MyISAM也是一个不错的选择。但是一般情况下，我们都是需要考虑到这些问题的。 + +### 字符集及校对规则 + +字符集指的是一种从二进制编码到某类字符符号的映射。校对规则则是指某种字符集下的排序规则。MySQL中每一种字符集都会对应一系列的校对规则。 + +MySQL采用的是类似继承的方式指定字符集的默认值，每个数据库以及每张数据表都有自己的默认值，他们逐层继承。比如：某个库中所有表的默认字符集将是该数据库所指定的字符集（这些表在没有指定字符集的情况下，才会采用默认字符集） PS：整理自《Java工程师修炼之道》 + +详细内容可以参考： [MySQL字符集及校对规则的理解](https://www.cnblogs.com/geaozhang/p/6724393.html#MySQLyuzifuji) + +### 索引 + +MySQL索引使用的数据结构主要有**BTree索引** 和 **哈希索引** 。对于哈希索引来说，底层的数据结构就是哈希表，因此在绝大多数需求为单条记录查询的时候，可以选择哈希索引，查询性能最快；其余大部分场景，建议选择BTree索引。 + +MySQL的BTree索引使用的是B树中的B+Tree，但对于主要的两种存储引擎的实现方式是不同的。 + +- **MyISAM:** B+Tree叶节点的data域存放的是数据记录的地址。在索引检索的时候，首先按照B+Tree搜索算法搜索索引，如果指定的Key存在，则取出其 data 域的值，然后以 data 域的值为地址读取相应的数据记录。这被称为“非聚簇索引”。 +- **InnoDB:** 其数据文件本身就是索引文件。相比MyISAM，索引文件和数据文件是分离的，其表数据文件本身就是按B+Tree组织的一个索引结构，树的叶节点data域保存了完整的数据记录。这个索引的key是数据表的主键，因此InnoDB表数据文件本身就是主索引。这被称为“聚簇索引（或聚集索引）”。而其余的索引都作为辅助索引，辅助索引的data域存储相应记录主键的值而不是地址，这也是和MyISAM不同的地方。**在根据主索引搜索时，直接找到key所在的节点即可取出数据；在根据辅助索引查找时，则需要先取出主键的值，再走一遍主索引。** **因此，在设计表的时候，不建议使用过长的字段作为主键，也不建议使用非单调的字段作为主键，这样会造成主索引频繁分裂。** PS：整理自《Java工程师修炼之道》 + +**更多关于索引的内容可以查看文档首页MySQL目录下关于索引的详细总结。** + +### 查询缓存的使用 + +> 执行查询语句的时候，会先查询缓存。不过，MySQL 8.0 版本后移除，因为这个功能不太实用 + +my.cnf加入以下配置，重启MySQL开启查询缓存 +```properties +query_cache_type=1 +query_cache_size=600000 +``` + +MySQL执行以下命令也可以开启查询缓存 + +```properties +set global query_cache_type=1; +set global query_cache_size=600000; +``` +如上，**开启查询缓存后在同样的查询条件以及数据情况下，会直接在缓存中返回结果**。这里的查询条件包括查询本身、当前要查询的数据库、客户端协议版本号等一些可能影响结果的信息。因此任何两个查询在任何字符上的不同都会导致缓存不命中。此外，如果查询中包含任何用户自定义函数、存储函数、用户变量、临时表、MySQL库中的系统表，其查询结果也不会被缓存。 + +缓存建立之后，MySQL的查询缓存系统会跟踪查询中涉及的每张表，如果这些表（数据或结构）发生变化，那么和这张表相关的所有缓存数据都将失效。 + +**缓存虽然能够提升数据库的查询性能，但是缓存同时也带来了额外的开销，每次查询后都要做一次缓存操作，失效后还要销毁。** 因此，开启缓存查询要谨慎，尤其对于写密集的应用来说更是如此。如果开启，要注意合理控制缓存空间大小，一般来说其大小设置为几十MB比较合适。此外，**还可以通过sql_cache和sql_no_cache来控制某个查询语句是否需要缓存：** +```sql +select sql_no_cache count(*) from usr; +``` + +### 什么是事务? + +**事务是逻辑上的一组操作，要么都执行，要么都不执行。** + +事务最经典也经常被拿出来说例子就是转账了。假如小明要给小红转账1000元，这个转账会涉及到两个关键操作就是：将小明的余额减少1000元，将小红的余额增加1000元。万一在这两个操作之间突然出现错误比如银行系统崩溃，导致小明余额减少而小红的余额没有增加，这样就不对了。事务就是保证这两个关键操作要么都成功，要么都要失败。 + +### 事物的四大特性(ACID) + +![事物的特性](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/事务特性.png) + +1. **原子性（Atomicity）：** 事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用； +2. **一致性（Consistency）：** 执行事务前后，数据保持一致，多个事务对同一个数据读取的结果是相同的； +3. **隔离性（Isolation）：** 并发访问数据库时，一个用户的事务不被其他事务所干扰，各并发事务之间数据库是独立的； +4. **持久性（Durability）：** 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。 + +### 并发事务带来哪些问题? + +在典型的应用程序中，多个事务并发运行，经常会操作相同的数据来完成各自的任务（多个用户对同一数据进行操作）。并发虽然是必须的，但可能会导致以下的问题。 + +- **脏读（Dirty read）:** 当一个事务正在访问数据并且对数据进行了修改，而这种修改还没有提交到数据库中，这时另外一个事务也访问了这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是“脏数据”，依据“脏数据”所做的操作可能是不正确的。 +- **丢失修改（Lost to modify）:** 指在一个事务读取一个数据时，另外一个事务也访问了该数据，那么在第一个事务中修改了这个数据后，第二个事务也修改了这个数据。这样第一个事务内的修改结果就被丢失，因此称为丢失修改。 例如：事务1读取某表中的数据A=20，事务2也读取A=20，事务1修改A=A-1，事务2也修改A=A-1，最终结果A=19，事务1的修改被丢失。 +- **不可重复读（Unrepeatableread）:** 指在一个事务内多次读同一数据。在这个事务还没有结束时，另一个事务也访问该数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改导致第一个事务两次读取的数据可能不太一样。这就发生了在一个事务内两次读到的数据是不一样的情况，因此称为不可重复读。 +- **幻读（Phantom read）:** 幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着另一个并发事务（T2）插入了一些数据时。在随后的查询中，第一个事务（T1）就会发现多了一些原本不存在的记录，就好像发生了幻觉一样，所以称为幻读。 + +**不可重复读和幻读区别：** + +不可重复读的重点是修改比如多次读取一条记录发现其中某些列的值被修改，幻读的重点在于新增或者删除比如多次读取一条记录发现记录增多或减少了。 + +### 事务隔离级别有哪些?MySQL的默认隔离级别是? + +**SQL 标准定义了四个隔离级别：** + +- **READ-UNCOMMITTED(读取未提交)：** 最低的隔离级别，允许读取尚未提交的数据变更，**可能会导致脏读、幻读或不可重复读**。 +- **READ-COMMITTED(读取已提交)：** 允许读取并发事务已经提交的数据，**可以阻止脏读，但是幻读或不可重复读仍有可能发生**。 +- **REPEATABLE-READ(可重复读)：** 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，**可以阻止脏读和不可重复读，但幻读仍有可能发生**。 +- **SERIALIZABLE(可串行化)：** 最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，**该级别可以防止脏读、不可重复读以及幻读**。 + +------ + +| 隔离级别 | 脏读 | 不可重复读 | 幻影读 | +| :--------------: | :--: | :--------: | :----: | +| READ-UNCOMMITTED | √ | √ | √ | +| READ-COMMITTED | × | √ | √ | +| REPEATABLE-READ | × | × | √ | +| SERIALIZABLE | × | × | × | + +MySQL InnoDB 存储引擎的默认支持的隔离级别是 **REPEATABLE-READ（可重读）**。我们可以通过`SELECT @@tx_isolation;`命令来查看 + +```sql +mysql> SELECT @@tx_isolation; ++-----------------+ +| @@tx_isolation | ++-----------------+ +| REPEATABLE-READ | ++-----------------+ +``` + +这里需要注意的是：与 SQL 标准不同的地方在于 InnoDB 存储引擎在 **REPEATABLE-READ（可重读）** +事务隔离级别下使用的是Next-Key Lock 锁算法，因此可以避免幻读的产生，这与其他数据库系统(如 SQL Server) +是不同的。所以说InnoDB 存储引擎的默认支持的隔离级别是 **REPEATABLE-READ（可重读）** 已经可以完全保证事务的隔离性要求，即达到了 + SQL标准的 **SERIALIZABLE(可串行化)** 隔离级别。因为隔离级别越低，事务请求的锁越少，所以大部分数据库系统的隔离级别都是 **READ-COMMITTED(读取提交内容)** ，但是你要知道的是InnoDB 存储引擎默认使用 **REPEAaTABLE-READ（可重读）** 并不会有任何性能损失。 + +InnoDB 存储引擎在 **分布式事务** 的情况下一般会用到 **SERIALIZABLE(可串行化)** 隔离级别。 + +### 锁机制与InnoDB锁算法 + +**MyISAM和InnoDB存储引擎使用的锁：** + +- MyISAM采用表级锁(table-level locking)。 +- InnoDB支持行级锁(row-level locking)和表级锁,默认为行级锁 + +**表级锁和行级锁对比：** + +- **表级锁：** MySQL中锁定 **粒度最大** 的一种锁，对当前操作的整张表加锁，实现简单，资源消耗也比较少，加锁快，不会出现死锁。其锁定粒度最大，触发锁冲突的概率最高，并发度最低，MyISAM和 InnoDB引擎都支持表级锁。 +- **行级锁：** MySQL中锁定 **粒度最小** 的一种锁，只针对当前操作的行进行加锁。 行级锁能大大减少数据库操作的冲突。其加锁粒度最小，并发度高，但加锁的开销也最大，加锁慢，会出现死锁。 + +详细内容可以参考： MySQL锁机制简单了解一下：[https://blog.csdn.net/qq_34337272/article/details/80611486](https://blog.csdn.net/qq_34337272/article/details/80611486) + +**InnoDB存储引擎的锁的算法有三种：** + +- Record lock：单个行记录上的锁 +- Gap lock：间隙锁，锁定一个范围，不包括记录本身 +- Next-key lock：record+gap 锁定一个范围，包含记录本身 + +**相关知识点：** + +1. innodb对于行的查询使用next-key lock +2. Next-locking keying为了解决Phantom Problem幻读问题 +3. 当查询的索引含有唯一属性时，将next-key lock降级为record key +4. Gap锁设计的目的是为了阻止多个事务将记录插入到同一范围内，而这会导致幻读问题的产生 +5. 有两种方式显式关闭gap锁：（除了外键约束和唯一性检查外，其余情况仅使用record lock） A. 将事务隔离级别设置为RC B. 将参数innodb_locks_unsafe_for_binlog设置为1 + +### 大表优化 + +当MySQL单表记录数过大时，数据库的CRUD性能会明显下降，一些常见的优化措施如下： + +#### 1. 限定数据的范围 + +务必禁止不带任何限制数据范围条件的查询语句。比如：我们当用户在查询订单历史的时候，我们可以控制在一个月的范围内； + +#### 2. 读/写分离 + +经典的数据库拆分方案，主库负责写，从库负责读； + +#### 3. 垂直分区 + + **根据数据库里面数据表的相关性进行拆分。** 例如，用户表中既有用户的登录信息又有用户的基本信息，可以将用户表拆分成两个单独的表，甚至放到单独的库做分库。 + + **简单来说垂直拆分是指数据表列的拆分，把一张列比较多的表拆分为多张表。** 如下图所示，这样来说大家应该就更容易理解了。 + ![数据库垂直分区](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/数据库垂直分区.png) + +- **垂直拆分的优点：** 可以使得列数据变小，在查询时减少读取的Block数，减少I/O次数。此外，垂直分区可以简化表的结构，易于维护。 +- **垂直拆分的缺点：** 主键会出现冗余，需要管理冗余列，并会引起Join操作，可以通过在应用层进行Join来解决。此外，垂直分区会让事务变得更加复杂； + +#### 4. 水平分区 + +**保持数据表结构不变，通过某种策略存储数据分片。这样每一片数据分散到不同的表或者库中，达到了分布式的目的。 水平拆分可以支撑非常大的数据量。** + + 水平拆分是指数据表行的拆分，表的行数超过200万行时，就会变慢，这时可以把一张的表的数据拆成多张表来存放。举个例子：我们可以将用户信息表拆分成多个用户信息表，这样就可以避免单一表数据量过大对性能造成影响。 + +![数据库水平拆分](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/数据库水平拆分.png) + +水平拆分可以支持非常大的数据量。需要注意的一点是：分表仅仅是解决了单一表数据过大的问题，但由于表的数据还是在同一台机器上，其实对于提升MySQL并发能力没有什么意义，所以 **水平拆分最好分库** 。 + +水平拆分能够 **支持非常大的数据量存储，应用端改造也少**，但 **分片事务难以解决** ，跨节点Join性能较差，逻辑复杂。《Java工程师修炼之道》的作者推荐 **尽量不要对数据进行分片，因为拆分会带来逻辑、部署、运维的各种复杂度** ，一般的数据表在优化得当的情况下支撑千万以下的数据量是没有太大问题的。如果实在要分片，尽量选择客户端分片架构，这样可以减少一次和中间件的网络I/O。 + +**下面补充一下数据库分片的两种常见方案：** + +- **客户端代理：** **分片逻辑在应用端，封装在jar包中，通过修改或者封装JDBC层来实现。** 当当网的 **Sharding-JDBC** 、阿里的TDDL是两种比较常用的实现。 +- **中间件代理：** **在应用和数据中间加了一个代理层。分片逻辑统一维护在中间件服务中。** 我们现在谈的 **Mycat** 、360的Atlas、网易的DDB等等都是这种架构的实现。 + +详细内容可以参考： MySQL大表优化方案: [https://segmentfault.com/a/1190000006158186](https://segmentfault.com/a/1190000006158186) + +### 解释一下什么是池化设计思想。什么是数据库连接池?为什么需要数据库连接池? + +池话设计应该不是一个新名词。我们常见的如java线程池、jdbc连接池、redis连接池等就是这类设计的代表实现。这种设计会初始预设资源，解决的问题就是抵消每次获取资源的消耗，如创建线程的开销，获取远程连接的开销等。就好比你去食堂打饭，打饭的大妈会先把饭盛好几份放那里，你来了就直接拿着饭盒加菜即可，不用再临时又盛饭又打菜，效率就高了。除了初始化资源，池化设计还包括如下这些特征：池子的初始值、池子的活跃值、池子的最大值等，这些特征可以直接映射到java线程池和数据库连接池的成员属性中。——这篇文章对[池化设计思想](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247485679&idx=1&sn=57dbca8c9ad49e1f3968ecff04a4f735&chksm=cea24724f9d5ce3212292fac291234a760c99c0960b5430d714269efe33554730b5f71208582&token=1141994790&lang=zh_CN#rd)介绍的还不错，直接复制过来，避免重复造轮子了。 + +数据库连接本质就是一个 socket 的连接。数据库服务端还要维护一些缓存和用户权限信息之类的 所以占用了一些内存。我们可以把数据库连接池是看做是维护的数据库连接的缓存，以便将来需要对数据库的请求时可以重用这些连接。为每个用户打开和维护数据库连接，尤其是对动态数据库驱动的网站应用程序的请求，既昂贵又浪费资源。**在连接池中，创建连接后，将其放置在池中，并再次使用它，因此不必建立新的连接。如果使用了所有连接，则会建立一个新连接并将其添加到池中。**连接池还减少了用户必须等待建立与数据库的连接的时间。 + +### 分库分表之后,id 主键如何处理？ + +因为要是分成多个表之后，每个表都是从 1 开始累加，这样是不对的，我们需要一个全局唯一的 id 来支持。 + +生成全局 id 有下面这几种方式： + +- **UUID**：不适合作为主键，因为太长了，并且无序不可读，查询效率低。比较适合用于生成唯一的名字的标示比如文件的名字。 +- **数据库自增 id** : 两台数据库分别设置不同步长，生成不重复ID的策略来实现高可用。这种方式生成的 id 有序，但是需要独立部署数据库实例，成本高，还会有性能瓶颈。 +- **利用 redis 生成 id :** 性能比较好，灵活方便，不依赖于数据库。但是，引入了新的组件造成系统更加复杂，可用性降低，编码更加复杂，增加了系统成本。 +- **Twitter的snowflake算法** ：Github 地址：https://github.com/twitter-archive/snowflake。 +- **美团的[Leaf](https://tech.meituan.com/2017/04/21/mt-leaf.html)分布式ID生成系统** ：Leaf 是美团开源的分布式ID生成器，能保证全局唯一性、趋势递增、单调递增、信息安全，里面也提到了几种分布式方案的对比，但也需要依赖关系数据库、Zookeeper等中间件。感觉还不错。美团技术团队的一篇文章：https://tech.meituan.com/2017/04/21/mt-leaf.html 。 +- ...... + +### 一条SQL语句在MySQL中如何执行的 + +[一条SQL语句在MySQL中如何执行的]() + +### MySQL高性能优化规范建议 + +[MySQL高性能优化规范建议]() + +### 一条SQL语句执行得很慢的原因有哪些？ + +[腾讯面试：一条SQL语句执行得很慢的原因有哪些？---不看后悔系列](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247485185&idx=1&sn=66ef08b4ab6af5757792223a83fc0d45&chksm=cea248caf9d5c1dc72ec8a281ec16aa3ec3e8066dbb252e27362438a26c33fbe842b0e0adf47&token=79317275&lang=zh_CN#rd) + +## 公众号 +如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 +**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！ -> ## 常见问题总结 - -- ### ①存储引擎 - - [MySQL常见的两种存储引擎：MyISAM与InnoDB的爱恨情仇](https://juejin.im/post/5b1685bef265da6e5c3c1c34) - -- ### ②字符集及校对规则 - - 字符集指的是一种从二进制编码到某类字符符号的映射。校对规则则是指某种字符集下的排序规则。Mysql中每一种字符集都会对应一系列的校对规则。 - - Mysql采用的是类似继承的方式指定字符集的默认值，每个数据库以及每张数据表都有自己的默认值，他们逐层继承。比如：某个库中所有表的默认字符集将是该数据库所指定的字符集（这些表在没有指定字符集的情况下，才会采用默认字符集） PS：整理自《Java工程师修炼之道》 - - 详细内容可以参考： [MySQL字符集及校对规则的理解](https://www.cnblogs.com/geaozhang/p/6724393.html#mysqlyuzifuji) - -- ### ③索引相关的内容（数据库使用中非常关键的技术，合理正确的使用索引可以大大提高数据库的查询性能） - - 　　Mysql索引使用的数据结构主要有**BTree索引** 和 **哈希索引** 。对于哈希索引来说，底层的数据结构就是哈希表，因此在绝大多数需求为单条记录查询的时候，可以选择哈希索引，查询性能最快；其余大部分场景，建议选择BTree索引。 - - 　　Mysql的BTree索引使用的是B数中的B+Tree，但对于主要的两种存储引擎的实现方式是不同的。 - - 　　**MyISAM:** B+Tree叶节点的data域存放的是数据记录的地址。在索引检索的时候，首先按照B+Tree搜索算法搜索索引，如果指定的Key存在，则取出其 data 域的值，然后以 data 域的值为地址读取相应的数据记录。这被称为“非聚簇索引”。 - - 　　**InnoDB:** 其数据文件本身就是索引文件。相比MyISAM，索引文件和数据文件是分离的，其表数据文件本身就是按B+Tree组织的一个索引结构，树的叶节点data域保存了完整的数据记录。这个索引的key是数据表的主键，因此InnoDB表数据文件本身就是主索引。这被称为“聚簇索引（或聚集索引）”。而其余的索引都作为辅助索引，辅助索引的data域存储相应记录主键的值而不是地址，这也是和MyISAM不同的地方。**在根据主索引搜索时，直接找到key所在的节点即可取出数据；在根据辅助索引查找时，则需要先取出主键的值，再走一遍主索引。** **因此，在设计表的时候，不建议使用过长的字段作为主键，也不建议使用非单调的字段作为主键，这样会造成主索引频繁分裂。** PS：整理自《Java工程师修炼之道》 - - 详细内容可以参考： - - [干货：mysql索引的数据结构](https://www.jianshu.com/p/1775b4ff123a) - - [MySQL优化系列（三）--索引的使用、原理和设计优化](https://blog.csdn.net/Jack__Frost/article/details/72571540) - - [数据库两大神器【索引和锁】](https://juejin.im/post/5b55b842f265da0f9e589e79#comment) - -- ### ④查询缓存的使用 - - my.cnf加入以下配置，重启Mysql开启查询缓存 - ``` - query_cache_type=1 - query_cache_size=600000 - ``` - - Mysql执行以下命令也可以开启查询缓存 - - ``` - set global query_cache_type=1; - set global query_cache_size=600000; - ``` - 如上，**开启查询缓存后在同样的查询条件以及数据情况下，会直接在缓存中返回结果**。这里的查询条件包括查询本身、当前要查询的数据库、客户端协议版本号等一些可能影响结果的信息。因此任何两个查询在任何字符上的不同都会导致缓存不命中。此外，如果查询中包含任何用户自定义函数、存储函数、用户变量、临时表、Mysql库中的系统表，其查询结果也不会被缓存。 - - 缓存建立之后，Mysql的查询缓存系统会跟踪查询中涉及的每张表，如果这些表（数据或结构）发生变化，那么和这张表相关的所有缓存数据都将失效。 - - **缓存虽然能够提升数据库的查询性能，但是缓存同时也带来了额外的开销，每次查询后都要做一次缓存操作，失效后还要销毁。** 因此，开启缓存查询要谨慎，尤其对于写密集的应用来说更是如此。如果开启，要注意合理控制缓存空间大小，一般来说其大小设置为几十MB比较合适。此外，**还可以通过sql_cache和sql_no_cache来控制某个查询语句是否需要缓存：** - ``` - select sql_no_cache count(*) from usr; - ``` - -- ### ⑤事务机制 - - **关系性数据库需要遵循ACID规则，具体内容如下：** - -![事务的特性](https://user-gold-cdn.xitu.io/2018/5/20/1637b08b98619455?w=312&h=305&f=png&s=22430) - - 1. **原子性：** 事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用； - 2. **一致性：** 执行事务前后，数据库从一个一致性状态转换到另一个一致性状态。 - 3. **隔离性：** 并发访问数据库时，一个用户的事物不被其他事务所干扰，各并发事务之间数据库是独立的； - 4. **持久性：** 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库 发生故障也不应该对其有任何影响。 - - **为了达到上述事务特性，数据库定义了几种不同的事务隔离级别：** - -- **READ_UNCOMMITTED（未提交读）:** 最低的隔离级别，允许读取尚未提交的数据变更，**可能会导致脏读、幻读或不可重复读** -- **READ_COMMITTED（提交读）:** 允许读取并发事务已经提交的数据，**可以阻止脏读，但是幻读或不可重复读仍有可能发生** -- **REPEATABLE_READ（可重复读）:** 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，**可以阻止脏读和不可重复读，但幻读仍有可能发生。** -- **SERIALIZABLE（串行）:** 最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，**该级别可以防止脏读、不可重复读以及幻读**。但是这将严重影响程序的性能。通常情况下也不会用到该级别。 - - 这里需要注意的是：**Mysql 默认采用的 REPEATABLE_READ隔离级别 Oracle 默认采用的 READ_COMMITTED隔离级别.** - - 事务隔离机制的实现基于锁机制和并发调度。其中并发调度使用的是MVCC（多版本并发控制），通过行的创建时间和行的过期时间来支持并发一致性读和回滚等特性。 - - 详细内容可以参考： [可能是最漂亮的Spring事务管理详解](https://blog.csdn.net/qq_34337272/article/details/80394121) - -- ### ⑥锁机制与InnoDB锁算法 - **MyISAM和InnoDB存储引擎使用的锁：** - - - MyISAM采用表级锁(table-level locking)。 - - InnoDB支持行级锁(row-level locking)和表级锁,默认为行级锁 - - **表级锁和行级锁对比：** - - - **表级锁：** Mysql中锁定 **粒度最大** 的一种锁，对当前操作的整张表加锁，实现简单，资源消耗也比较少，加锁快，不会出现死锁。其锁定粒度最大，触发锁冲突的概率最高，并发度最低，MyISAM和 InnoDB引擎都支持表级锁。 - - **行级锁：** Mysql中锁定 **粒度最小** 的一种锁，只针对当前操作的行进行加锁。 行级锁能大大减少数据库操作的冲突。其加锁粒度最小，并发度高，但加锁的开销也最大，加锁慢，会出现死锁。 - - 详细内容可以参考： - [Mysql锁机制简单了解一下](https://blog.csdn.net/qq_34337272/article/details/80611486) - - **InnoDB存储引擎的锁的算法有三种：** - - Record lock：单个行记录上的锁 - - Gap lock：间隙锁，锁定一个范围，不包括记录本身 - - Next-key lock：record+gap 锁定一个范围，包含记录本身 - - **相关知识点：** - 1. innodb对于行的查询使用next-key lock - 2. Next-locking keying为了解决Phantom Problem幻读问题 - 3. 当查询的索引含有唯一属性时，将next-key lock降级为record key - 4. Gap锁设计的目的是为了阻止多个事务将记录插入到同一范围内，而这会导致幻读问题的产生 - 5. 有两种方式显式关闭gap锁：（除了外键约束和唯一性检查外，其余情况仅使用record lock） A. 将事务隔离级别设置为RC B. 将参数innodb_locks_unsafe_for_binlog设置为1 - -- ### ⑦大表优化 - - 当MySQL单表记录数过大时，数据库的CRUD性能会明显下降，一些常见的优化措施如下： - - 1. **限定数据的范围：** 务必禁止不带任何限制数据范围条件的查询语句。比如：我们当用户在查询订单历史的时候，我们可以控制在一个月的范围内。； - 2. **读/写分离：** 经典的数据库拆分方案，主库负责写，从库负责读； - 3 . **垂直分区：** - - **根据数据库里面数据表的相关性进行拆分。** 例如，用户表中既有用户的登录信息又有用户的基本信息，可以将用户表拆分成两个单独的表，甚至放到单独的库做分库。 - - **简单来说垂直拆分是指数据表列的拆分，把一张列比较多的表拆分为多张表。** 如下图所示，这样来说大家应该就更容易理解了。 - ![](https://user-gold-cdn.xitu.io/2018/6/16/164084354ba2e0fd?w=950&h=279&f=jpeg&s=26015) - - **垂直拆分的优点：** 可以使得行数据变小，在查询时减少读取的Block数，减少I/O次数。此外，垂直分区可以简化表的结构，易于维护。 - - **垂直拆分的缺点：** 主键会出现冗余，需要管理冗余列，并会引起Join操作，可以通过在应用层进行Join来解决。此外，垂直分区会让事务变得更加复杂； - - 4. **水平分区：** - - - **保持数据表结构不变，通过某种策略存储数据分片。这样每一片数据分散到不同的表或者库中，达到了分布式的目的。 水平拆分可以支撑非常大的数据量。** - - 水平拆分是指数据表行的拆分，表的行数超过200万行时，就会变慢，这时可以把一张的表的数据拆成多张表来存放。举个例子：我们可以将用户信息表拆分成多个用户信息表，这样就可以避免单一表数据量过大对性能造成影响。 - - ![数据库水平拆分](https://user-gold-cdn.xitu.io/2018/6/16/164084b7e9e423e3?w=690&h=271&f=jpeg&s=23119) - - 水平拆分可以支持非常大的数据量。需要注意的一点是:分表仅仅是解决了单一表数据过大的问题，但由于表的数据还是在同一台机器上，其实对于提升MySQL并发能力没有什么意义，所以 **水平拆分最好分库** 。 - - 水平拆分能够 **支持非常大的数据量存储，应用端改造也少**，但 **分片事务难以解决** ，跨界点Join性能较差，逻辑复杂。《Java工程师修炼之道》的作者推荐 **尽量不要对数据进行分片，因为拆分会带来逻辑、部署、运维的各种复杂度** ，一般的数据表在优化得当的情况下支撑千万以下的数据量是没有太大问题的。如果实在要分片，尽量选择客户端分片架构，这样可以减少一次和中间件的网络I/O。 - - **下面补充一下数据库分片的两种常见方案：** - - **客户端代理：** **分片逻辑在应用端，封装在jar包中，通过修改或者封装JDBC层来实现。** 当当网的 **Sharding-JDBC** 、阿里的TDDL是两种比较常用的实现。 - - **中间件代理：** **在应用和数据中间加了一个代理层。分片逻辑统一维护在中间件服务中。** 我们现在谈的 **Mycat** 、360的Atlas、网易的DDB等等都是这种架构的实现。 - - - 详细内容可以参考： - [MySQL大表优化方案](https://segmentfault.com/a/1190000006158186) - +**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 +![我的公众号](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/167598cd2e17b8ec.png) diff --git "a/docs/database/MySQL\351\253\230\346\200\247\350\203\275\344\274\230\345\214\226\350\247\204\350\214\203\345\273\272\350\256\256.md" "b/docs/database/MySQL\351\253\230\346\200\247\350\203\275\344\274\230\345\214\226\350\247\204\350\214\203\345\273\272\350\256\256.md" new file mode 100644 index 00000000000..f079ad77593 --- /dev/null +++ "b/docs/database/MySQL\351\253\230\346\200\247\350\203\275\344\274\230\345\214\226\350\247\204\350\214\203\345\273\272\350\256\256.md" @@ -0,0 +1,441 @@ +> 作者: 听风，原文地址: 。JavaGuide 已获得作者授权。 + + + +- [数据库命令规范](#数据库命令规范) +- [数据库基本设计规范](#数据库基本设计规范) + - [1. 所有表必须使用 Innodb 存储引擎](#1-所有表必须使用-innodb-存储引擎) + - [2. 数据库和表的字符集统一使用 UTF8](#2-数据库和表的字符集统一使用-utf8) + - [3. 所有表和字段都需要添加注释](#3-所有表和字段都需要添加注释) + - [4. 尽量控制单表数据量的大小,建议控制在 500 万以内。](#4-尽量控制单表数据量的大小建议控制在-500-万以内) + - [5. 谨慎使用 MySQL 分区表](#5-谨慎使用-mysql-分区表) + - [6.尽量做到冷热数据分离,减小表的宽度](#6尽量做到冷热数据分离减小表的宽度) + - [7. 禁止在表中建立预留字段](#7-禁止在表中建立预留字段) + - [8. 禁止在数据库中存储图片,文件等大的二进制数据](#8-禁止在数据库中存储图片文件等大的二进制数据) + - [9. 禁止在线上做数据库压力测试](#9-禁止在线上做数据库压力测试) + - [10. 禁止从开发环境,测试环境直接连接生成环境数据库](#10-禁止从开发环境测试环境直接连接生成环境数据库) +- [数据库字段设计规范](#数据库字段设计规范) + - [1. 优先选择符合存储需要的最小的数据类型](#1-优先选择符合存储需要的最小的数据类型) + - [2. 避免使用 TEXT,BLOB 数据类型，最常见的 TEXT 类型可以存储 64k 的数据](#2-避免使用-textblob-数据类型最常见的-text-类型可以存储-64k-的数据) + - [3. 避免使用 ENUM 类型](#3-避免使用-enum-类型) + - [4. 尽可能把所有列定义为 NOT NULL](#4-尽可能把所有列定义为-not-null) + - [5. 使用 TIMESTAMP(4 个字节) 或 DATETIME 类型 (8 个字节) 存储时间](#5-使用-timestamp4-个字节-或-datetime-类型-8-个字节-存储时间) + - [6. 同财务相关的金额类数据必须使用 decimal 类型](#6-同财务相关的金额类数据必须使用-decimal-类型) +- [索引设计规范](#索引设计规范) + - [1. 限制每张表上的索引数量,建议单张表索引不超过 5 个](#1-限制每张表上的索引数量建议单张表索引不超过-5-个) + - [2. 禁止给表中的每一列都建立单独的索引](#2-禁止给表中的每一列都建立单独的索引) + - [3. 每个 Innodb 表必须有个主键](#3-每个-innodb-表必须有个主键) + - [4. 常见索引列建议](#4-常见索引列建议) + - [5.如何选择索引列的顺序](#5如何选择索引列的顺序) + - [6. 避免建立冗余索引和重复索引（增加了查询优化器生成执行计划的时间）](#6-避免建立冗余索引和重复索引增加了查询优化器生成执行计划的时间) + - [7. 对于频繁的查询优先考虑使用覆盖索引](#7-对于频繁的查询优先考虑使用覆盖索引) + - [8.索引 SET 规范](#8索引-set-规范) +- [数据库 SQL 开发规范](#数据库-sql-开发规范) + - [1. 建议使用预编译语句进行数据库操作](#1-建议使用预编译语句进行数据库操作) + - [2. 避免数据类型的隐式转换](#2-避免数据类型的隐式转换) + - [3. 充分利用表上已经存在的索引](#3-充分利用表上已经存在的索引) + - [4. 数据库设计时，应该要对以后扩展进行考虑](#4-数据库设计时应该要对以后扩展进行考虑) + - [5. 程序连接不同的数据库使用不同的账号，进制跨库查询](#5-程序连接不同的数据库使用不同的账号进制跨库查询) + - [6. 禁止使用 SELECT * 必须使用 SELECT <字段列表> 查询](#6-禁止使用-select--必须使用-select-字段列表-查询) + - [7. 禁止使用不含字段列表的 INSERT 语句](#7-禁止使用不含字段列表的-insert-语句) + - [8. 避免使用子查询，可以把子查询优化为 join 操作](#8-避免使用子查询可以把子查询优化为-join-操作) + - [9. 避免使用 JOIN 关联太多的表](#9-避免使用-join-关联太多的表) + - [10. 减少同数据库的交互次数](#10-减少同数据库的交互次数) + - [11. 对应同一列进行 or 判断时，使用 in 代替 or](#11-对应同一列进行-or-判断时使用-in-代替-or) + - [12. 禁止使用 order by rand() 进行随机排序](#12-禁止使用-order-by-rand-进行随机排序) + - [13. WHERE 从句中禁止对列进行函数转换和计算](#13-where-从句中禁止对列进行函数转换和计算) + - [14. 在明显不会有重复值时使用 UNION ALL 而不是 UNION](#14-在明显不会有重复值时使用-union-all-而不是-union) + - [15. 拆分复杂的大 SQL 为多个小 SQL](#15-拆分复杂的大-sql-为多个小-sql) +- [数据库操作行为规范](#数据库操作行为规范) + - [1. 超 100 万行的批量写 (UPDATE,DELETE,INSERT) 操作,要分批多次进行操作](#1-超-100-万行的批量写-updatedeleteinsert-操作要分批多次进行操作) + - [2. 对于大表使用 pt-online-schema-change 修改表结构](#2-对于大表使用-pt-online-schema-change-修改表结构) + - [3. 禁止为程序使用的账号赋予 super 权限](#3-禁止为程序使用的账号赋予-super-权限) + - [4. 对于程序连接数据库账号,遵循权限最小原则](#4-对于程序连接数据库账号遵循权限最小原则) + + + +## 数据库命令规范 + +- 所有数据库对象名称必须使用小写字母并用下划线分割 +- 所有数据库对象名称禁止使用 MySQL 保留关键字（如果表名中包含关键字查询时，需要将其用单引号括起来） +- 数据库对象的命名要能做到见名识意，并且最后不要超过 32 个字符 +- 临时库表必须以 tmp_为前缀并以日期为后缀，备份表必须以 bak_为前缀并以日期 (时间戳) 为后缀 +- 所有存储相同数据的列名和列类型必须一致（一般作为关联列，如果查询时关联列类型不一致会自动进行数据类型隐式转换，会造成列上的索引失效，导致查询效率降低） + +------ + +## 数据库基本设计规范 + +### 1. 所有表必须使用 Innodb 存储引擎 + +没有特殊要求（即 Innodb 无法满足的功能如：列存储，存储空间数据等）的情况下，所有表必须使用 Innodb 存储引擎（MySQL5.5 之前默认使用 Myisam，5.6 以后默认的为 Innodb）。 + +Innodb 支持事务，支持行级锁，更好的恢复性，高并发下性能更好。 + +### 2. 数据库和表的字符集统一使用 UTF8 + +兼容性更好，统一字符集可以避免由于字符集转换产生的乱码，不同的字符集进行比较前需要进行转换会造成索引失效，如果数据库中有存储 emoji 表情的需要，字符集需要采用 utf8mb4 字符集。 + +### 3. 所有表和字段都需要添加注释 + +使用 comment 从句添加表和列的备注，从一开始就进行数据字典的维护 + +### 4. 尽量控制单表数据量的大小,建议控制在 500 万以内。 + +500 万并不是 MySQL 数据库的限制，过大会造成修改表结构，备份，恢复都会有很大的问题。 + +可以用历史数据归档（应用于日志数据），分库分表（应用于业务数据）等手段来控制数据量大小 + +### 5. 谨慎使用 MySQL 分区表 + +分区表在物理上表现为多个文件，在逻辑上表现为一个表； + +谨慎选择分区键，跨分区查询效率可能更低； + +建议采用物理分表的方式管理大数据。 + +### 6.尽量做到冷热数据分离,减小表的宽度 + +> MySQL 限制每个表最多存储 4096 列，并且每一行数据的大小不能超过 65535 字节。 + +减少磁盘 IO,保证热数据的内存缓存命中率（表越宽，把表装载进内存缓冲池时所占用的内存也就越大,也会消耗更多的 IO）； + +更有效的利用缓存，避免读入无用的冷数据； + +经常一起使用的列放到一个表中（避免更多的关联操作）。 + +### 7. 禁止在表中建立预留字段 + +预留字段的命名很难做到见名识义。 + +预留字段无法确认存储的数据类型，所以无法选择合适的类型。 + +对预留字段类型的修改，会对表进行锁定。 + +### 8. 禁止在数据库中存储图片,文件等大的二进制数据 + +通常文件很大，会短时间内造成数据量快速增长，数据库进行数据库读取时，通常会进行大量的随机 IO 操作，文件很大时，IO 操作很耗时。 + +通常存储于文件服务器，数据库只存储文件地址信息 + +### 9. 禁止在线上做数据库压力测试 + +### 10. 禁止从开发环境,测试环境直接连接生产环境数据库 + +------ + +## 数据库字段设计规范 + +### 1. 优先选择符合存储需要的最小的数据类型 + +**原因：** + +列的字段越大，建立索引时所需要的空间也就越大，这样一页中所能存储的索引节点的数量也就越少也越少，在遍历时所需要的 IO 次数也就越多，索引的性能也就越差。 + +**方法：** + +**a.将字符串转换成数字类型存储,如:将 IP 地址转换成整形数据** + +MySQL 提供了两个方法来处理 ip 地址 + +- inet_aton 把 ip 转为无符号整型 (4-8 位) +- inet_ntoa 把整型的 ip 转为地址 + +插入数据前，先用 inet_aton 把 ip 地址转为整型，可以节省空间，显示数据时，使用 inet_ntoa 把整型的 ip 地址转为地址显示即可。 + +**b.对于非负型的数据 (如自增 ID,整型 IP) 来说,要优先使用无符号整型来存储** + +**原因：** + +无符号相对于有符号可以多出一倍的存储空间 + +``` +SIGNED INT -2147483648~2147483647 +UNSIGNED INT 0~4294967295 +``` + +VARCHAR(N) 中的 N 代表的是字符数，而不是字节数，使用 UTF8 存储 255 个汉字 Varchar(255)=765 个字节。**过大的长度会消耗更多的内存。** + +### 2. 避免使用 TEXT,BLOB 数据类型，最常见的 TEXT 类型可以存储 64k 的数据 + +**a. 建议把 BLOB 或是 TEXT 列分离到单独的扩展表中** + +MySQL 内存临时表不支持 TEXT、BLOB 这样的大数据类型，如果查询中包含这样的数据，在排序等操作时，就不能使用内存临时表，必须使用磁盘临时表进行。而且对于这种数据，MySQL 还是要进行二次查询，会使 sql 性能变得很差，但是不是说一定不能使用这样的数据类型。 + +如果一定要使用，建议把 BLOB 或是 TEXT 列分离到单独的扩展表中，查询时一定不要使用 select * 而只需要取出必要的列，不需要 TEXT 列的数据时不要对该列进行查询。 + +**2、TEXT 或 BLOB 类型只能使用前缀索引** + +因为[MySQL](http://mp.weixin.qq.com/s?__biz=MzI4Njc5NjM1NQ==&mid=2247487885&idx=1&sn=65b1bf5f7d4505502620179669a9c2df&chksm=ebd62ea1dca1a7b7bf884bcd9d538d78ba064ee03c09436ca8e57873b1d98a55afd6d7884cfc&scene=21#wechat_redirect) 对索引字段长度是有限制的，所以 TEXT 类型只能使用前缀索引，并且 TEXT 列上是不能有默认值的 + +### 3. 避免使用 ENUM 类型 + +修改 ENUM 值需要使用 ALTER 语句 + +ENUM 类型的 ORDER BY 操作效率低，需要额外操作 + +禁止使用数值作为 ENUM 的枚举值 + +### 4. 尽可能把所有列定义为 NOT NULL + +**原因：** + +索引 NULL 列需要额外的空间来保存，所以要占用更多的空间 + +进行比较和计算时要对 NULL 值做特别的处理 + +### 5. 使用 TIMESTAMP(4 个字节) 或 DATETIME 类型 (8 个字节) 存储时间 + +TIMESTAMP 存储的时间范围 1970-01-01 00:00:01 ~ 2038-01-19-03:14:07 + +TIMESTAMP 占用 4 字节和 INT 相同，但比 INT 可读性高 + +超出 TIMESTAMP 取值范围的使用 DATETIME 类型存储 + +**经常会有人用字符串存储日期型的数据（不正确的做法）** + +- 缺点 1：无法用日期函数进行计算和比较 +- 缺点 2：用字符串存储日期要占用更多的空间 + +### 6. 同财务相关的金额类数据必须使用 decimal 类型 + +- 非精准浮点：float,double +- 精准浮点：decimal + +Decimal 类型为精准浮点数，在计算时不会丢失精度 + +占用空间由定义的宽度决定，每 4 个字节可以存储 9 位数字，并且小数点要占用一个字节 + +可用于存储比 bigint 更大的整型数据 + +------ + +## 索引设计规范 + +### 1. 限制每张表上的索引数量,建议单张表索引不超过 5 个 + +索引并不是越多越好！索引可以提高效率同样可以降低效率。 + +索引可以增加查询效率，但同样也会降低插入和更新的效率，甚至有些情况下会降低查询效率。 + +因为 MySQL 优化器在选择如何优化查询时，会根据统一信息，对每一个可以用到的索引来进行评估，以生成出一个最好的执行计划，如果同时有很多个索引都可以用于查询，就会增加 MySQL 优化器生成执行计划的时间，同样会降低查询性能。 + +### 2. 禁止给表中的每一列都建立单独的索引 + +5.6 版本之前，一个 sql 只能使用到一个表中的一个索引，5.6 以后，虽然有了合并索引的优化方式，但是还是远远没有使用一个联合索引的查询方式好。 + +### 3. 每个 Innodb 表必须有个主键 + +Innodb 是一种索引组织表：数据的存储的逻辑顺序和索引的顺序是相同的。每个表都可以有多个索引，但是表的存储顺序只能有一种。 + +Innodb 是按照主键索引的顺序来组织表的 + +- 不要使用更新频繁的列作为主键，不适用多列主键（相当于联合索引） +- 不要使用 UUID,MD5,HASH,字符串列作为主键（无法保证数据的顺序增长） +- 主键建议使用自增 ID 值 + +------ + +### 4. 常见索引列建议 + +- 出现在 SELECT、UPDATE、DELETE 语句的 WHERE 从句中的列 +- 包含在 ORDER BY、GROUP BY、DISTINCT 中的字段 +- 并不要将符合 1 和 2 中的字段的列都建立一个索引， 通常将 1、2 中的字段建立联合索引效果更好 +- 多表 join 的关联列 + +------ + +### 5.如何选择索引列的顺序 + +建立索引的目的是：希望通过索引进行数据查找，减少随机 IO，增加查询性能 ，索引能过滤出越少的数据，则从磁盘中读入的数据也就越少。 + +- 区分度最高的放在联合索引的最左侧（区分度=列中不同值的数量/列的总行数） +- 尽量把字段长度小的列放在联合索引的最左侧（因为字段长度越小，一页能存储的数据量越大，IO 性能也就越好） +- 使用最频繁的列放到联合索引的左侧（这样可以比较少的建立一些索引） + +------ + +### 6. 避免建立冗余索引和重复索引（增加了查询优化器生成执行计划的时间） + +- 重复索引示例：primary key(id)、index(id)、unique index(id) +- 冗余索引示例：index(a,b,c)、index(a,b)、index(a) + +------ + +### 7. 对于频繁的查询优先考虑使用覆盖索引 + +> 覆盖索引：就是包含了所有查询字段 (where,select,ordery by,group by 包含的字段) 的索引 + +**覆盖索引的好处：** + +- **避免 Innodb 表进行索引的二次查询:** Innodb 是以聚集索引的顺序来存储的，对于 Innodb 来说，二级索引在叶子节点中所保存的是行的主键信息，如果是用二级索引查询数据的话，在查找到相应的键值后，还要通过主键进行二次查询才能获取我们真实所需要的数据。而在覆盖索引中，二级索引的键值中可以获取所有的数据，避免了对主键的二次查询 ，减少了 IO 操作，提升了查询效率。 +- **可以把随机 IO 变成顺序 IO 加快查询效率:** 由于覆盖索引是按键值的顺序存储的，对于 IO 密集型的范围查找来说，对比随机从磁盘读取每一行的数据 IO 要少的多，因此利用覆盖索引在访问时也可以把磁盘的随机读取的 IO 转变成索引查找的顺序 IO。 + +------ + +### 8.索引 SET 规范 + +**尽量避免使用外键约束** + +- 不建议使用外键约束（foreign key），但一定要在表与表之间的关联键上建立索引 +- 外键可用于保证数据的参照完整性，但建议在业务端实现 +- 外键会影响父表和子表的写操作从而降低性能 + +------ + +## 数据库 SQL 开发规范 + +### 1. 建议使用预编译语句进行数据库操作 + +预编译语句可以重复使用这些计划，减少 SQL 编译所需要的时间，还可以解决动态 SQL 所带来的 SQL 注入的问题。 + +只传参数，比传递 SQL 语句更高效。 + +相同语句可以一次解析，多次使用，提高处理效率。 + +### 2. 避免数据类型的隐式转换 + +隐式转换会导致索引失效如: + +``` +select name,phone from customer where id = '111'; +``` + +### 3. 充分利用表上已经存在的索引 + +避免使用双%号的查询条件。如：`a like '%123%'`，（如果无前置%,只有后置%，是可以用到列上的索引的） + +一个 SQL 只能利用到复合索引中的一列进行范围查询。如：有 a,b,c 列的联合索引，在查询条件中有 a 列的范围查询，则在 b,c 列上的索引将不会被用到。 + +在定义联合索引时，如果 a 列要用到范围查找的话，就要把 a 列放到联合索引的右侧，使用 left join 或 not exists 来优化 not in 操作，因为 not in 也通常会使用索引失效。 + +### 4. 数据库设计时，应该要对以后扩展进行考虑 + +### 5. 程序连接不同的数据库使用不同的账号，禁止跨库查询 + +- 为数据库迁移和分库分表留出余地 +- 降低业务耦合度 +- 避免权限过大而产生的安全风险 + +### 6. 禁止使用 SELECT * 必须使用 SELECT <字段列表> 查询 + +**原因：** + +- 消耗更多的 CPU 和 IO 以网络带宽资源 +- 无法使用覆盖索引 +- 可减少表结构变更带来的影响 + +### 7. 禁止使用不含字段列表的 INSERT 语句 + +如： + +``` +insert into values ('a','b','c'); +``` + +应使用： + +``` +insert into t(c1,c2,c3) values ('a','b','c'); +``` + +### 8. 避免使用子查询，可以把子查询优化为 join 操作 + +通常子查询在 in 子句中，且子查询中为简单 SQL(不包含 union、group by、order by、limit 从句) 时,才可以把子查询转化为关联查询进行优化。 + +**子查询性能差的原因：** + +子查询的结果集无法使用索引，通常子查询的结果集会被存储到临时表中，不论是内存临时表还是磁盘临时表都不会存在索引，所以查询性能会受到一定的影响。特别是对于返回结果集比较大的子查询，其对查询性能的影响也就越大。 + +由于子查询会产生大量的临时表也没有索引，所以会消耗过多的 CPU 和 IO 资源，产生大量的慢查询。 + +### 9. 避免使用 JOIN 关联太多的表 + +对于 MySQL 来说，是存在关联缓存的，缓存的大小可以由 join_buffer_size 参数进行设置。 + +在 MySQL 中，对于同一个 SQL 多关联（join）一个表，就会多分配一个关联缓存，如果在一个 SQL 中关联的表越多，所占用的内存也就越大。 + +如果程序中大量的使用了多表关联的操作，同时 join_buffer_size 设置的也不合理的情况下，就容易造成服务器内存溢出的情况，就会影响到服务器数据库性能的稳定性。 + +同时对于关联操作来说，会产生临时表操作，影响查询效率，MySQL 最多允许关联 61 个表，建议不超过 5 个。 + +### 10. 减少同数据库的交互次数 + +数据库更适合处理批量操作，合并多个相同的操作到一起，可以提高处理效率。 + +### 11. 对应同一列进行 or 判断时，使用 in 代替 or + +in 的值不要超过 500 个，in 操作可以更有效的利用索引，or 大多数情况下很少能利用到索引。 + +### 12. 禁止使用 order by rand() 进行随机排序 + +order by rand() 会把表中所有符合条件的数据装载到内存中，然后在内存中对所有数据根据随机生成的值进行排序，并且可能会对每一行都生成一个随机值，如果满足条件的数据集非常大，就会消耗大量的 CPU 和 IO 及内存资源。 + +推荐在程序中获取一个随机值，然后从数据库中获取数据的方式。 + +### 13. WHERE 从句中禁止对列进行函数转换和计算 + +对列进行函数转换或计算时会导致无法使用索引 + +**不推荐：** + +``` +where date(create_time)='20190101' +``` + +**推荐：** + +``` +where create_time >= '20190101' and create_time < '20190102' +``` + +### 14. 在明显不会有重复值时使用 UNION ALL 而不是 UNION + +- UNION 会把两个结果集的所有数据放到临时表中后再进行去重操作 +- UNION ALL 不会再对结果集进行去重操作 + +### 15. 拆分复杂的大 SQL 为多个小 SQL + +- 大 SQL 逻辑上比较复杂，需要占用大量 CPU 进行计算的 SQL +- MySQL 中，一个 SQL 只能使用一个 CPU 进行计算 +- SQL 拆分后可以通过并行执行来提高处理效率 + +------ + +## 数据库操作行为规范 + +### 1. 超 100 万行的批量写 (UPDATE,DELETE,INSERT) 操作,要分批多次进行操作 + +**大批量操作可能会造成严重的主从延迟** + +主从环境中,大批量操作可能会造成严重的主从延迟，大批量的写操作一般都需要执行一定长的时间， +而只有当主库上执行完成后，才会在其他从库上执行，所以会造成主库与从库长时间的延迟情况 + +**binlog 日志为 row 格式时会产生大量的日志** + +大批量写操作会产生大量日志，特别是对于 row 格式二进制数据而言，由于在 row 格式中会记录每一行数据的修改，我们一次修改的数据越多，产生的日志量也就会越多，日志的传输和恢复所需要的时间也就越长，这也是造成主从延迟的一个原因 + +**避免产生大事务操作** + +大批量修改数据，一定是在一个事务中进行的，这就会造成表中大批量数据进行锁定，从而导致大量的阻塞，阻塞会对 MySQL 的性能产生非常大的影响。 + +特别是长时间的阻塞会占满所有数据库的可用连接，这会使生产环境中的其他应用无法连接到数据库，因此一定要注意大批量写操作要进行分批 + +### 2. 对于大表使用 pt-online-schema-change 修改表结构 + +- 避免大表修改产生的主从延迟 +- 避免在对表字段进行修改时进行锁表 + +对大表数据结构的修改一定要谨慎，会造成严重的锁表操作，尤其是生产环境，是不能容忍的。 + +pt-online-schema-change 它会首先建立一个与原表结构相同的新表，并且在新表上进行表结构的修改，然后再把原表中的数据复制到新表中，并在原表中增加一些触发器。把原表中新增的数据也复制到新表中，在行所有数据复制完成之后，把新表命名成原表，并把原来的表删除掉。把原来一个 DDL 操作，分解成多个小的批次进行。 + +### 3. 禁止为程序使用的账号赋予 super 权限 + +- 当达到最大连接数限制时，还运行 1 个有 super 权限的用户连接 +- super 权限只能留给 DBA 处理问题的账号使用 + +### 4. 对于程序连接数据库账号,遵循权限最小原则 + +- 程序使用数据库账号只能在一个 DB 下使用，不准跨库 +- 程序使用的账号原则上不准有 drop 权限 diff --git a/docs/database/Redis/Redis.md b/docs/database/Redis/Redis.md index a53a6481a00..53f8abca9f4 100644 --- a/docs/database/Redis/Redis.md +++ b/docs/database/Redis/Redis.md @@ -1,38 +1,38 @@ - +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 + + - [redis 简介](#redis-简介) -- [为什么要用 redis /为什么要用缓存](#为什么要用-redis-为什么要用缓存) +- [为什么要用 redis/为什么要用缓存](#为什么要用-redis为什么要用缓存) - [为什么要用 redis 而不用 map/guava 做缓存?](#为什么要用-redis-而不用-mapguava-做缓存) - [redis 和 memcached 的区别](#redis-和-memcached-的区别) - [redis 常见数据结构以及使用场景分析](#redis-常见数据结构以及使用场景分析) - - [1. String](#1-string) - - [2.Hash](#2hash) - - [3.List](#3list) - - [4.Set](#4set) - - [5.Sorted Set](#5sorted-set) + - [1.String](#1string) + - [2.Hash](#2hash) + - [3.List](#3list) + - [4.Set](#4set) + - [5.Sorted Set](#5sorted-set) - [redis 设置过期时间](#redis-设置过期时间) -- [redis 内存淘汰机制（MySQL里有2000w数据，Redis中只存20w的数据，如何保证Redis中的数据都是热点数据？）](#redis-内存淘汰机制（mysql里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据？）) -- [redis 持久化机制（怎么保证 redis 挂掉之后再重启数据可以进行恢复）](#redis-持久化机制（怎么保证-redis-挂掉之后再重启数据可以进行恢复）) +- [redis 内存淘汰机制(MySQL里有2000w数据，Redis中只存20w的数据，如何保证Redis中的数据都是热点数据?)](#redis-内存淘汰机制mysql里有2000w数据redis中只存20w的数据如何保证redis中的数据都是热点数据) +- [redis 持久化机制(怎么保证 redis 挂掉之后再重启数据可以进行恢复)](#redis-持久化机制怎么保证-redis-挂掉之后再重启数据可以进行恢复) - [redis 事务](#redis-事务) - [缓存雪崩和缓存穿透问题解决方案](#缓存雪崩和缓存穿透问题解决方案) - [如何解决 Redis 的并发竞争 Key 问题](#如何解决-redis-的并发竞争-key-问题) -- [如何保证缓存与数据库双写时的数据一致性？](#如何保证缓存与数据库双写时的数据一致性？) -- [参考：](#参考：) - - +- [如何保证缓存与数据库双写时的数据一致性?](#如何保证缓存与数据库双写时的数据一致性) + ### redis 简介 -简单来说 redis 就是一个数据库，不过与传统数据库不同的是 redis 的数据是存在内存中的，所以存写速度非常快，因此 redis 被广泛应用于缓存方向。另外，redis 也经常用来做分布式锁。redis 提供了多种数据类型来支持不同的业务场景。除此之外，redis 支持事务 、持久化、LUA脚本、LRU驱动事件、多种集群方案。 +简单来说 redis 就是一个数据库，不过与传统数据库不同的是 redis 的数据是存在内存中的，所以读写速度非常快，因此 redis 被广泛应用于缓存方向。另外，redis 也经常用来做分布式锁。redis 提供了多种数据类型来支持不同的业务场景。除此之外，redis 支持事务 、持久化、LUA脚本、LRU驱动事件、多种集群方案。 -### 为什么要用 redis /为什么要用缓存 +### 为什么要用 redis/为什么要用缓存 主要从“高性能”和“高并发”这两点来看待这个问题。 **高性能：** -假如用户第一次访问数据库中的某些数据。这个过程会比较慢，因为是从硬盘上读取的。将该用户访问的数据存在数缓存中，这样下一次再访问这些数据的时候就可以直接从缓存中获取了。操作缓存就是直接操作内存，所以速度相当快。如果数据库中的对应数据改变的之后，同步改变缓存中相应的数据即可！ +假如用户第一次访问数据库中的某些数据。这个过程会比较慢，因为是从硬盘上读取的。将该用户访问的数据存在缓存中，这样下一次再访问这些数据的时候就可以直接从缓存中获取了。操作缓存就是直接操作内存，所以速度相当快。如果数据库中的对应数据改变的之后，同步改变缓存中相应的数据即可！ ![](http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-9-24/54316596.jpg) @@ -54,6 +54,21 @@ 使用 redis 或 memcached 之类的称为分布式缓存，在多实例的情况下，各实例共用一份缓存数据，缓存具有一致性。缺点是需要保持 redis 或 memcached服务的高可用，整个程序架构上较为复杂。 +### redis 的线程模型 + +> 参考地址:https://www.javazhiyin.com/22943.html + +redis 内部使用文件事件处理器 `file event handler`，这个文件事件处理器是单线程的，所以 redis 才叫做单线程的模型。它采用 IO 多路复用机制同时监听多个 socket，根据 socket 上的事件来选择对应的事件处理器进行处理。 + +文件事件处理器的结构包含 4 个部分： + +- 多个 socket +- IO 多路复用程序 +- 文件事件分派器 +- 事件处理器（连接应答处理器、命令请求处理器、命令回复处理器） + +多个 socket 可能会并发产生不同的操作，每个操作对应不同的文件事件，但是 IO 多路复用程序会监听多个 socket，会将 socket 产生的事件放入队列中排队，事件分派器每次从队列中取出一个事件，把该事件交给对应的事件处理器进行处理。 + ### redis 和 memcached 的区别 @@ -72,7 +87,7 @@ ### redis 常见数据结构以及使用场景分析 -#### 1. String +#### 1.String > **常用命令:** set,get,decr,incr,mget 等。 @@ -84,7 +99,7 @@ String数据结构是简单的key-value类型，value其实不仅可以是String #### 2.Hash > **常用命令：** hget,hset,hgetall 等。 -Hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象，后续操作的时候，你可以直接仅仅修改这个对象中的某个字段的值。 比如我们可以Hash数据结构来存储用户信息，商品信息等等。比如下面我就用 hash 类型存放了我本人的一些信息： +hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象，后续操作的时候，你可以直接仅仅修改这个对象中的某个字段的值。 比如我们可以 hash 数据结构来存储用户信息，商品信息等等。比如下面我就用 hash 类型存放了我本人的一些信息： ``` key=JavaUser293847 @@ -128,7 +143,7 @@ sinterstore key1 key2 key3 将交集存在key1内 和set相比，sorted set增加了一个权重参数score，使得集合中的元素能够按score进行有序排列。 -**举例：** 在直播系统中，实时排行信息包含直播间在线用户列表，各种礼物排行榜，弹幕消息（可以理解为按消息维度的消息排行榜）等信息，适合使用 Redis 中的 SortedSet 结构进行存储。 +**举例：** 在直播系统中，实时排行信息包含直播间在线用户列表，各种礼物排行榜，弹幕消息（可以理解为按消息维度的消息排行榜）等信息，适合使用 Redis 中的 Sorted Set 结构进行存储。 ### redis 设置过期时间 @@ -147,11 +162,9 @@ Redis中有个设置时间过期的功能，即对存储在 redis 数据库中 - **惰性删除** ：定期删除可能会导致很多过期 key 到了时间并没有被删除掉。所以就有了惰性删除。假如你的过期 key，靠定期删除没有被删除掉，还停留在内存里，除非你的系统去查一下那个 key，才会被redis给删除掉。这就是所谓的惰性删除，也是够懒的哈！ -但是仅仅通过设置过期时间还是有问题的。我们想一下：如果定期删除漏掉了很多过期 key，然后你也没及时去查，也就没走惰性删除，此时会怎么样？如果大量过期key堆积在内存里，导致redis内存块耗尽了。怎么解决这个问题呢？ +但是仅仅通过设置过期时间还是有问题的。我们想一下：如果定期删除漏掉了很多过期 key，然后你也没及时去查，也就没走惰性删除，此时会怎么样？如果大量过期key堆积在内存里，导致redis内存块耗尽了。怎么解决这个问题呢？ **redis 内存淘汰机制。** -**redis 内存淘汰机制。** - -### redis 内存淘汰机制（MySQL里有2000w数据，Redis中只存20w的数据，如何保证Redis中的数据都是热点数据？） +### redis 内存淘汰机制(MySQL里有2000w数据，Redis中只存20w的数据，如何保证Redis中的数据都是热点数据?) redis 配置文件 redis.conf 中有相关注释，我这里就不贴了，大家可以自行查阅或者通过这个网址查看： [http://download.redis.io/redis-stable/redis.conf](http://download.redis.io/redis-stable/redis.conf) @@ -160,19 +173,23 @@ redis 配置文件 redis.conf 中有相关注释，我这里就不贴了，大 1. **volatile-lru**：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰 2. **volatile-ttl**：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰 3. **volatile-random**：从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰 -4. **allkeys-lru**：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的key（这个是最常用的）. +4. **allkeys-lru**：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的key（这个是最常用的） 5. **allkeys-random**：从数据集（server.db[i].dict）中任意选择数据淘汰 6. **no-eviction**：禁止驱逐数据，也就是说当内存不足以容纳新写入数据时，新写入操作会报错。这个应该没人使用吧！ +4.0版本后增加以下两种： + +7. **volatile-lfu**：从已设置过期时间的数据集(server.db[i].expires)中挑选最不经常使用的数据淘汰 +8. **allkeys-lfu**：当内存不足以容纳新写入数据时，在键空间中，移除最不经常使用的key **备注： 关于 redis 设置过期时间以及内存淘汰机制，我这里只是简单的总结一下，后面会专门写一篇文章来总结！** -### redis 持久化机制（怎么保证 redis 挂掉之后再重启数据可以进行恢复） +### redis 持久化机制(怎么保证 redis 挂掉之后再重启数据可以进行恢复) -很多时候我们需要持久化数据也就是将内存中的数据写入到硬盘里面，大部分原因是为了之后重用数据（比如重启机器、机器故障之后回复数据），或者是为了防止系统故障而将数据备份到一个远程位置。 +很多时候我们需要持久化数据也就是将内存中的数据写入到硬盘里面，大部分原因是为了之后重用数据（比如重启机器、机器故障之后恢复数据），或者是为了防止系统故障而将数据备份到一个远程位置。 -Redis不同于Memcached的很重一点就是，Redis支持持久化，而且支持两种不同的持久化操作。**Redis的一种持久化方式叫快照（snapshotting，RDB）,另一种方式是只追加文件（append-only file,AOF）**.这两种方法各有千秋，下面我会详细这两种持久化方法是什么，怎么用，如何选择适合自己的持久化方法。 +Redis不同于Memcached的很重一点就是，Redis支持持久化，而且支持两种不同的持久化操作。**Redis的一种持久化方式叫快照（snapshotting，RDB），另一种方式是只追加文件（append-only file,AOF）**。这两种方法各有千秋，下面我会详细这两种持久化方法是什么，怎么用，如何选择适合自己的持久化方法。 **快照（snapshotting）持久化（RDB）** @@ -182,14 +199,13 @@ Redis可以通过创建快照来获得存储在内存里面的数据在某个时 ```conf -save 900 1 #在900秒(15分钟)之后，如果至少有1个key发生变化，Redis就会自动触发BGSAVE命令创建快照。 +save 900 1 #在900秒(15分钟)之后，如果至少有1个key发生变化，Redis就会自动触发BGSAVE命令创建快照。 -save 300 10 #在300秒(5分钟)之后，如果至少有10个key发生变化，Redis就会自动触发BGSAVE命令创建快照。 +save 300 10 #在300秒(5分钟)之后，如果至少有10个key发生变化，Redis就会自动触发BGSAVE命令创建快照。 save 60 10000 #在60秒(1分钟)之后，如果至少有10000个key发生变化，Redis就会自动触发BGSAVE命令创建快照。 ``` - **AOF（append-only file）持久化** 与快照持久化相比，AOF持久化 的实时性更好，因此已成为主流的持久化方案。默认情况下Redis没有开启AOF（append only file）方式的持久化，可以通过appendonly参数开启： @@ -203,41 +219,41 @@ appendonly yes 在Redis的配置文件中存在三种不同的 AOF 持久化方式，它们分别是： ```conf -appendfsync always #每次有数据修改发生时都会写入AOF文件,这样会严重降低Redis的速度 +appendfsync always #每次有数据修改发生时都会写入AOF文件,这样会严重降低Redis的速度 appendfsync everysec #每秒钟同步一次，显示地将多个写命令同步到硬盘 -appendfsync no #让操作系统决定何时进行同步 +appendfsync no #让操作系统决定何时进行同步 ``` 为了兼顾数据和写入性能，用户可以考虑 appendfsync everysec选项 ，让Redis每秒同步一次AOF文件，Redis性能几乎没受到任何影响。而且这样即使出现系统崩溃，用户最多只会丢失一秒之内产生的数据。当硬盘忙于执行写入操作的时候，Redis还会优雅的放慢自己的速度以便适应硬盘的最大写入速度。 - **Redis 4.0 对于持久化机制的优化** Redis 4.0 开始支持 RDB 和 AOF 的混合持久化（默认关闭，可以通过配置项 `aof-use-rdb-preamble` 开启）。 如果把混合持久化打开，AOF 重写的时候就直接把 RDB 的内容写到 AOF 文件开头。这样做的好处是可以结合 RDB 和 AOF 的优点, 快速加载同时避免丢失过多的数据。当然缺点也是有的， AOF 里面的 RDB 部分是压缩格式不再是 AOF 格式，可读性较差。 - - **补充内容：AOF 重写** AOF重写可以产生一个新的AOF文件，这个新的AOF文件和原有的AOF文件所保存的数据库状态一样，但体积更小。 -AOF重写是一个有歧义的名字，该功能是通过读取数据库中的键值对来实现的，程序无须对现有AOF文件进行任伺读入、分析或者写入操作。 +AOF重写是一个有歧义的名字，该功能是通过读取数据库中的键值对来实现的，程序无须对现有AOF文件进行任何读入、分析或者写入操作。 在执行 BGREWRITEAOF 命令时，Redis 服务器会维护一个 AOF 重写缓冲区，该缓冲区会在子进程创建新AOF文件期间，记录服务器执行的所有写命令。当子进程完成创建新AOF文件的工作之后，服务器会将重写缓冲区中的所有内容追加到新AOF文件的末尾，使得新旧两个AOF文件所保存的数据库状态一致。最后，服务器用新的AOF文件替换旧的AOF文件，以此来完成AOF文件重写操作 - **更多内容可以查看我的这篇文章：** -- [https://github.com/Snailclimb/JavaGuide/blob/master/数据存储/Redis/Redis持久化.md](https://github.com/Snailclimb/JavaGuide/blob/master/数据存储/Redis/Redis持久化.md) +- [Redis持久化](Redis持久化.md) ### redis 事务 Redis 通过 MULTI、EXEC、WATCH 等命令来实现事务(transaction)功能。事务提供了一种将多个命令请求打包，然后一次性、按顺序地执行多个命令的机制，并且在事务执行期间，服务器不会中断事务而改去执行其他客户端的命令请求，它会将事务中的所有命令都执行完毕，然后才去处理其他客户端的命令请求。 -在传统的关系式数据库中，常常用 ACID 性质来检验事务功能的可靠性和安全性。在 Redis 中，事务总是具有原子性（Atomicity)、一致性(Consistency)和隔离性（Isolation），并且当 Redis 运行在某种特定的持久化模式下时，事务也具有持久性（Durability）。 +在传统的关系式数据库中，常常用 ACID 性质来检验事务功能的可靠性和安全性。在 Redis 中，事务总是具有原子性（Atomicity）、一致性（Consistency）和隔离性（Isolation），并且当 Redis 运行在某种特定的持久化模式下时，事务也具有持久性（Durability）。 + +补充内容： + +> 1. redis同一个事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚。（来自[issue:关于Redis事务不是原子性问题](https://github.com/Snailclimb/JavaGuide/issues/452) ） ### 缓存雪崩和缓存穿透问题解决方案 @@ -278,9 +294,9 @@ Redis 通过 MULTI、EXEC、WATCH 等命令来实现事务(transaction)功能。 - https://www.jianshu.com/p/8bddd381de06 +### 如何保证缓存与数据库双写时的数据一致性? -### 如何保证缓存与数据库双写时的数据一致性？ - +> 一般情况下我们都是这样使用缓存的：先读缓存，缓存没有的话，就读数据库，然后取出数据后放入缓存，同时返回响应。这种方式很明显会存在缓存和数据库的数据不一致的情况。 你只要用缓存，就可能会涉及到缓存与数据库双存储双写，你只要是双写，就一定会有数据一致性的问题，那么你如何解决一致性问题？ @@ -288,13 +304,16 @@ Redis 通过 MULTI、EXEC、WATCH 等命令来实现事务(transaction)功能。 串行化之后，就会导致系统的吞吐量会大幅度的降低，用比正常情况下多几倍的机器去支撑线上的一个请求。 -**参考：** +更多内容可以查看：https://github.com/doocs/advanced-java/blob/master/docs/high-concurrency/redis-consistence.md + +**参考：** Java工程师面试突击第1季（可能是史上最好的Java面试突击课程）-中华石杉老师！公众号后台回复关键字“1”即可获取该视频内容。 + +## 公众号 -- Java工程师面试突击第1季（可能是史上最好的Java面试突击课程）-中华石杉老师。视频地址见下面！ - - 链接： https://pan.baidu.com/s/18pp6g1xKVGCfUATf_nMrOA - - 密码：5i58 +如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 -### 参考： +**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！ -- redis设计与实现(第二版) +**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 +![我的公众号](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/167598cd2e17b8ec.png) \ No newline at end of file diff --git "a/docs/database/Redis/Redlock\345\210\206\345\270\203\345\274\217\351\224\201.md" "b/docs/database/Redis/Redlock\345\210\206\345\270\203\345\274\217\351\224\201.md" index b1742f2fbf9..86a15ff6faf 100644 --- "a/docs/database/Redis/Redlock\345\210\206\345\270\203\345\274\217\351\224\201.md" +++ "b/docs/database/Redis/Redlock\345\210\206\345\270\203\345\274\217\351\224\201.md" @@ -28,7 +28,7 @@ end 算法很易懂，起 5 个 master 节点，分布在不同的机房尽量保证可用性。为了获得锁，client 会进行如下操作： -1. 得到当前的时间，微妙单位 +1. 得到当前的时间，微秒单位 2. 尝试顺序地在 5 个实例上申请锁，当然需要使用相同的 key 和 random value，这里一个 client 需要合理设置与 master 节点沟通的 timeout 大小，避免长时间和一个 fail 了的节点浪费时间 3. 当 client 在大于等于 3 个 master 上成功申请到锁的时候，且它会计算申请锁消耗了多少时间，这部分消耗的时间采用获得锁的当下时间减去第一步获得的时间戳得到，如果锁的持续时长（lock validity time）比流逝的时间多的话，那么锁就真正获取到了。 4. 如果锁申请到了，那么锁真正的 lock validity time 应该是 origin（lock validity time） - 申请锁期间流逝的时间 diff --git "a/docs/database/Redis/redis\351\233\206\347\276\244\344\273\245\345\217\212\345\272\224\347\224\250\345\234\272\346\231\257.md" "b/docs/database/Redis/redis\351\233\206\347\276\244\344\273\245\345\217\212\345\272\224\347\224\250\345\234\272\346\231\257.md" new file mode 100644 index 00000000000..c858248ce33 --- /dev/null +++ "b/docs/database/Redis/redis\351\233\206\347\276\244\344\273\245\345\217\212\345\272\224\347\224\250\345\234\272\346\231\257.md" @@ -0,0 +1,149 @@ +相关阅读： + +- [史上最全Redis高可用技术解决方案大全](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247484850&idx=1&sn=3238360bfa8105cf758dcf7354af2814&chksm=cea24a79f9d5c36fb2399aafa91d7fb2699b5006d8d037fe8aaf2e5577ff20ae322868b04a87&token=1082669959&lang=zh_CN&scene=21#wechat_redirect) + +# Redis 集群以及应用 + +## 集群 +### 主从复制 +#### 主从链(拓扑结构) +![主从](https://user-images.githubusercontent.com/26766909/67539461-d1a26c00-f714-11e9-81ae-61fa89faf156.png) + +![主从](https://user-images.githubusercontent.com/26766909/67539485-e0891e80-f714-11e9-8980-d253239fcd8b.png) + +#### 复制模式 +- 全量复制:master 全部同步到 slave +- 部分复制:slave 数据丢失进行备份 + +#### 问题点 +- 同步故障 + - 复制数据延迟(不一致) + - 读取过期数据(Slave 不能删除数据) + - 从节点故障 + - 主节点故障 +- 配置不一致 + - maxmemory 不一致:丢失数据 + - 优化参数不一致:内存不一致. +- 避免全量复制 + - 选择小主节点(分片)、低峰期间操作. + - 如果节点运行 id 不匹配(如主节点重启、运行 id 发送变化),此时要执行全量复制,应该配合哨兵和集群解决. + - 主从复制挤压缓冲区不足产生的问题(网络中断,部分复制无法满足),可增大复制缓冲区( rel_backlog_size 参数). +- 复制风暴 + +### 哨兵机制 +#### 拓扑图 +![image](https://user-images.githubusercontent.com/26766909/67539495-f0086780-f714-11e9-9eab-c11a163ac6c0.png) + +#### 节点下线 +- 客观下线 + - 所有 Sentinel 节点对 Redis 节点失败要达成共识,即超过 quorum 个统一. +- 主观下线 + - 即 Sentinel 节点对 Redis 节点失败的偏见,超出超时时间认为 Master 已经宕机. +#### leader选举 +- 选举出一个 Sentinel 作为 Leader:集群中至少有三个 Sentinel 节点,但只有其中一个节点可完成故障转移.通过以下命令可以进行失败判定或领导者选举. +- 选举流程 + 1. 每个主观下线的 Sentinel 节点向其他 Sentinel 节点发送命令,要求设置它为领导者. + 1. 收到命令的 Sentinel 节点如果没有同意通过其他 Sentinel 节点发送的命令,则同意该请求,否则拒绝. + 1. 如果该 Sentinel 节点发现自己的票数已经超过 Sentinel 集合半数且超过 quorum,则它成为领导者. + 1. 如果此过程有多个 Sentinel 节点成为领导者,则等待一段时间再重新进行选举. +#### 故障转移 +- 转移流程 + 1. Sentinel 选出一个合适的 Slave 作为新的 Master(slaveof no one 命令). + 1. 向其余 Slave 发出通知,让它们成为新 Master 的 Slave( parallel-syncs 参数). + 1. 等待旧 Master 复活,并使之称为新 Master 的 Slave. + 1. 向客户端通知 Master 变化. +- 从 Slave 中选择新 Master 节点的规则(slave 升级成 master 之后) + 1. 选择 slave-priority 最高的节点. + 1. 选择复制偏移量最大的节点(同步数据最多). + 1. 选择 runId 最小的节点. +#### 读写分离 +#### 定时任务 +- 每 1s 每个 Sentinel 对其他 Sentinel 和 Redis 执行 ping,进行心跳检测. +- 每 2s 每个 Sentinel 通过 Master 的 Channel 交换信息(pub - sub). +- 每 10s 每个 Sentinel 对 Master 和 Slave 执行 info,目的是发现 Slave 节点、确定主从关系. + +### 分布式集群(Cluster) +#### 拓扑图 + +![image](https://user-images.githubusercontent.com/26766909/67539510-f8f93900-f714-11e9-9d8d-08afdecff95a.png) + +#### 通讯 +##### 集中式 +> 将集群元数据(节点信息、故障等等)几种存储在某个节点上. +- 优势 + 1. 元数据的更新读取具有很强的时效性,元数据修改立即更新 +- 劣势 + 1. 数据集中存储 +##### Gossip +![image](https://user-images.githubusercontent.com/26766909/67539546-16c69e00-f715-11e9-9891-1e81b6af624c.png) + +- [Gossip 协议](https://www.jianshu.com/p/8279d6fd65bb) + +#### 寻址分片 +##### hash取模 +- hash(key)%机器数量 +- 问题 + 1. 机器宕机,造成数据丢失,数据读取失败 + 1. 伸缩性 +##### 一致性hash +- ![image](https://user-images.githubusercontent.com/26766909/67539595-352c9980-f715-11e9-8e4a-9d9c04027785.png) + +- 问题 + 1. 一致性哈希算法在节点太少时，容易因为节点分布不均匀而造成缓存热点的问题。 + - 解决方案 + - 可以通过引入虚拟节点机制解决：即对每一个节点计算多个 hash，每个计算结果位置都放置一个虚拟节点。这样就实现了数据的均匀分布，负载均衡。 +##### hash槽 +- CRC16(key)%16384 +- +![image](https://user-images.githubusercontent.com/26766909/67539610-3fe72e80-f715-11e9-8e0d-ea58bc965795.png) + + + + + + +## 使用场景 +### 热点数据 +### 会话维持 session +### 分布式锁 SETNX +### 表缓存 +### 消息队列 list +### 计数器 string + + + + + +## 缓存设计 +### 更新策略 +- LRU、LFU、FIFO 算法自动清除:一致性最差,维护成本低. +- 超时自动清除(key expire):一致性较差,维护成本低. +- 主动更新:代码层面控制生命周期,一致性最好,维护成本高. +### 更新一致性 +- 读请求:先读缓存,缓存没有的话,就读数据库,然后取出数据后放入缓存,同时返回响应. +- 写请求:先删除缓存,然后再更新数据库(避免大量地写、却又不经常读的数据导致缓存频繁更新). +### 缓存粒度 +- 通用性:全量属性更好. +- 占用空间:部分属性更好. +- 代码维护成本. + +### 缓存穿透 +> 当大量的请求无命中缓存、直接请求到后端数据库(业务代码的 bug、或恶意攻击),同时后端数据库也没有查询到相应的记录、无法添加缓存. + 这种状态会一直维持,流量一直打到存储层上,无法利用缓存、还会给存储层带来巨大压力. +> +#### 解决方案 +1. 请求无法命中缓存、同时数据库记录为空时在缓存添加该 key 的空对象(设置过期时间)，缺点是可能会在缓存中添加大量的空值键(比如遭到恶意攻击或爬虫)，而且缓存层和存储层数据短期内不一致； +1. 使用布隆过滤器在缓存层前拦截非法请求、自动为空值添加黑名单(同时可能要为误判的记录添加白名单).但需要考虑布隆过滤器的维护(离线生成/ 实时生成). +### 缓存雪崩 +> 缓存崩溃时请求会直接落到数据库上,很可能由于无法承受大量的并发请求而崩溃,此时如果只重启数据库,或因为缓存重启后没有数据,新的流量进来很快又会把数据库击倒 +> +#### 出现后应对 +- 事前:Redis 高可用,主从 + 哨兵,Redis Cluster,避免全盘崩溃. +- 事中:本地 ehcache 缓存 + hystrix 限流 & 降级,避免数据库承受太多压力. +- 事后:Redis 持久化,一旦重启,自动从磁盘上加载数据,快速恢复缓存数据. +#### 请求过程 +1. 用户请求先访问本地缓存,无命中后再访问 Redis,如果本地缓存和 Redis 都没有再查数据库,并把数据添加到本地缓存和 Redis； +1. 由于设置了限流,一段时间范围内超出的请求走降级处理(返回默认值,或给出友情提示). + + + diff --git "a/docs/database/\344\270\200\345\215\203\350\241\214MySQL\345\221\275\344\273\244.md" "b/docs/database/\344\270\200\345\215\203\350\241\214MySQL\345\221\275\344\273\244.md" index acbfda3d7ac..1ddc9ade2c6 100644 --- "a/docs/database/\344\270\200\345\215\203\350\241\214MySQL\345\221\275\344\273\244.md" +++ "b/docs/database/\344\270\200\345\215\203\350\241\214MySQL\345\221\275\344\273\244.md" @@ -104,7 +104,7 @@ SHOW VARIABLES -- 显示系统变量信息 -- 查看所有表 SHOW TABLES[ LIKE 'pattern'] SHOW TABLES FROM 库名 --- 查看表机构 +-- 查看表结构 SHOW CREATE TABLE 表名 （信息更详细） DESC 表名 / DESCRIBE 表名 / EXPLAIN 表名 / SHOW COLUMNS FROM 表名 [LIKE 'PATTERN'] SHOW TABLE STATUS [FROM db_name] [LIKE 'pattern'] @@ -363,7 +363,7 @@ set(val1, val2, val3...) 字段不能再分，就满足第一范式。 -- 2NF, 第二范式 满足第一范式的前提下，不能出现部分依赖。 - 消除符合主键就可以避免部分依赖。增加单列关键字。 + 消除复合主键就可以避免部分依赖。增加单列关键字。 -- 3NF, 第三范式 满足第二范式的前提下，不能出现传递依赖。 某个字段依赖于主键，而有其他字段依赖于该字段。这就是传递依赖。 @@ -590,7 +590,7 @@ CREATE [OR REPLACE] [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}] VIEW view_name ```mysql 事务是指逻辑上的一组操作，组成这组操作的各个单元，要不全成功要不全失败。 - 支持连续SQL的集体成功或集体撤销。 - - 事务是数据库在数据晚自习方面的一个功能。 + - 事务是数据库在数据完整性方面的一个功能。 - 需要利用 InnoDB 或 BDB 存储引擎，对自动提交的特性支持完成。 - InnoDB被称为事务安全型引擎。 -- 事务开启 diff --git "a/docs/database/\344\270\200\346\235\241sql\350\257\255\345\217\245\345\234\250mysql\344\270\255\345\246\202\344\275\225\346\211\247\350\241\214\347\232\204.md" "b/docs/database/\344\270\200\346\235\241sql\350\257\255\345\217\245\345\234\250mysql\344\270\255\345\246\202\344\275\225\346\211\247\350\241\214\347\232\204.md" index 20e4bd72cc9..261a0c0b975 100644 --- "a/docs/database/\344\270\200\346\235\241sql\350\257\255\345\217\245\345\234\250mysql\344\270\255\345\246\202\344\275\225\346\211\247\350\241\214\347\232\204.md" +++ "b/docs/database/\344\270\200\346\235\241sql\350\257\255\345\217\245\345\234\250mysql\344\270\255\345\246\202\344\275\225\346\211\247\350\241\214\347\232\204.md" @@ -138,7 +138,7 @@ update tb_student A set A.age='19' where A.name=' 张三 '; ## 三 总结 -* MySQL 主要分为 Server 曾和引擎层，Server 层主要包括连接器、查询缓存、分析器、优化器、执行器，同时还有一个日志模块（binlog），这个日志模块所有执行引擎都可以共用,redolog 只有 InnoDB 有。 +* MySQL 主要分为 Server 层和引擎层，Server 层主要包括连接器、查询缓存、分析器、优化器、执行器，同时还有一个日志模块（binlog），这个日志模块所有执行引擎都可以共用,redolog 只有 InnoDB 有。 * 引擎层是插件式的，目前主要包括，MyISAM,InnoDB,Memory 等。 * 查询语句的执行流程如下：权限校验（如果命中缓存）---》查询缓存---》分析器---》优化器---》权限校验---》执行器---》引擎 * 更新语句执行流程如下：分析器----》权限校验----》执行器---》引擎---redo log(prepare 状态---》binlog---》redo log(commit状态) diff --git "a/docs/database/\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253(\345\233\276\346\226\207\350\257\246\350\247\243).md" "b/docs/database/\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253(\345\233\276\346\226\207\350\257\246\350\247\243).md" index cf94512e7c1..2c8ef1c14e8 100644 --- "a/docs/database/\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253(\345\233\276\346\226\207\350\257\246\350\247\243).md" +++ "b/docs/database/\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253(\345\233\276\346\226\207\350\257\246\350\247\243).md" @@ -3,7 +3,7 @@ - [事务隔离级别(图文详解)](#事务隔离级别图文详解) - [什么是事务?](#什么是事务) - - [事物的特性(ACID)](#事物的特性acid) + - [事务的特性(ACID)](#事务的特性acid) - [并发事务带来的问题](#并发事务带来的问题) - [事务隔离级别](#事务隔离级别) - [实际情况演示](#实际情况演示) @@ -24,20 +24,19 @@ 事务最经典也经常被拿出来说例子就是转账了。假如小明要给小红转账1000元，这个转账会涉及到两个关键操作就是：将小明的余额减少1000元，将小红的余额增加1000元。万一在这两个操作之间突然出现错误比如银行系统崩溃，导致小明余额减少而小红的余额没有增加，这样就不对了。事务就是保证这两个关键操作要么都成功，要么都要失败。 -### 事物的特性(ACID) +### 事务的特性(ACID) + +![事务的特性](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/事务特性.png) -
- -
1. **原子性：** 事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用； -2. **一致性：** 执行事务前后，数据保持一致； -3. **隔离性：** 并发访问数据库时，一个用户的事物不被其他事物所干扰，各并发事务之间数据库是独立的； -4. **持久性:** 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。 +2. **一致性：** 执行事务前后，数据保持一致，例如转账业务中，无论事务是否成功，转账者和收款人的总额应该是不变的； +3. **隔离性：** 并发访问数据库时，一个用户的事务不被其他事务所干扰，各并发事务之间数据库是独立的； +4. **持久性：** 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。 ### 并发事务带来的问题 -在典型的应用程序中，多个事务并发运行，经常会操作相同的数据来完成各自的任务（多个用户对统一数据进行操作）。并发虽然是必须的，但可能会导致一下的问题。 +在典型的应用程序中，多个事务并发运行，经常会操作相同的数据来完成各自的任务（多个用户对统一数据进行操作）。并发虽然是必须的，但可能会导致以下的问题。 - **脏读（Dirty read）:** 当一个事务正在访问数据并且对数据进行了修改，而这种修改还没有提交到数据库中，这时另外一个事务也访问了这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是“脏数据”，依据“脏数据”所做的操作可能是不正确的。 - **丢失修改（Lost to modify）:** 指在一个事务读取一个数据时，另外一个事务也访问了该数据，那么在第一个事务中修改了这个数据后，第二个事务也修改了这个数据。这样第一个事务内的修改结果就被丢失，因此称为丢失修改。 例如：事务1读取某表中的数据A=20，事务2也读取A=20，事务1修改A=A-1，事务2也修改A=A-1，最终结果A=19，事务1的修改被丢失。 @@ -56,12 +55,21 @@ **SQL 标准定义了四个隔离级别：** -- **READ-UNCOMMITTED(读取未提交)：** 最低的隔离级别，允许读取尚未提交的数据变更，**可能会导致脏读、幻读或不可重复读** -- **READ-COMMITTED(读取已提交):** 允许读取并发事务已经提交的数据，**可以阻止脏读，但是幻读或不可重复读仍有可能发生** -- **REPEATABLE-READ（可重读）:** 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，**可以阻止脏读和不可重复读，但幻读仍有可能发生。** -- **SERIALIZABLE(可串行化):** 最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，**该级别可以防止脏读、不可重复读以及幻读**。 +- **READ-UNCOMMITTED(读取未提交)：** 最低的隔离级别，允许读取尚未提交的数据变更，**可能会导致脏读、幻读或不可重复读**。 +- **READ-COMMITTED(读取已提交)：** 允许读取并发事务已经提交的数据，**可以阻止脏读，但是幻读或不可重复读仍有可能发生**。 +- **REPEATABLE-READ(可重复读)：** 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，**可以阻止脏读和不可重复读，但幻读仍有可能发生**。 +- **SERIALIZABLE(可串行化)：** 最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，**该级别可以防止脏读、不可重复读以及幻读**。 + +---- + +| 隔离级别 | 脏读 | 不可重复读 | 幻影读 | +| :---: | :---: | :---:| :---: | +| READ-UNCOMMITTED | √ | √ | √ | +| READ-COMMITTED | × | √ | √ | +| REPEATABLE-READ | × | × | √ | +| SERIALIZABLE | × | × | × | -MySQL InnoDB 存储引擎的默认支持的隔离级别是 **REPEATABLE-READ（可重读）**。我们可以通过`SELECT @@tx_isolation;`命令来查看 +MySQL InnoDB 存储引擎的默认支持的隔离级别是 **REPEATABLE-READ（可重读）**。我们可以通过`SELECT @@tx_isolation;`命令来查看,MySQL 8.0 该命令改为`SELECT @@transaction_isolation;` ```sql mysql> SELECT @@tx_isolation; @@ -92,9 +100,9 @@ SET [SESSION|GLOBAL] TRANSACTION ISOLATION LEVEL [READ UNCOMMITTED|READ COMMITTE 我们再来看一下我们在下面实际操作中使用到的一些并发控制语句: -- `START TARNSACTION` |`BEGIN`:显式地开启一个事务。 -- `COMMIT`:提交事务，使得对数据库做的所有修改成为永久性。 -- `ROLLBACK` 回滚会结束用户的事务，并撤销正在进行的所有未提交的修改。 +- `START TARNSACTION` |`BEGIN`：显式地开启一个事务。 +- `COMMIT`：提交事务，使得对数据库做的所有修改成为永久性。 +- `ROLLBACK`：回滚会结束用户的事务，并撤销正在进行的所有未提交的修改。 #### 脏读(读未提交) @@ -136,3 +144,5 @@ SET [SESSION|GLOBAL] TRANSACTION ISOLATION LEVEL [READ UNCOMMITTED|READ COMMITTE - 《MySQL技术内幕：InnoDB存储引擎》 - +- [Mysql 锁：灵魂七拷问](https://tech.youzan.com/seven-questions-about-the-lock-of-mysql/) +- [Innodb 中的事务隔离级别和锁的关系](https://tech.meituan.com/2014/08/20/innodb-lock.html) diff --git "a/docs/database/\346\225\260\346\215\256\345\272\223\350\277\236\346\216\245\346\261\240.md" "b/docs/database/\346\225\260\346\215\256\345\272\223\350\277\236\346\216\245\346\261\240.md" new file mode 100644 index 00000000000..3e84dfc8efd --- /dev/null +++ "b/docs/database/\346\225\260\346\215\256\345\272\223\350\277\236\346\216\245\346\261\240.md" @@ -0,0 +1,21 @@ +- 公众号和Github待发文章：[数据库：数据库连接池原理详解与自定义连接池实现](https://www.fangzhipeng.com/javainterview/2019/07/15/mysql-connector-pool.html) +- [基于JDBC的数据库连接池技术研究与应用](http://blog.itpub.net/9403012/viewspace-111794/) +- [数据库连接池技术详解](https://juejin.im/post/5b7944c6e51d4538c86cf195) + +数据库连接本质就是一个 socket 的连接。数据库服务端还要维护一些缓存和用户权限信息之类的 所以占用了一些内存 + +连接池是维护的数据库连接的缓存，以便将来需要对数据库的请求时可以重用这些连接。为每个用户打开和维护数据库连接，尤其是对动态数据库驱动的网站应用程序的请求，既昂贵又浪费资源。**在连接池中，创建连接后，将其放置在池中，并再次使用它，因此不必建立新的连接。如果使用了所有连接，则会建立一个新连接并将其添加到池中。**连接池还减少了用户必须等待建立与数据库的连接的时间。 + +操作过数据库的朋友应该都知道数据库连接池这个概念，它几乎每天都在和我们打交道，但是你真的了解 **数据库连接池** 吗？ + +### 没有数据库连接池之前 + +我相信你一定听过这样一句话：**Java语言中，JDBC（Java DataBase Connection）是应用程序与数据库沟通的桥梁**。 + + + + + + + + diff --git "a/docs/database/\351\230\277\351\207\214\345\267\264\345\267\264\345\274\200\345\217\221\346\211\213\345\206\214\346\225\260\346\215\256\345\272\223\351\203\250\345\210\206\347\232\204\344\270\200\344\272\233\346\234\200\344\275\263\345\256\236\350\267\265.md" "b/docs/database/\351\230\277\351\207\214\345\267\264\345\267\264\345\274\200\345\217\221\346\211\213\345\206\214\346\225\260\346\215\256\345\272\223\351\203\250\345\210\206\347\232\204\344\270\200\344\272\233\346\234\200\344\275\263\345\256\236\350\267\265.md" new file mode 100644 index 00000000000..7eb84001c00 --- /dev/null +++ "b/docs/database/\351\230\277\351\207\214\345\267\264\345\267\264\345\274\200\345\217\221\346\211\213\345\206\214\346\225\260\346\215\256\345\272\223\351\203\250\345\210\206\347\232\204\344\270\200\344\272\233\346\234\200\344\275\263\345\256\236\350\267\265.md" @@ -0,0 +1,41 @@ +# 阿里巴巴Java开发手册数据库部分的一些最佳实践总结 + +## 模糊查询 + +对于模糊查询阿里巴巴开发手册这样说到： + +> 【强制】页面搜索严禁左模糊或者全模糊，如果需要请走搜索引擎来解决。 +> +> 说明:索引文件具有 B-Tree 的最左前缀匹配特性，如果左边的值未确定，那么无法使用此索引。 + +## 外键和级联 + +对于外键和级联，阿里巴巴开发手册这样说到： + +>【强制】不得使用外键与级联，一切外键概念必须在应用层解决。 +> +>说明:以学生和成绩的关系为例，学生表中的 student_id 是主键，那么成绩表中的 student_id 则为外键。如果更新学生表中的 student_id，同时触发成绩表中的 student_id 更新，即为级联更新。外键与级联更新适用于单机低并发，不适合分布式、高并发集群;级联更新是强阻塞，存在数据库更新风暴的风 险;外键影响数据库的插入速度 + +为什么不要用外键呢？大部分人可能会这样回答： + +> 1. **增加了复杂性：** a.每次做DELETE 或者UPDATE都必须考虑外键约束，会导致开发的时候很痛苦,测试数据极为不方便;b.外键的主从关系是定的，假如那天需求有变化，数据库中的这个字段根本不需要和其他表有关联的话就会增加很多麻烦。 +> 2. **增加了额外工作**： 数据库需要增加维护外键的工作，比如当我们做一些涉及外键字段的增，删，更新操作之后，需要触发相关操作去检查，保证数据的的一致性和正确性，这样会不得不消耗资源；（个人觉得这个不是不用外键的原因，因为即使你不使用外键，你在应用层面也还是要保证的。所以，我觉得这个影响可以忽略不计。） +> 3. 外键还会因为需要请求对其他表内部加锁而容易出现死锁情况； +> 4. **对分不分表不友好** ：因为分库分表下外键是无法生效的。 +> 5. ...... + +我个人觉得上面这种回答不是特别的全面，只是说了外键存在的一个常见的问题。实际上，我们知道外键也是有很多好处的，比如： + +1. 保证了数据库数据的一致性和完整性； +2. 级联操作方便，减轻了程序代码量； +3. ...... + +所以说，不要一股脑的就抛弃了外键这个概念，既然它存在就有它存在的道理，如果系统不涉及分不分表，并发量不是很高的情况还是可以考虑使用外键的。 + +我个人是不太喜欢外键约束，比较喜欢在应用层去进行相关操作。 + +## 关于@Transactional注解 + +对于`@Transactional`事务注解，阿里巴巴开发手册这样说到： + +>【参考】@Transactional事务不要滥用。事务会影响数据库的QPS，另外使用事务的地方需要考虑各方面的回滚方案，包括缓存回滚、搜索引擎回滚、消息补偿、统计修正等。 diff --git a/docs/essential-content-for-interview/BATJrealInterviewExperience/2019alipay-pinduoduo-toutiao.md b/docs/essential-content-for-interview/BATJrealInterviewExperience/2019alipay-pinduoduo-toutiao.md new file mode 100644 index 00000000000..183a1852a90 --- /dev/null +++ b/docs/essential-content-for-interview/BATJrealInterviewExperience/2019alipay-pinduoduo-toutiao.md @@ -0,0 +1,294 @@ +作者： rhwayfun,原文地址：https://mp.weixin.qq.com/s/msYty4vjjC0PvrwasRH5Bw ,JavaGuide 已经获得作者授权并对原文进行了重新排版。 + + +- [写在2019年后的蚂蚁、头条、拼多多的面试总结](#写在2019年后的蚂蚁头条拼多多的面试总结) + - [准备过程](#准备过程) + - [蚂蚁金服](#蚂蚁金服) + - [一面](#一面) + - [二面](#二面) + - [三面](#三面) + - [四面](#四面) + - [五面](#五面) + - [小结](#小结) + - [拼多多](#拼多多) + - [面试前](#面试前) + - [一面](#一面-1) + - [二面](#二面-1) + - [三面](#三面-1) + - [小结](#小结-1) + - [字节跳动](#字节跳动) + - [面试前](#面试前-1) + - [一面](#一面-2) + - [二面](#二面-2) + - [小结](#小结-2) + - [总结](#总结) + + + +# 2019年蚂蚁金服、头条、拼多多的面试总结 + +文章有点长，请耐心看完，绝对有收获！不想听我BB直接进入面试分享： + +- 准备过程 +- 蚂蚁金服面试分享 +- 拼多多面试分享 +- 字节跳动面试分享 +- 总结 + +说起来开始进行面试是年前倒数第二周，上午9点，我还在去公司的公交上，突然收到蚂蚁的面试电话，其实算不上真正的面试。面试官只是和我聊了下他们在做的事情（主要是做双十一这里大促的稳定性保障，偏中间件吧），说的很详细，然后和我沟通了下是否有兴趣，我表示有兴趣，后面就收到正式面试的通知，最后没选择去蚂蚁表示抱歉。 + +当时我自己也准备出去看看机会，顺便看看自己的实力。当时我其实挺纠结的，一方面现在部门也正需要我，还是可以有一番作为的，另一方面觉得近一年来进步缓慢，没有以前飞速进步的成就感了，而且业务和技术偏于稳定，加上自己也属于那种比较懒散的人，骨子里还是希望能够突破现状，持续在技术上有所精进。 + +在开始正式的总结之前，还是希望各位同仁能否听我继续发泄一会，抱拳！ + +我翻开自己2018年初立的flag，觉得甚是惭愧。其中就有一条是保持一周写一篇博客，奈何中间因为各种原因没能坚持下去。细细想来，主要是自己没能真正静下来心认真投入到技术的研究和学习，那么为什么会这样？说白了还是因为没有确定目标或者目标不明确，没有目标或者目标不明确都可能导致行动的失败。 + +那么问题来了，目标是啥？就我而言，短期目标是深入研究某一项技术，比如最近在研究mysql，那么深入研究一定要动手实践并且有所产出，这就够了么？还需要我们能够举一反三，结合实际开发场景想一想日常开发要注意什么，这中间有没有什么坑？可以看出，要进步真的不是一件简单的事，这种反人类的行为需要我们克服自我的弱点，逐渐形成习惯。真正牛逼的人，从不觉得认真学习是一件多么难的事，因为这已经形成了他的习惯，就喝早上起床刷牙洗脸那么自然简单。 + +扯了那么多，开始进入正题，先后进行了蚂蚁、拼多多和字节跳动的面试。 + +## 准备过程 + +先说说我自己的情况，我2016先在蚂蚁实习了将近三个月，然后去了我现在的老东家，2.5年工作经验，可以说毕业后就一直老老实实在老东家打怪升级，虽说有蚂蚁的实习经历，但是因为时间太短，还是有点虚的。所以面试官看到我简历第一个问题绝对是这样的。 + +“哇，你在蚂蚁待过，不错啊”，面试官笑嘻嘻地问到。“是的，还好”，我说。“为啥才三个月？”，面试官脸色一沉问到。“哗啦啦解释一通。。。”，我解释道。“哦，原来如此，那我们开始面试吧”，面试官一本正经说到。 + +尼玛，早知道不写蚂蚁的实习经历了，后面仔细一想，当初写上蚂蚁不就给简历加点料嘛。 + +言归正传，准备过程其实很早开始了（当然这不是说我工作时老想着跳槽，因为我明白现在的老东家并不是终点，我还需要不断提升），具体可追溯到从蚂蚁离职的时候，当时出来也面了很多公司，没啥大公司，面了大概5家公司，都拿到offer了。 + +工作之余常常会去额外研究自己感兴趣的技术以及工作用到的技术，力求把原理搞明白，并且会自己实践一把。此外，买了N多书，基本有时间就会去看，补补基础，什么操作系统、数据结构与算法、MySQL、JDK之类的源码，基本都好好温习了（文末会列一下自己看过的书和一些好的资料）。**我深知基础就像“木桶效应”的短板，决定了能装多少水。** + +此外，在正式决定看机会之前，我给自己列了一个提纲，主要包括Java要掌握的核心要点，有不懂的就查资料搞懂。我给自己定位还是Java工程师，所以Java体系是一定要做到心中有数的，很多东西没有常年的积累面试的时候很容易露馅，学习要对得起自己，不要骗人。 + +剩下的就是找平台和内推了，除了蚂蚁，头条和拼多多都是找人内推的，感谢蚂蚁面试官对我的欣赏，以后说不定会去蚂蚁咯😄。 + +平台：脉脉、GitHub、v2 + +## 蚂蚁金服 + +![img](https://mmbiz.qpic.cn/mmbiz_jpg/zsXjkGNcic53JMPc0FUw1lBXl5iaibrEXvt9qal7lJSgfGJ8mq00yE1J4UQ9H1oo9t6RAL4T3whhx17TYlj1mjlXA/?wx_fmt=jpeg) + +- 一面 +- 二面 +- 三面 +- 四面 +- 五面 +- 小结 + +### 一面 + +一面就做了一道算法题，要求两小时内完成，给了长度为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以上，除了基础还问了不少架构设计方面的问题，收获还是挺大的。 + +## 拼多多 + +![img](https://mmbiz.qpic.cn/mmbiz_jpg/zsXjkGNcic53JMPc0FUw1lBXl5iaibrEXvtsmoh9TdJcV0hwnrjtbWPdOacyj2uYe2qaI5jvlGIQHwYtknwnGTibbQ/?wx_fmt=jpeg) + +- 面试前 +- 一面 +- 二面 +- 三面 +- 小结 + +### 面试前 + +面完蚂蚁后，早就听闻拼多多这个独角兽，决定也去面一把。首先我在脉脉找了一个拼多多的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就提前和我确认能否接受这样强度的工作，想来的老铁还是要做好准备 + +## 字节跳动 + +![img](https://mmbiz.qpic.cn/mmbiz_jpg/zsXjkGNcic53JMPc0FUw1lBXl5iaibrEXvtRoTSCMeUWramk7M4CekxE9ssH5DFGBxmDcw0x9hjzmbIGHVWenDK8w/?wx_fmt=jpeg) + +- 面试前 +- 一面 +- 二面 +- 小结 + +### 面试前 + +头条的面试是三家里最专业的，每次面试前有专门的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 + +全文完。 diff --git "a/docs/essential-content-for-interview/BATJrealInterviewExperience/\350\232\202\350\232\201\351\207\221\346\234\215\345\256\236\344\271\240\347\224\237\351\235\242\347\273\217\346\200\273\347\273\223(\345\267\262\346\213\277\345\217\243\345\244\264offer).md" "b/docs/essential-content-for-interview/BATJrealInterviewExperience/\350\232\202\350\232\201\351\207\221\346\234\215\345\256\236\344\271\240\347\224\237\351\235\242\347\273\217\346\200\273\347\273\223(\345\267\262\346\213\277\345\217\243\345\244\264offer).md" new file mode 100644 index 00000000000..2e2df23b941 --- /dev/null +++ "b/docs/essential-content-for-interview/BATJrealInterviewExperience/\350\232\202\350\232\201\351\207\221\346\234\215\345\256\236\344\271\240\347\224\237\351\235\242\347\273\217\346\200\273\347\273\223(\345\267\262\346\213\277\345\217\243\345\244\264offer).md" @@ -0,0 +1,251 @@ +本文来自 Anonymous 的投稿 ，JavaGuide 对原文进行了重新排版和一点完善。 + + + +- [一面 (37 分钟左右)](#一面-37-分钟左右) +- [二面 (33 分钟左右)](#二面-33-分钟左右) +- [三面 (46 分钟)](#三面-46-分钟) +- [HR 面](#hr-面) + + + +### 一面 (37 分钟左右) + +一面是上海的小哥打来的，3.12 号中午确认的内推，下午就打来约时间了，也是唯一一个约时间的面试官。约的晚上八点。紧张的一比，人生第一次面试就献给了阿里。 + +幸运的是一面的小哥特温柔。好像是个海归？口语中夹杂着英文。废话不多说，上干货： + +**面试官：** 先自我介绍下吧！ + +**我：** 巴拉巴拉...。 + +> 关于自我介绍：从 HR 面、技术面到高管面/部门主管面，面试官一般会让你先自我介绍一下，所以好好准备自己的自我介绍真的非常重要。网上一般建议的是准备好两份自我介绍：一份对 HR 说的，主要讲能突出自己的经历，会的编程技术一语带过；另一份对技术面试官说的，主要讲自己会的技术细节，项目经验，经历那些就一语带过。 + +**面试官：** 我看你简历上写你做了个秒杀系统？我们就从这个项目开始吧，先介绍下你的项目。 + +> 关于项目介绍：如果有项目的话，技术面试第一步，面试官一般都是让你自己介绍一下你的项目。你可以从下面几个方向来考虑： +> +> 1. 对项目整体设计的一个感受（面试官可能会让你画系统的架构图） +> 2. 在这个项目中你负责了什么、做了什么、担任了什么角色 +> 3. 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用 +> 4. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如:用 redis 做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。 + +**我：** 我说了我是如何考虑它的需求（秒杀地址隐藏，记录订单，减库存），一开始简单的用 synchronized 锁住方法，出现了问题，后来乐观锁改进，又有瓶颈，再上缓存，出现了缓存雪崩，于是缓存预热，错开缓存失效时间。最后，发现先记录订单再减库存会减少行级锁等待时间。 + +> 一面面试官很耐心地听，并给了我一些指导，问了我乐观锁是怎么实现的，我说是基于 sql 语句，在减库存操作的 where 条件里加剩余库存数>0，他说这应该不算是一种乐观锁，应该先查库存，在减库存的时候判断当前库存是否与读到的库存一样（可这样不是多一次查询操作吗？不是很理解，不过我没有反驳，只是说理解您的意思。事实证明千万别怼面试官，即使你觉得他说的不对） + +**面试官:** 我缓存雪崩什么情况下会发生？如何避免？ + +**我：** 当多个商品缓存同时失效时会雪崩，导致大量查询数据库。还有就是秒杀刚开始的时候缓存里没有数据。解决方案：缓存预热，错开缓存失效时间 + +**面试官：** 问我更新数据库的同时为什么不马上更新缓存，而是删除缓存？ + +**我：** 因为考虑到更新数据库后更新缓存可能会因为多线程下导致写入脏数据（比如线程 A 先更新数据库成功，接下来要取更新缓存，接着线程 B 更新数据库，但 B 又更新了缓存，接着 B 的时间片用完了，线程 A 更新了缓存） + +逼逼了将近 30 分钟，面试官居然用周杰伦的语气对我说： + +![not bad](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3not-bad.jpg) + +我突然受宠若惊，连忙说谢谢，也正是因为第一次面试得到了面试官的肯定，才让我信心大增，二三面稳定发挥。 + +**面试官又曰：** 我看你还懂数据库是吧，答：略懂略懂。。。那我问个简单的吧！ + +**我：** 因为这个问题太简单了，所以我忘记它是什么了。 + +**面试官：** 你还会啥数据库知识？ + +**我：** 我一听，问的这么随意的吗。。。都让我选题了，我就说我了解索引，慢查询优化，巴拉巴拉 + +**面试官：** 等等，你说索引是吧，那你能说下索引的存储数据结构吗？ + +**我：** 我心想这简单啊，我就说 B+树，还说了为什么用 B+树 + +**面试官：** 你简历上写的这个 J.U.C 包是什么啊？（他居然不知道 JUC） + +**我：** 就是 java 多线程的那个包啊。。。 + +**面试官：** 那你都了解里面的哪些东西呢？ + +**我：** 哈哈哈！这可是我的强项，从 ConcurrentHashMap，ConcurrentLinkedQueue 说到 CountDownLatch，CyclicBarrier，又说到线程池，分别说了底层实现和项目中的应用。 + +**面试官:** 我觉得差不多了，那我再问个与技术无关的问题哈，虽然这个问题可能不应该我问，就是你是如何考虑你的项目架构的呢？ + +**我：** 先用最简单的方式实现它，再去发掘系统的问题和瓶颈，于是查资料改进架构。。。 + +**面试官：** 好，那我给你介绍下我这边的情况吧 + +![chat-end](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3chat-end.jpg) + +**总结：** 一面可能是简历面吧，问的比较简单，我在讲项目中说出了我做项目时的学习历程和思考，赢得了面试官的好感，感觉他应该给我的评价很好。 + +### 二面 (33 分钟左右) + +然而开心了没一会，内推人问我面的怎么样啊？看我流程已经到大大 boss 那了。我一听二面不是主管吗？？？怎么直接跳了一面。于是瞬间慌了，赶紧（下床）学习准备二面。 + +隔了一天，3.14 的早上 10：56 分，杭州的大大 boss 给我打来了电话，卧槽我当时在上毛概课，万恶的毛概课每节课都点名，我还在最后一排不敢跑出去。于是接起电话来怂怂地说不好意思我在上课，晚上可以面试吗？大大 boss 看来很忙啊，跟我说晚上没时间啊，再说吧！ + +于是又隔了一天，3.16 中午我收到了北京的电话，当时心里小失望，我的大大 boss 呢？？？接起电话来，就是一番狂轰乱炸。。。 + +第一步还是先自我介绍，这个就不多说了，提前准备好要说的重点就没问题！ + +**面试官:** 我们还是从你的项目开始吧，说说你的秒杀系统。 + +**我:** 一面时的套路。。。我考虑到秒杀地址在开始前不应暴露给用户。。。 + +**面试官:** 等下啊，为什么要这样呢？暴露给用户会怎么样？ + +**我:** 用户提前知道秒杀地址就可以写脚本来抢购了，这样不公平 + +**面试官:** 那比如说啊，我现在是个黑客，我在秒杀开始时写好了脚本，运行一万个线程获取秒杀地址，这样是不是也不公平呢？ + +**我：** 我考虑到了这方面，于是我自己写了个 LRU 缓存（划重点，这么多好用的缓存我为啥不用偏要自己写？就是为了让面试官上钩问我是怎么写的，这样我就可以逼逼准备好的内容了！），用这个缓存存储请求的 ip 和用户名，一个 ip 和用户名只能同时透过 3 个请求。 + +**面试官:** 那我可不可以创建一个 ip 代理池和很多用户来抢购呢？假设我有很多手机号的账户。 + +**我：** 这就是在为难我胖虎啊，我说这种情况跟真实用户操作太像了。。。我没法区别，不过我觉得可以通过地理位置信息或者机器学习算法来做吧。。。 + +**面试官:** 好的这个问题就到这吧，你接着说 + +**我：** 我把生成订单和减库存两条 sql 语句放在一个事务里，都操作成功了则认为秒杀成功。 + +**面试官:** 等等，你这个订单表和商品库存表是在一个数据库的吧，那如果在不同的数据库中呢？ + +**我:** 这面试官好变态啊，我只是个本科生？！？！我觉得应该要用分布式锁来实现吧。。。 + +**面试官:** 有没有更轻量级的做法？ + +**我:** 不知道了。后来查资料发现可以用消息队列来实现。使用消息队列主要能带来两个好处：(1) 通过异步处理提高系统性能（削峰、减少响应所需时间）;(2) 降低系统耦合性。关于消息队列的更多内容可以查看这篇文章： + +后来发现消息队列作用好大，于是现在在学手写一个消息队列。 + +**面试官:** 好的你接着说项目吧。 + +**我:** 我考虑到了缓存雪崩问题，于是。。。 + +**面试官:** 等等，你有没有考虑到一种情况，假如说你的缓存刚刚失效，大量流量就来查缓存，你的数据库会不会炸？ + +**我:** 我不知道数据库会不会炸，反正我快炸了。当时说没考虑这么高的并发量，后来发现也是可以用消息队列来解决，对流量削峰填谷。 + +**面试官:** 好项目聊（怼）完了，我们来说说别的，操作系统了解吧，你能说说 NIO 吗？ + +**我:** NIO 是。。。 + +**面试官:** 那你知道 NIO 的系统调用有哪些吗，具体是怎么实现的？ + +**我：** 当时复习 NIO 的时候就知道是咋回事，不知道咋实现。最近在补这方面的知识，可见 NIO 还是很重要的！ + +**面试官:** 说说进程切换时操作系统都会发生什么？ + +**我:** 不如杀了我，我最讨厌操作系统了。简单说了下，可能不对，需要答案自行百度。 + +**面试官:** 说说线程池？ + +**答：** 卧槽这我熟啊，把 Java 并发编程的艺术里讲的都说出来了，说了得有十分钟，自夸一波，毕竟这本书我看了五遍😂 + +**面试官:** 好问问计网吧如果设计一个聊天系统，应该用 TCP 还是 UDP？为什么 + +**我:** 当然是 TCP！原因如下： + +![TCP VS UDP](https://user-gold-cdn.xitu.io/2018/4/19/162db5e97e9a9e01?imageView2/0/w/1280/h/960/format/webp/ignore-error/1) + +**面试官:** 好的，你有什么要问我的吗？ + +**我:** 我还有下一次面试吗? + +**面试官：** 应该。应该有的，一周内吧。还告诉我居然转正前要实习三个月？wtf，一个大三满课的本科生让我如何在八月底前实习三个月？ + +**我：** 面试官再见 + +![saygoodbye-smile](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3saygoodbye-smile.jpg) + +### 三面 (46 分钟) + +3.18 号，三面来了，这次又是那个大大 boss！ + +第一步还是先自我介绍，这个就不多说了，提前准备好要说的重点就没问题！ + +**面试官:** 聊聊你的项目？ + +**我:** 经过二面的教训，我迅速学习了一下分布式的理论知识，并应用到了我的项目（吹牛逼）中。 + +**面试官:** 看你用到了 Spring 的事务机制，你能说下 Spring 的事务传播吗？ + +**我：** 完了这个问题好像没准备，虽然之前刷知乎看到过。。。我就只说出来一条，面试官说其实这个有很多机制的，比如事务嵌套，内事务回滚外事务回滚都会有不同情况，你可以回去看看。 + +**面试官:** 说说你的分布式事务解决方案？ + +**我:** 我叭叭的照着资料查到的解决方案说了一通，面试官怎么好像没大听懂？？？ + +> 阿里巴巴之前开源了一个分布式 Fescar（一种易于使用，高性能，基于 Java 的开源分布式事务解决方案），后来，Ant Financial 加入 Fescar，使其成为一个更加中立和开放的分布式交易社区，Fescar 重命名为 Seata。Github 地址： + +**面试官:** 好，我们聊聊其他项目，说说你这个 MapReduce 项目？MapReduce 原理了解过吗？ + +**我:** 我叭叭地说了一通，面试官好像觉得这个项目太简单了。要不是没项目，我会把我的实验写上吗？？？ + +**面试官:** 你这个手写 BP 神经网络是干了啥？ + +**我:** 这是我选修机器学习课程时的一个作业，我又对它进行了扩展。 + +**面试官:** 你能说说为什么调整权值时要沿着梯度下降的方向？ + +**我:** 老大，你太厉害了，怎么什么都懂。我压根没准备这个项目。。。没想到会问，做过去好几个月了，加上当时一紧张就忘了，后来想起来大概是....。 + +**面试官:** 好我们问问基础知识吧，说说什么叫 xisuo？ + +**我：**？？？xisuo，您说什么，不好意思我没听清。（这面试官有点口音。。。）就是 xisuo 啊！xisuo 你不知道吗？。。。尴尬了十几秒后我终于意识到，他在说死锁！！！ + +**面试官:** 假如 A 账户给 B 账户转钱，会发生 xisuo 吗？能具体说说吗？ + +**我:** 当时答的不好，后来发现面试官又是想问分布式，具体答案参考这个： + +**面试官:** 为什么不考研？ + +**我：** 不喜欢学术氛围，巴拉巴拉。 + +**面试官:** 你有什么问题吗？ + +**我:** 我还有下一面吗。。。面试官说让我等，一周内答复。 + +------ + +等了十天，一度以为我凉了，内推人说我流程到 HR 了，让我等着吧可能 HR 太忙了，3.28 号 HR 打来了电话，当时在教室，我直接飞了出去。 + +### HR 面 + +**面试官:** 你好啊，先自我介绍下吧 + +**我：** 巴拉巴拉....HR 面的技术面试和技术面的还是有所区别的！ + +面试官人特别好，一听就是很会说话的小姐姐！说我这里给你悄悄透露下，你的评级是 A 哦！ + +![panghu-knowledge](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3panghu-knowledge.jpg) + +接下来就是几个经典 HR 面挂人的问题，什么难给我来什么，我看别人的 HR 面怎么都是聊聊天。。。 + +**面试官:** 你为什么选择支付宝呢，你怎么看待支付宝？ + +**我:** 我从个人情怀，公司理念，环境氛围，市场价值，趋势导向分析了一波（说白了就是疯狂夸支付宝，不过说实话我说的那些一点都没撒谎，阿里确实做到了。比如我举了个雷军和格力打赌 5 年 2000 亿销售额，大部分企业家关注的是利益，而马云更关注的是真的为人类为世界做一些事情，利益不是第一位的。） + +**面试官:** 明白了解，那你的优点我们都很明了了，你能说说你的缺点吗？ + +> 缺点肯定不能是目标岗位需要的关键能力！！！ +> +> 总之，记住一点，面试官问你这个问题的话，你可以说一些不影响你这个职位工作需要的一些缺点。比如你面试后端工程师，面试官问你的缺点是什么的话，你可以这样说：自己比较内向，平时不太爱与人交流，但是考虑到以后可能要和客户沟通，自己正在努力改。 + +**我:** 据说这是 HR 面最难的一个问题。。。我当时翻了好几天的知乎才找到一个合适的，也符合我的答案：我有时候会表现的不太自信，比如阿里的内推二月份就开始了，其实我当时已经复习了很久了，但是老是觉得自己还不行，不敢投简历，于是又把书看了一遍才投的，当时也是舍友怂恿一波才投的，面了之后发现其实自己也没有很差。（划重点，一定要把自己的缺点圆回来）。 + +**面试官:** HR 好像不太满意我的答案，继续问我还有缺点吗？ + +**我:** 我说比较容易紧张吧，举了自己大一面实验室因为紧张没进去的例子，后来不断调整心态，现在已经好很多了。 + +接下来又是个好难的问题。 + +**面试官：** BAT 都给你 offer 了，你怎么选？ + +其实我当时好想说，BT 是什么？不好意思我只知道阿里。 + +**我 :** 哈哈哈哈开玩笑，就说了阿里的文化，支付宝给我们带来很多便利，想加入支付宝为人类做贡献！ + +最后 HR 问了我实习时间，现在大几之类的问题，说肯定会给我发 offer 的，让我等着就好了，希望过两天能收到好的结果。 + +![mengbi](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3mengbi.jpg) diff --git "a/docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" "b/docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" index 4ca58dbfff6..300f1fd6c11 100644 --- "a/docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" +++ "b/docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" @@ -78,7 +78,7 @@ num2 = 20 ![example 2](http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-9-27/3825204.jpg) -array 被初始化 arr 的拷贝也就是一个对象的引用，也就是说 array 和 arr 指向的时同一个数组对象。 因此，外部对引用对象的改变会反映到所对应的对象上。 +array 被初始化 arr 的拷贝也就是一个对象的引用，也就是说 array 和 arr 指向的是同一个数组对象。 因此，外部对引用对象的改变会反映到所对应的对象上。 **通过 example2 我们已经看到，实现一个改变对象参数状态的方法并不是一件难事。理由很简单，方法得到的是对象引用的拷贝，对象引用及其他的拷贝同时引用同一个对象。** @@ -139,7 +139,7 @@ Java程序设计语言对对象采用的不是引用调用，实际上，对象 下面再总结一下Java中方法参数的使用情况： -- 一个方法不能修改一个基本数据类型的参数（即数值型或布尔型》 +- 一个方法不能修改一个基本数据类型的参数（即数值型或布尔型）。 - 一个方法可以改变一个对象参数的状态。 - 一个方法不能让对象参数引用一个新的对象。 @@ -247,7 +247,5 @@ hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返 [https://www.cnblogs.com/skywang12345/p/3324958.html](https://www.cnblogs.com/skywang12345/p/3324958.html) -[https://www.cnblogs.com/skywang12345/p/3324958.html](https://www.cnblogs.com/skywang12345/p/3324958.html) - [https://www.cnblogs.com/Eason-S/p/5524837.html](https://www.cnblogs.com/Eason-S/p/5524837.html) diff --git "a/docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" "b/docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" index 426498cb2d9..2839aae916c 100644 --- "a/docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" +++ "b/docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" @@ -168,10 +168,10 @@ Java语言通过字节码的方式，在一定程度上解决了传统解释型 ### 接口和抽象类的区别是什么？ 1. 接口的方法默认是public，所有方法在接口中不能有实现，抽象类可以有非抽象的方法 -2. 接口中的实例变量默认是final类型的，而抽象类中则不一定 -3. 一个类可以实现多个接口，但最多只能实现一个抽象类 -4. 一个类实现接口的话要实现接口的所有方法，而抽象类不一定 -5. 接口不能用new实例化，但可以声明，但是必须引用一个实现该接口的对象 从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。 +2. 接口中的实例变量默认是final类型的，而抽象类中则不一定 +3. 一个类可以实现多个接口，但最多只能实现一个抽象类 +4. 一个类实现接口的话要实现接口的所有方法，而抽象类不一定 +5. 接口不能用new实例化，但可以声明，但是必须引用一个实现该接口的对象 从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。 注意：Java8 后接口可以有默认实现( default )。 diff --git "a/docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" "b/docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" index 3cb02d73d5b..82d0a02b0b1 100644 --- "a/docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" +++ "b/docs/essential-content-for-interview/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" @@ -16,39 +16,40 @@ ## 2. 线程有哪些基本状态？这些状态是如何定义的? -1. **新建(new)**：新创建了一个线程对象。 -2. **可运行(runnable)**：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获 取cpu的使用权。 -3. **运行(running)**：可运行状态(runnable)的线程获得了cpu时间片（timeslice），执行程序代码。 -4. **阻塞(block)**：阻塞状态是指线程因为某种原因放弃了cpu使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有 机会再次获得cpu timeslice转到运行(running)状态。阻塞的情况分三种： - - **(一). 等待阻塞**：运行(running)的线程执行o.wait()方法，JVM会把该线程放 入等待队列(waiting queue)中。 - - **(二). 同步阻塞**：运行(running)的线程在获取对象的同步锁时，若该同步 锁 被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。 - - **(三). 其他阻塞**: 运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。 -5. **死亡(dead)**：线程run()、main()方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。 +Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态（图源《Java 并发编程艺术》4.1.4 节）。 -![](https://user-gold-cdn.xitu.io/2018/8/9/1651f19d7c4e93a3?w=876&h=492&f=png&s=128092) +![Java 线程的状态 ](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/19-1-29/Java%E7%BA%BF%E7%A8%8B%E7%9A%84%E7%8A%B6%E6%80%81.png) -备注： 可以用早起坐地铁来比喻这个过程（下面参考自牛客网某位同学的回答）： +线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示（图源《Java 并发编程艺术》4.1.4 节）： -1. 还没起床：sleeping -2. 起床收拾好了，随时可以坐地铁出发：Runnable -3. 等地铁来：Waiting -4. 地铁来了，但要排队上地铁：I/O阻塞 -5. 上了地铁，发现暂时没座位：synchronized阻塞 -6. 地铁上找到座位：Running -7. 到达目的地：Dead +![Java 线程状态变迁 ](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/19-1-29/Java%20%E7%BA%BF%E7%A8%8B%E7%8A%B6%E6%80%81%E5%8F%98%E8%BF%81.png) + +由上图可以看出：线程创建之后它将处于 **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（运行中）** 状态 。 + +![RUNNABLE-VS-RUNNING](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/RUNNABLE-VS-RUNNING.png) + +当线程执行 `wait()`方法之后，线程进入 **WAITING（等待）**状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 **TIME_WAITING(超时等待)** 状态相当于在等待状态的基础上增加了超时限制，比如通过 `sleep（long millis）`方法或 `wait（long millis）`方法可以将 Java 线程置于 TIMED WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 **BLOCKED（阻塞）** 状态。线程在执行 Runnable 的` run() `方法之后将会进入到 **TERMINATED（终止）** 状态。 + ## 3. 何为多线程？ 多线程就是多个线程同时运行或交替运行。单核CPU的话是顺序执行，也就是交替运行。多核CPU的话，因为每个CPU有自己的运算器，所以在多个CPU中可以同时运行。 -## 4. 为什么多线程是必要的？ +## 4. 为什么要使用多线程? + +先从总体上来说： + +- **从计算机底层来说：**线程可以比作是轻量级的进程，是程序执行的最小单位,线程间的切换和调度的成本远远小于进程。另外，多核 CPU 时代意味着多个线程可以同时运行，这减少了线程上下文切换的开销。 +- **从当代互联网发展趋势来说：**现在的系统动不动就要求百万级甚至千万级的并发量，而多线程并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能。 -1. 使用线程可以把占据长时间的程序中的任务放到后台去处理。 -2. 用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度。 -3. 程序的运行速度可能加快。 +再深入到计算机底层来探讨： +- **单核时代：** 在单核时代多线程主要是为了提高 CPU 和 IO 设备的综合利用率。举个例子：当只有一个线程的时候会导致 CPU 计算时，IO 设备空闲；进行 IO 操作时，CPU 空闲。我们可以简单地说这两者的利用率目前都是 50%左右。但是当有两个线程的时候就不一样了，当一个线程执行 CPU 计算时，另外一个线程可以进行 IO 操作，这样两个的利用率就可以在理想情况下达到 100%了。 +- **多核时代:** 多核时代多线程主要是为了提高 CPU 利用率。举个例子：假如我们要计算一个复杂的任务，我们只用一个线程的话，CPU 只会一个 CPU 核心被利用到，而创建多个线程就可以让多个 CPU 核心被利用到，这样就提高了 CPU 的利用率。 ## 5 使用多线程常见的三种方式 ### ①继承Thread类 @@ -186,7 +187,7 @@ Thread类中包含的成员变量代表了线程的某些优先级。如**Thread 这是另一个非常经典的java多线程面试问题，而且在面试中会经常被问到。很简单，但是很多人都会答不上来！ new一个Thread，线程进入了新建状态;调用start()方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 -start()会执行线程的相应准备工作，然后自动执行run()方法的内容，这是真正的多线程工作。 而直接执行run()方法，会把run方法当成一个mian线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。 +start()会执行线程的相应准备工作，然后自动执行run()方法的内容，这是真正的多线程工作。 而直接执行run()方法，会把run方法当成一个main线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。 **总结： 调用start方法方可启动线程并使线程进入就绪状态，而run方法只是thread的一个普通方法调用，还是在主线程里执行。** diff --git a/docs/essential-content-for-interview/PreparingForInterview/JavaInterviewLibrary.md b/docs/essential-content-for-interview/PreparingForInterview/JavaInterviewLibrary.md index 4901f88932d..835b6a54fa0 100644 --- a/docs/essential-content-for-interview/PreparingForInterview/JavaInterviewLibrary.md +++ b/docs/essential-content-for-interview/PreparingForInterview/JavaInterviewLibrary.md @@ -1,78 +1,89 @@ -最近浏览 Github ，收藏了一些还算不错的 Java面试/学习相关的仓库，分享给大家，希望对你有帮助。我暂且按照目前的 Star 数量来排序。 +昨天我整理了公众号历史所有和面试相关的我觉得还不错的文章：[整理了一些有助于你拿Offer的文章]() 。今天分享一下最近逛Github看到了一些我觉得对于Java面试以及学习有帮助的仓库，这些仓库涉及Java核心知识点整理、Java常见面试题、算法、基础知识点比如网络和操作系统等等。 -本文由 SnailClimb 整理，如需转载请联系作者。 +## 知识点相关 -### 1. interviews +### 1.JavaGuide -- Github地址: [https://github.com/kdn251/interviews/blob/master/README-zh-cn.md](https://github.com/kdn251/interviews/blob/master/README-zh-cn.md) -- star: 31k -- 介绍: 软件工程技术面试个人指南。 -- 概览： - - ![interviews](http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-12-24/47663247.jpg) +- Github地址： [https://github.com/Snailclimb/JavaGuide](https://github.com/Snailclimb/JavaGuide) +- star: 64.0k +- 介绍: 【Java学习+面试指南】 一份涵盖大部分Java程序员所需要掌握的核心知识。 + +### 2.CS-Notes + +- Github 地址： +- Star: 68.3k +- 介绍: 技术面试必备基础知识、Leetcode 题解、后端面试、Java 面试、春招、秋招、操作系统、计算机网络、系统设计。 -### 2. JCSprout +### 3. advanced-java + +- Github地址：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java) +- star: 23.4k +- 介绍: 互联网 Java 工程师进阶知识完全扫盲：涵盖高并发、分布式、高可用、微服务等领域知识，后端同学必看，前端同学也可学习。 + +### 4.JCSprout - Github地址：[https://github.com/crossoverJie/JCSprout](https://github.com/crossoverJie/JCSprout) -- star: 17.7k +- star: 21.2k - 介绍: Java Core Sprout：处于萌芽阶段的 Java 核心知识库。 -- 概览： - - ![ JCSprout](http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-12-24/85903384.jpg) -### 3. JavaGuide +### 5.toBeTopJavaer -- Github地址： [https://github.com/Snailclimb/JavaGuide](https://github.com/Snailclimb/JavaGuide) -- star: 17.4k -- 介绍: 【Java学习+面试指南】 一份涵盖大部分Java程序员所需要掌握的核心知识。 -- 概览： +- Github地址：[https://github.com/hollischuang/toBeTopJavaer](https://github.com/hollischuang/toBeTopJavaer) +- star: 4.0 k +- 介绍: Java工程师成神之路。 + +### 6.architect-awesome - ![JavaGuide](http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-12-24/1352784.jpg) +- Github地址：[https://github.com/xingshaocheng/architect-awesome](https://github.com/xingshaocheng/architect-awesome) +- star: 34.4 k +- 介绍:后端架构师技术图谱。 -### 4. technology-talk +### 7.technology-talk - Github地址： [https://github.com/aalansehaiyang/technology-talk](https://github.com/aalansehaiyang/technology-talk) -- star: 4.2k +- star: 6.1k - 介绍: 汇总java生态圈常用技术框架、开源中间件，系统架构、项目管理、经典架构案例、数据库、常用三方库、线上运维等知识。 -### 5. fullstack-tutorial +### 8.fullstack-tutorial - Github地址： [https://github.com/frank-lam/fullstack-tutorial](https://github.com/frank-lam/fullstack-tutorial) -- star: 2.8k -- 介绍: Full Stack Developer Tutorial，后台技术栈/全栈开发/架构师之路，秋招/春招/校招/面试。 from zero to hero。 -- 概览： +- star: 4.0k +- 介绍: fullstack tutorial 2019，后台技术栈/架构师之路/全栈开发社区，春招/秋招/校招/面试。 - ![fullstack-tutorial](http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-12-24/67104534.jpg) +### 9.3y + +- Github地址：[https://github.com/ZhongFuCheng3y/3y](https://github.com/ZhongFuCheng3y/3y) +- star: 1.9 k +- 介绍: Java 知识整合。 -### 6. java-bible +### 10.java-bible - Github地址：[https://github.com/biezhi/java-bible](https://github.com/biezhi/java-bible) -- star: 1.9k +- star: 2.3k - 介绍: 这里记录了一些技术摘要，部分文章来自网络，本项目的目的力求分享精品技术干货，以Java为主。 -- 概览： - ![ java-bible](http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-12-24/90223588.jpg) +### 11.interviews -### 7. EasyJob +- Github地址: [https://github.com/kdn251/interviews/blob/master/README-zh-cn.md](https://github.com/kdn251/interviews/blob/master/README-zh-cn.md) +- star: 35.3k +- 介绍: 软件工程技术面试个人指南（国外的一个项目，虽然有翻译版，但是不太推荐，因为很多内容并不适用于国内）。 -- Github地址：[https://github.com/it-interview/EasyJob](https://github.com/it-interview/EasyJob) -- star: 1.9k -- 介绍: 互联网求职面试题、知识点和面经整理。 +## 算法相关 -### 8. advanced-java +### 1.LeetCodeAnimation -- Github地址：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java) -- star: 1k -- 介绍: 互联网 Java 工程师进阶知识完全扫盲 +- Github 地址： +- Star: 33.4k +- 介绍: Demonstrate all the questions on LeetCode in the form of animation.（用动画的形式呈现解LeetCode题目的思路）。 -### 9. 3y +### 2.awesome-java-leetcode -- Github地址：[https://github.com/ZhongFuCheng3y/3y](https://github.com/ZhongFuCheng3y/3y) -- star: 0.4 k -- 介绍: Java 知识整合。 +- Github地址：[https://github.com/Blankj/awesome-java-leetcode](https://github.com/Blankj/awesome-java-leetcode) +- star: 6.1k +- 介绍: LeetCode 上 Facebook 的面试题目。 -除了这九个仓库，再推荐几个不错的学习方向的仓库给大家。 +### 3.leetcode -1. Star 数高达 4w+的 CS 笔记-CS-Notes：[https://github.com/CyC2018/CS-Notes](https://github.com/CyC2018/CS-Notes) -2. 后端（尤其是Java）程序员的 Linux 学习仓库-Linux-Tutorial：[https://github.com/judasn/Linux-Tutorial](https://github.com/judasn/Linux-Tutorial)( Star:4.6k) -3. 两个算法相关的仓库，刷 Leetcode 的小伙伴必备：①awesome-java-leetcode：[https://github.com/Blankj/awesome-java-leetcode](https://github.com/Blankj/awesome-java-leetcode)；②LintCode：[https://github.com/awangdev/LintCode](https://github.com/awangdev/LintCode) +- Github地址：[https://github.com/azl397985856/leetcode](https://github.com/azl397985856/leetcode) +- star: 12.0k +- 介绍: LeetCode Solutions: A Record of My Problem Solving Journey.( leetcode题解，记录自己的leetcode解题之路。) \ No newline at end of file diff --git a/docs/essential-content-for-interview/PreparingForInterview/JavaProgrammerNeedKnow.md b/docs/essential-content-for-interview/PreparingForInterview/JavaProgrammerNeedKnow.md index ef111f4cf15..d515693722e 100644 --- a/docs/essential-content-for-interview/PreparingForInterview/JavaProgrammerNeedKnow.md +++ b/docs/essential-content-for-interview/PreparingForInterview/JavaProgrammerNeedKnow.md @@ -1,4 +1,4 @@ -　　身边的朋友或者公众号的粉丝很多人都向我询问过:“我是双非/三本/专科学校的，我有机会进入大厂吗？”、“非计算机专业的学生能学好吗？”、“如何学习Java？”、“Java学习该学那些东西？”、“我该如何准备Java面试？”......这些方面的问题。我会根据自己的一点经验对大部分人关心的这些问题进行答疑解惑。现在又刚好赶上考研结束，这篇文章也算是给考研结束准备往Java后端方向发展的朋友们指名一条学习之路。道理懂了如果没有实际行动，那这篇文章对你或许没有任何意义。 +　　身边的朋友或者公众号的粉丝很多人都向我询问过：“我是双非/三本/专科学校的，我有机会进入大厂吗？”、“非计算机专业的学生能学好吗？”、“如何学习Java？”、“Java学习该学哪些东西？”、“我该如何准备Java面试？”......这些方面的问题。我会根据自己的一点经验对大部分人关心的这些问题进行答疑解惑。现在又刚好赶上考研结束，这篇文章也算是给考研结束准备往Java后端方向发展的朋友们指明一条学习之路。道理懂了如果没有实际行动，那这篇文章对你或许没有任何意义。 ### Question1:我是双非/三本/专科学校的，我有机会进入大厂吗？ @@ -6,7 +6,7 @@ 　　首先，我觉得学校歧视很正常，真的太正常了，如果要抱怨的话，你只能抱怨自己没有进入名校。但是，千万不要动不动说自己学校差，动不动拿自己学校当做自己进不了大厂的借口，学历只是筛选简历的很多标准中的一个而已，如果你够优秀，简历够丰富，你也一样可以和名校同学一起同台竞争。 -　　企业HR肯定是更喜欢高学历的人，毕竟985，211优秀人才比例肯定比普通学校高很多，HR团队肯定会优先在这些学校里选。这就好比相亲，你是愿意在很多优秀的人中选一个优秀的，还是愿意在很多普通的人中选一个优秀的呢？ +　　企业HR肯定是更喜欢高学历的人，毕竟985、211优秀人才比例肯定比普通学校高很多，HR团队肯定会优先在这些学校里选。这就好比相亲，你是愿意在很多优秀的人中选一个优秀的，还是愿意在很多普通的人中选一个优秀的呢？ 　　 　　双非本科甚至是二本、三本甚至是专科的同学也有很多进入大厂的，不过比率相比于名校的低很多而已。从大厂招聘的结果上看，高学历人才的数量占据大头，那些成功进入BAT、美团，京东，网易等大厂的双非本科甚至是二本、三本甚至是专科的同学往往是因为具备丰富的项目经历或者在某个含金量比较高的竞赛比如ACM中取得了不错的成绩。**一部分学历不突出但能力出众的面试者能够进入大厂并不是说明学历不重要，而是学历的软肋能够通过其他的优势来弥补。** 所以，如果你的学校不够好而你自己又想去大厂的话，建议你可以从这几点来做：**①尽量在面试前最好有一个可以拿的出手的项目；②有实习条件的话，尽早出去实习，实习经历也会是你的简历的一个亮点（有能力在大厂实习最佳！）；③参加一些含金量比较高的比赛，拿不拿得到名次没关系，重在锻炼。** @@ -17,7 +17,7 @@ 　　我觉得我们不应该因为自己的专业给自己划界限或者贴标签，说实话，很多科班的同学可能并不如你，你以为科班的同学就会认真听讲吗？还不是几乎全靠自己课下自学！不过如果你是非科班的话，你想要学好，那么注定就要舍弃自己本专业的一些学习时间，这是无可厚非的。 -　　建议非科班的同学，首先要打好计算机基础知识基础：①计算机网络、②操作系统、③数据机构与算法，我个人觉得这3个对你最重要。这些东西就像是内功，对你以后的长远发展非常有用。当然，如果你想要进大厂的话，这些知识也是一定会被问到的。另外，“一定学好数据机构与算法！一定学好数据机构与算法！一定学好数据机构与算法！”，重要的东西说3遍。 +　　建议非科班的同学，首先要打好计算机基础知识基础：①计算机网络、②操作系统、③数据机构与算法，我个人觉得这3个对你最重要。这些东西就像是内功，对你以后的长远发展非常有用。当然，如果你想要进大厂的话，这些知识也是一定会被问到的。另外，“一定学好数据结构与算法！一定学好数据结构与算法！一定学好数据结构与算法！”，重要的东西说3遍。 @@ -31,12 +31,12 @@ 下面是我总结的一些准备面试的Tips以及面试必备的注意事项： -1. **准备一份自己的自我介绍，面试的时候根据面试对象适当进行修改**（突出重点，突出自己的优势在哪里，切忌流水账）； +1. **准备一份自己的自我介绍，面试的时候根据面试对象适当进行修改**（突出重点，突出自己的优势在哪里，切忌流水账）； 2. **注意随身带上自己的成绩单和简历复印件；** （有的公司在面试前都会让你交一份成绩单和简历当做面试中的参考。） 3. **如果需要笔试就提前刷一些笔试题，大部分在线笔试的类型是选择题+编程题，有的还会有简答题。**（平时空闲时间多的可以刷一下笔试题目（牛客网上有很多），但是不要只刷面试题，不动手code，程序员不是为了考试而存在的。）另外，注意抓重点，因为题目太多了，但是有很多题目几乎次次遇到，像这样的题目一定要搞定。 -4. **提前准备技术面试。** 搞清楚自己面试中可能涉及哪些知识点、那些知识点是重点。面试中哪些问题会被经常问到、自己改如何回答。(强烈不推荐背题，第一：通过背这种方式你能记住多少？能记住多久？第二：背题的方式的学习很难坚持下去！) +4. **提前准备技术面试。** 搞清楚自己面试中可能涉及哪些知识点、哪些知识点是重点。面试中哪些问题会被经常问到、自己该如何回答。(强烈不推荐背题，第一：通过背这种方式你能记住多少？能记住多久？第二：背题的方式的学习很难坚持下去！) 5. **面试之前做好定向复习。** 也就是专门针对你要面试的公司来复习。比如你在面试之前可以在网上找找有没有你要面试的公司的面经。 -6. **准备好自己的项目介绍。** 如果有项目的话，技术面试第一步，面试官一般都是让你自己介绍一下你的项目。你可以从下面几个方向来考虑：①对项目整体设计的一个感受（面试官可能会让你画系统的架构图；②在这个项目中你负责了什么、做了什么、担任了什么角色；③ 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用；④项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如:用redis做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。 +6. **准备好自己的项目介绍。** 如果有项目的话，技术面试第一步，面试官一般都是让你自己介绍一下你的项目。你可以从下面几个方向来考虑：①对项目整体设计的一个感受（面试官可能会让你画系统的架构图）；②在这个项目中你负责了什么、做了什么、担任了什么角色；③ 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用；④项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如：用 redis 做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。 7. **面试之后记得复盘。** 面试遭遇失败是很正常的事情，所以善于总结自己的失败原因才是最重要的。如果失败，不要灰心；如果通过，切勿狂喜。 diff --git a/docs/essential-content-for-interview/PreparingForInterview/books.md b/docs/essential-content-for-interview/PreparingForInterview/books.md deleted file mode 100644 index 34f495fd798..00000000000 --- a/docs/essential-content-for-interview/PreparingForInterview/books.md +++ /dev/null @@ -1,66 +0,0 @@ - -### 核心基础知识 - -- [《图解HTTP》](https://book.douban.com/subject/25863515/)（推荐,豆瓣评分 8.1 , 1.6K+人评价）： 讲漫画一样的讲HTTP，很有意思，不会觉得枯燥，大概也涵盖也HTTP常见的知识点。因为篇幅问题，内容可能不太全面。不过，如果不是专门做网络方向研究的小伙伴想研究HTTP相关知识的话，读这本书的话应该来说就差不多了。 -- [《大话数据结构》](https://book.douban.com/subject/6424904/)（推荐，豆瓣评分 7.9 , 1K+人评价）：入门类型的书籍，读起来比较浅显易懂，适合没有数据结构基础或者说数据结构没学好的小伙伴用来入门数据结构。 -- [《数据结构与算法分析：C语言描述》](https://book.douban.com/subject/1139426/)（推荐，豆瓣评分 8.9，1.6K+人评价）:本书是《Data Structures and Algorithm Analysis in C》一书第2版的简体中译本。原书曾被评为20世纪顶尖的30部计算机著作之一，作者Mark Allen Weiss在数据结构和算法分析方面卓有建树，他的数据结构和算法分析的著作尤其畅销，并受到广泛好评．已被世界500余所大学用作教材。 -- [《算法图解》](https://book.douban.com/subject/26979890/)（推荐，豆瓣评分 8.4，0.6K+人评价）：入门类型的书籍，读起来比较浅显易懂，适合没有算法基础或者说算法没学好的小伙伴用来入门。示例丰富，图文并茂，以让人容易理解的方式阐释了算法.读起来比较快，内容不枯燥！ -- [《算法 第四版》](https://book.douban.com/subject/10432347/)（推荐，豆瓣评分 9.3，0.4K+人评价）：Java语言描述，算法领域经典的参考书，全面介绍了关于算法和数据结构的必备知识，并特别针对排序、搜索、图处理和字符串处理进行了论述。书的内容非常多，可以说是Java程序员的必备书籍之一了。 - - - - -### Java相关 - -- [《Effective java 》](https://book.douban.com/subject/3360807/)（推荐，豆瓣评分 9.0，1.4K+人评价）：本书介绍了在Java编程中78条极具实用价值的经验规则，这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。通过对Java平台设计专家所使用的技术的全面描述，揭示了应该做什么，不应该做什么才能产生清晰、健壮和高效的代码。本书中的每条规则都以简短、独立的小文章形式出现，并通过例子代码加以进一步说明。本书内容全面，结构清晰，讲解详细。可作为技术人员的参考用书。 -- [《Head First Java.第二版》](https://book.douban.com/subject/2000732/)(推荐，豆瓣评分 8.7，1.0K+人评价)： 可以说是我的Java启蒙书籍了，特别适合新手读当然也适合我们用来温故Java知识点。 -- [《Java多线程编程核心技术》](https://book.douban.com/subject/26555197/)： Java多线程入门级书籍还不错，但是说实话，质量不是很高，很快就可以阅读完。 -- [《JAVA网络编程 第4版》](https://book.douban.com/subject/26259017/)： 可以系统的学习一下网络的一些概念以及网络编程在Java中的使用。 -- [《Java核心技术卷1+卷2》](https://book.douban.com/subject/25762168/)（推荐）: 很棒的两本书，建议有点Java基础之后再读，介绍的还是比较深入的，非常推荐。这两本书我一般也会用来巩固知识点，是两本适合放在自己身边的好书。 -- [《Java编程思想(第4版)》](https://book.douban.com/subject/2130190/)（推荐，豆瓣评分 9.1，3.2K+人评价）：这本书要常读，初学者可以快速概览，中等程序员可以深入看看java，老鸟还可以用之回顾java的体系。这本书之所以厉害，因为它在无形中整合了设计模式，这本书之所以难读，也恰恰在于他对设计模式的整合是无形的。 -- [《Java并发编程的艺术》](https://book.douban.com/subject/26591326/)（推荐，豆瓣评分 7.2，0.2K+人评价）： 这本书不是很适合作为Java并发入门书籍，需要具备一定的JVM基础。我感觉有些东西讲的还是挺深入的，推荐阅读。 -- [《实战Java高并发程序设计》](https://book.douban.com/subject/26663605/)（推荐）：豆瓣评分 8.3 ，书的质量没的说，推荐大家好好看一下。 -- [《Java程序员修炼之道》](https://book.douban.com/subject/24841235/)： 很杂，我只看了前面几章，不太推荐阅读。 -- [《深入理解Java虚拟机（第2版）周志明》](https://book.douban.com/subject/24722612/)（推荐，豆瓣评分 8.9，1.0K+人评价）：建议多刷几遍，书中的所有知识点可以通过JAVA运行时区域和JAVA的内存模型与线程两个大模块罗列完全。 -- [《Netty实战》](https://book.douban.com/subject/27038538/)（推荐，豆瓣评分 7.8，92人评价）：内容很细，如果想学Netty的话，推荐阅读这本书！ -- [《从Paxos到Zookeeper》](https://book.douban.com/subject/26292004/)（推荐，豆瓣评分 7.8，0.3K人评价）：简要介绍几种典型的分布式一致性协议，以及解决分布式一致性问题的思路，其中重点讲解了Paxos和ZAB协议。同时，本书深入介绍了分布式一致性问题的工业解决方案——ZooKeeper，并着重向读者展示这一分布式协调框架的使用方法、内部实现及运维技巧，旨在帮助读者全面了解ZooKeeper，并更好地使用和运维ZooKeeper。 - -### JavaWeb相关 - -- [《深入分析Java Web技术内幕》](https://book.douban.com/subject/25953851/)： 感觉还行，涉及的东西也蛮多。 -- [《Spring实战（第4版）》](https://book.douban.com/subject/26767354/)（推荐，豆瓣评分 8.3 -，0.3K+人评价）：不建议当做入门书籍读，入门的话可以找点国人的书或者视频看。这本定位就相当于是关于Spring的新华字典，只有一些基本概念的介绍和示例，涵盖了Spring的各个方面，但都不够深入。就像作者在最后一页写的那样：“学习Spring，这才刚刚开始”。 -- [《Java Web整合开发王者归来》](https://book.douban.com/subject/4189495/)（已过时）：当时刚开始学的时候就是开的这本书，基本上是完完整整的看完了。不过，我不是很推荐大家看。这本书比较老了，里面很多东西都已经算是过时了。不过，这本书的一个很大优点是：基础知识点概括全面。 -- [《Redis实战》](https://book.douban.com/subject/26612779/)：如果你想了解Redis的一些概念性知识的话，这本书真的非常不错。 -- [《Redis设计与实现》](https://book.douban.com/subject/25900156/)（推荐，豆瓣评分 8.5，0.5K+人评价） -- [《深入剖析Tomcat》](https://book.douban.com/subject/10426640/)（推荐，豆瓣评分 8.4，0.2K+人评价）：本书深入剖析Tomcat 4和Tomcat 5中的每个组件，并揭示其内部工作原理。通过学习本书，你将可以自行开发Tomcat组件，或者扩展已有的组件。 读完这本书，基本可以摆脱背诵面试题的尴尬。 -- [《高性能MySQL》](https://book.douban.com/subject/23008813/)（推荐，豆瓣评分 9.3，0.4K+人评价）：mysql 领域的经典之作，拥有广泛的影响力。不但适合数据库管理员（dba）阅读，也适合开发人员参考学习。不管是数据库新手还是专家，相信都能从本书有所收获。 -- [深入理解Nginx（第2版）](https://book.douban.com/subject/26745255/)：作者讲的非常细致，注释都写的都很工整，对于 Nginx 的开发人员非常有帮助。优点是细致，缺点是过于细致，到处都是代码片段，缺少一些抽象。 -- [《RabbitMQ实战指南》](https://book.douban.com/subject/27591386/)：《RabbitMQ实战指南》从消息中间件的概念和RabbitMQ的历史切入，主要阐述RabbitMQ的安装、使用、配置、管理、运维、原理、扩展等方面的细节。如果你想浅尝RabbitMQ的使用，这本书是你最好的选择；如果你想深入RabbitMQ的原理，这本书也是你最好的选择；总之，如果你想玩转RabbitMQ，这本书一定是最值得看的书之一 -- [《Spring Cloud微服务实战》](https://book.douban.com/subject/27025912/)：从时下流行的微服务架构概念出发，详细介绍了Spring Cloud针对微服务架构中几大核心要素的解决方案和基础组件。对于各个组件的介绍，《Spring Cloud微服务实战》主要以示例与源码结合的方式来帮助读者更好地理解这些组件的使用方法以及运行原理。同时，在介绍的过程中，还包含了作者在实践中所遇到的一些问题和解决思路，可供读者在实践中作为参考。 -- [《第一本Docker书》](https://book.douban.com/subject/26780404/)：Docker入门书籍！ - -### 操作系统 - -- [《鸟哥的Linux私房菜》](https://book.douban.com/subject/4889838/)（推荐，，豆瓣评分 9.1，0.3K+人评价）：本书是最具知名度的Linux入门书《鸟哥的Linux私房菜基础学习篇》的最新版，全面而详细地介绍了Linux操作系统。全书分为5个部分：第一部分着重说明Linux的起源及功能，如何规划和安装Linux主机；第二部分介绍Linux的文件系统、文件、目录与磁盘的管理；第三部分介绍文字模式接口 shell和管理系统的好帮手shell脚本，另外还介绍了文字编辑器vi和vim的使用方法；第四部分介绍了对于系统安全非常重要的Linux账号的管理，以及主机系统与程序的管理，如查看进程、任务分配和作业管理；第五部分介绍了系统管理员(root)的管理事项，如了解系统运行状况、系统服务，针对登录文件进行解析，对系统进行备份以及核心的管理等。 - -### 架构相关 - -- [《大型网站技术架构：核心原理与案例分析+李智慧》](https://book.douban.com/subject/25723064/)（推荐）:这本书我读过，基本不需要你有什么基础啊~读起来特别轻松，但是却可以学到很多东西，非常推荐了。另外我写过这本书的思维导图，关注我的微信公众号：“Java面试通关手册”回复“大型网站技术架构”即可领取思维导图。 -- [《亿级流量网站架构核心技术》](https://book.douban.com/subject/26999243/)（推荐）：一书总结并梳理了亿级流量网站高可用和高并发原则，通过实例详细介绍了如何落地这些原则。本书分为四部分：概述、高可用原则、高并发原则、案例实战。从负载均衡、限流、降级、隔离、超时与重试、回滚机制、压测与预案、缓存、池化、异步化、扩容、队列等多方面详细介绍了亿级流量网站的架构核心技术，让读者看后能快速运用到实践项目中。 -- [《架构解密从分布式到微服务（Leaderus著）》](https://book.douban.com/subject/27081188/)：很一般的书籍，我就是当做课后图书来阅读的。 - -### 代码优化 - -- [《重构_改善既有代码的设计》](https://book.douban.com/subject/4262627/)（推荐）：豆瓣 9.1 分，重构书籍的开山鼻祖。 - -### 课外书籍 - -- 《追风筝的人》（推荐） -- 《穆斯林的葬礼》 （推荐） -- 《三体》 （推荐） -- 《活着——余华》 （推荐） - - - - diff --git a/docs/essential-content-for-interview/PreparingForInterview/interviewPrepare.md b/docs/essential-content-for-interview/PreparingForInterview/interviewPrepare.md index c99ca1c156e..1ae36a35734 100644 --- a/docs/essential-content-for-interview/PreparingForInterview/interviewPrepare.md +++ b/docs/essential-content-for-interview/PreparingForInterview/interviewPrepare.md @@ -1,8 +1,22 @@ -这是【备战春招/秋招系列】的第二篇文章，主要是简单地介绍如何去准备面试。 - 不论是校招还是社招都避免不了各种面试、笔试，如何去准备这些东西就显得格外重要。不论是笔试还是面试都是有章可循的，我这个“有章可循”说的意思只是说应对技术面试是可以提前准备。 我其实特别不喜欢那种临近考试就提前背啊记啊各种题的行为，非常反对！我觉得这种方法特别极端，而且在稍有一点经验的面试官面前是根本没有用的。建议大家还是一步一个脚印踏踏实实地走。 -### 1 如何获取大厂面试机会？ + + +- [1 如何获取大厂面试机会？](#1-如何获取大厂面试机会) +- [2 面试前的准备](#2--面试前的准备) + - [2.1 准备自己的自我介绍](#21-准备自己的自我介绍) + - [2.2 关于着装](#22-关于着装) + - [2.3 随身带上自己的成绩单和简历](#23-随身带上自己的成绩单和简历) + - [2.4 如果需要笔试就提前刷一些笔试题](#24-如果需要笔试就提前刷一些笔试题) + - [2.5 花时间一些逻辑题](#25-花时间一些逻辑题) + - [2.6 准备好自己的项目介绍](#26-准备好自己的项目介绍) + - [2.7 提前准备技术面试](#27-提前准备技术面试) + - [2.7 面试之前做好定向复习](#27-面试之前做好定向复习) +- [3 面试之后复盘](#3-面试之后复盘) + + + +## 1 如何获取大厂面试机会？ **在讲如何获取大厂面试机会之前，先来给大家科普/对比一下两个校招非常常见的概念——春招和秋招。** @@ -24,7 +38,7 @@ 除了这些方法，我也遇到过这样的经历：有些大公司的一些部门可能暂时没招够人，然后如果你的亲戚或者朋友刚好在这个公司，而你正好又在寻求offer，那么面试机会基本上是有了，而且这种面试的难度好像一般还普遍比其他正规面试低很多。 -### 2 面试前的准备 +## 2 面试前的准备 ### 2.1 准备自己的自我介绍 @@ -57,11 +71,11 @@ 1. 对项目整体设计的一个感受（面试官可能会让你画系统的架构图） 2. 在这个项目中你负责了什么、做了什么、担任了什么角色 3. 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用 -4. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如:用redis做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。 +4. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如：用redis做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。 ### 2.7 提前准备技术面试 -搞清楚自己面试中可能涉及哪些知识点、那些知识点是重点。面试中哪些问题会被经常问到、自己改如何回答。(强烈不推荐背题，第一：通过背这种方式你能记住多少？能记住多久？第二：背题的方式的学习很难坚持下去！) +搞清楚自己面试中可能涉及哪些知识点、哪些知识点是重点。面试中哪些问题会被经常问到、自己该如何回答。(强烈不推荐背题，第一：通过背这种方式你能记住多少？能记住多久？第二：背题的方式的学习很难坚持下去！) ### 2.7 面试之前做好定向复习 @@ -69,6 +83,6 @@ 举个栗子：在我面试 ThoughtWorks 的前几天我就在网上找了一些关于 ThoughtWorks 的技术面的一些文章。然后知道了 ThoughtWorks 的技术面会让我们在之前做的作业的基础上增加一个或两个功能，所以我提前一天就把我之前做的程序重新重构了一下。然后在技术面的时候，简单的改了几行代码之后写个测试就完事了。如果没有提前准备，我觉得 20 分钟我很大几率会完不成这项任务。 -# 3 面试之后复盘 +## 3 面试之后复盘 -如果失败，不要灰心；如果通过，切勿狂喜。面试和工作实际上是两回事，可能很多面试未通过的人，工作能力比你强的多，反之亦然。我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！ \ No newline at end of file +如果失败，不要灰心；如果通过，切勿狂喜。面试和工作实际上是两回事，可能很多面试未通过的人，工作能力比你强的多，反之亦然。我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！ diff --git "a/docs/essential-content-for-interview/PreparingForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" "b/docs/essential-content-for-interview/PreparingForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" index d07fa52a7e7..7feead7d8bd 100644 --- "a/docs/essential-content-for-interview/PreparingForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" +++ "b/docs/essential-content-for-interview/PreparingForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" @@ -1,21 +1,43 @@ -# 程序员的简历就该这样写 + -### 1 前言 -一份好的简历可以在整个申请面试以及面试过程中起到非常好的作用。 在不夸大自己能力的情况下，写出一份好的简历也是一项很棒的能力。 +- [程序员简历就该这样写](#程序员简历就该这样写) + - [为什么说简历很重要？](#为什么说简历很重要) + - [先从面试前来说](#先从面试前来说) + - [再从面试中来说](#再从面试中来说) + - [下面这几点你必须知道](#下面这几点你必须知道) + - [必须了解的两大法则](#必须了解的两大法则) + - [STAR法则（Situation Task Action Result）](#star法则situation-task-action-result) + - [FAB 法则（Feature Advantage Benefit）](#fab-法则feature-advantage-benefit) + - [项目经历怎么写？](#项目经历怎么写) + - [专业技能该怎么写？](#专业技能该怎么写) + - [排版注意事项](#排版注意事项) + - [其他的一些小tips](#其他的一些小tips) + - [推荐的工具/网站](#推荐的工具网站) -### 2 为什么说简历很重要？ + -#### 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 内存淘汰机制等等。 @@ -23,17 +45,16 @@ 面试和工作是两回事，聪明的人会把面试官往自己擅长的领域领，其他人则被面试官牵着鼻子走。虽说面试和工作是两回事，但是你要想要获得自己满意的 offer ，你自身的实力必须要强。 -### 3 下面这几点你必须知道 +## 下面这几点你必须知道 -1. 大部分公司的HR都说我们不看重学历（骗你的！），但是如果你的学校不出众的话，很难在一堆简历中脱颖而出，除非你的简历上有特别的亮点，比如：某某大厂的实习经历、获得了某某大赛的奖等等。 +1. 大部分公司的HR都说我们不看重学历（骗你的！），但是如果你的学校不出众的话，很难在一堆简历中脱颖而出，除非你的简历上有特别的亮点，比如：某某大厂的实习经历、获得了某某大赛的奖等等。 2. **大部分应届生找工作的硬伤是没有工作经验或实习经历，所以如果你是应届生就不要错过秋招和春招。一旦错过，你后面就极大可能会面临社招，这个时候没有工作经验的你可能就会面临各种碰壁，导致找不到一个好的工作** 3. **写在简历上的东西一定要慎重，这是面试官大量提问的地方；** -4. **将自己的项目经历完美的展示出来非常重要。** - -### 4 必须了解的两大法则 +4. **将自己的项目经历完美的展示出来非常重要。** +## 必须了解的两大法则 -**①STAR法则（Situation Task Action Result）：** +### STAR法则（Situation Task Action Result） - **Situation：** 事情是在什么情况下发生； - **Task:：** 你是如何明确你的任务的； @@ -42,14 +63,7 @@ 简而言之，STAR法则，就是一种讲述自己故事的方式，或者说，是一个清晰、条理的作文模板。不管是什么，合理熟练运用此法则，可以轻松的对面试官描述事物的逻辑方式，表现出自己分析阐述问题的清晰性、条理性和逻辑性。 -下面这段内容摘自百度百科，我觉得写的非常不错： - -> STAR法则，500强面试题回答时的技巧法则，备受面试者成功者和500强HR的推崇。 -由于这个法则被广泛应用于面试问题的回答，尽管我们还在写简历阶段，但是，写简历时能把面试的问题就想好，会使自己更加主动和自信，做到简历，面试关联性，逻辑性强，不至于在一个月后去面试，却把简历里的东西都忘掉了（更何况有些朋友会稍微夸大简历内容） -在我们写简历时，每个人都要写上自己的工作经历，活动经历，想必每一个同学，都会起码花上半天甚至更长的时间去搜寻脑海里所有有关的经历，争取找出最好的东西写在简历上。 -但是此时，我们要注意了，简历上的任何一个信息点都有可能成为日后面试时的重点提问对象，所以说，不能只管写上让自己感觉最牛的经历就完事了，要想到今后，在面试中，你所写的经历万一被面试官问到，你真的能回答得流利，顺畅，且能通过这段经历，证明自己正是适合这个职位的人吗？ - -**②FAB 法则（Feature Advantage Benefit）：** +### FAB 法则（Feature Advantage Benefit） - **Feature：** 是什么； - **Advantage：** 比别人好在哪些地方； @@ -57,7 +71,7 @@ 简单来说，这个法则主要是让你的面试官知道你的优势、招了你之后对公司有什么帮助。 -### 5 项目经历怎么写？ +## 项目经历怎么写？ 简历上有一两个项目经历很正常，但是真正能把项目经历很好的展示给面试官的非常少。对于项目经历大家可以考虑从如下几点来写： @@ -66,7 +80,8 @@ 3. 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用 4. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如:用redis做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。 -### 6 专业技能该怎么写？ +## 专业技能该怎么写？ + 先问一下你自己会什么，然后看看你意向的公司需要什么。一般HR可能并不太懂技术，所以他在筛选简历的时候可能就盯着你专业技能的关键词来看。对于公司有要求而你不会的技能，你可以花几天时间学习一下，然后在简历上可以写上自己了解这个技能。比如你可以这样写(下面这部分内容摘自我的简历，大家可以根据自己的情况做一些修改和完善)： - 计算机网络、数据结构、算法、操作系统等课内基础知识：掌握 @@ -79,28 +94,28 @@ - Zookeeper: 掌握 - 常见消息队列: 掌握 - Linux：掌握 -- MySQL常见优化手段：掌握 +- MySQL常见优化手段：掌握 - Spring Boot +Spring Cloud +Docker:了解 - Hadoop 生态相关技术中的 HDFS、Storm、MapReduce、Hive、Hbase ：了解 - Python 基础、一些常见第三方库比如OpenCV、wxpy、wordcloud、matplotlib：熟悉 -### 7 开源程序员Markdown格式简历模板分享 +## 排版注意事项 -分享一个Github上开源的程序员简历模板。包括PHP程序员简历模板、iOS程序员简历模板、Android程序员简历模板、Web前端程序员简历模板、Java程序员简历模板、C/C++程序员简历模板、NodeJS程序员简历模板、架构师简历模板以及通用程序员简历模板 。 -Github地址：[https://github.com/geekcompany/ResumeSample](https://github.com/geekcompany/ResumeSample) +1. 尽量简洁，不要太花里胡哨； +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) +1. 尽量避免主观表述，少一点语义模糊的形容词，尽量要简洁明了，逻辑结构清晰。 +2. 如果自己有博客或者个人技术栈点的话，写上去会为你加分很多。 +3. 如果自己的Github比较活跃的话，写上去也会为你加分很多。 +4. 注意简历真实性，一定不要写自己不会的东西，或者带有欺骗性的内容 +5. 项目经历建议以时间倒序排序，另外项目经历不在于多，而在于有亮点。 +6. 如果内容过多的话，不需要非把内容压缩到一页，保持排版干净整洁就可以了。 +7. 简历最后最好能加上：“感谢您花时间阅读我的简历，期待能有机会和您共事。”这句话，显的你会很有礼貌。 -### 8 其他的一些小tips +## 推荐的工具/网站 -1. 尽量避免主观表述，少一点语义模糊的形容词，尽量要简洁明了，逻辑结构清晰。 -2. 注意排版（不需要花花绿绿的），尽量使用Markdown语法。 -3. 如果自己有博客或者个人技术栈点的话，写上去会为你加分很多。 -4. 如果自己的Github比较活跃的话，写上去也会为你加分很多。 -5. 注意简历真实性，一定不要写自己不会的东西，或者带有欺骗性的内容 -6. 项目经历建议以时间倒序排序，另外项目经历不在于多，而在于有亮点。 -7. 如果内容过多的话，不需要非把内容压缩到一页，保持排版干净整洁就可以了。 -8. 简历最后最好能加上：“感谢您花时间阅读我的简历，期待能有机会和您共事。”这句话，显的你会很有礼貌。 +- 冷熊简历(MarkDown在线简历工具，可在线预览、编辑和生成PDF): +- Typora+[Java程序员简历模板](https://github.com/geekcompany/ResumeSample/blob/master/java.md) diff --git "a/docs/essential-content-for-interview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" "b/docs/essential-content-for-interview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" index 0efdd618688..da3e04d78e4 100644 --- "a/docs/essential-content-for-interview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" +++ "b/docs/essential-content-for-interview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" @@ -32,7 +32,7 @@ - [2.1 两者的对比](#21-两者的对比) - [2.2 关于两者的总结](#22-关于两者的总结) - [3 聊聊 Java 中的集合吧！](#3-聊聊-java-中的集合吧) - - [3.1 Arraylist 与 LinkedList 有什么不同?\(注意加上从数据结构分析的内容\)](#31-arraylist-与-linkedlist-有什么不同注意加上从数据结构分析的内容) + - [3.1 ArrayList 与 LinkedList 有什么不同?\(注意加上从数据结构分析的内容\)](#31-arraylist-与-linkedlist-有什么不同注意加上从数据结构分析的内容) - [3.2 HashMap的底层实现](#32-hashmap的底层实现) - [1)JDK1.8之前](#1jdk18之前) - [2)JDK1.8之后](#2jdk18之后) @@ -78,7 +78,7 @@ ## 1. `System.out.println(3|9)`输出什么? -正确答案：11. +正确答案：11。 **考察知识点：&和&&；|和||** @@ -108,12 +108,12 @@ request.getRequestDispatcher("login_success.jsp").forward(request, response); ``` -**重定向（Redirect）** 是利用服务器返回的状态吗来实现的。客户端浏览器请求服务器的时候，服务器会返回一个状态码。服务器通过HttpServletRequestResponse的setStatus(int status)方法设置状态码。如果服务器返回301或者302，则浏览器会到新的网址重新请求该资源。 +**重定向（Redirect）** 是利用服务器返回的状态码来实现的。客户端浏览器请求服务器的时候，服务器会返回一个状态码。服务器通过HttpServletRequestResponse的setStatus(int status)方法设置状态码。如果服务器返回301或者302，则浏览器会到新的网址重新请求该资源。 -1. **从地址栏显示来说:** forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址. redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL. -2. **从数据共享来说:** forward:转发页面和转发到的页面可以共享request里面的数据. redirect:不能共享数据. -3. **从运用地方来说:** forward:一般用于用户登陆的时候,根据角色转发到相应的模块. redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等 -4. **从效率来说:** forward:高. redirect:低. +1. **从地址栏显示来说**：forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器。浏览器根本不知道服务器发送的内容从哪里来的，所以它的地址栏还是原来的地址。redirect是服务端根据逻辑，发送一个状态码，告诉浏览器重新去请求那个地址。所以地址栏显示的是新的URL。 +2. **从数据共享来说**：forward：转发页面和转发到的页面可以共享request里面的数据。redirect：不能共享数据。 +3. **从运用地方来说**：forward：一般用于用户登陆的时候，根据角色转发到相应的模块。redirect：一般用于用户注销登陆时返回主页面和跳转到其它的网站等。 +4. **从效率来说**：forward：高。redirect：低。 ## 3. 在浏览器中输入url地址到显示主页的过程,整个过程会使用哪些协议 @@ -159,7 +159,7 @@ request.getRequestDispatcher("login_success.jsp").forward(request, response); 第二次握手：Client 确认了：自己发送、接收正常，对方发送、接收正常；Server 确认了：自己接收正常，对方发送正常 -第三次握手：Client 确认了：自己发送、接收正常，对方发送、接收正常；Server 确认了：自己发送、接收正常，对方发送接收正常 +第三次握手：Client 确认了：自己发送、接收正常，对方发送、接收正常；Server 确认了：自己发送、接收正常，对方发送、接收正常 所以三次握手就能确认双发收发功能都正常，缺一不可。 @@ -382,7 +382,7 @@ TransactionDefinition 接口中定义了五个表示隔离级别的常量： ![SpringMVC 原理](https://user-gold-cdn.xitu.io/2018/11/10/166fd45787394192?w=1015&h=466&f=webp&s=35352) -客户端发送请求-> 前端控制器 DispatcherServlet 接受客户端请求 -> 找到处理器映射 HandlerMapping 解析请求对应的 Handler-> HandlerAdapter 会根据 Handler 来调用真正的处理器开处理请求，并处理相应的业务逻辑 -> 处理器返回一个模型视图 ModelAndView -> 视图解析器进行解析 -> 返回一个视图对象->前端控制器 DispatcherServlet 渲染数据（Model）->将得到视图对象返回给用户 +客户端发送请求-> 前端控制器 DispatcherServlet 接受客户端请求 -> 找到处理器映射 HandlerMapping 解析请求对应的 Handler-> HandlerAdapter 会根据 Handler 来调用真正的处理器处理请求，并处理相应的业务逻辑 -> 处理器返回一个模型视图 ModelAndView -> 视图解析器进行解析 -> 返回一个视图对象->前端控制器 DispatcherServlet 渲染数据（Model）->将得到视图对象返回给用户 关于 SpringMVC 原理更多内容可以查看我的这篇文章：[SpringMVC 工作原理详解](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484496&idx=1&sn=5472ffa687fe4a05f8900d8ee6726de4&chksm=fd985231caefdb27fc75b44ecf76b6f43e4617e0b01b3c040f8b8fab32e51dfa5118eed1d6ad&token=1990180468&lang=zh_CN#rd) @@ -390,7 +390,7 @@ TransactionDefinition 接口中定义了五个表示隔离级别的常量： 过了秋招挺长一段时间了，说实话我自己也忘了如何简要概括 Spring AOP IOC 实现原理，就在网上找了一个较为简洁的答案，下面分享给各位。 -**IOC:** 控制反转也叫依赖注入。IOC利用java反射机制，AOP利用代理模式。IOC 概念看似很抽象，但是很容易理解。说简单点就是将对象交给容器管理，你只需要在spring配置文件中配置对应的bean以及设置相关的属性，让spring容器来生成类的实例对象以及管理对象。在spring容器启动的时候，spring会把你在配置文件中配置的bean都初始化好，然后在你需要调用的时候，就把它已经初始化好的那些bean分配给你需要调用这些bean的类。 +**IOC：** 控制反转也叫依赖注入。IOC利用java反射机制，AOP利用代理模式。IOC 概念看似很抽象，但是很容易理解。说简单点就是将对象交给容器管理，你只需要在spring配置文件中配置对应的bean以及设置相关的属性，让spring容器来生成类的实例对象以及管理对象。在spring容器启动的时候，spring会把你在配置文件中配置的bean都初始化好，然后在你需要调用的时候，就把它已经初始化好的那些bean分配给你需要调用这些bean的类。 **AOP：** 面向切面编程。（Aspect-Oriented Programming） 。AOP可以说是对OOP的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码，属于静态代理。 @@ -421,7 +421,7 @@ TransactionDefinition 接口中定义了五个表示隔离级别的常量： > **先来简单说一下分布式服务：** -目前使用比较多的用来构建**SOA（Service Oriented Architecture面向服务体系结构）**的**分布式服务框架**是阿里巴巴开源的**Dubbo**.如果想深入了解Dubbo的可以看我写的关于Dubbo的这一篇文章：**《高性能优秀的服务框架-dubbo介绍》**：[https://juejin.im/post/5acadeb1f265da2375072f9c](https://juejin.im/post/5acadeb1f265da2375072f9c) +目前使用比较多的用来构建**SOA（Service Oriented Architecture面向服务体系结构）**的**分布式服务框架**是阿里巴巴开源的**Dubbo**。如果想深入了解Dubbo的可以看我写的关于Dubbo的这一篇文章：**《高性能优秀的服务框架-dubbo介绍》**：[https://juejin.im/post/5acadeb1f265da2375072f9c](https://juejin.im/post/5acadeb1f265da2375072f9c) > **再来谈我们的分布式消息队列：** @@ -450,7 +450,7 @@ TransactionDefinition 接口中定义了五个表示隔离级别的常量： ### 1.3 介绍一下你知道哪几种消息队列,该如何选择呢? -| 特性 | ActiveMQ | RabbitMQ | RocketMQ | Kafaka | +| 特性 | ActiveMQ | RabbitMQ | RocketMQ | Kafka | | :---------------------- | -----------------------------------------------------------: | -----------------------------------------------------------: | -----------------------------------------------------------: | -----------------------------------------------------------: | | 单机吞吐量 | 万级，吞吐量比RocketMQ和Kafka要低了一个数量级 | 万级，吞吐量比RocketMQ和Kafka要低了一个数量级 | 10万级，RocketMQ也是可以支撑高吞吐的一种MQ | 10万级别，这是kafka最大的优点，就是吞吐量高。一般配合大数据类的系统来进行实时数据计算、日志采集等场景 | | topic数量对吞吐量的影响 | | | topic可以达到几百，几千个的级别，吞吐量会有较小幅度的下降这是RocketMQ的一大优势，在同等机器下，可以支撑大量的topic | topic从几十个到几百个的时候，吞吐量会大幅度下降。所以在同等机器下，kafka尽量保证topic数量不要过多。如果要支撑大规模topic，需要增加更多的机器资源 | @@ -464,7 +464,7 @@ TransactionDefinition 接口中定义了五个表示隔离级别的常量： ### 1.4 关于消息队列其他一些常见的问题展望 -1. 引入消息队列之后如何保证高可用性 +1. 引入消息队列之后如何保证高可用性？ 2. 如何保证消息不被重复消费呢？ 3. 如何保证消息的可靠性传输（如何处理消息丢失的问题）？ 4. 我该怎么保证从消息队列里拿到的数据按顺序执行？ @@ -478,13 +478,13 @@ TransactionDefinition 接口中定义了五个表示隔离级别的常量： ### 2.1 两者的对比 1. **count运算上的区别：** 因为MyISAM缓存有表meta-data（行数等），因此在做COUNT(*)时对于一个结构很好的查询是不需要消耗多少资源的。而对于InnoDB来说，则没有这种缓存 -2. **是否支持事务和崩溃后的安全恢复：** MyISAM 强调的是性能，每次查询具有原子性,其执行数度比InnoDB类型更快，但是不提供事务支持。但是InnoDB 提供事务支持事务，外部键等高级数据库功能。 具有事务(commit)、回滚(rollback)和崩溃修复能力(crash recovery capabilities)的事务安全(transaction-safe (ACID compliant))型表。 +2. **是否支持事务和崩溃后的安全恢复：** MyISAM 强调的是性能，每次查询具有原子性，其执行速度比InnoDB类型更快，但是不提供事务支持。但是 InnoDB 提供事务支持，外部键等高级数据库功能。 具有事务(commit)、回滚(rollback)和崩溃修复能力(crash recovery capabilities)的事务安全(transaction-safe (ACID compliant))型表。 3. **是否支持外键：** MyISAM不支持，而InnoDB支持。 ### 2.2 关于两者的总结 -MyISAM更适合读密集的表，而InnoDB更适合写密集的的表。 在数据库做主从分离的情况下，经常选择MyISAM作为主库的存储引擎。 +MyISAM更适合读密集的表，而InnoDB更适合写密集的表。 在数据库做主从分离的情况下，经常选择MyISAM作为主库的存储引擎。 一般来说，如果需要事务支持，并且有较高的并发读取频率(MyISAM的表锁的粒度太大，所以当该表写并发量较高时，要等待的查询就会很多了)，InnoDB是不错的选择。如果你的数据量很大（MyISAM支持压缩特性可以减少磁盘的空间占用），而且不需要支持事务时，MyISAM是最好的选择。 @@ -495,8 +495,8 @@ MyISAM更适合读密集的表，而InnoDB更适合写密集的的表。 在数 - **1. 是否保证线程安全：** ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全； - **2. 底层数据结构：** Arraylist 底层使用的是Object数组；LinkedList 底层使用的是双向链表数据结构（注意双向链表和双向循环链表的区别：）； -- **3. 插入和删除是否受元素位置的影响：** ① **ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。** 比如：执行`add(E e) `方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是O(1)。但是如果要在指定位置 i 插入和删除元素的话（`add(int index, E element) `）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ② **LinkedList 采用链表存储，所以插入，删除元素时间复杂度不受元素位置的影响，都是近似 O（1）而数组为近似 O（n）。** -- **4. 是否支持快速随机访问：** LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于`get(int index) `方法)。 +- **3. 插入和删除是否受元素位置的影响：** ① **ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。** 比如：执行`add(E e) `方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是O(1)。但是如果要在指定位置 i 插入和删除元素的话（`add(int index, E element) `）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ② **LinkedList 采用链表存储，所以插入，删除元素时间复杂度不受元素位置的影响，都是近似 O(1) 而数组为近似 O(n) 。** +- **4. 是否支持快速随机访问：** LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象（对应于`get(int index) `方法）。 - **5. 内存空间占用：** ArrayList的空 间浪费主要体现在在list列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）。 **补充内容:RandomAccess接口** @@ -508,7 +508,7 @@ public interface RandomAccess { 查看源码我们发现实际上 RandomAccess 接口中什么都没有定义。所以，在我看来 RandomAccess 接口不过是一个标识罢了。标识什么？ 标识实现这个接口的类具有随机访问功能。 -在binarySearch（）方法中，它要判断传入的list 是否RamdomAccess的实例，如果是，调用indexedBinarySearch（）方法，如果不是，那么调用iteratorBinarySearch（）方法 +在 binarySearch() 方法中，它要判断传入的 list 是否RamdomAccess的实例，如果是，调用 indexedBinarySearch() 方法，如果不是，那么调用 iteratorBinarySearch() 方法 ```java public static @@ -520,7 +520,7 @@ public interface RandomAccess { } ``` -ArraysList 实现了 RandomAccess 接口， 而 LinkedList 没有实现。为什么呢？我觉得还是和底层数据结构有关！ArraysList 底层是数组，而 LinkedList 底层是链表。数组天然支持随机访问，时间复杂度为 O（1），所以称为快速随机访问。链表需要遍历到特定位置才能访问特定位置的元素，时间复杂度为 O（n），所以不支持快速随机访问。，ArraysList 实现了 RandomAccess 接口，就表明了他具有快速随机访问功能。 RandomAccess 接口只是标识，并不是说 ArraysList 实现 RandomAccess 接口才具有快速随机访问功能的！ +ArraysList 实现了 RandomAccess 接口， 而 LinkedList 没有实现。为什么呢？我觉得还是和底层数据结构有关！ArraysList 底层是数组，而 LinkedList 底层是链表。数组天然支持随机访问，时间复杂度为 O(1) ，所以称为快速随机访问。链表需要遍历到特定位置才能访问特定位置的元素，时间复杂度为 O(n) ，所以不支持快速随机访问。，ArraysList 实现了 RandomAccess 接口，就表明了他具有快速随机访问功能。 RandomAccess 接口只是标识，并不是说 ArraysList 实现 RandomAccess 接口才具有快速随机访问功能的！ @@ -614,9 +614,9 @@ TreeMap、TreeSet以及JDK1.8之后的HashMap底层都用到了红黑树。 **HashMap 和 Hashtable 的区别** -1. **线程是否安全：** HashMap 是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过 `synchronized` 修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！）； -2. **效率：** 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它； -3. **对Null key 和Null value的支持：** HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。。但是在 HashTable 中 put 进的键值只要有一个 null，直接抛出 NullPointerException。 +1. **线程是否安全：** HashMap 是非线程安全的，Hashtable 是线程安全的；Hashtable 内部的方法基本都经过 `synchronized` 修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！）； +2. **效率：** 因为线程安全的问题，HashMap 要比 Hashtable 效率高一点。另外，Hashtable 基本被淘汰，不要在代码中使用它； +3. **对Null key 和Null value的支持：** HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。但是在 Hashtable 中 put 进的键值只要有一个 null，直接抛出 NullPointerException。 4. **初始容量大小和每次扩充容量大小的不同 ：** ①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。②创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小（HashMap 中的`tableSizeFor()`方法保证，下面给出了源代码）。也就是说 HashMap 总是使用2的幂作为哈希表的大小,后面会介绍到为什么是2的幂次方。 5. **底层数据结构：** JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。 @@ -688,7 +688,7 @@ hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返 #### 1.2.3 hashCode()与equals()的相关规定 1. 如果两个对象相等，则hashcode一定也是相同的 -2. 两个对象相等,对两个对象分别调用equals方法都返回true +2. 两个对象相等，对两个对象分别调用equals方法都返回true 3. 两个对象有相同的hashcode值，它们也不一定是相等的 4. **因此，equals方法被覆盖过，则hashCode方法也必须被覆盖** 5. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据） @@ -737,7 +737,7 @@ public class test1 { **说明：** -- String中的equals方法是被重写过的，因为object的equals方法是比较的对象的内存地址，而String的equals方法比较的是对象的值。 +- String中的equals()方法是被重写过的，因为Object的equals()方法是比较的对象的内存地址，而String的equals()方法比较的是对象的值。 - 当创建String类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个String对象。 > 在[【备战春招/秋招系列5】美团面经总结进阶篇 （附详解答案）](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484625&idx=1&sn=9c4fa1f7d4291a5fbd7daa44bac2b012&chksm=fd9852b0caefdba6edcf9a827aa4a17ddc97bf6ad2e5ee6f7e1aa1b443b54444d05d2b76732b&token=723699735&lang=zh_CN#rd) 这篇文章中，我们已经提到了一下关于 HashMap 在面试中常见的问题：HashMap 的底层实现、简单讲一下自己对于红黑树的理解、红黑树这么优秀，为何不直接使用红黑树得了、HashMap 和 Hashtable 的区别/HashSet 和 HashMap 区别。HashMap 和 ConcurrentHashMap 这俩兄弟在一般只要面试中问到集合相关的问题就一定会被问到，所以各位务必引起重视！ @@ -749,13 +749,13 @@ public class test1 { ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。 - **底层数据结构：** JDK1.7的 ConcurrentHashMap 底层采用 **分段的数组+链表** 实现，JDK1.8 采用的数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树。Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 **数组+链表** 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的； -- **实现线程安全的方式（重要）：** ① **在JDK1.7的时候，ConcurrentHashMap（分段锁）** 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。（默认分配16个Segment，比Hashtable效率提高16倍。） **到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6以后 对 synchronized锁做了很多优化）** 整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② **Hashtable(同一把锁)** :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。 +- **实现线程安全的方式（重要）：** ① **在JDK1.7的时候，ConcurrentHashMap（分段锁）** 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。（默认分配16个Segment，比Hashtable效率提高16倍。） **到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6以后 对 synchronized锁做了很多优化）** 整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② **Hashtable(同一把锁)**：使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。 **两者的对比图：** 图片来源：http://www.cnblogs.com/chengxiao/p/6842045.html -HashTable: +Hashtable： ![](http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-8-22/50656681.jpg) JDK1.7的ConcurrentHashMap： @@ -772,7 +772,7 @@ Node: 链表节点）： **ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成**。 -Segment 实现了 ReentrantLock,所以 Segment 是一种可重入锁，扮演锁的角色。HashEntry 用于存储键值对数据。 +Segment 实现了 ReentrantLock，所以 Segment 是一种可重入锁，扮演锁的角色。HashEntry 用于存储键值对数据。 ```java static class Segment extends ReentrantLock implements Serializable { @@ -787,29 +787,29 @@ ConcurrentHashMap取消了Segment分段锁，采用CAS和synchronized来保证 synchronized只锁定当前链表或红黑二叉树的首节点，这样只要hash不冲突，就不会产生并发，效率又提升N倍。 -## 3 谈谈 synchronized 和 ReenTrantLock 的区别 +## 3 谈谈 synchronized 和 ReentrantLock 的区别 **① 两者都是可重入锁** 两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。 -**② synchronized 依赖于 JVM 而 ReenTrantLock 依赖于 API** +**② synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API** -synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReenTrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。 +synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。 -**③ ReenTrantLock 比 synchronized 增加了一些高级功能** +**③ ReentrantLock 比 synchronized 增加了一些高级功能** -相比synchronized，ReenTrantLock增加了一些高级功能。主要来说主要有三点：**①等待可中断；②可实现公平锁；③可实现选择性通知（锁可以绑定多个条件）** +相比synchronized，ReentrantLock增加了一些高级功能。主要来说主要有三点：**①等待可中断；②可实现公平锁；③可实现选择性通知（锁可以绑定多个条件）** -- **ReenTrantLock提供了一种能够中断等待锁的线程的机制**，通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。 -- **ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。** ReenTrantLock默认情况是非公平的，可以通过 ReenTrantLock类的`ReentrantLock(boolean fair)`构造方法来制定是否是公平的。 +- **ReentrantLock提供了一种能够中断等待锁的线程的机制**，通过 lock.lockInterruptibly() 来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。 +- **ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。** ReentrantLock默认情况是非公平的，可以通过 ReentrantLock类的`ReentrantLock(boolean fair)`构造方法来制定是否是公平的。 - synchronized关键字与wait()和notify/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），**线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。 在使用notify/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用ReentrantLock类结合Condition实例可以实现“选择性通知”** ，这个功能非常重要，而且是Condition接口默认提供的。而synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法 只会唤醒注册在该Condition实例中的所有等待线程。 -如果你想使用上述功能，那么选择ReenTrantLock是一个不错的选择。 +如果你想使用上述功能，那么选择ReentrantLock是一个不错的选择。 **④ 两者的性能已经相差无几** -在JDK1.6之前，synchronized 的性能是比 ReenTrantLock 差很多。具体表示为：synchronized 关键字吞吐量岁线程数的增加，下降得非常严重。而ReenTrantLock 基本保持一个比较稳定的水平。我觉得这也侧面反映了， synchronized 关键字还有非常大的优化余地。后续的技术发展也证明了这一点，我们上面也讲了在 JDK1.6 之后 JVM 团队对 synchronized 关键字做了很多优化。JDK1.6 之后，synchronized 和 ReenTrantLock 的性能基本是持平了。所以网上那些说因为性能才选择 ReenTrantLock 的文章都是错的！JDK1.6之后，性能已经不是选择synchronized和ReenTrantLock的影响因素了！而且虚拟机在未来的性能改进中会更偏向于原生的synchronized，所以还是提倡在synchronized能满足你的需求的情况下，优先考虑使用synchronized关键字来进行同步！优化后的synchronized和ReenTrantLock一样，在很多地方都是用到了CAS操作。 +在JDK1.6之前，synchronized 的性能是比 ReentrantLock 差很多。具体表示为：synchronized 关键字吞吐量岁线程数的增加，下降得非常严重。而ReentrantLock 基本保持一个比较稳定的水平。我觉得这也侧面反映了， synchronized 关键字还有非常大的优化余地。后续的技术发展也证明了这一点，我们上面也讲了在 JDK1.6 之后 JVM 团队对 synchronized 关键字做了很多优化。JDK1.6 之后，synchronized 和 ReentrantLock 的性能基本是持平了。所以网上那些说因为性能才选择 ReentrantLock 的文章都是错的！JDK1.6之后，性能已经不是选择synchronized和ReentrantLock的影响因素了！而且虚拟机在未来的性能改进中会更偏向于原生的synchronized，所以还是提倡在synchronized能满足你的需求的情况下，优先考虑使用synchronized关键字来进行同步！优化后的synchronized和ReentrantLock一样，在很多地方都是用到了CAS操作。 ## 4 线程池了解吗? @@ -837,9 +837,9 @@ synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团 #### 各种线程池的适用场景介绍 - **FixedThreadPool：** 适用于为了满足资源管理需求，而需要限制当前线程数量的应用场景。它适用于负载比较重的服务器； -- **SingleThreadExecutor：** 适用于需要保证顺序地执行各个任务并且在任意时间点，不会有多个线程是活动的应用场景。 +- **SingleThreadExecutor：** 适用于需要保证顺序地执行各个任务并且在任意时间点，不会有多个线程是活动的应用场景； - **CachedThreadPool：** 适用于执行很多的短期异步任务的小程序，或者是负载较轻的服务器； -- **ScheduledThreadPoolExecutor：** 适用于需要多个后台执行周期任务，同时为了满足资源管理需求而需要限制后台线程的数量的应用场景， +- **ScheduledThreadPoolExecutor：** 适用于需要多个后台执行周期任务，同时为了满足资源管理需求而需要限制后台线程的数量的应用场景； - **SingleThreadScheduledExecutor：** 适用于需要单个后台线程执行周期任务，同时保证顺序地执行各个任务的应用场景。 ### 4.3 创建的线程池的方式 @@ -903,7 +903,7 @@ Nginx是一款轻量级的Web 服务器/反向代理服务器及电子邮件（I 谈到反向代理，就不得不提一下正向代理。无论是正向代理，还是反向代理，说到底，就是代理模式的衍生版本罢了 -- **正向代理：**某些情况下，代理我们用户去访问服务器，需要用户手动的设置代理服务器的ip和端口号。正向代理比较常见的一个例子就是 VPN了。 +- **正向代理：**某些情况下，代理我们用户去访问服务器，需要用户手动的设置代理服务器的ip和端口号。正向代理比较常见的一个例子就是 VPN 了。 - **反向代理：** 是用来代理服务器的，代理我们要访问的目标服务器。代理服务器接受请求，然后将请求转发给内部网络的服务器，并将从服务器上得到的结果返回给客户端，此时代理服务器对外就表现为一个服务器。 通过下面两幅图，大家应该更好理解（图源：http://blog.720ui.com/2016/nginx_action_05_proxy/）： @@ -920,7 +920,7 @@ Nginx是一款轻量级的Web 服务器/反向代理服务器及电子邮件（I Nginx支持的weight轮询（默认）、ip_hash、fair、url_hash这四种负载均衡调度算法，感兴趣的可以自行查阅。 -负载均衡相比于反向代理更侧重的时将请求分担到多台服务器上去，所以谈论负载均衡只有在提供某服务的服务器大于两台时才有意义。 +负载均衡相比于反向代理更侧重的是将请求分担到多台服务器上去，所以谈论负载均衡只有在提供某服务的服务器大于两台时才有意义。 #### 动静分离 @@ -945,6 +945,6 @@ Nginx 有以下5个优点： > 这部分内容参考极客时间—[Nginx核心知识100讲的内容](https://time.geekbang.org/course/intro/138?code=AycjiiQk6uQRxnVJzBupFkrGkvZlmYELPRsZbWzaAHE=)。 - Nginx 二进制可执行文件：由各模块源码编译出一个文件 -- Nginx.conf 配置文件：控制Nginx 行为 +- nginx.conf 配置文件：控制Nginx 行为 - acess.log 访问日志： 记录每一条HTTP请求信息 -- error.log 错误日志:定位问题 +- error.log 错误日志：定位问题 diff --git "a/docs/essential-content-for-interview/PreparingForInterview/\345\246\202\346\236\234\351\235\242\350\257\225\345\256\230\351\227\256\344\275\240\342\200\234\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\351\227\256\346\210\221\345\220\227\357\274\237\342\200\235\346\227\266\357\274\214\344\275\240\350\257\245\345\246\202\344\275\225\345\233\236\347\255\224.md" "b/docs/essential-content-for-interview/PreparingForInterview/\351\235\242\350\257\225\345\256\230-\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\350\246\201\351\227\256\346\210\221.md" similarity index 88% rename from "docs/essential-content-for-interview/PreparingForInterview/\345\246\202\346\236\234\351\235\242\350\257\225\345\256\230\351\227\256\344\275\240\342\200\234\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\351\227\256\346\210\221\345\220\227\357\274\237\342\200\235\346\227\266\357\274\214\344\275\240\350\257\245\345\246\202\344\275\225\345\233\236\347\255\224.md" rename to "docs/essential-content-for-interview/PreparingForInterview/\351\235\242\350\257\225\345\256\230-\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\350\246\201\351\227\256\346\210\221.md" index d4d6b64b0a5..7a55d539d11 100644 --- "a/docs/essential-content-for-interview/PreparingForInterview/\345\246\202\346\236\234\351\235\242\350\257\225\345\256\230\351\227\256\344\275\240\342\200\234\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\351\227\256\346\210\221\345\220\227\357\274\237\342\200\235\346\227\266\357\274\214\344\275\240\350\257\245\345\246\202\344\275\225\345\233\236\347\255\224.md" +++ "b/docs/essential-content-for-interview/PreparingForInterview/\351\235\242\350\257\225\345\256\230-\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\350\246\201\351\227\256\346\210\221.md" @@ -1,4 +1,4 @@ -我还记得当时我去参加面试的时候，几乎每一场面试，特别是HR面和高管面的时候，面试官总是会在结尾问我:“问了你这么多问题了，你有什么问题问我吗？”。这个时候很多人内心就会陷入短暂的纠结中:我该问吗？不问的话面试官会不会对我影响不好？问什么问题？问这个问题会不会让面试官对我的影响不好啊？ +我还记得当时我去参加面试的时候，几乎每一场面试，特别是HR面和高管面的时候，面试官总是会在结尾问我:“问了你这么多问题了，你有什么问题问我吗？”。这个时候很多人内心就会陷入短暂的纠结中：我该问吗？不问的话面试官会不会对我影响不好？问什么问题？问这个问题会不会让面试官对我的影响不好啊？ ![无奈](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-2/无奈.jpg) @@ -14,7 +14,7 @@ ### 真诚一点,不要问太 Low 的问题 -回答这个问题很重要的一点就是你没有必要放低自己的姿态问一些很虚或者故意讨好面试官的问题，也不要把自己从面经上学到的东西照搬下来使用。面试官也不是傻子，特别是那种特别有经验的面试官，你是真心诚意的问问题，还是从别处照搬问题来讨好面试官，人家可能一听就听出来了。总的来说，还是要真诚。除此之外，不要问太Low的问题，会显得你整个人格局比较小或者说你根本没有准备（侧面反映你对这家公司不伤心，既然你不上心，为什么要要你呢）。举例几个比较 Low 的问题，大家看看自己有没有问过其中的问题： +回答这个问题很重要的一点就是你没有必要放低自己的姿态问一些很虚或者故意讨好面试官的问题，也不要把自己从面经上学到的东西照搬下来使用。面试官也不是傻子，特别是那种特别有经验的面试官，你是真心诚意的问问题，还是从别处照搬问题来讨好面试官，人家可能一听就听出来了。总的来说，还是要真诚。除此之外，不要问太 Low 的问题，会显得你整个人格局比较小或者说你根本没有准备（侧面反映你对这家公司不上心，既然你不上心，为什么要要你呢）。举例几个比较 Low 的问题，大家看看自己有没有问过其中的问题： - 贵公司的主要业务是什么？（面试之前自己不知道提前网上查一下吗？） - 贵公司的男女比例如何？（考虑脱单？记住你是来工作的！） @@ -28,9 +28,9 @@ #### 面对HR或者其他Level比较低的面试官时 1. **能不能谈谈你作为一个公司老员工对公司的感受?** (这个问题比较容易回答，不会让面试官陷入无话可说的尴尬境地。另外，从面试官的回答中你可以加深对这个公司的了解，让你更加清楚这个公司到底是不是你想的那样或者说你是否能适应这个公司的文化。除此之外，这样的问题在某种程度上还可以拉进你与面试官的距离。) -2. **能不能问一下，你当时因为什么原因选择加入这家公司的呢或者说这家公司有哪些地方吸引你?有什么地方你觉得还不太好或者可以继续完善吗？** （类似第一个问题，都是问面试官个人对于公司的看法，） +2. **能不能问一下，你当时因为什么原因选择加入这家公司的呢或者说这家公司有哪些地方吸引你？有什么地方你觉得还不太好或者可以继续完善吗？** （类似第一个问题，都是问面试官个人对于公司的看法。） 3. **我觉得我这次表现的不是太好，你有什么建议或者评价给我吗？**(这个是我常问的。我觉得说自己表现不好只是这个语境需要这样来说，这样可以显的你比较谦虚好学上进。) -4. **接下来我会有一段空档期，有什么值得注意或者建议学习的吗？** （体现出你对工作比较上心，自助学习意识比较强。） +4. **接下来我会有一段空档期，有什么值得注意或者建议学习的吗？** （体现出你对工作比较上心，自助学习意识比较强。） 5. **这个岗位为什么还在招人？** (岗位真实性和价值咨询) 6. **大概什么时候能给我回复呢？** (终面的时候，如果面试官没有说的话，可以问一下) 7. ...... diff --git "a/docs/essential-content-for-interview/\351\235\242\350\257\225\345\277\205\345\244\207\344\271\213\344\271\220\350\247\202\351\224\201\344\270\216\346\202\262\350\247\202\351\224\201.md" "b/docs/essential-content-for-interview/\351\235\242\350\257\225\345\277\205\345\244\207\344\271\213\344\271\220\350\247\202\351\224\201\344\270\216\346\202\262\350\247\202\351\224\201.md" index b6f40fbc31b..00aaecd8c5b 100644 --- "a/docs/essential-content-for-interview/\351\235\242\350\257\225\345\277\205\345\244\207\344\271\213\344\271\220\350\247\202\351\224\201\344\270\216\346\202\262\350\247\202\351\224\201.md" +++ "b/docs/essential-content-for-interview/\351\235\242\350\257\225\345\277\205\345\244\207\344\271\213\344\271\220\350\247\202\351\224\201\344\270\216\346\202\262\350\247\202\351\224\201.md" @@ -1,3 +1,22 @@ +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 + + + +- [何谓悲观锁与乐观锁](#何谓悲观锁与乐观锁) + - [悲观锁](#悲观锁) + - [乐观锁](#乐观锁) + - [两种锁的使用场景](#两种锁的使用场景) +- [乐观锁常见的两种实现方式](#乐观锁常见的两种实现方式) + - [1. 版本号机制](#1-版本号机制) + - [2. CAS算法](#2-cas算法) +- [乐观锁的缺点](#乐观锁的缺点) + - [1 ABA 问题](#1-aba-问题) + - [2 循环时间长开销大](#2-循环时间长开销大) + - [3 只能保证一个共享变量的原子操作](#3-只能保证一个共享变量的原子操作) +- [CAS与synchronized的使用情景](#cas与synchronized的使用情景) + + + ### 何谓悲观锁与乐观锁 > 乐观锁对应于生活中乐观的人总是想着事情往好的方向发展，悲观锁对应于生活中悲观的人总是想着事情往坏的方向发展。这两种人各有优缺点，不能不以场景而定说一种人好于另外一种人。 @@ -64,8 +83,6 @@ JDK 1.5 以后的 `AtomicStampedReference 类`就提供了此种能力，其中 CAS 只对单个共享变量有效，当操作涉及跨多个共享变量时 CAS 无效。但是从 JDK 1.5开始，提供了`AtomicReference类`来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行 CAS 操作.所以我们可以使用锁或者利用`AtomicReference类`把多个共享变量合并成一个共享变量来操作。 - - ### CAS与synchronized的使用情景 > **简单的来说CAS适用于写比较少的情况下（多读场景，冲突一般较少），synchronized适用于写比较多的情况下（多写场景，冲突一般较多）** @@ -73,10 +90,17 @@ CAS 只对单个共享变量有效，当操作涉及跨多个共享变量时 CAS 1. 对于资源竞争较少（线程冲突较轻）的情况，使用synchronized同步锁进行线程阻塞和唤醒切换以及用户态内核态间的切换操作额外浪费消耗cpu资源；而CAS基于硬件实现，不需要进入内核，不需要切换线程，操作自旋几率较少，因此可以获得更高的性能。 2. 对于资源竞争严重（线程冲突严重）的情况，CAS自旋的概率会比较大，从而浪费更多的CPU资源，效率低于synchronized。 - 补充： Java并发编程这个领域中synchronized关键字一直都是元老级的角色，很久之前很多人都会称它为 **“重量级锁”** 。但是，在JavaSE 1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的 **偏向锁** 和 **轻量级锁** 以及其它**各种优化**之后变得在某些情况下并不是那么重了。synchronized的底层实现主要依靠 **Lock-Free** 的队列，基本思路是 **自旋后阻塞**，**竞争切换后继续竞争锁**，**稍微牺牲了公平性，但获得了高吞吐量**。在线程冲突较少的情况下，可以获得和CAS类似的性能；而线程冲突严重的情况下，性能远高于CAS。 +## 公众号 + +如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 + +**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"面试突击"** 即可免费领取！ + +**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 +![我的公众号](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/167598cd2e17b8ec.png) diff --git a/docs/github-trending/2019-4.md b/docs/github-trending/2019-4.md new file mode 100644 index 00000000000..713a76da642 --- /dev/null +++ b/docs/github-trending/2019-4.md @@ -0,0 +1,98 @@ +以下涉及到的数据统计与 2019 年 5 月 1 日 12 点，数据来源： 。 + +下面的内容从 Java 学习文档到最热门的框架再到热门的工具应有尽有，比如下面推荐到的开源项目 Hutool 就是近期比较热门的项目之一，它是 Java 工具包，能够帮助我们简化代码！我觉得下面这些项目对于学习 Java 的朋友还是很有帮助的！ + + +### 1. JavaGuide + +- **Github 地址**： [https://github.com/Snailclimb/JavaGuide](https://github.com/Snailclimb/JavaGuide) +- **Star**: 37.9k (5,660 stars this month) +- **介绍**: 【Java 学习+面试指南】 一份涵盖大部分 Java 程序员所需要掌握的核心知识。 + +### 2. advanced-java + +- **Github 地址**：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java) +- **Star**: 15.1k (4,654 stars this month) +- **介绍**: 互联网 Java 工程师进阶知识完全扫盲。 + +### 3. CS-Notes + +- **Github 地址**： +- **Star**: 59.2k (4,012 stars this month) +- **介绍**: 技术面试必备基础知识。 + +### 4. ghidra + +- **Github 地址**： +- **Star**: 15.0k (2,995 stars this month) +- **介绍**: Ghidra是一个软件逆向工程（SRE）框架。 + +### 5. mall + +- **Github 地址**： [https://github.com/macrozheng/mall](https://github.com/macrozheng/mall) +- **star**: 11.6 k (2,100 stars this month) +- **介绍**: mall 项目是一套电商系统，包括前台商城系统及后台管理系统，基于 SpringBoot+MyBatis 实现。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。 + +### 6. ZXBlog + +- **Github 地址**： +- **star**: 2.1 k (2,086 stars this month) +- **介绍**: 记录各种学习笔记(算法、Java、数据库、并发......)。 + +### 7.DoraemonKit + +- **Github地址**： +- **Star**: 7.6k (1,541 stars this month) +- **介绍**: 简称 "DoKit" 。一款功能齐全的客户端（ iOS 、Android ）研发助手，你值得拥有。 + +### 8. spring-boot + +- **Github地址**： [https://github.com/spring-projects/spring-boot](https://github.com/spring-projects/spring-boot) +- **star:** 37.3k (1,489 stars this month) +- **介绍**： 虽然Spring的组件代码是轻量级的，但它的配置却是重量级的（需要大量XML配置）,不过Spring Boot 让这一切成为了过去。 另外Spring Cloud也是基于Spring Boot构建的，我个人非常有必要学习一下。 + +**Spring Boot官方的介绍：** + +> Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”…Most Spring Boot applications need very little Spring configuration.(Spring Boot可以轻松创建独立的生产级基于Spring的应用程序,只要通过 “just run”（可能是run ‘Application’或java -jar 或 tomcat 或 maven插件run 或 shell脚本）便可以运行项目。大部分Spring Boot项目只需要少量的配置即可) + +### 9. spring-boot-examples + +- **Github 地址**：[https://github.com/ityouknow/spring-boot-examples](https://github.com/ityouknow/spring-boot-examples) +- **Star**: 12.8k (1,453 stars this month) +- **介绍**: Spring Boot 教程、技术栈示例代码，快速简单上手教程。 + +### 10. seata + +- **Github 地址** : [https://github.com/seata/seata](https://github.com/seata/seata) +- **star**: 8.4 k (1441 stars this month) +- **介绍**: Seata 是一种易于使用，高性能，基于 Java 的开源分布式事务解决方案。 + +### 11. litemall + +- **Github 地址**：[https://github.com/ityouknow/spring-boot-examples](https://github.com/ityouknow/spring-boot-examples) +- **Star**: 6.0k (1,427 stars this month) +- **介绍**: 又一个小商城。litemall = Spring Boot后端 + Vue管理员前端 + 微信小程序用户前端 + Vue用户移动端。 + +### 12. skywalking + +- **Github 地址**： +- **Star**: 8.0k (1,381 stars this month) +- **介绍**: 针对分布式系统的应用性能监控，尤其是针对微服务、云原生和面向容器的分布式系统架构。 + +### 13. elasticsearch + +- **Github 地址** [https://github.com/elastic/elasticsearch](https://github.com/elastic/elasticsearch) +- **Star**: 4.0k (1,068stars this month) +- **介绍**: 开源，分布式，RESTful 搜索引擎。 + +### 14. arthas + +- **Github地址**：[https://github.com/alibaba/arthas](https://github.com/alibaba/arthas) +- **star**: 12.6 k (1,080 stars this month) +- **介绍**: Arthas 是Alibaba开源的Java诊断工具。 + +### 15. hutool + +- **Github地址**： +- **star**: 4.5 k (1,031 stars this month) +- **介绍**: Hutool是一个Java工具包，也只是一个工具包，它帮助我们简化每一行代码，减少每一个方法，让Java语言也可以“甜甜的”。Hutool最初是我项目中“util”包的一个整理，后来慢慢积累并加入更多非业务相关功能，并广泛学习其它开源项目精髓，经过自己整理修改，最终形成丰富的开源工具集。官网: 。 \ No newline at end of file diff --git a/docs/github-trending/2019-5.md b/docs/github-trending/2019-5.md new file mode 100644 index 00000000000..1ac28b22cd7 --- /dev/null +++ b/docs/github-trending/2019-5.md @@ -0,0 +1,125 @@ +以下涉及到的数据统计与 2019 年 6 月 1 日 18 点，数据来源： 。下面推荐的内容从 Java 学习文档到最热门的框架再到热门的工具应有尽有，建议收藏+在看！ + +### 1.LeetCodeAnimation + +- **Github 地址**： +- **Star**: 29.0k (11,492 stars this month) +- **介绍**: Demonstrate all the questions on LeetCode in the form of animation.（用动画的形式呈现解LeetCode题目的思路）。 + +### 2.CS-Notes + +- **Github 地址**： +- **Star**: 64.4k (5513 stars this month) +- **介绍**: 技术面试必备基础知识、Leetcode 题解、后端面试、Java 面试、春招、秋招、操作系统、计算机网络、系统设计。 + +### 3.JavaGuide + +- **Github 地址**： +- **Star**: 42.0k (4,442 stars this month) +- **介绍**: 【Java 学习+面试指南】 一份涵盖大部分 Java 程序员所需要掌握的核心知识。 + +### 4.mall + +- **Github 地址**： [https://github.com/macrozheng/mall](https://github.com/macrozheng/mall) +- **star**: 14.6 k (3,086 stars this month) +- **介绍**: mall 项目是一套电商系统，包括前台商城系统及后台管理系统，基于 SpringBoot+MyBatis 实现。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。 + +### 5.advanced-java + +- **Github 地址**：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java) +- **Star**: 20.8k (2,394 stars this month) +- **介绍**: 互联网 Java 工程师进阶知识完全扫盲。 + +### 6.spring-boot + +- **Github地址**： [https://github.com/spring-projects/spring-boot](https://github.com/spring-projects/spring-boot) +- **star:** 38.5k (1,339 stars this month) +- **介绍**： 虽然Spring的组件代码是轻量级的，但它的配置却是重量级的（需要大量XML配置）,不过Spring Boot 让这一切成为了过去。 另外Spring Cloud也是基于Spring Boot构建的，我个人非常有必要学习一下。 + +**Spring Boot官方的介绍：** + +> Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”…Most Spring Boot applications need very little Spring configuration.(Spring Boot可以轻松创建独立的生产级基于Spring的应用程序,只要通过 “just run”（可能是run ‘Application’或java -jar 或 tomcat 或 maven插件run 或 shell脚本）便可以运行项目。大部分Spring Boot项目只需要少量的配置即可) + +### 7. Java + +- **Github 地址**： +- **Star**:14.3k (1,334 stars this month) +- **介绍**: All Algorithms implemented in Java。 + +### 8.server + +- **Github 地址**： +- **star**: 2.2 k (1,275 stars this month) +- **介绍**: 全开源即时通讯(IM)系统。 + +### 9.litemall + +- **Github 地址**： +- **Star**: 7.1k (1,114 stars this month) +- **介绍**: 又一个小商城。litemall = Spring Boot后端 + Vue管理员前端 + 微信小程序用户前端 + Vue用户移动端。 + +### 10.Linkage-RecyclerView + +- **Github 地址**： +- **Star**: 10.0k (1,093 stars this month) +- **介绍**: 即使不用饿了么订餐，也请务必收藏好该库！🔥 一行代码即可接入，二级联动订餐列表 - Even if you don't order food by PrubHub, be sure to collect this library, please! 🔥 This secondary linkage list widget can be accessed by only one line of code. Supporting by RecyclerView & AndroidX. + +### 11.toBeTopJavaer + +- **Github 地址** : +- **Star**: 3.3k (1,007 stars this month) +- **介绍**: To Be Top Javaer - Java工程师成神之路 + +### 12.elasticsearch + +- **Github 地址** : [https://github.com/elastic/elasticsearch](https://github.com/elastic/elasticsearch) +- **Star**: 48.0k (968 stars this month) +- **介绍**: Design patterns implemented in Java。 + +### 13.java-design-patterns + +- **Github 地址** : +- **Star**: 41.5k (955 stars this month) +- **介绍**: 开源，分布式，RESTful 搜索引擎。 + +### 14.apollo + +- **Github 地址** : +- **Star**: 14.5k (927 stars this month) +- **介绍**: Apollo（阿波罗）是携程框架部门研发的分布式配置中心，能够集中化管理应用不同环境、不同集群的配置，配置修改后能够实时推送到应用端，并且具备规范的权限、流程治理等特性，适用于微服务配置管理场景。 + +### 15.arthas + +- **Github地址**：[https://github.com/alibaba/arthas](https://github.com/alibaba/arthas) +- **star**: 13.5 k (933 stars this month) +- **介绍**: Arthas 是Alibaba开源的Java诊断工具。 + +### 16.dubbo + +- **Github地址**： +- **star**: 26.9 k (769 stars this month) +- **介绍**: Apache Dubbo是一个基于Java的高性能开源RPC框架。 + +### 17.DoraemonKit + +- **Github地址**： +- **Star**: 8.5k (909 stars this month) +- **介绍**: 简称 "DoKit" 。一款功能齐全的客户端（ iOS 、Android ）研发助手，你值得拥有。 + +### 18.halo + +- **Github地址**： +- **Star**: 4.1k (829 stars this month) +- **介绍**: Halo 可能是最好的 Java 博客系统。 + +### 19.seata + +- **Github 地址** : [https://github.com/seata/seata](https://github.com/seata/seata) +- **star**: 9.2 k (776 stars this month) +- **介绍**: Seata 是一种易于使用，高性能，基于 Java 的开源分布式事务解决方案。 + +### 20.hutool + +- **Github地址**： +- **star**: 5,3 k (812 stars this month) +- **介绍**: Hutool是一个Java工具包，也只是一个工具包，它帮助我们简化每一行代码，减少每一个方法，让Java语言也可以“甜甜的”。Hutool最初是我项目中“util”包的一个整理，后来慢慢积累并加入更多非业务相关功能，并广泛学习其它开源项目精髓，经过自己整理修改，最终形成丰富的开源工具集。官网: 。 \ No newline at end of file diff --git a/docs/github-trending/2019-6.md b/docs/github-trending/2019-6.md new file mode 100644 index 00000000000..2a395e160d6 --- /dev/null +++ b/docs/github-trending/2019-6.md @@ -0,0 +1,119 @@ +### 1.CS-Notes + +- **Github 地址**：https://github.com/CyC2018/CS-Notes +- **Star**: 69.8k +- **介绍**: 技术面试必备基础知识、Leetcode 题解、后端面试、Java 面试、春招、秋招、操作系统、计算机网络、系统设计。 + +### 2.toBeTopJavaer + +- **Github 地址：**[https://github.com/hollischuang/toBeTopJavaer](https://github.com/hollischuang/toBeTopJavaer) +- **Star**: 4.7k +- **介绍**: To Be Top Javaer - Java工程师成神之路。 + +### 3.p3c + +- **Github 地址：** [https://github.com/alibaba/p3c](https://github.com/alibaba/p3c) +- **Star**: 16.6k +- **介绍**: Alibaba Java Coding Guidelines pmd implements and IDE plugin。Eclipse 和 IDEA 上都有该插件，推荐使用！ + +### 4.SpringCloudLearning + +- **Github 地址：** [https://github.com/forezp/SpringCloudLearning](https://github.com/forezp/SpringCloudLearning) +- **Star**: 8.7k +- **介绍**: 史上最简单的Spring Cloud教程源码。 + +### 5.dubbo + +- **Github地址**： +- **star**: 27.6 k +- **介绍**: Apache Dubbo是一个基于Java的高性能开源RPC框架。 + +### 6.jeecg-boot + +- **Github地址**： [https://github.com/zhangdaiscott/jeecg-boot](https://github.com/zhangdaiscott/jeecg-boot) +- **star**: 3.3 k +- **介绍**: 一款基于代码生成器的JAVA快速开发平台！全新架构前后端分离：SpringBoot 2.x，Ant Design&Vue，Mybatis，Shiro，JWT。强大的代码生成器让前后端代码一键生成，无需写任何代码，绝对是全栈开发福音！！ JeecgBoot的宗旨是提高UI能力的同时,降低前后分离的开发成本，JeecgBoot还独创在线开发模式，No代码概念，一系列在线智能开发：在线配置表单、在线配置报表、在线设计流程等等。 + +### 7.advanced-java + +- **Github 地址**：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java) +- **Star**: 24.2k +- **介绍**: 互联网 Java 工程师进阶知识完全扫盲：涵盖高并发、分布式、高可用、微服务等领域知识，后端同学必看，前端同学也可学习。 + +### 8.FEBS-Shiro + +- **Github 地址**：[https://github.com/wuyouzhuguli/FEBS-Shiro](https://github.com/wuyouzhuguli/FEBS-Shiro) +- **Star**: 2.6k +- **介绍**: Spring Boot 2.1.3，Shiro1.4.0 & Layui 2.5.4 权限管理系统。预览地址：http://49.234.20.223:8080/login。 + +### 9.SpringAll + +- **Github 地址**: [https://github.com/wuyouzhuguli/SpringAll](https://github.com/wuyouzhuguli/SpringAll) +- **Star**: 5.4k +- **介绍**: 循序渐进，学习Spring Boot、Spring Boot & Shiro、Spring Cloud、Spring Security & Spring Security OAuth2，博客Spring系列源码。 + +### 10.JavaGuide + +- **Github 地址**： +- **Star**: 47.2k +- **介绍**: 【Java 学习+面试指南】 一份涵盖大部分 Java 程序员所需要掌握的核心知识。 + +### 11.vhr + +- **Github 地址**：[https://github.com/lenve/vhr](https://github.com/lenve/vhr) +- **Star**: 4.9k +- **介绍**: 微人事是一个前后端分离的人力资源管理系统，项目采用SpringBoot+Vue开发。 + +### 12. tutorials + +- **Github 地址**：[https://github.com/eugenp/tutorials](https://github.com/eugenp/tutorials) +- **star**: 15.4 k +- **介绍**: 该项目是一系列小而专注的教程 - 每个教程都涵盖 Java 生态系统中单一且定义明确的开发领域。 当然，它们的重点是 Spring Framework - Spring，Spring Boot 和 Spring Securiyt。 除了 Spring 之外，还有以下技术：核心 Java，Jackson，HttpClient，Guava。 + +### 13.EasyScheduler + +- **Github 地址**：[https://github.com/analysys/EasyScheduler](https://github.com/analysys/EasyScheduler) +- **star**: 1.1 k +- **介绍**: Easy Scheduler是一个分布式工作流任务调度系统，主要解决“复杂任务依赖但无法直接监控任务健康状态”的问题。Easy Scheduler以DAG方式组装任务，可以实时监控任务的运行状态。同时，它支持重试，重新运行等操作... 。https://analysys.github.io/easyscheduler_docs_cn/ + +### 14.thingsboard + +- **Github 地址**：[https://github.com/thingsboard/thingsboard](https://github.com/thingsboard/thingsboard) +- **star**: 3.7 k +- **介绍**: 开源物联网平台 - 设备管理，数据收集，处理和可视化。 [https://thingsboard.io](https://thingsboard.io/) + +### 15.mall-learning + +- **Github 地址**: [https://github.com/macrozheng/mall-learning](https://github.com/macrozheng/mall-learning) +- **star**: 0.6 k +- **介绍**: mall学习教程，架构、业务、技术要点全方位解析。mall项目（16k+star）是一套电商系统，使用现阶段主流技术实现。 涵盖了SpringBoot2.1.3、MyBatis3.4.6、Elasticsearch6.2.2、RabbitMQ3.7.15、Redis3.2、Mongodb3.2、Mysql5.7等技术，采用Docker容器化部署。 https://github.com/macrozheng/mall + +### 16. flink + +- **Github地址**：[https://github.com/apache/flink](https://github.com/apache/flink) +- **star**: 9.3 k +- **介绍**: Apache Flink是一个开源流处理框架，具有强大的流和批处理功能。 + +### 17.spring-cloud-kubernetes + +- **Github地址**：[https://github.com/spring-cloud/spring-cloud-kubernetes](https://github.com/spring-cloud/spring-cloud-kubernetes) +- **star**: 1.4 k +- **介绍**: Kubernetes 集成 Spring Cloud Discovery Client, Configuration, etc... + +### 18.springboot-learning-example + +- **Github地址**：[https://github.com/JeffLi1993/springboot-learning-example](https://github.com/JeffLi1993/springboot-learning-example) +- **star**: 10.0 k +- **介绍**: spring boot 实践学习案例，是 spring boot 初学者及核心技术巩固的最佳实践。 + +### 19.canal + +- **Github地址**：[https://github.com/alibaba/canal](https://github.com/alibaba/canal) +- **star**: 9.3 k +- **介绍**: 阿里巴巴 MySQL binlog 增量订阅&消费组件。 + +### 20.react-native-device-info + +- **Github地址**：[https://github.com/react-native-community/react-native-device-info](https://github.com/react-native-community/react-native-device-info) +- **star**: 4.0 k +- **介绍**: React Native iOS和Android的设备信息。 \ No newline at end of file diff --git a/docs/github-trending/JavaGithubTrending.md b/docs/github-trending/JavaGithubTrending.md index 0639622212f..91d544ed37e 100644 --- a/docs/github-trending/JavaGithubTrending.md +++ b/docs/github-trending/JavaGithubTrending.md @@ -1,4 +1,8 @@ - [2018 年 12 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2018-12.md) - [2019 年 1 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2019-1.md) - [2019 年 2 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2019-2.md) +- [2019 年 3 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2019-3.md) +- [2019 年 4 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2019-4.md) +- [2019 年 5 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2019-5.md) +- [2019 年 6 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2019-6.md) diff --git a/docs/java/BIO-NIO-AIO.md b/docs/java/BIO-NIO-AIO.md index c5ec6dddd04..ee8e751cd6d 100644 --- a/docs/java/BIO-NIO-AIO.md +++ b/docs/java/BIO-NIO-AIO.md @@ -42,7 +42,7 @@ - **阻塞：** 阻塞就是发起一个请求，调用者一直等待请求结果返回，也就是当前线程会被挂起，无法从事其他任务，只有当条件就绪才能继续。 - **非阻塞：** 非阻塞就是发起一个请求，调用者不用一直等着结果返回，可以先去干其他事情。 -举个生活中简单的例子，你妈妈让你烧水，小时候你比较笨啊，在哪里傻等着水开（**同步阻塞**）。等你稍微再长大一点，你知道每次烧水的空隙可以去干点其他事，然后只需要时不时来看看水开了没有（**同步非阻塞**）。后来，你们家用上了水开了会发出声音的壶，这样你就只需要听到响声后就知道水开了，在这期间你可以随便干自己的事情，你需要去倒水了（**异步非阻塞**）。 +举个生活中简单的例子，你妈妈让你烧水，小时候你比较笨啊，在那里傻等着水开（**同步阻塞**）。等你稍微再长大一点，你知道每次烧水的空隙可以去干点其他事，然后只需要时不时来看看水开了没有（**同步非阻塞**）。后来，你们家用上了水开了会发出声音的壶，这样你就只需要听到响声后就知道水开了，在这期间你可以随便干自己的事情，你需要去倒水了（**异步非阻塞**）。 ## 1. BIO (Blocking I/O) @@ -73,7 +73,7 @@ BIO通信（一请求一应答）模型图如下(图源网络，原出处不明) 采用线程池和任务队列可以实现一种叫做伪异步的 I/O 通信框架，它的模型图如上图所示。当有新的客户端接入时，将客户端的 Socket 封装成一个Task（该任务实现java.lang.Runnable接口）投递到后端的线程池中进行处理，JDK 的线程池维护一个消息队列和 N 个活跃线程，对消息队列中的任务进行处理。由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。 -伪异步I/O通信框架采用了线程池实现，因此避免了为每个请求都创建一个独立线程造成的线程资源耗尽问题。不过因为它的底层任然是同步阻塞的BIO模型，因此无法从根本上解决问题。 +伪异步I/O通信框架采用了线程池实现，因此避免了为每个请求都创建一个独立线程造成的线程资源耗尽问题。不过因为它的底层仍然是同步阻塞的BIO模型，因此无法从根本上解决问题。 ### 1.3 代码示例 @@ -202,13 +202,13 @@ NIO 通过Channel（通道） 进行读写。 通道是双向的，可读也可写，而流的读写是单向的。无论读写，通道只能和Buffer交互。因为 Buffer，通道可以异步地读写。 -#### 4)Selectors(选择器) +#### 4)Selector (选择器) NIO有选择器，而IO没有。 选择器用于使用单个线程处理多个通道。因此，它需要较少的线程来处理这些通道。线程之间的切换对于操作系统来说是昂贵的。 因此，为了提高系统效率选择器是有用的。 -![一个单线程中Slector维护3个Channel的示意图](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-2/Slector.png) +![一个单线程中Selector维护3个Channel的示意图](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-2/Slector.png) ### 2.3 NIO 读数据和写数据方式 通常来说NIO中的所有IO都是从 Channel（通道） 开始的。 @@ -273,8 +273,7 @@ public class NIOServer { if (key.isAcceptable()) { try { - // (1) - // 每来一个新连接，不需要创建一个线程，而是直接注册到clientSelector + // (1) 每来一个新连接，不需要创建一个线程，而是直接注册到clientSelector SocketChannel clientChannel = ((ServerSocketChannel) key.channel()).accept(); clientChannel.configureBlocking(false); clientChannel.register(clientSelector, SelectionKey.OP_READ); diff --git a/docs/java/Basis/Arrays,CollectionsCommonMethods.md b/docs/java/Basis/Arrays,CollectionsCommonMethods.md index f3b97c5eb40..0710de44a95 100644 --- a/docs/java/Basis/Arrays,CollectionsCommonMethods.md +++ b/docs/java/Basis/Arrays,CollectionsCommonMethods.md @@ -54,12 +54,12 @@ void rotate(List list, int distance)//旋转。当distance为正数时，将list Collections.reverse(arrayList); System.out.println("Collections.reverse(arrayList):"); System.out.println(arrayList); - - + + Collections.rotate(arrayList, 4); System.out.println("Collections.rotate(arrayList, 4):"); System.out.println(arrayList); - + // void sort(List list),按自然排序的升序排序 Collections.sort(arrayList); System.out.println("Collections.sort(arrayList):"); @@ -69,7 +69,7 @@ void rotate(List list, int distance)//旋转。当distance为正数时，将list Collections.shuffle(arrayList); System.out.println("Collections.shuffle(arrayList):"); System.out.println(arrayList); - + // void swap(List list, int i , int j),交换两个索引位置的元素 Collections.swap(arrayList, 2, 5); System.out.println("Collections.swap(arrayList, 2, 5):"); @@ -93,7 +93,7 @@ void rotate(List list, int distance)//旋转。当distance为正数时，将list int binarySearch(List list, Object key)//对List进行二分查找，返回索引，注意List必须是有序的 int max(Collection coll)//根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll) int max(Collection coll, Comparator c)//根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c) -void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素。 +void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素。 int frequency(Collection c, Object o)//统计元素出现次数 int indexOfSubList(List list, List target)//统计target在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target). boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换旧元素 @@ -142,7 +142,7 @@ boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换 ### 同步控制 -Collectons提供了多个`synchronizedXxx()`方法·，该方法可以将指定集合包装成线程同步的集合，从而解决多线程并发访问集合时的线程安全问题。 +Collections提供了多个`synchronizedXxx()`方法·，该方法可以将指定集合包装成线程同步的集合，从而解决多线程并发访问集合时的线程安全问题。 我们知道 HashSet，TreeSet，ArrayList,LinkedList,HashMap,TreeMap 都是线程不安全的。Collections提供了多个静态方法可以把他们包装成线程同步的集合。 @@ -152,9 +152,9 @@ Collectons提供了多个`synchronizedXxx()`方法·，该方法可以将指定 ```java synchronizedCollection(Collection c) //返回指定 collection 支持的同步（线程安全的）collection。 -synchronizedList(List list)//返回指定列表支持的同步（线程安全的）List。 +synchronizedList(List list)//返回指定列表支持的同步（线程安全的）List。 synchronizedMap(Map m) //返回由指定映射支持的同步（线程安全的）Map。 -synchronizedSet(Set s) //返回指定 set 支持的同步（线程安全的）set。 +synchronizedSet(Set s) //返回指定 set 支持的同步（线程安全的）set。 ``` ### Collections还可以设置不可变集合，提供了如下三类方法： @@ -224,7 +224,8 @@ unmodifiableXxx(): 返回指定集合对象的不可变视图，此处的集合 4. 填充 : `fill()` 5. 转列表: `asList()` 6. 转字符串 : `toString()` -7. +7. 复制: `copyOf()` + ### 排序 : `sort()` @@ -251,7 +252,7 @@ unmodifiableXxx(): 返回指定集合对象的不可变视图，此处的集合 System.out.println(); int c[] = { 1, 3, 2, 7, 6, 5, 4, 9 }; - // parallelSort(int[] a) 按照数字顺序排列指定的数组。同sort方法一样也有按范围的排序 + // parallelSort(int[] a) 按照数字顺序排列指定的数组(并行的)。同sort方法一样也有按范围的排序 Arrays.parallelSort(c); System.out.println("Arrays.parallelSort(c)："); for (int i : c) { @@ -285,6 +286,9 @@ System.out.println(Arrays.toString(strs));//[abcdeag, abcdefg, abcdehg] ```java // *************查找 binarySearch()**************** char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' }; + // 排序后再进行二分查找，否则找不到 + Arrays.sort(e); + System.out.println("Arrays.sort(e)" + Arrays.toString(e)); System.out.println("Arrays.binarySearch(e, 'c')："); int s = Arrays.binarySearch(e, 'c'); System.out.println("字符c在数组的位置：" + s); @@ -293,12 +297,12 @@ System.out.println(Arrays.toString(strs));//[abcdeag, abcdefg, abcdehg] ### 比较: `equals()` ```java - // *************比较 equals**************** - char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' }; + // *************比较 equals**************** + char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' }; char[] f = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' }; /* - * 元素数量相同，并且相同位置的元素相同。 另外，如果两个数组引用都是null，则它们被认为是相等的 。 - */ + * 元素数量相同，并且相同位置的元素相同。 另外，如果两个数组引用都是null，则它们被认为是相等的 。 + */ // 输出true System.out.println("Arrays.equals(e, f):" + Arrays.equals(e, f)); ``` @@ -345,12 +349,12 @@ System.out.println(Arrays.toString(strs));//[abcdeag, abcdefg, abcdehg] ### 转字符串 `toString()` ```java - // *************转字符串 toString()**************** - /* - * 返回指定数组的内容的字符串表示形式。 - */ - char[] k = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' }; - System.out.println(Arrays.toString(k));// [a, f, b, c, e, A, C, B] + // *************转字符串 toString()**************** + /* + * 返回指定数组的内容的字符串表示形式。 + */ + char[] k = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' }; + System.out.println(Arrays.toString(k));// [a, f, b, c, e, A, C, B] ``` ### 复制 `copyOf()` @@ -358,7 +362,7 @@ System.out.println(Arrays.toString(strs));//[abcdeag, abcdefg, abcdehg] ```java // *************复制 copy**************** // copyOf 方法实现数组复制,h为数组，6为复制的长度 - int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, }; + int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, }; int i[] = Arrays.copyOf(h, 6); System.out.println("Arrays.copyOf(h, 6);："); // 输出结果：123333 @@ -377,4 +381,3 @@ System.out.println(Arrays.toString(strs));//[abcdeag, abcdefg, abcdehg] // 换行 System.out.println(); ``` - diff --git "a/docs/java/J2EE\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/docs/java/J2EE\345\237\272\347\241\200\347\237\245\350\257\206.md" index ced017ab47b..1c9ccc6e50f 100644 --- "a/docs/java/J2EE\345\237\272\347\241\200\347\237\245\350\257\206.md" +++ "b/docs/java/J2EE\345\237\272\347\241\200\347\237\245\350\257\206.md" @@ -1,3 +1,5 @@ +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 + - [Servlet总结](#servlet总结) @@ -26,7 +28,7 @@ ## Servlet总结 -在Java Web程序中，**Servlet**主要负责接收用户请求**HttpServletRequest**,在**doGet()**,**doPost()**中做相应的处理，并将回应**HttpServletResponse**反馈给用户。Servlet可以设置初始化参数，供Servlet内部使用。一个Servlet类只会有一个实例，在它初始化时调用**init()方法**，销毁时调用**destroy()方法**。**Servlet需要在web.xml中配置**（MyEclipse中创建Servlet会自动配置），**一个Servlet可以设置多个URL访问**。**Servlet不是线程安全**，因此要谨慎使用类变量。 +在Java Web程序中，**Servlet**主要负责接收用户请求 `HttpServletRequest`,在`doGet()`,`doPost()`中做相应的处理，并将回应`HttpServletResponse`反馈给用户。**Servlet** 可以设置初始化参数，供Servlet内部使用。一个Servlet类只会有一个实例，在它初始化时调用`init()`方法，销毁时调用`destroy()`方法**。**Servlet需要在web.xml中配置（MyEclipse中创建Servlet会自动配置），**一个Servlet可以设置多个URL访问**。**Servlet不是线程安全**，因此要谨慎使用类变量。 ## 阐述Servlet和CGI的区别? @@ -55,11 +57,11 @@ ## Servlet接口中有哪些方法及Servlet生命周期探秘 Servlet接口定义了5个方法，其中**前三个方法与Servlet生命周期相关**： -- **void init(ServletConfig config) throws ServletException** -- **void service(ServletRequest req, ServletResponse resp) throws ServletException, java.io.IOException** -- **void destory()** -- java.lang.String getServletInfo() -- ServletConfig getServletConfig() +- `void init(ServletConfig config) throws ServletException` +- `void service(ServletRequest req, ServletResponse resp) throws ServletException, java.io.IOException` +- `void destroy()` +- `java.lang.String getServletInfo()` +- `ServletConfig getServletConfig()` **生命周期：** **Web容器加载Servlet并将其实例化后，Servlet生命周期开始**，容器运行其**init()方法**进行Servlet的初始化；请求到达时调用Servlet的**service()方法**，service()方法会根据需要调用与请求对应的**doGet或doPost**等方法；当服务器关闭或项目被卸载时服务器会将Servlet实例销毁，此时会调用Servlet的**destroy()方法**。**init方法和destroy方法只会执行一次，service方法客户端每次请求Servlet都会执行**。Servlet中有时会用到一些需要初始化与销毁的资源，因此可以把初始化资源的代码放入init方法中，销毁资源的代码放入destroy方法中，这样就不需要每次处理客户端的请求都要初始化与销毁资源。 @@ -93,7 +95,7 @@ Form标签里的method的属性为get时调用doGet()，为post时调用doPost() **转发是服务器行为，重定向是客户端行为。** -**转发（Forword）** +**转发（Forward）** 通过RequestDispatcher对象的forward（HttpServletRequest request,HttpServletResponse response）方法实现的。RequestDispatcher可以通过HttpServletRequest 的getRequestDispatcher()方法获得。例如下面的代码就是跳转到login_success.jsp页面。 ```java request.getRequestDispatcher("login_success.jsp").forward(request, response); @@ -143,13 +145,11 @@ Response.setHeader("Refresh","5;URL=http://localhost:8080/servlet/example.htm"); JSP是一种Servlet，但是与HttpServlet的工作方式不太一样。HttpServlet是先由源代码编译为class文件后部署到服务器下，为先编译后部署。而JSP则是先部署后编译。JSP会在客户端第一次请求JSP文件时被编译为HttpJspPage类（接口Servlet的一个子类）。该类会被服务器临时存放在服务器工作目录里面。下面通过实例给大家介绍。 工程JspLoginDemo下有一个名为login.jsp的Jsp文件，把工程第一次部署到服务器上后访问这个Jsp文件，我们发现这个目录下多了下图这两个东东。 .class文件便是JSP对应的Servlet。编译完毕后再运行class文件来响应客户端请求。以后客户端访问login.jsp的时候，Tomcat将不再重新编译JSP文件，而是直接调用class文件来响应客户端请求。 -![JSP工作原理](https://user-gold-cdn.xitu.io/2018/3/31/1627bee073079a28?w=675&h=292&f=jpeg&s=133553) +![JSP工作原理](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/1.png) 由于JSP只会在客户端第一次请求的时候被编译 ，因此第一次请求JSP时会感觉比较慢，之后就会感觉快很多。如果把服务器保存的class文件删除，服务器也会重新编译JSP。 开发Web程序时经常需要修改JSP。Tomcat能够自动检测到JSP程序的改动。如果检测到JSP源代码发生了改动。Tomcat会在下次客户端请求JSP时重新编译JSP，而不需要重启Tomcat。这种自动检测功能是默认开启的，检测改动会消耗少量的时间，在部署Web应用的时候可以在web.xml中将它关掉。 - - 参考：《javaweb整合开发王者归来》P97 ## JSP有哪些内置对象、作用分别是什么 @@ -195,31 +195,31 @@ JSP有9个内置对象： ## request.getAttribute()和 request.getParameter()有何区别 **从获取方向来看：** -getParameter()是获取 POST/GET 传递的参数值； +`getParameter()`是获取 POST/GET 传递的参数值； -getAttribute()是获取对象容器中的数据值； +`getAttribute()`是获取对象容器中的数据值； **从用途来看：** -getParameter用于客户端重定向时，即点击了链接或提交按扭时传值用，即用于在用表单或url重定向传值时接收数据用。 +`getParameter()`用于客户端重定向时，即点击了链接或提交按扭时传值用，即用于在用表单或url重定向传值时接收数据用。 -getAttribute用于服务器端重定向时，即在 sevlet 中使用了 forward 函数,或 struts 中使用了 +`getAttribute()` 用于服务器端重定向时，即在 sevlet 中使用了 forward 函数,或 struts 中使用了 mapping.findForward。 getAttribute 只能收到程序用 setAttribute 传过来的值。 -另外，可以用 setAttribute,getAttribute 发送接收对象.而 getParameter 显然只能传字符串。 -setAttribute 是应用服务器把这个对象放在该页面所对应的一块内存中去，当你的页面服务器重定向到另一个页面时，应用服务器会把这块内存拷贝另一个页面所对应的内存中。这样getAttribute就能取得你所设下的值，当然这种方法可以传对象。session也一样，只是对象在内存中的生命周期不一样而已。getParameter只是应用服务器在分析你送上来的 request页面的文本时，取得你设在表单或 url 重定向时的值。 +另外，可以用 `setAttribute()`,`getAttribute()` 发送接收对象.而 `getParameter()` 显然只能传字符串。 +`setAttribute()` 是应用服务器把这个对象放在该页面所对应的一块内存中去，当你的页面服务器重定向到另一个页面时，应用服务器会把这块内存拷贝另一个页面所对应的内存中。这样`getAttribute()`就能取得你所设下的值，当然这种方法可以传对象。session也一样，只是对象在内存中的生命周期不一样而已。`getParameter()`只是应用服务器在分析你送上来的 request页面的文本时，取得你设在表单或 url 重定向时的值。 **总结：** -getParameter 返回的是String,用于读取提交的表单中的值;（获取之后会根据实际需要转换为自己需要的相应类型，比如整型，日期类型啊等等） +`getParameter()`返回的是String,用于读取提交的表单中的值;（获取之后会根据实际需要转换为自己需要的相应类型，比如整型，日期类型啊等等） -getAttribute 返回的是Object，需进行转换,可用setAttribute 设置成任意对象，使用很灵活，可随时用 +`getAttribute()`返回的是Object，需进行转换,可用`setAttribute()`设置成任意对象，使用很灵活，可随时用 ## include指令include的行为的区别 **include指令：** JSP可以通过include指令来包含其他文件。被包含的文件可以是JSP文件、HTML文件或文本文件。包含的文件就好像是该JSP文件的一部分，会被同时编译执行。 语法格式如下： <%@ include file="文件相对 url 地址" %> -i**nclude动作：** 动作元素用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面。语法格式如下： +i**nclude动作：** ``动作元素用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面。语法格式如下： ## JSP九大内置对象，七大动作，三大指令 @@ -232,11 +232,9 @@ JSP中的四种作用域包括page、request、session和application，具体来 - **session**代表与某个用户与服务器建立的一次会话相关的对象和属性。跟某个用户相关的数据应该放在用户自己的session中。 - **application**代表与整个Web应用程序相关的对象和属性，它实质上是跨越整个Web应用程序，包括多个页面、请求和会话的一个全局作用域。 - - ## 如何实现JSP或Servlet的单线程模式 对于JSP页面，可以通过page指令进行设置。 -<%@page isThreadSafe=”false”%> +`<%@page isThreadSafe="false"%>` 对于Servlet，可以让自定义的Servlet实现SingleThreadModel标识接口。 @@ -294,12 +292,20 @@ if(cookies !=null){ 在所有会话跟踪技术中，HttpSession对象是最强大也是功能最多的。当一个用户第一次访问某个网站时会自动创建 HttpSession，每个用户可以访问他自己的HttpSession。可以通过HttpServletRequest对象的getSession方 法获得HttpSession，通过HttpSession的setAttribute方法可以将一个值放在HttpSession中，通过调用 HttpSession对象的getAttribute方法，同时传入属性名就可以获取保存在HttpSession中的对象。与上面三种方式不同的 是，HttpSession放在服务器的内存中，因此不要将过大的对象放在里面，即使目前的Servlet容器可以在内存将满时将HttpSession 中的对象移到其他存储设备中，但是这样势必影响性能。添加到HttpSession中的值可以是任意Java对象，这个对象最好实现了 Serializable接口，这样Servlet容器在必要的时候可以将其序列化到文件中，否则在序列化时就会出现异常。 ## Cookie和Session的的区别 -1. 由于HTTP协议是无状态的协议，所以服务端需要记录用户的状态时，就需要用某种机制来识具体的用户，这个机制就是Session.典型的场景比如购物车，当你点击下单按钮时，由于HTTP协议无状态，所以并不知道是哪个用户操作的，所以服务端要为特定的用户创建了特定的Session，用用于标识这个用户，并且跟踪用户，这样才知道购物车里面有几本书。这个Session是保存在服务端的，有一个唯一标识。在服务端保存Session的方法很多，内存、数据库、文件都有。集群的时候也要考虑Session的转移，在大型的网站，一般会有专门的Session服务器集群，用来保存用户会话，这个时候 Session 信息都是放在内存的，使用一些缓存服务比如Memcached之类的来放 Session。 -2. 思考一下服务端如何识别特定的客户？这个时候Cookie就登场了。每次HTTP请求的时候，客户端都会发送相应的Cookie信息到服务端。实际上大多数的应用都是用 Cookie 来实现Session跟踪的，第一次创建Session的时候，服务端会在HTTP协议中告诉客户端，需要在 Cookie 里面记录一个Session ID，以后每次请求把这个会话ID发送到服务器，我就知道你是谁了。有人问，如果客户端的浏览器禁用了 Cookie 怎么办？一般这种情况下，会使用一种叫做URL重写的技术来进行会话跟踪，即每次HTTP交互，URL后面都会被附加上一个诸如 sid=xxxxx 这样的参数，服务端据此来识别用户。 -3. Cookie其实还可以用在一些方便用户的场景下，设想你某次登陆过一个网站，下次登录的时候不想再次输入账号了，怎么办？这个信息可以写到Cookie里面，访问网站的时候，网站页面的脚本可以读取这个信息，就自动帮你把用户名给填了，能够方便一下用户。这也是Cookie名称的由来，给用户的一点甜头。所以，总结一下：Session是在服务端保存的一个数据结构，用来跟踪用户的状态，这个数据可以保存在集群、数据库、文件中；Cookie是客户端保存用户信息的一种机制，用来记录用户的一些信息，也是实现Session的一种方式。 +Cookie 和 Session都是用来跟踪浏览器用户身份的会话方式，但是两者的应用场景不太一样。 + + **Cookie 一般用来保存用户信息** 比如①我们在 Cookie 中保存已经登录过得用户信息，下次访问网站的时候页面可以自动帮你登录的一些基本信息给填了；②一般的网站都会有保持登录也就是说下次你再访问网站的时候就不需要重新登录了，这是因为用户登录的时候我们可以存放了一个 Token 在 Cookie 中，下次登录的时候只需要根据 Token 值来查找用户即可(为了安全考虑，重新登录一般要将 Token 重写)；③登录一次网站后访问网站其他页面不需要重新登录。**Session 的主要作用就是通过服务端记录用户的状态。** 典型的场景是购物车，当你要添加商品到购物车的时候，系统不知道是哪个用户操作的，因为 HTTP 协议是无状态的。服务端给特定的用户创建特定的 Session 之后就可以标识这个用户并且跟踪这个用户了。 + +Cookie 数据保存在客户端(浏览器端)，Session 数据保存在服务器端。 + +Cookie 存储在客户端中，而Session存储在服务器上，相对来说 Session 安全性更高。如果使用 Cookie 的一些敏感信息不要写入 Cookie 中，最好能将 Cookie 信息加密然后使用到的时候再去服务器端解密。 + +## 公众号 + +如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 -参考： +**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！ -https://www.zhihu.com/question/19786827/answer/28752144 +**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 -《javaweb整合开发王者归来》P158 Cookie和Session的比较 +![我的公众号](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/167598cd2e17b8ec.png) diff --git "a/docs/java/Java IO\344\270\216NIO.md" "b/docs/java/Java IO\344\270\216NIO.md" index 905df527c40..74bd850e696 100644 --- "a/docs/java/Java IO\344\270\216NIO.md" +++ "b/docs/java/Java IO\344\270\216NIO.md" @@ -27,12 +27,12 @@ **（1） 按操作方式分类结构图：** -![按操作方式分类结构图：](https://user-gold-cdn.xitu.io/2018/5/16/16367d4fd1ce1b46?w=720&h=1080&f=jpeg&s=69522) +![IO-操作方式分类](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/IO-操作方式分类.png) **（2）按操作对象分类结构图** -![按操作对象分类结构图](https://user-gold-cdn.xitu.io/2018/5/16/16367d673b0e268d?w=720&h=535&f=jpeg&s=46081) +![IO-操作对象分类](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/IO-操作对象分类.png) ### [二　java IO体系的学习总结](https://blog.csdn.net/nightcurtis/article/details/51324105) 1. **IO流的分类：** @@ -92,7 +92,7 @@ - 写入数据到缓冲区（Writing Data to a Buffer） **写数据到Buffer有两种方法：** - + 1.从Channel中写数据到Buffer ```java int bytesRead = inChannel.read(buf); //read into buffer. @@ -103,7 +103,7 @@ ``` 4. **Buffer常用方法测试** - + 说实话，NIO编程真的难，通过后面这个测试例子，你可能才能勉强理解前面说的Buffer方法的作用。 diff --git "a/docs/java/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/docs/java/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" index c7d57e342ca..baa160ad26f 100644 --- "a/docs/java/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" +++ "b/docs/java/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" @@ -1,73 +1,73 @@ +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 - - + - [1. 面向对象和面向过程的区别](#1-面向对象和面向过程的区别) - - [面向过程](#面向过程) - - [面向对象](#面向对象) -- [2. Java 语言有哪些特点](#2-java-语言有哪些特点) +- [2. Java 语言有哪些特点?](#2-java-语言有哪些特点) - [3. 关于 JVM JDK 和 JRE 最详细通俗的解答](#3-关于-jvm-jdk-和-jre-最详细通俗的解答) - - [JVM](#jvm) - - [JDK 和 JRE](#jdk-和-jre) + - [JVM](#jvm) + - [JDK 和 JRE](#jdk-和-jre) - [4. Oracle JDK 和 OpenJDK 的对比](#4-oracle-jdk-和-openjdk-的对比) -- [5. Java和C++的区别](#5-java和c的区别) -- [6. 什么是 Java 程序的主类 应用程序和小程序的主类有何不同](#6-什么是-java-程序的主类-应用程序和小程序的主类有何不同) -- [7. Java 应用程序与小程序之间有那些差别](#7-java-应用程序与小程序之间有那些差别) -- [8. 字符型常量和字符串常量的区别](#8-字符型常量和字符串常量的区别) -- [9. 构造器 Constructor 是否可被 override](#9-构造器-constructor-是否可被-override) +- [5. Java和C++的区别?](#5-java和c的区别) +- [6. 什么是 Java 程序的主类 应用程序和小程序的主类有何不同?](#6-什么是-java-程序的主类-应用程序和小程序的主类有何不同) +- [7. Java 应用程序与小程序之间有哪些差别?](#7-java-应用程序与小程序之间有哪些差别) +- [8. 字符型常量和字符串常量的区别?](#8-字符型常量和字符串常量的区别) +- [9. 构造器 Constructor 是否可被 override?](#9-构造器-constructor-是否可被-override) - [10. 重载和重写的区别](#10-重载和重写的区别) - [11. Java 面向对象编程三大特性: 封装 继承 多态](#11-java-面向对象编程三大特性-封装-继承-多态) - - [封装](#封装) - - [继承](#继承) - - [多态](#多态) -- [12. String StringBuffer 和 StringBuilder 的区别是什么 String 为什么是不可变的](#12-string-stringbuffer-和-stringbuilder-的区别是什么-string-为什么是不可变的) + - [封装](#封装) + - [继承](#继承) + - [多态](#多态) +- [12. String StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的?](#12-string-stringbuffer-和-stringbuilder-的区别是什么-string-为什么是不可变的) - [13. 自动装箱与拆箱](#13-自动装箱与拆箱) -- [14. 在一个静态方法内调用一个非静态成员为什么是非法的](#14-在一个静态方法内调用一个非静态成员为什么是非法的) +- [14. 在一个静态方法内调用一个非静态成员为什么是非法的?](#14-在一个静态方法内调用一个非静态成员为什么是非法的) - [15. 在 Java 中定义一个不做事且没有参数的构造方法的作用](#15-在-java-中定义一个不做事且没有参数的构造方法的作用) -- [16. import java和javax有什么区别](#16-import-java和javax有什么区别) -- [17. 接口和抽象类的区别是什么](#17-接口和抽象类的区别是什么) -- [18. 成员变量与局部变量的区别有那些](#18-成员变量与局部变量的区别有那些) +- [16. import java和javax有什么区别？](#16-import-java和javax有什么区别) +- [17. 接口和抽象类的区别是什么？](#17-接口和抽象类的区别是什么) +- [18. 成员变量与局部变量的区别有哪些？](#18-成员变量与局部变量的区别有哪些) - [19. 创建一个对象用什么运算符?对象实体与对象引用有何不同?](#19-创建一个对象用什么运算符对象实体与对象引用有何不同) - [20. 什么是方法的返回值?返回值在类的方法里的作用是什么?](#20-什么是方法的返回值返回值在类的方法里的作用是什么) -- [21. 一个类的构造方法的作用是什么 若一个类没有声明构造方法,该程序能正确执行吗 ?为什么?](#21-一个类的构造方法的作用是什么-若一个类没有声明构造方法该程序能正确执行吗-为什么) -- [22. 构造方法有哪些特性](#22-构造方法有哪些特性) +- [21. 一个类的构造方法的作用是什么? 若一个类没有声明构造方法，该程序能正确执行吗? 为什么?](#21-一个类的构造方法的作用是什么-若一个类没有声明构造方法该程序能正确执行吗-为什么) +- [22. 构造方法有哪些特性？](#22-构造方法有哪些特性) - [23. 静态方法和实例方法有何不同](#23-静态方法和实例方法有何不同) -- [24. 对象的相等与指向他们的引用相等，两者有什么不同？](#24-对象的相等与指向他们的引用相等两者有什么不同) -- [25. 在调用子类构造方法之前会先调用父类没有参数的构造方法，其目的是?](#25-在调用子类构造方法之前会先调用父类没有参数的构造方法其目的是) -- [26. == 与 equals\(重要\)](#26--与-equals重要) -- [27. hashCode 与 equals \(重要\)](#27-hashcode-与-equals-重要) - - [hashCode（）介绍](#hashcode（）介绍) - - [为什么要有 hashCode](#为什么要有-hashcode) - - [hashCode（）与equals（）的相关规定](#hashcode（）与equals（）的相关规定) -- [28. 为什么Java中只有值传递](#28-为什么java中只有值传递) -- [29. 简述线程，程序、进程的基本概念。以及他们之间关系是什么](#29-简述线程程序进程的基本概念以及他们之间关系是什么) +- [24. 对象的相等与指向他们的引用相等,两者有什么不同?](#24-对象的相等与指向他们的引用相等两者有什么不同) +- [25. 在调用子类构造方法之前会先调用父类没有参数的构造方法,其目的是?](#25-在调用子类构造方法之前会先调用父类没有参数的构造方法其目的是) +- [26. == 与 equals(重要)](#26--与-equals重要) +- [27. hashCode 与 equals (重要)](#27-hashcode-与-equals-重要) + - [hashCode（）介绍](#hashcode介绍) + - [为什么要有 hashCode](#为什么要有-hashcode) + - [hashCode（）与equals（）的相关规定](#hashcode与equals的相关规定) +- [28. 为什么Java中只有值传递？](#28-为什么java中只有值传递) +- [29. 简述线程、程序、进程的基本概念。以及他们之间关系是什么?](#29-简述线程程序进程的基本概念以及他们之间关系是什么) - [30. 线程有哪些基本状态?](#30-线程有哪些基本状态) - [31 关于 final 关键字的一些总结](#31-关于-final-关键字的一些总结) - [32 Java 中的异常处理](#32-java-中的异常处理) - - [Java异常类层次结构图](#java异常类层次结构图) - - [Throwable类常用方法](#throwable类常用方法) - - [异常处理总结](#异常处理总结) -- [33 Java序列化中如果有些字段不想进行序列化 怎么办](#33-java序列化中如果有些字段不想进行序列化-怎么办) -- [34 获取用键盘输入常用的的两种方法](#34-获取用键盘输入常用的的两种方法) + - [Java异常类层次结构图](#java异常类层次结构图) + - [Throwable类常用方法](#throwable类常用方法) + - [异常处理总结](#异常处理总结) +- [33 Java序列化中如果有些字段不想进行序列化，怎么办？](#33-java序列化中如果有些字段不想进行序列化怎么办) +- [34 获取用键盘输入常用的两种方法](#34-获取用键盘输入常用的两种方法) +- [35 Java 中 IO 流](#35-java-中-io-流) + - [Java 中 IO 流分为几种?](#java-中-io-流分为几种) + - [既然有了字节流,为什么还要有字符流?](#既然有了字节流为什么还要有字符流) + - [BIO,NIO,AIO 有什么区别?](#bionioaio-有什么区别) +- [36. 常见关键字总结:static,final,this,super](#36-常见关键字总结staticfinalthissuper) +- [37. Collections 工具类和 Arrays 工具类常见方法总结](#37-collections-工具类和-arrays-工具类常见方法总结) - [参考](#参考) +- [公众号](#公众号) - - - + ## 1. 面向对象和面向过程的区别 -### 面向过程 - -**优点：** 性能比面向对象高。因为类调用时需要实例化，开销比较大，比较消耗资源，所以当性能是最重要的考量因素的时候，比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发 +- **面向过程** ：**面向过程性能比面向对象高。** 因为类调用时需要实例化，开销比较大，比较消耗资源，所以当性能是最重要的考量因素的时候，比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发。但是，**面向过程没有面向对象易维护、易复用、易扩展。** +- **面向对象** ：**面向对象易维护、易复用、易扩展。** 因为面向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。但是，**面向对象性能比面向过程低**。 -**缺点：** 没有面向对象易维护、易复用、易扩展 +参见 issue : [面向过程 ：面向过程性能比面向对象高？？](https://github.com/Snailclimb/JavaGuide/issues/431) -### 面向对象 - -**优点：** 易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护 - -**缺点：** 性能比面向过程低 +> 这个并不是根本原因，面向过程也需要分配内存，计算内存偏移量，Java性能差的主要原因并不是因为它是面向对象语言，而是Java是半编译语言，最终的执行代码并不是可以直接被CPU执行的二进制机械码。 +> +> 而面向过程语言大多都是直接编译成机械码在电脑上执行，并且其它一些面向过程的脚本语言性能也并不一定比Java好。 ## 2. Java 语言有哪些特点? @@ -80,6 +80,8 @@ 7. 支持网络编程并且很方便（ Java 语言诞生本身就是为简化网络编程设计的，因此 Java 语言不仅支持网络编程而且很方便）； 8. 编译与解释并存； +> 修正（参见： [issue#544](https://github.com/Snailclimb/JavaGuide/issues/544)）：C++11开始（2011年的时候）,C++就引入了多线程库，在windows、linux、macos都可以使用`std::thread`和`std::async`来创建线程。参考链接：http://www.cplusplus.com/reference/thread/thread/?kw=thread + ## 3. 关于 JVM JDK 和 JRE 最详细通俗的解答 ### JVM @@ -98,7 +100,9 @@ Java虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM有针对不同 > HotSpot采用了惰性评估(Lazy Evaluation)的做法，根据二八定律，消耗大部分系统资源的只有那一小部分的代码（热点代码），而这也就是JIT所需要编译的部分。JVM会根据代码每次被执行的情况收集信息并相应地做出一些优化，因此执行的次数越多，它的速度就越快。JDK 9引入了一种新的编译模式AOT(Ahead of Time Compilation)，它是直接将字节码编译成机器码，这样就避免了JIT预热等各方面的开销。JDK支持分层编译和AOT协作使用。但是 ，AOT 编译器的编译质量是肯定比不上 JIT 编译器的。 -总结：Java虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。 +**总结：** + +Java虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。 ### JDK 和 JRE @@ -118,9 +122,9 @@ JRE 是 Java运行时环境。它是运行已编译 Java 程序所需的所有 > > 答：非常接近 - 我们的Oracle JDK版本构建过程基于OpenJDK 7构建，只添加了几个部分，例如部署代码，其中包括Oracle的Java插件和Java WebStart的实现，以及一些封闭的源代码派对组件，如图形光栅化器，一些开源的第三方组件，如Rhino，以及一些零碎的东西，如附加文档或第三方字体。展望未来，我们的目的是开源Oracle JDK的所有部分，除了我们考虑商业功能的部分。 -总结： +**总结：** -1. Oracle JDK版本将每三年发布一次，而OpenJDK版本每三个月发布一次； +1. Oracle JDK大概每6个月发一次主要版本，而OpenJDK版本大概每三个月发布一次。但这不是固定的，我觉得了解这个没啥用处。详情参见：https://blogs.oracle.com/java-platform-group/update-and-faq-on-the-java-se-release-cadence。 2. OpenJDK 是一个参考模型并且是完全开源的，而Oracle JDK是OpenJDK的一个实现，并不是完全开源的； 3. Oracle JDK 比 OpenJDK 更稳定。OpenJDK和Oracle JDK的代码几乎相同，但Oracle JDK有更多的类和一些错误修复。因此，如果您想开发企业/商业软件，我建议您选择Oracle JDK，因为它经过了彻底的测试和稳定。某些情况下，有些人提到在使用OpenJDK 可能会遇到了许多应用程序崩溃的问题，但是，只需切换到Oracle JDK就可以解决问题； 4. 在响应性和JVM性能方面，Oracle JDK与OpenJDK相比提供了更好的性能； @@ -141,14 +145,14 @@ JRE 是 Java运行时环境。它是运行已编译 Java 程序所需的所有 一个程序中可以有多个类，但只能有一个类是主类。在 Java 应用程序中，这个主类是指包含 main（）方法的类。而在 Java 小程序中，这个主类是一个继承自系统类 JApplet 或 Applet 的子类。应用程序的主类不一定要求是 public 类，但小程序的主类要求必须是 public 类。主类是 Java 程序执行的入口点。 -## 7. Java 应用程序与小程序之间有那些差别? +## 7. Java 应用程序与小程序之间有哪些差别? -简单说应用程序是从主线程启动(也就是 main() 方法)。applet 小程序没有main方法，主要是嵌在浏览器页面上运行(调用init()线程或者run()来启动)，嵌入浏览器这点跟 flash 的小游戏类似。 +简单说应用程序是从主线程启动(也就是 `main()` 方法)。applet 小程序没有 `main()` 方法，主要是嵌在浏览器页面上运行(调用`init()`或者`run()`来启动)，嵌入浏览器这点跟 flash 的小游戏类似。 ## 8. 字符型常量和字符串常量的区别? 1. 形式上: 字符常量是单引号引起的一个字符; 字符串常量是双引号引起的若干个字符 -2. 含义上: 字符常量相当于一个整形值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置) +2. 含义上: 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置) 3. 占内存大小 字符常量只占2个字节; 字符串常量占若干个字节(至少一个字符结束标志) (**注意： char在Java中占两个字节**) > java编程思想第四版：2.2.2节 @@ -160,9 +164,8 @@ JRE 是 Java运行时环境。它是运行已编译 Java 程序所需的所有 ## 10. 重载和重写的区别 -**重载：** 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。 　　 - -**重写：** 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法。 +- **重载：** 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。 　　 +- **重写：** 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法。 ## 11. Java 面向对象编程三大特性: 封装 继承 多态 @@ -176,7 +179,7 @@ JRE 是 Java运行时环境。它是运行已编译 Java 程序所需的所有 **关于继承如下 3 点请记住：** -1. 子类拥有父类非 private 的属性和方法。 +1. 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，**只是拥有**。 2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。 3. 子类可以用自己的方式实现父类的方法。（以后介绍）。 @@ -189,7 +192,6 @@ JRE 是 Java运行时环境。它是运行已编译 Java 程序所需的所有 ## 12. String StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的? **可变性** -　 简单的来说：String 类中使用 final 关键字修饰字符数组来保存字符串，`private　final　char　value[]`，所以 String 对象是不可变的。而StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串`char[]value` 但是没有用 final 关键字修饰，所以这两种对象都是可变的。 @@ -211,52 +213,53 @@ abstract class AbstractStringBuilder implements Appendable, CharSequence { **线程安全性** -String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。 -　　 +String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。　 **性能** 每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。 **对于三者使用的总结：** + 1. 操作少量的数据: 适用String 2. 单线程操作字符串缓冲区下操作大量数据: 适用StringBuilder 3. 多线程操作字符串缓冲区下操作大量数据: 适用StringBuffer ## 13. 自动装箱与拆箱 -**装箱**：将基本类型用它们对应的引用类型包装起来； -**拆箱**：将包装类型转换为基本数据类型； +- **装箱**：将基本类型用它们对应的引用类型包装起来； +- **拆箱**：将包装类型转换为基本数据类型； ## 14. 在一个静态方法内调用一个非静态成员为什么是非法的? 由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。 ## 15. 在 Java 中定义一个不做事且没有参数的构造方法的作用 -　Java 程序在执行子类的构造方法之前，如果没有用 super() 来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super() 来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。 + +Java 程序在执行子类的构造方法之前，如果没有用 `super() `来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 `super() `来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。 　 ## 16. import java和javax有什么区别？ -刚开始的时候 JavaAPI 所必需的包是 java 开头的包，javax 当时只是扩展 API 包来使用。然而随着时间的推移，javax 逐渐地扩展成为 Java API 的组成部分。但是，但是，将扩展从 javax 包移动到 java 包确实太麻烦了，最终会破坏一堆现有的代码。因此，最终决定 javax 包将成为标准API的一部分。 +刚开始的时候 JavaAPI 所必需的包是 java 开头的包，javax 当时只是扩展 API 包来使用。然而随着时间的推移，javax 逐渐地扩展成为 Java API 的组成部分。但是，将扩展从 javax 包移动到 java 包确实太麻烦了，最终会破坏一堆现有的代码。因此，最终决定 javax 包将成为标准API的一部分。 所以，实际上java和javax没有区别。这都是一个名字。 ## 17. 接口和抽象类的区别是什么？ 1. 接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），而抽象类可以有非抽象的方法。 -2. 接口中的实例变量默认是 final 类型的，而抽象类中则不一定。 -3. 一个类可以实现多个接口，但最多只能实现一个抽象类。 -4. 一个类实现接口的话要实现接口的所有方法，而抽象类不一定。 -5. 接口不能用 new 实例化，但可以声明，但是必须引用一个实现该接口的对象。从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。 +2. 接口中除了static、final变量，不能有其他变量，而抽象类中则不一定。 +3. 一个类可以实现多个接口，但只能实现一个抽象类。接口自己本身可以通过extends关键字扩展多个接口。 +4. 接口方法默认修饰符是public，抽象方法可以有public、protected和default这些修饰符（抽象方法就是为了被重写所以不能使用private关键字修饰！）。 +5. 从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。 -备注:在JDK8中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，则必须重写，不然会报错。(详见issue:[https://github.com/Snailclimb/JavaGuide/issues/146](https://github.com/Snailclimb/JavaGuide/issues/146)) +备注：在JDK8中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，则必须重写，不然会报错。(详见issue:[https://github.com/Snailclimb/JavaGuide/issues/146](https://github.com/Snailclimb/JavaGuide/issues/146)) -## 18. 成员变量与局部变量的区别有那些？ +## 18. 成员变量与局部变量的区别有哪些？ 1. 从语法形式上看:成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。 -2. 从变量在内存中的存储方式来看:如果成员变量是使用`static`修饰的，那么这个成员变量是属于类的，如果没有使用使用`static`修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。 +2. 从变量在内存中的存储方式来看:如果成员变量是使用`static`修饰的，那么这个成员变量是属于类的，如果没有使用`static`修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。 3. 从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。 -4. 成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外被 final 修饰的成员变量也必须显示地赋值），而局部变量则不会自动赋值。 +4. 成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。 ## 19. 创建一个对象用什么运算符?对象实体与对象引用有何不同? @@ -296,7 +299,7 @@ new运算符，new创建对象实例（对象实例在堆内存中），对象 **equals()** : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况： - 情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。 -- 情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象的内容相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。 +- 情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来比较两个对象的内容是否相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。 **举个例子：** @@ -322,11 +325,10 @@ public class test1 { ``` **说明：** + - String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。 - 当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。 - - ## 27. hashCode 与 equals (重要) 面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写equals时必须重写hashCode方法？” @@ -338,12 +340,9 @@ hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返 ### 为什么要有 hashCode +**我们先以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：** 当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 `equals()`方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的Java启蒙书《Head first java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。 -**我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：** - -当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals（）方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的Java启蒙书《Head first java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。 - - +通过我们可以看出：`hashCode()` 的作用就是**获取哈希码**，也称为散列码；它实际上是返回一个int整数。这个**哈希码的作用**是确定该对象在哈希表中的索引位置。**`hashCode() `在散列表中才有用，在其它情况下没用**。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。 ### hashCode（）与equals（）的相关规定 @@ -353,6 +352,8 @@ hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返 4. **因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖** 5. hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据） +推荐阅读：[Java hashCode() 和 equals()的若干问题解答](https://www.cnblogs.com/skywang12345/p/3324958.html) + ## 28. 为什么Java中只有值传递？ @@ -365,7 +366,7 @@ hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返 **程序**是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。 -**进程**是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。 +**进程**是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。 线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。 ## 30. 线程有哪些基本状态? @@ -384,7 +385,7 @@ Java 线程在运行的生命周期中的指定时刻只可能处于下面6种 线程创建之后它将处于 **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（运行中）** 状态 。 +> 操作系统隐藏 Java虚拟机（JVM）中的 READY 和 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（运行中）** 状态 。 ![RUNNABLE-VS-RUNNING](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/RUNNABLE-VS-RUNNING.png) @@ -403,7 +404,10 @@ final关键字主要用在三个地方：变量、方法、类。 ### Java异常类层次结构图 ![Java异常类层次结构图](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-2/Exception.png) - 在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 **Throwable类**。Throwable： 有两个重要的子类：**Exception（异常）** 和 **Error（错误）** ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。 + + + +在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 **Throwable类**。Throwable： 有两个重要的子类：**Exception（异常）** 和 **Error（错误）** ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。 **Error（错误）:是程序无法处理的错误**，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。 @@ -411,20 +415,21 @@ final关键字主要用在三个地方：变量、方法、类。 **Exception（异常）:是程序本身可以处理的异常**。Exception 类有一个重要的子类 **RuntimeException**。RuntimeException 异常由Java虚拟机抛出。**NullPointerException**（要访问的变量没有引用任何对象时，抛出该异常）、**ArithmeticException**（算术运算异常，一个整数除以0时，抛出该异常）和 **ArrayIndexOutOfBoundsException** （下标越界异常）。 -**注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。** +**注意：异常和错误的区别：异常能被程序本身处理，错误是无法处理。** ### Throwable类常用方法 -- **public string getMessage()**:返回异常发生时的详细信息 -- **public string toString()**:返回异常发生时的简要描述 -- **public string getLocalizedMessage()**:返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同 +- **public string getMessage()**:返回异常发生时的简要描述 +- **public string toString()**:返回异常发生时的详细信息 +- **public string getLocalizedMessage()**:返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以生成本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同 - **public void printStackTrace()**:在控制台上打印Throwable对象封装的异常信息 ### 异常处理总结 -- **try 块：**用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。 -- **catch 块：**用于处理try捕获到的异常。 -- **finally 块：**无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。 +- **try 块：** 用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。 +- **catch 块：** 用于处理try捕获到的异常。 +- **finally 块：** 无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return +语句时，finally语句块将在方法返回之前被执行。 **在以下4种特殊情况下，finally块不会被执行：** @@ -435,15 +440,21 @@ final关键字主要用在三个地方：变量、方法、类。 下面这部分内容来自issue:。 -**关于返回值：** +**注意：** 当try语句和finally语句中都有return语句时，在方法返回之前，finally语句的内容将被执行，并且finally语句的返回值将会覆盖原始的返回值。如下： -如果try语句里有return，返回的是try语句块中变量值。 -详细执行过程如下： +```java + public static int f(int value) { + try { + return value * value; + } finally { + if (value == 2) { + return 0; + } + } + } +``` -1. 如果有返回值，就把返回值保存到局部变量中； -2. 执行jsr指令跳到finally语句里执行； -3. 执行完finally语句后，返回之前保存在局部变量表里的值。 -4. 如果try，finally语句里均有return，忽略try的return，而使用finally的return. +如果调用 `f(2)`，返回值将是0，因为finally语句的返回值覆盖了try语句块的返回值。 ## 33 Java序列化中如果有些字段不想进行序列化，怎么办？ @@ -451,7 +462,7 @@ final关键字主要用在三个地方：变量、方法、类。 transient关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被transient修饰的变量值不会被持久化和恢复。transient只能修饰变量，不能修饰类和方法。 -## 34 获取用键盘输入常用的的两种方法 +## 34 获取用键盘输入常用的两种方法 方法1：通过 Scanner @@ -468,8 +479,68 @@ BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); String s = input.readLine(); ``` +## 35 Java 中 IO 流 + +### Java 中 IO 流分为几种? + + - 按照流的流向分，可以分为输入流和输出流； + - 按照操作单元划分，可以划分为字节流和字符流； + - 按照流的角色划分为节点流和处理流。 + +Java Io流共涉及40多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系， Java I0流的40多个类都是从如下4个抽象类基类中派生出来的。 + + - InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。 + - OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。 + +按操作方式分类结构图： + +![IO-操作方式分类](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/IO-操作方式分类.png) + + +按操作对象分类结构图： + +![IO-操作对象分类](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/IO-操作对象分类.png) + +### 既然有了字节流,为什么还要有字符流? + +问题本质想问：**不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？** + +回答：字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。 + +### BIO,NIO,AIO 有什么区别? + +- **BIO (Blocking I/O):** 同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。 +- **NIO (New I/O):** NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.nio 包，提供了 Channel , Selector，Buffer等抽象。NIO中的N可以理解为Non-blocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的 `Socket` 和 `ServerSocket` 相对应的 `SocketChannel` 和 `ServerSocketChannel` 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发 +- **AIO (Asynchronous I/O):** AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO操作本身是同步的。查阅网上相关资料，我发现就目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。 + +## 36. 常见关键字总结:static,final,this,super + +详见笔主的这篇文章: + +## 37. Collections 工具类和 Arrays 工具类常见方法总结 + +详见笔主的这篇文章: + +### 38. 深拷贝 vs 浅拷贝 + +1. **浅拷贝**：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。 +2. **深拷贝**：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。 + +![deep and shallow copy](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-7/java-deep-and-shallow-copy.jpg) + ## 参考 - https://stackoverflow.com/questions/1906445/what-is-the-difference-between-jdk-and-jre - https://www.educba.com/oracle-vs-openjdk/ - https://stackoverflow.com/questions/22358071/differences-between-oracle-jdk-and-openjdk?answertab=active#tab-top + +## 公众号 + +如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 + +**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！ + +**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 + +![我的公众号](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/167598cd2e17b8ec.png) + diff --git "a/docs/java/Java\347\226\221\351\232\276\347\202\271.md" "b/docs/java/Java\347\226\221\351\232\276\347\202\271.md" new file mode 100644 index 00000000000..1a10e9586ef --- /dev/null +++ "b/docs/java/Java\347\226\221\351\232\276\347\202\271.md" @@ -0,0 +1,373 @@ + + +- [1. 基础](#1-基础) + - [1.1. 正确使用 equals 方法](#11-正确使用-equals-方法) + - [1.2. 整型包装类值的比较](#12-整型包装类值的比较) + - [1.3. BigDecimal](#13-bigdecimal) + - [1.3.1. BigDecimal 的用处](#131-bigdecimal-的用处) + - [1.3.2. BigDecimal 的大小比较](#132-bigdecimal-的大小比较) + - [1.3.3. BigDecimal 保留几位小数](#133-bigdecimal-保留几位小数) + - [1.3.4. BigDecimal 的使用注意事项](#134-bigdecimal-的使用注意事项) + - [1.3.5. 总结](#135-总结) + - [1.4. 基本数据类型与包装数据类型的使用标准](#14-基本数据类型与包装数据类型的使用标准) +- [2. 集合](#2-集合) + - [2.1. Arrays.asList()使用指南](#21-arraysaslist使用指南) + - [2.1.1. 简介](#211-简介) + - [2.1.2. 《阿里巴巴Java 开发手册》对其的描述](#212-阿里巴巴java-开发手册对其的描述) + - [2.1.3. 使用时的注意事项总结](#213-使用时的注意事项总结) + - [2.1.4. 如何正确的将数组转换为ArrayList?](#214-如何正确的将数组转换为arraylist) + - [2.2. Collection.toArray()方法使用的坑&如何反转数组](#22-collectiontoarray方法使用的坑如何反转数组) + - [2.3. 不要在 foreach 循环里进行元素的 remove/add 操作](#23-不要在-foreach-循环里进行元素的-removeadd-操作) + + + +# 1. 基础 + +## 1.1. 正确使用 equals 方法 + +Object的equals方法容易抛空指针异常，应使用常量或确定有值的对象来调用 equals。 + +举个例子： + +```java +// 不能使用一个值为null的引用类型变量来调用非静态方法，否则会抛出异常 +String str = null; +if (str.equals("SnailClimb")) { + ... +} else { + .. +} +``` + +运行上面的程序会抛出空指针异常，但是我们把第二行的条件判断语句改为下面这样的话，就不会抛出空指针异常，else 语句块得到执行。： + +```java +"SnailClimb".equals(str);// false +``` +不过更推荐使用 `java.util.Objects#equals`(JDK7 引入的工具类)。 + +```java +Objects.equals(null,"SnailClimb");// false +``` +我们看一下`java.util.Objects#equals`的源码就知道原因了。 +```java +public static boolean equals(Object a, Object b) { + // 可以避免空指针异常。如果a==null的话此时a.equals(b)就不会得到执行，避免出现空指针异常。 + return (a == b) || (a != null && a.equals(b)); + } +``` + +**注意：** + +Reference:[Java中equals方法造成空指针异常的原因及解决方案](https://blog.csdn.net/tick_tock97/article/details/72824894) + +- 每种原始类型都有默认值一样，如int默认值为 0，boolean 的默认值为 false，null 是任何引用类型的默认值，不严格的说是所有 Object 类型的默认值。 +- 可以使用 == 或者 != 操作来比较null值，但是不能使用其他算法或者逻辑操作。在Java中`null == null`将返回true。 +- 不能使用一个值为null的引用类型变量来调用非静态方法，否则会抛出异常 + +## 1.2. 整型包装类值的比较 + +所有整型包装类对象值的比较必须使用equals方法。 + +先看下面这个例子： + +```java +Integer x = 3; +Integer y = 3; +System.out.println(x == y);// true +Integer a = new Integer(3); +Integer b = new Integer(3); +System.out.println(a == b);//false +System.out.println(a.equals(b));//true +``` + +当使用自动装箱方式创建一个Integer对象时，当数值在-128 ~127时，会将创建的 Integer 对象缓存起来，当下次再出现该数值时，直接从缓存中取出对应的Integer对象。所以上述代码中，x和y引用的是相同的Integer对象。 + +**注意：**如果你的IDE(IDEA/Eclipse)上安装了阿里巴巴的p3c插件，这个插件如果检测到你用 ==的话会报错提示，推荐安装一个这个插件，很不错。 + +## 1.3. BigDecimal + +### 1.3.1. BigDecimal 的用处 + +《阿里巴巴Java开发手册》中提到：**浮点数之间的等值判断，基本数据类型不能用==来比较，包装数据类型不能用 equals 来判断。** 具体原理和浮点数的编码方式有关，这里就不多提了，我们下面直接上实例： + +```java +float a = 1.0f - 0.9f; +float b = 0.9f - 0.8f; +System.out.println(a);// 0.100000024 +System.out.println(b);// 0.099999964 +System.out.println(a == b);// false +``` +具有基本数学知识的我们很清楚的知道输出并不是我们想要的结果（**精度丢失**），我们如何解决这个问题呢？一种很常用的方法是：**使用使用 BigDecimal 来定义浮点数的值，再进行浮点数的运算操作。** + +```java +BigDecimal a = new BigDecimal("1.0"); +BigDecimal b = new BigDecimal("0.9"); +BigDecimal c = new BigDecimal("0.8"); +BigDecimal x = a.subtract(b);// 0.1 +BigDecimal y = b.subtract(c);// 0.1 +System.out.println(x.equals(y));// true +``` + +### 1.3.2. BigDecimal 的大小比较 + +`a.compareTo(b)` : 返回 -1 表示小于，0 表示 等于， 1表示 大于。 + +```java +BigDecimal a = new BigDecimal("1.0"); +BigDecimal b = new BigDecimal("0.9"); +System.out.println(a.compareTo(b));// 1 +``` +### 1.3.3. BigDecimal 保留几位小数 + +通过 `setScale`方法设置保留几位小数以及保留规则。保留规则有挺多种，不需要记，IDEA会提示。 + +```java +BigDecimal m = new BigDecimal("1.255433"); +BigDecimal n = m.setScale(3,BigDecimal.ROUND_HALF_DOWN); +System.out.println(n);// 1.255 +``` + +### 1.3.4. BigDecimal 的使用注意事项 + +注意：我们在使用BigDecimal时，为了防止精度丢失，推荐使用它的 **BigDecimal(String)** 构造方法来创建对象。《阿里巴巴Java开发手册》对这部分内容也有提到如下图所示。 + +![《阿里巴巴Java开发手册》对这部分BigDecimal的描述](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019/7/BigDecimal.png) + +### 1.3.5. 总结 + +BigDecimal 主要用来操作（大）浮点数，BigInteger 主要用来操作大整数（超过 long 类型）。 + +BigDecimal 的实现利用到了 BigInteger, 所不同的是 BigDecimal 加入了小数位的概念 + +## 1.4. 基本数据类型与包装数据类型的使用标准 + +Reference:《阿里巴巴Java开发手册》 + +- 【强制】所有的 POJO 类属性必须使用包装数据类型。 +- 【强制】RPC 方法的返回值和参数必须使用包装数据类型。 +- 【推荐】所有的局部变量使用基本数据类型。 + +比如我们如果自定义了一个Student类,其中有一个属性是成绩score,如果用Integer而不用int定义,一次考试,学生可能没考,值是null,也可能考了,但考了0分,值是0,这两个表达的状态明显不一样. + +**说明** :POJO 类属性没有初值是提醒使用者在需要使用时，必须自己显式地进行赋值，任何 NPE 问题，或者入库检查，都由使用者来保证。 + +**正例** : 数据库的查询结果可能是 null，因为自动拆箱，用基本数据类型接收有 NPE 风险。 + +**反例** : 比如显示成交总额涨跌情况，即正负 x%，x 为基本数据类型，调用的 RPC 服务，调用不成功时，返回的是默认值，页面显示为 0%，这是不合理的，应该显示成中划线。所以包装数据类型的 null 值，能够表示额外的信息，如:远程调用失败，异常退出。 + +# 2. 集合 + +## 2.1. Arrays.asList()使用指南 + +最近使用`Arrays.asList()`遇到了一些坑，然后在网上看到这篇文章：[Java Array to List Examples](http://javadevnotes.com/java-array-to-list-examples) 感觉挺不错的，但是还不是特别全面。所以，自己对于这块小知识点进行了简单的总结。 + +### 2.1.1. 简介 + +`Arrays.asList()`在平时开发中还是比较常见的，我们可以使用它将一个数组转换为一个List集合。 + +```java +String[] myArray = { "Apple", "Banana", "Orange" }； +List myList = Arrays.asList(myArray); +//上面两个语句等价于下面一条语句 +List myList = Arrays.asList("Apple","Banana", "Orange"); +``` + +JDK 源码对于这个方法的说明： + +```java +/** + *返回由指定数组支持的固定大小的列表。此方法作为基于数组和基于集合的API之间的桥梁，与 Collection.toArray()结合使用。返回的List是可序列化并实现RandomAccess接口。 + */ +public static List asList(T... a) { + return new ArrayList<>(a); +} +``` + +### 2.1.2. 《阿里巴巴Java 开发手册》对其的描述 + +`Arrays.asList()`将数组转换为集合后,底层其实还是数组，《阿里巴巴Java 开发手册》对于这个方法有如下描述： + +![阿里巴巴Java开发手-Arrays.asList()方法](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/阿里巴巴Java开发手-Arrays.asList()方法.png) + +### 2.1.3. 使用时的注意事项总结 + +**传递的数组必须是对象数组，而不是基本类型。** + +`Arrays.asList()`是泛型方法，传入的对象必须是对象数组。 + +```java +int[] myArray = { 1, 2, 3 }; +List myList = Arrays.asList(myArray); +System.out.println(myList.size());//1 +System.out.println(myList.get(0));//数组地址值 +System.out.println(myList.get(1));//报错：ArrayIndexOutOfBoundsException +int [] array=(int[]) myList.get(0); +System.out.println(array[0]);//1 +``` +当传入一个原生数据类型数组时，`Arrays.asList()` 的真正得到的参数就不是数组中的元素，而是数组对象本身！此时List 的唯一元素就是这个数组，这也就解释了上面的代码。 + +我们使用包装类型数组就可以解决这个问题。 + +```java +Integer[] myArray = { 1, 2, 3 }; +``` + +**使用集合的修改方法:`add()`、`remove()`、`clear()`会抛出异常。** + +```java +List myList = Arrays.asList(1, 2, 3); +myList.add(4);//运行时报错：UnsupportedOperationException +myList.remove(1);//运行时报错：UnsupportedOperationException +myList.clear();//运行时报错：UnsupportedOperationException +``` + +`Arrays.asList()` 方法返回的并不是 `java.util.ArrayList` ，而是 `java.util.Arrays` 的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。 + +```java +List myList = Arrays.asList(1, 2, 3); +System.out.println(myList.getClass());//class java.util.Arrays$ArrayList +``` + +下图是`java.util.Arrays$ArrayList`的简易源码，我们可以看到这个类重写的方法有哪些。 + +```java + private static class ArrayList extends AbstractList + implements RandomAccess, java.io.Serializable + { + ... + + @Override + public E get(int index) { + ... + } + + @Override + public E set(int index, E element) { + ... + } + + @Override + public int indexOf(Object o) { + ... + } + + @Override + public boolean contains(Object o) { + ... + } + + @Override + public void forEach(Consumer action) { + ... + } + + @Override + public void replaceAll(UnaryOperator operator) { + ... + } + + @Override + public void sort(Comparator c) { + ... + } + } +``` + +我们再看一下`java.util.AbstractList`的`remove()`方法，这样我们就明白为啥会抛出`UnsupportedOperationException`。 + +```java +public E remove(int index) { + throw new UnsupportedOperationException(); +} +``` + +### 2.1.4. 如何正确的将数组转换为ArrayList? + +stackoverflow：https://dwz.cn/vcBkTiTW + +**1. 自己动手实现（教育目的）** + +```java +//JDK1.5+ +static List arrayToList(final T[] array) { + final List l = new ArrayList(array.length); + + for (final T s : array) { + l.add(s); + } + return (l); +} +``` + +```java +Integer [] myArray = { 1, 2, 3 }; +System.out.println(arrayToList(myArray).getClass());//class java.util.ArrayList +``` + +**2. 最简便的方法(推荐)** + +```java +List list = new ArrayList<>(Arrays.asList("a", "b", "c")) +``` + +**3. 使用 Java8 的Stream(推荐)** + +```java +Integer [] myArray = { 1, 2, 3 }; +List myList = Arrays.stream(myArray).collect(Collectors.toList()); +//基本类型也可以实现转换（依赖boxed的装箱操作） +int [] myArray2 = { 1, 2, 3 }; +List myList = Arrays.stream(myArray2).boxed().collect(Collectors.toList()); +``` + +**4. 使用 Guava(推荐)** + +对于不可变集合，你可以使用[`ImmutableList`](https://github.com/google/guava/blob/master/guava/src/com/google/common/collect/ImmutableList.java)类及其[`of()`](https://github.com/google/guava/blob/master/guava/src/com/google/common/collect/ImmutableList.java#L101)与[`copyOf()`](https://github.com/google/guava/blob/master/guava/src/com/google/common/collect/ImmutableList.java#L225)工厂方法：（参数不能为空） + +```java +List il = ImmutableList.of("string", "elements"); // from varargs +List il = ImmutableList.copyOf(aStringArray); // from array +``` +对于可变集合，你可以使用[`Lists`](https://github.com/google/guava/blob/master/guava/src/com/google/common/collect/Lists.java)类及其[`newArrayList()`](https://github.com/google/guava/blob/master/guava/src/com/google/common/collect/Lists.java#L87)工厂方法： + +```java +List l1 = Lists.newArrayList(anotherListOrCollection); // from collection +List l2 = Lists.newArrayList(aStringArray); // from array +List l3 = Lists.newArrayList("or", "string", "elements"); // from varargs +``` + +**5. 使用 Apache Commons Collections** + +```java +List list = new ArrayList(); +CollectionUtils.addAll(list, str); +``` + +## 2.2. Collection.toArray()方法使用的坑&如何反转数组 + +该方法是一个泛型方法：` T[] toArray(T[] a);` 如果`toArray`方法中没有传递任何参数的话返回的是`Object`类型数组。 + +```java +String [] s= new String[]{ + "dog", "lazy", "a", "over", "jumps", "fox", "brown", "quick", "A" +}; +List list = Arrays.asList(s); +Collections.reverse(list); +s=list.toArray(new String[0]);//没有指定类型的话会报错 +``` + +由于JVM优化，`new String[0]`作为`Collection.toArray()`方法的参数现在使用更好，`new String[0]`就是起一个模板的作用，指定了返回数组的类型，0是为了节省空间，因为它只是为了说明返回的类型。详见： + +## 2.3. 不要在 foreach 循环里进行元素的 remove/add 操作 + +如果要进行`remove`操作，可以调用迭代器的 `remove `方法而不是集合类的 remove 方法。因为如果列表在任何时间从结构上修改创建迭代器之后，以任何方式除非通过迭代器自身`remove/add`方法，迭代器都将抛出一个`ConcurrentModificationException`,这就是单线程状态下产生的 **fail-fast 机制**。 + +> **fail-fast 机制** ：多个线程对 fail-fast 集合进行修改的时，可能会抛出ConcurrentModificationException，单线程下也会出现这种情况，上面已经提到过。 + +`java.util`包下面的所有的集合类都是fail-fast的，而`java.util.concurrent`包下面的所有的类都是fail-safe的。 + +![不要在 foreach 循环里进行元素的 remove/add 操作](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019/7/foreach-remove:add.png) + + + diff --git "a/docs/java/Java\347\250\213\345\272\217\350\256\276\350\256\241\351\242\230.md" "b/docs/java/Java\347\250\213\345\272\217\350\256\276\350\256\241\351\242\230.md" new file mode 100644 index 00000000000..46c9c16994b --- /dev/null +++ "b/docs/java/Java\347\250\213\345\272\217\350\256\276\350\256\241\351\242\230.md" @@ -0,0 +1,125 @@ +## 泛型的实际应用 + +### 实现最小值函数 + +自己设计一个泛型的获取数组最小值的函数.并且这个方法只能接受Number的子类并且实现了Comparable接口。 + +```java +//注意：Number并没有实现Comparable +private static > T min(T[] values) { + if (values == null || values.length == 0) return null; + T min = values[0]; + for (int i = 1; i < values.length; i++) { + if (min.compareTo(values[i]) > 0) min = values[i]; + } + return min; +} +``` + +测试： + +```java +int minInteger = min(new Integer[]{1, 2, 3});//result:1 +double minDouble = min(new Double[]{1.2, 2.2, -1d});//result:-1d +String typeError = min(new String[]{"1","3"});//报错 +``` + +## 数据结构 + +### 使用数组实现栈 + +**自己实现一个栈，要求这个栈具有`push()`、`pop()`（返回栈顶元素并出栈）、`peek()` （返回栈顶元素不出栈）、`isEmpty()`、`size()`这些基本的方法。** + +提示：每次入栈之前先判断栈的容量是否够用，如果不够用就用`Arrays.copyOf()`进行扩容； + +```java +public class MyStack { + private int[] storage;//存放栈中元素的数组 + private int capacity;//栈的容量 + private int count;//栈中元素数量 + private static final int GROW_FACTOR = 2; + + //TODO：不带初始容量的构造方法。默认容量为8 + public MyStack() { + this.capacity = 8; + this.storage=new int[8]; + this.count = 0; + } + + //TODO：带初始容量的构造方法 + public MyStack(int initialCapacity) { + if (initialCapacity < 1) + throw new IllegalArgumentException("Capacity too small."); + + this.capacity = initialCapacity; + this.storage = new int[initialCapacity]; + this.count = 0; + } + + //TODO：入栈 + public void push(int value) { + if (count == capacity) { + ensureCapacity(); + } + storage[count++] = value; + } + + //TODO：确保容量大小 + private void ensureCapacity() { + int newCapacity = capacity * GROW_FACTOR; + storage = Arrays.copyOf(storage, newCapacity); + capacity = newCapacity; + } + + //TODO：返回栈顶元素并出栈 + private int pop() { + count--; + if (count == -1) + throw new IllegalArgumentException("Stack is empty."); + + return storage[count]; + } + + //TODO：返回栈顶元素不出栈 + private int peek() { + if (count == 0){ + throw new IllegalArgumentException("Stack is empty."); + }else { + return storage[count-1]; + } + } + + //TODO：判断栈是否为空 + private boolean isEmpty() { + return count == 0; + } + + //TODO：返回栈中元素的个数 + private int size() { + return count; + } + +} + +``` + +验证 + +```java +MyStack myStack = new MyStack(3); +myStack.push(1); +myStack.push(2); +myStack.push(3); +myStack.push(4); +myStack.push(5); +myStack.push(6); +myStack.push(7); +myStack.push(8); +System.out.println(myStack.peek());//8 +System.out.println(myStack.size());//8 +for (int i = 0; i < 8; i++) { + System.out.println(myStack.pop()); +} +System.out.println(myStack.isEmpty());//true +myStack.pop();//报错：java.lang.IllegalArgumentException: Stack is empty. +``` \ No newline at end of file diff --git "a/docs/java/Java\347\274\226\347\250\213\350\247\204\350\214\203.md" "b/docs/java/Java\347\274\226\347\250\213\350\247\204\350\214\203.md" index b96a6726d77..6b4731ef3c9 100644 --- "a/docs/java/Java\347\274\226\347\250\213\350\247\204\350\214\203.md" +++ "b/docs/java/Java\347\274\226\347\250\213\350\247\204\350\214\203.md" @@ -1,6 +1,30 @@ +讲真的，下面推荐的文章或者资源建议阅读 3 遍以上。 +### 团队 -根据各位建议加上了这部分内容，我暂时只是给出了两个资源，后续可能会对重要的点进行总结，然后更新在这里，如果你总结过这类东西，欢迎与我联系！ +- **阿里巴巴Java开发手册（详尽版）** +- **Google Java编程风格指南：** -- **阿里巴巴Java开发手册（详尽版）** -- **Google Java编程风格指南：** \ No newline at end of file +### 个人 + +- **程序员你为什么这么累:** + +### 如何写出优雅的 Java 代码 + +1. 使用 IntelliJ IDEA 作为您的集成开发环境 (IDE) +1. 使用 JDK 8 或更高版本 +1. 使用 Maven/Gradle +1. 使用 Lombok +1. 编写单元测试 +1. 重构:常见,但也很慢 +1. 注意代码规范 +1. 定期联络客户，以获取他们的反馈 + +上述建议的详细内容：[八点建议助您写出优雅的Java代码](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247485140&idx=1&sn=ecaeace613474f1859aaeed0282ae680&chksm=cea2491ff9d5c00982ffaece847ce1aead89fdb3fe190752d9837c075c79fc95db5940992c56&token=1328169465&lang=zh_CN&scene=21#wechat_redirect)。 + +更多代码优化相关内容推荐： + +- [业务复杂=if else？刚来的大神竟然用策略+工厂彻底干掉了他们！](https://juejin.im/post/5dad23685188251d2c4ea2b6) +- [一些不错的 Java 实践！推荐阅读3遍以上！](http://lrwinx.github.io/2017/03/04/%E7%BB%86%E6%80%9D%E6%9E%81%E6%81%90-%E4%BD%A0%E7%9C%9F%E7%9A%84%E4%BC%9A%E5%86%99java%E5%90%97/) +- [[解锁新姿势] 兄dei，你代码需要优化了](https://juejin.im/post/5dafbc02e51d4524a0060bdd) +- [消灭 Java 代码的“坏味道”](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247485599&idx=1&sn=d83ff4e6b1ee951a0a33508a10980ea3&chksm=cea24754f9d5ce426d18b435a8c373ddc580c06c7d6a45cc51377361729c31c7301f1bbc3b78&token=1328169465&lang=zh_CN#rd) \ No newline at end of file diff --git "a/docs/java/Java\350\231\232\346\213\237\346\234\272\357\274\210jvm\357\274\211.md" "b/docs/java/Java\350\231\232\346\213\237\346\234\272\357\274\210jvm\357\274\211.md" deleted file mode 100644 index 9be88bc89c3..00000000000 --- "a/docs/java/Java\350\231\232\346\213\237\346\234\272\357\274\210jvm\357\274\211.md" +++ /dev/null @@ -1,59 +0,0 @@ - -下面是按jvm虚拟机知识点分章节总结的一些jvm学习与面试相关的一些东西。一般作为Java程序员在面试的时候一般会问的大多就是**Java内存区域、虚拟机垃圾算法、虚拟垃圾收集器、JVM内存管理**这些问题了。这些内容参考周的《深入理解Java虚拟机》中第二章和第三章就足够了对应下面的[深入理解虚拟机之Java内存区域：](https://link.zhihu.com/?target=https%3A//mp.weixin.qq.com/s%3F__biz%3DMzU4NDQ4MzU5OA%3D%3D%26mid%3D2247483910%26idx%3D1%26sn%3D246f39051a85fc312577499691fba89f%26chksm%3Dfd985467caefdd71f9a7c275952be34484b14f9e092723c19bd4ef557c324169ed084f868bdb%23rd)和[深入理解虚拟机之垃圾回收](https://link.zhihu.com/?target=https%3A//mp.weixin.qq.com/s%3F__biz%3DMzU4NDQ4MzU5OA%3D%3D%26mid%3D2247483914%26idx%3D1%26sn%3D9aa157d4a1570962c39783cdeec7e539%26chksm%3Dfd98546bcaefdd7d9f61cd356e5584e56b64e234c3a403ed93cb6d4dde07a505e3000fd0c427%23rd)这两篇文章。 - - -> ### 常见面试题 - -[深入理解虚拟机之Java内存区域](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247484960&idx=1&sn=ff3739fe849030178346bef28a4556c3&chksm=cea249ebf9d5c0fdbde7c86155d0d7ac8925153742aff472bcb79e5e9d400534a855bad38375&token=1082669959&lang=zh_CN#rd) - -1. 介绍下Java内存区域（运行时数据区）。 - -2. 对象的访问定位的两种方式。 - - -[深入理解虚拟机之垃圾回收](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247484959&idx=1&sn=9ac740edba59981b7c89482043776280&chksm=cea249d4f9d5c0c21703382510a47d4bb387932bd814ac891fd214b92cead5d2cf0ee2dff797&token=1082669959&lang=zh_CN#rd) - -1. 如何判断对象是否死亡（两种方法）。 - -2. 简单的介绍一下强引用、软引用、弱引用、虚引用（虚引用与软引用和弱引用的区别、使用软引用能带来的好处）。 - -3. 垃圾收集有哪些算法，各自的特点？ - -4. HotSpot为什么要分为新生代和老年代？ - -5. 常见的垃圾回收器有那些？ - -6. 介绍一下CMS,G1收集器。 - -7. Minor Gc和Full GC 有什么不同呢？ - - - - [虚拟机性能监控和故障处理工具](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247484957&idx=1&sn=713ed6003d23ef883ded14cb43e9ebb7&chksm=cea249d6f9d5c0c0ce0854a03f0d02fcacc8a46e29c2fd4f085a375b00e1cd1b632937a9895e&token=1082669959&lang=zh_CN#rd) - -1. JVM调优的常见命令行工具有哪些？ - - [深入理解虚拟机之类文件结构](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247484956&idx=1&sn=05f46ccacacdbce7c43de594d3fe93db&chksm=cea249d7f9d5c0c1ef6d29b0fbbf0701acd28490deb0974ae71b4d23ae793bec0b0993a4c829&token=1082669959&lang=zh_CN#rd) - -1. 简单介绍一下Class类文件结构（常量池主要存放的是那两大常量？Class文件的继承关系是如何确定的？字段表、方法表、属性表主要包含那些信息？） - -[深入理解虚拟机之虚拟机字节码执行引擎](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247484952&idx=1&sn=d0ec9443600dc5b2a81782b7ae0691d5&chksm=cea249d3f9d5c0c50642f1829fd6fe9e35d155bbbb6718611330c7c46c7158279275b533181e&token=1082669959&lang=zh_CN#rd) - -1. 简单说说类加载过程，里面执行了哪些操作？ - -2. 对类加载器有了解吗？ - -3. 什么是双亲委派模型？ - -4. 双亲委派模型的工作过程以及使用它的好处。 - - - - - -> ### 推荐阅读 - - [《深入理解 Java 内存模型》读书笔记](http://www.54tianzhisheng.cn/2018/02/28/Java-Memory-Model/) （非常不错的文章） - [全面理解Java内存模型(JMM)及volatile关键字 ](https://blog.csdn.net/javazejian/article/details/72772461) - - diff --git "a/docs/java/Java\351\233\206\345\220\210\346\241\206\346\236\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md" "b/docs/java/Java\351\233\206\345\220\210\346\241\206\346\236\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md" deleted file mode 100644 index cb0bd1fe0e3..00000000000 --- "a/docs/java/Java\351\233\206\345\220\210\346\241\206\346\236\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md" +++ /dev/null @@ -1,353 +0,0 @@ - - -1. [List，Set,Map三者的区别及总结](#list，setmap三者的区别及总结) -1. [Arraylist 与 LinkedList 区别](#arraylist-与-linkedlist-区别) -1. [ArrayList 与 Vector 区别（为什么要用Arraylist取代Vector呢？）](#arraylist-与-vector-区别) -1. [HashMap 和 Hashtable 的区别](#hashmap-和-hashtable-的区别) -1. [HashSet 和 HashMap 区别](#hashset-和-hashmap-区别) -1. [HashMap 和 ConcurrentHashMap 的区别](#hashmap-和-concurrenthashmap-的区别) -1. [HashSet如何检查重复](#hashset如何检查重复) -1. [comparable 和 comparator的区别](#comparable-和-comparator的区别) - 1. [Comparator定制排序](#comparator定制排序) - 1. [重写compareTo方法实现按年龄来排序](#重写compareto方法实现按年龄来排序) -1. [如何对Object的list排序？](#如何对object的list排序) -1. [如何实现数组与List的相互转换？](#如何实现数组与list的相互转换) -1. [如何求ArrayList集合的交集 并集 差集 去重复并集](#如何求arraylist集合的交集-并集-差集-去重复并集) -1. [HashMap 的工作原理及代码实现](#hashmap-的工作原理及代码实现) -1. [ConcurrentHashMap 的工作原理及代码实现](#concurrenthashmap-的工作原理及代码实现) -1. [集合框架底层数据结构总结](#集合框架底层数据结构总结) - 1. [- Collection](#--collection) - 1. [1. List](#1-list) - 1. [2. Set](#2-set) - 1. [- Map](#--map) -1. [集合的选用](#集合的选用) -1. [集合的常用方法](#集合的常用方法) - - - - -## List，Set,Map三者的区别及总结 -- **List：对付顺序的好帮手** - - List接口存储一组不唯一（可以有多个元素引用相同的对象），有序的对象 -- **Set:注重独一无二的性质** - - 不允许重复的集合。不会有多个元素引用相同的对象。 - -- **Map:用Key来搜索的专家** - - 使用键值对存储。Map会维护与Key有关联的值。两个Key可以引用相同的对象，但Key不能重复，典型的Key是String类型，但也可以是任何对象。 - - -## Arraylist 与 LinkedList 区别 -Arraylist底层使用的是数组（存读数据效率高，插入删除特定位置效率低），LinkedList 底层使用的是双向链表数据结构（插入，删除效率特别高）（JDK1.6之前为循环链表，JDK1.7取消了循环。注意双向链表和双向循环链表的区别：）； 详细可阅读JDK1.7-LinkedList循环链表优化。学过数据结构这门课后我们就知道采用链表存储，插入，删除元素时间复杂度不受元素位置的影响，都是近似O（1）而数组为近似O（n），因此当数据特别多，而且经常需要插入删除元素时建议选用LinkedList.一般程序只用Arraylist就够用了，因为一般数据量都不会蛮大，Arraylist是使用最多的集合类。 - -## ArrayList 与 Vector 区别 -Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象、但是一个线程访问Vector -，代码要在同步操作上耗费大量的时间。Arraylist不是同步的，所以在不需要同步时建议使用Arraylist。 - -## HashMap 和 Hashtable 的区别 -1. HashMap是非线程安全的，HashTable是线程安全的；HashTable内部的方法基本都经过synchronized修饰。 - -2. 因为线程安全的问题，HashMap要比HashTable效率高一点，HashTable基本被淘汰。 -3. HashMap允许有null值的存在，而在HashTable中put进的键值只要有一个null，直接抛出NullPointerException。 - -Hashtable和HashMap有几个主要的不同：线程安全以及速度。仅在你需要完全的线程安全的时候使用Hashtable，而如果你使用Java5或以上的话，请使用ConcurrentHashMap吧 - -## HashSet 和 HashMap 区别 -![HashSet 和 HashMap 区别](https://user-gold-cdn.xitu.io/2018/3/2/161e717d734f3b23?w=896&h=363&f=jpeg&s=205536) - -## HashMap 和 ConcurrentHashMap 的区别 -[HashMap与ConcurrentHashMap的区别](https://blog.csdn.net/xuefeng0707/article/details/40834595) - -1. ConcurrentHashMap对整个桶数组进行了分割分段(Segment)，然后在每一个分段上都用lock锁进行保护，相对于HashTable的synchronized锁的粒度更精细了一些，并发性能更好，而HashMap没有锁机制，不是线程安全的。（JDK1.8之后ConcurrentHashMap启用了一种全新的方式实现,利用CAS算法。） -2. HashMap的键值对允许有null，但是ConCurrentHashMap都不允许。 - -## HashSet如何检查重复 -当你把对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，同时也会与其他加入的对象的hashcode值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同hashcode值的对象，这时会调用equals（）方法来检查hashcode相等的对象是否真的相同。如果两者相同，HashSet就不会让加入操作成功。（摘自我的Java启蒙书《Head fist java》第二版） - -**hashCode（）与equals（）的相关规定：** -1. 如果两个对象相等，则hashcode一定也是相同的 -2. 两个对象相等,对两个equals方法返回true -3. 两个对象有相同的hashcode值，它们也不一定是相等的 -4. 综上，equals方法被覆盖过，则hashCode方法也必须被覆盖 -5. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）。 - -**==与equals的区别** - -1. ==是判断两个变量或实例是不是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是不是相同 -2. ==是指对内存地址进行比较 equals()是对字符串的内容进行比较 -3. ==指引用是否相同 equals()指的是值是否相同 - -## comparable 和 comparator的区别 -- comparable接口实际上是出自java.lang包 它有一个 compareTo(Object obj)方法用来排序 -- comparator接口实际上是出自 java.util 包它有一个compare(Object obj1, Object obj2)方法用来排序 - -一般我们需要对一个集合使用自定义排序时，我们就要重写compareTo方法或compare方法，当我们需要对某一个集合实现两种排序方式，比如一个song对象中的歌名和歌手名分别采用一种排序方法的话，我们可以重写compareTo方法和使用自制的Comparator方法或者以两个Comparator来实现歌名排序和歌星名排序，第二种代表我们只能使用两个参数版的Collections.sort(). - -### Comparator定制排序 -```java -import java.util.ArrayList; -import java.util.Collections; -import java.util.Comparator; - -/** - * TODO Collections类方法测试之排序 - * @author 寇爽 - * @date 2017年11月20日 - * @version 1.8 - */ -public class CollectionsSort { - - public static void main(String[] args) { - - ArrayList arrayList = new ArrayList(); - arrayList.add(-1); - arrayList.add(3); - arrayList.add(3); - arrayList.add(-5); - arrayList.add(7); - arrayList.add(4); - arrayList.add(-9); - arrayList.add(-7); - System.out.println("原始数组:"); - System.out.println(arrayList); - // void reverse(List list)：反转 - Collections.reverse(arrayList); - System.out.println("Collections.reverse(arrayList):"); - System.out.println(arrayList); -/* - * void rotate(List list, int distance),旋转。 - * 当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 - * list的前distance个元素整体移到后面。 - - Collections.rotate(arrayList, 4); - System.out.println("Collections.rotate(arrayList, 4):"); - System.out.println(arrayList);*/ - - // void sort(List list),按自然排序的升序排序 - Collections.sort(arrayList); - System.out.println("Collections.sort(arrayList):"); - System.out.println(arrayList); - - // void shuffle(List list),随机排序 - Collections.shuffle(arrayList); - System.out.println("Collections.shuffle(arrayList):"); - System.out.println(arrayList); - - // 定制排序的用法 - Collections.sort(arrayList, new Comparator() { - - @Override - public int compare(Integer o1, Integer o2) { - return o2.compareTo(o1); - } - }); - System.out.println("定制排序后："); - System.out.println(arrayList); - } - -} - -``` -### 重写compareTo方法实现按年龄来排序 -```java -package map; - -import java.util.Set; -import java.util.TreeMap; - -public class TreeMap2 { - - public static void main(String[] args) { - // TODO Auto-generated method stub - TreeMap pdata = new TreeMap(); - pdata.put(new Person("张三", 30), "zhangsan"); - pdata.put(new Person("李四", 20), "lisi"); - pdata.put(new Person("王五", 10), "wangwu"); - pdata.put(new Person("小红", 5), "xiaohong"); - // 得到key的值的同时得到key所对应的值 - Set keys = pdata.keySet(); - for (Person key : keys) { - System.out.println(key.getAge() + "-" + key.getName()); - - } - } -} - -// person对象没有实现Comparable接口，所以必须实现，这样才不会出错，才可以使treemap中的数据按顺序排列 -// 前面一个例子的String类已经默认实现了Comparable接口，详细可以查看String类的API文档，另外其他 -// 像Integer类等都已经实现了Comparable接口，所以不需要另外实现了 - -class Person implements Comparable { - private String name; - private int age; - - public Person(String name, int age) { - super(); - this.name = name; - this.age = age; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public int getAge() { - return age; - } - - public void setAge(int age) { - this.age = age; - } - - /** - * TODO重写compareTo方法实现按年龄来排序 - */ - @Override - public int compareTo(Person o) { - // TODO Auto-generated method stub - if (this.age > o.getAge()) { - return 1; - } else if (this.age < o.getAge()) { - return -1; - } - return age; - } -} -``` - -## 如何对Object的list排序 -- 对objects数组进行排序，我们可以用Arrays.sort()方法 -- 对objects的集合进行排序，需要使用Collections.sort()方法 - - -## 如何实现数组与List的相互转换 -List转数组：toArray(arraylist.size()方法；数组转List:Arrays的asList(a)方法 -```java -List arrayList = new ArrayList(); - arrayList.add("s"); - arrayList.add("e"); - arrayList.add("n"); - /** - * ArrayList转数组 - */ - int size=arrayList.size(); - String[] a = arrayList.toArray(new String[size]); - //输出第二个元素 - System.out.println(a[1]);//结果：e - //输出整个数组 - System.out.println(Arrays.toString(a));//结果：[s, e, n] - /** - * 数组转list - */ - List list=Arrays.asList(a); - /** - * list转Arraylist - */ - List arrayList2 = new ArrayList(); - arrayList2.addAll(list); - System.out.println(list); -``` -## 如何求ArrayList集合的交集 并集 差集 去重复并集 -需要用到List接口中定义的几个方法： - -- addAll(Collection c) :按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾 -实例代码： -- retainAll(Collection c): 仅保留此列表中包含在指定集合中的元素。 -- removeAll(Collection c) :从此列表中删除指定集合中包含的所有元素。 -```java -package list; - -import java.util.ArrayList; -import java.util.List; - -/** - *TODO 两个集合之间求交集 并集 差集 去重复并集 - * @author 寇爽 - * @date 2017年11月21日 - * @version 1.8 - */ -public class MethodDemo { - - public static void main(String[] args) { - // TODO Auto-generated method stub - List list1 = new ArrayList(); - list1.add(1); - list1.add(2); - list1.add(3); - list1.add(4); - - List list2 = new ArrayList(); - list2.add(2); - list2.add(3); - list2.add(4); - list2.add(5); - // 并集 - // list1.addAll(list2); - // 交集 - //list1.retainAll(list2); - // 差集 - // list1.removeAll(list2); - // 无重复并集 - list2.removeAll(list1); - list1.addAll(list2); - for (Integer i : list1) { - System.out.println(i); - } - } - -} - -``` - -## HashMap 的工作原理及代码实现 - -[集合框架源码学习之HashMap(JDK1.8)](https://juejin.im/post/5ab0568b5188255580020e56) - -## ConcurrentHashMap 的工作原理及代码实现 - -[ConcurrentHashMap实现原理及源码分析](http://www.cnblogs.com/chengxiao/p/6842045.html) - - -## 集合框架底层数据结构总结 -### - Collection - -#### 1. List - - Arraylist：数组（查询快,增删慢 线程不安全,效率高 ） - - Vector：数组（查询快,增删慢 线程安全,效率低 ） - - LinkedList：链表（查询慢,增删快 线程不安全,效率高 ） - -#### 2. Set - - HashSet（无序，唯一）:哈希表或者叫散列集(hash table) - - LinkedHashSet：链表和哈希表组成 。 由链表保证元素的排序 ， 由哈希表证元素的唯一性 - - TreeSet（有序，唯一）：红黑树(自平衡的排序二叉树。) - -### - Map - - HashMap：基于哈希表的Map接口实现（哈希表对键进行散列，Map结构即映射表存放键值对） - - LinkedHashMap:HashMap 的基础上加上了链表数据结构 - - HashTable:哈希表 - - TreeMap:红黑树（自平衡的排序二叉树） - - -## 集合的选用 -主要根据集合的特点来选用，比如我们需要根据键值获取到元素值时就选用Map接口下的集合，需要排序时选择TreeMap,不需要排序时就选择HashMap,需要保证线程安全就选用ConcurrentHashMap.当我们只需要存放元素值时，就选择实现Collection接口的集合，需要保证元素唯一时选择实现Set接口的集合比如TreeSet或HashSet，不需要就选择实现List接口的比如ArrayList或LinkedList，然后再根据实现这些接口的集合的特点来选用。 - -2018/3/11更新 -## 集合的常用方法 -今天下午无意看见一道某大厂的面试题，面试题的内容就是问你某一个集合常见的方法有哪些。虽然平时也经常见到这些集合，但是猛一下让我想某一个集合的常用的方法难免会有遗漏或者与其他集合搞混，所以建议大家还是照着API文档把常见的那几个集合的常用方法看一看。 - -会持续更新。。。 - -**参考书籍：** - -《Head first java 》第二版 推荐阅读真心不错 （适合基础较差的） - - 《Java核心技术卷1》推荐阅读真心不错 （适合基础较好的） - - 《算法》第四版 （适合想对数据结构的Java实现感兴趣的） - diff --git a/docs/java/Multithread/AQS.md b/docs/java/Multithread/AQS.md index f405db1f17d..287116d7da2 100644 --- a/docs/java/Multithread/AQS.md +++ b/docs/java/Multithread/AQS.md @@ -1,5 +1,5 @@ -**目录：** +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 - [1 AQS 简单介绍](#1-aqs-简单介绍) @@ -23,10 +23,6 @@ > 常见问题：AQS原理？;CountDownLatch和CyclicBarrier了解吗,两者的区别是什么？用过Semaphore吗？ -**本节思维导图：** - -![并发编程面试必备：AQS 原理以及 AQS 同步组件总结](http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-10-31/61115865.jpg) - ### 1 AQS 简单介绍 AQS的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包下面。 @@ -37,7 +33,7 @@ AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效 ### 2 AQS 原理 -> 在面试中被问到并发知识的时候，大多都会被问到“请你说一下自己对于AQS原理的理解”。下面给大家一个示例供大家参加，面试不是背题，大家一定要加入自己的思想，即使加入不了自己的思想也要保证自己能够通俗的讲出来而不是背出来。 +> 在面试中被问到并发知识的时候，大多都会被问到“请你说一下自己对于AQS原理的理解”。下面给大家一个示例供大家参考，面试不是背题，大家一定要加入自己的思想，即使加入不了自己的思想也要保证自己能够通俗的讲出来而不是背出来。 下面大部分内容其实在AQS类注释上已经给出了，不过是英语看着比较吃力一点，感兴趣的话可以看看源码。 @@ -128,7 +124,7 @@ tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true ### 3 Semaphore(信号量)-允许多个线程同时访问 -**synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。**示例代码如下： +**synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。** 示例代码如下： ```java /** @@ -471,6 +467,12 @@ CyclicBarrier和CountDownLatch的区别这部分内容参考了如下两篇文 ReentrantLock 和 synchronized 的区别在上面已经讲过了这里就不多做讲解。另外，需要注意的是：读写锁 ReentrantReadWriteLock 可以保证多个线程可以同时读，所以在读操作远大于写操作的时候，读写锁就非常有用了。 -由于篇幅问题，关于 ReentrantLock 和 ReentrantReadWriteLock 详细内容可以查看我的这篇原创文章。 +## 公众号 + +如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 + +**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"面试突击"** 即可免费领取！ + +**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 -- [ReentrantLock 和 ReentrantReadWriteLock](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483745&idx=2&sn=6778ee954a19816310df54ef9a3c2f8a&chksm=fd985700caefde16b9970f5e093b0c140d3121fb3a8458b11871e5e9723c5fd1b5a961fd2228&token=1829606453&lang=zh_CN#rd) +![我的公众号](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/167598cd2e17b8ec.png) \ No newline at end of file diff --git a/docs/java/Multithread/Atomic.md b/docs/java/Multithread/Atomic.md index 33dd7ef3d9b..627ea3d41ee 100644 --- a/docs/java/Multithread/Atomic.md +++ b/docs/java/Multithread/Atomic.md @@ -1,8 +1,28 @@ -> 个人觉得这一节掌握基本的使用即可！ +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 -**本节思维导图:** +> 个人觉得这一节掌握基本的使用即可！ -![](https://user-gold-cdn.xitu.io/2018/10/30/166c58b785368234?w=1200&h=657&f=png&s=49615) + + +- [1 Atomic 原子类介绍](#1-atomic-原子类介绍) +- [2 基本类型原子类](#2-基本类型原子类) + - [2.1 基本类型原子类介绍](#21-基本类型原子类介绍) + - [2.2 AtomicInteger 常见方法使用](#22-atomicinteger-常见方法使用) + - [2.3 基本数据类型原子类的优势](#23-基本数据类型原子类的优势) + - [2.4 AtomicInteger 线程安全原理简单分析](#24-atomicinteger-线程安全原理简单分析) +- [3 数组类型原子类](#3-数组类型原子类) + - [3.1 数组类型原子类介绍](#31-数组类型原子类介绍) + - [3.2 AtomicIntegerArray 常见方法使用](#32-atomicintegerarray-常见方法使用) +- [4 引用类型原子类](#4-引用类型原子类) + - [4.1 引用类型原子类介绍](#41--引用类型原子类介绍) + - [4.2 AtomicReference 类使用示例](#42-atomicreference-类使用示例) + - [4.3 AtomicStampedReference 类使用示例](#43-atomicstampedreference-类使用示例) + - [4.4 AtomicMarkableReference 类使用示例](#44-atomicmarkablereference-类使用示例) +- [5 对象的属性修改类型原子类](#5-对象的属性修改类型原子类) + - [5.1 对象的属性修改类型原子类介绍](#51-对象的属性修改类型原子类介绍) + - [5.2 AtomicIntegerFieldUpdater 类使用示例](#52-atomicintegerfieldupdater-类使用示例) + + ### 1 Atomic 原子类介绍 @@ -12,7 +32,7 @@ Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是 并发包 `java.util.concurrent` 的原子类都存放在`java.util.concurrent.atomic`下,如下图所示。 -![ JUC 原子类概览](https://user-gold-cdn.xitu.io/2018/10/30/166c4ac08d4c5547?w=317&h=367&f=png&s=13267) +![JUC原子类概览](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/JUC原子类概览.png) 根据操作的数据类型，可以将JUC包中的原子类分为4类 @@ -36,7 +56,7 @@ Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是 **引用类型** - AtomicReference：引用类型原子类 -- AtomicStampedRerence：原子更新引用类型里的字段原子类 +- AtomicReferenceFieldUpdater：原子更新引用类型里的字段 - AtomicMarkableReference ：原子更新带有标记位的引用类型 **对象的属性修改类型** @@ -44,6 +64,82 @@ Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是 - AtomicIntegerFieldUpdater:原子更新整型字段的更新器 - AtomicLongFieldUpdater：原子更新长整型字段的更新器 - AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。 +- AtomicMarkableReference：原子更新带有标记的引用类型。该类将 boolean 标记与引用关联起来，也可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。 + +**CAS ABA 问题** +- 描述: 第一个线程取到了变量 x 的值 A，然后巴拉巴拉干别的事，总之就是只拿到了变量 x 的值 A。这段时间内第二个线程也取到了变量 x 的值 A，然后把变量 x 的值改为 B，然后巴拉巴拉干别的事，最后又把变量 x 的值变为 A （相当于还原了）。在这之后第一个线程终于进行了变量 x 的操作，但是此时变量 x 的值还是 A，所以 compareAndSet 操作是成功。 +- 例子描述(可能不太合适，但好理解): 年初，现金为零，然后通过正常劳动赚了三百万，之后正常消费了（比如买房子）三百万。年末，虽然现金零收入（可能变成其他形式了），但是赚了钱是事实，还是得交税的！ +- 代码例子（以``` AtomicInteger ```为例） + +```java +import java.util.concurrent.atomic.AtomicInteger; + +public class AtomicIntegerDefectDemo { + public static void main(String[] args) { + defectOfABA(); + } + + static void defectOfABA() { + final AtomicInteger atomicInteger = new AtomicInteger(1); + + Thread coreThread = new Thread( + () -> { + final int currentValue = atomicInteger.get(); + System.out.println(Thread.currentThread().getName() + " ------ currentValue=" + currentValue); + + // 这段目的：模拟处理其他业务花费的时间 + try { + Thread.sleep(300); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + boolean casResult = atomicInteger.compareAndSet(1, 2); + System.out.println(Thread.currentThread().getName() + + " ------ currentValue=" + currentValue + + ", finalValue=" + atomicInteger.get() + + ", compareAndSet Result=" + casResult); + } + ); + coreThread.start(); + + // 这段目的：为了让 coreThread 线程先跑起来 + try { + Thread.sleep(100); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + Thread amateurThread = new Thread( + () -> { + int currentValue = atomicInteger.get(); + boolean casResult = atomicInteger.compareAndSet(1, 2); + System.out.println(Thread.currentThread().getName() + + " ------ currentValue=" + currentValue + + ", finalValue=" + atomicInteger.get() + + ", compareAndSet Result=" + casResult); + + currentValue = atomicInteger.get(); + casResult = atomicInteger.compareAndSet(2, 1); + System.out.println(Thread.currentThread().getName() + + " ------ currentValue=" + currentValue + + ", finalValue=" + atomicInteger.get() + + ", compareAndSet Result=" + casResult); + } + ); + amateurThread.start(); + } +} +``` + +输出内容如下： + +``` +Thread-0 ------ currentValue=1 +Thread-1 ------ currentValue=1, finalValue=2, compareAndSet Result=true +Thread-1 ------ currentValue=2, finalValue=1, compareAndSet Result=true +Thread-0 ------ currentValue=1, finalValue=2, compareAndSet Result=true +``` 下面我们来详细介绍一下这些原子类。 @@ -60,7 +156,7 @@ Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是 上面三个类提供的方法几乎相同，所以我们这里以 AtomicInteger 为例子来介绍。 **AtomicInteger 类常用方法** - + ```java public final int get() //获取当前的值 public final int getAndSet(int newValue)//获取当前的值，并设置新的值 @@ -149,7 +245,7 @@ AtomicInteger 类的部分源码： AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。 -CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址，返回值是 valueOffset。另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。 +CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址。另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。 ### 3 数组类型原子类 @@ -210,7 +306,7 @@ public class AtomicIntegerArrayTest { 基本类型原子类只能更新一个变量，如果需要原子更新多个变量，需要使用 引用类型原子类。 - AtomicReference：引用类型原子类 -- AtomicStampedRerence：原子更新引用类型里的字段原子类 +- AtomicStampedReference：原子更新引用类型里的字段原子类 - AtomicMarkableReference ：原子更新带有标记位的引用类型 上面三个类提供的方法几乎相同，所以我们这里以 AtomicReference 为例子来介绍。 @@ -262,13 +358,127 @@ class Person { } ``` -上述代码首先创建了一个 Person 对象，然后把 Person 对象设置进 AtomicReference 对象中，然后调用 compareAndSet 方法，该方法就是通过通过 CAS 操作设置 ar。如果 ar 的值为 person 的话，则将其设置为 updatePerson。实现原理与 AtomicInteger 类中的 compareAndSet 方法相同。运行上面的代码后的输出结果如下： +上述代码首先创建了一个 Person 对象，然后把 Person 对象设置进 AtomicReference 对象中，然后调用 compareAndSet 方法，该方法就是通过 CAS 操作设置 ar。如果 ar 的值为 person 的话，则将其设置为 updatePerson。实现原理与 AtomicInteger 类中的 compareAndSet 方法相同。运行上面的代码后的输出结果如下： ``` Daisy 20 ``` +#### 4.3 AtomicStampedReference 类使用示例 + +```java +import java.util.concurrent.atomic.AtomicStampedReference; + +public class AtomicStampedReferenceDemo { + public static void main(String[] args) { + // 实例化、取当前值和 stamp 值 + final Integer initialRef = 0, initialStamp = 0; + final AtomicStampedReference asr = new AtomicStampedReference<>(initialRef, initialStamp); + System.out.println("currentValue=" + asr.getReference() + ", currentStamp=" + asr.getStamp()); + + // compare and set + final Integer newReference = 666, newStamp = 999; + final boolean casResult = asr.compareAndSet(initialRef, newReference, initialStamp, newStamp); + System.out.println("currentValue=" + asr.getReference() + + ", currentStamp=" + asr.getStamp() + + ", casResult=" + casResult); + + // 获取当前的值和当前的 stamp 值 + int[] arr = new int[1]; + final Integer currentValue = asr.get(arr); + final int currentStamp = arr[0]; + System.out.println("currentValue=" + currentValue + ", currentStamp=" + currentStamp); + + // 单独设置 stamp 值 + final boolean attemptStampResult = asr.attemptStamp(newReference, 88); + System.out.println("currentValue=" + asr.getReference() + + ", currentStamp=" + asr.getStamp() + + ", attemptStampResult=" + attemptStampResult); + + // 重新设置当前值和 stamp 值 + asr.set(initialRef, initialStamp); + System.out.println("currentValue=" + asr.getReference() + ", currentStamp=" + asr.getStamp()); + + // [不推荐使用，除非搞清楚注释的意思了] weak compare and set + // 困惑！weakCompareAndSet 这个方法最终还是调用 compareAndSet 方法。[版本: jdk-8u191] + // 但是注释上写着 "May fail spuriously and does not provide ordering guarantees, + // so is only rarely an appropriate alternative to compareAndSet." + // todo 感觉有可能是 jvm 通过方法名在 native 方法里面做了转发 + final boolean wCasResult = asr.weakCompareAndSet(initialRef, newReference, initialStamp, newStamp); + System.out.println("currentValue=" + asr.getReference() + + ", currentStamp=" + asr.getStamp() + + ", wCasResult=" + wCasResult); + } +} +``` +输出结果如下： +``` +currentValue=0, currentStamp=0 +currentValue=666, currentStamp=999, casResult=true +currentValue=666, currentStamp=999 +currentValue=666, currentStamp=88, attemptStampResult=true +currentValue=0, currentStamp=0 +currentValue=666, currentStamp=999, wCasResult=true +``` + +#### 4.4 AtomicMarkableReference 类使用示例 + +``` java +import java.util.concurrent.atomic.AtomicMarkableReference; + +public class AtomicMarkableReferenceDemo { + public static void main(String[] args) { + // 实例化、取当前值和 mark 值 + final Boolean initialRef = null, initialMark = false; + final AtomicMarkableReference amr = new AtomicMarkableReference<>(initialRef, initialMark); + System.out.println("currentValue=" + amr.getReference() + ", currentMark=" + amr.isMarked()); + + // compare and set + final Boolean newReference1 = true, newMark1 = true; + final boolean casResult = amr.compareAndSet(initialRef, newReference1, initialMark, newMark1); + System.out.println("currentValue=" + amr.getReference() + + ", currentMark=" + amr.isMarked() + + ", casResult=" + casResult); + + // 获取当前的值和当前的 mark 值 + boolean[] arr = new boolean[1]; + final Boolean currentValue = amr.get(arr); + final boolean currentMark = arr[0]; + System.out.println("currentValue=" + currentValue + ", currentMark=" + currentMark); + + // 单独设置 mark 值 + final boolean attemptMarkResult = amr.attemptMark(newReference1, false); + System.out.println("currentValue=" + amr.getReference() + + ", currentMark=" + amr.isMarked() + + ", attemptMarkResult=" + attemptMarkResult); + + // 重新设置当前值和 mark 值 + amr.set(initialRef, initialMark); + System.out.println("currentValue=" + amr.getReference() + ", currentMark=" + amr.isMarked()); + + // [不推荐使用，除非搞清楚注释的意思了] weak compare and set + // 困惑！weakCompareAndSet 这个方法最终还是调用 compareAndSet 方法。[版本: jdk-8u191] + // 但是注释上写着 "May fail spuriously and does not provide ordering guarantees, + // so is only rarely an appropriate alternative to compareAndSet." + // todo 感觉有可能是 jvm 通过方法名在 native 方法里面做了转发 + final boolean wCasResult = amr.weakCompareAndSet(initialRef, newReference1, initialMark, newMark1); + System.out.println("currentValue=" + amr.getReference() + + ", currentMark=" + amr.isMarked() + + ", wCasResult=" + wCasResult); + } +} +``` + +输出结果如下： +``` +currentValue=null, currentMark=false +currentValue=true, currentMark=true, casResult=true +currentValue=true, currentMark=true +currentValue=true, currentMark=false, attemptMarkResult=true +currentValue=null, currentMark=false +currentValue=true, currentMark=true, wCasResult=true +``` ### 5 对象的属性修改类型原子类 @@ -335,3 +545,12 @@ class User { 23 ``` +## 公众号 + +如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 + +**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"面试突击"** 即可免费领取！ + +**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 + +![我的公众号](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/167598cd2e17b8ec.png) diff --git "a/docs/java/Multithread/BATJ\351\203\275\347\210\261\351\227\256\347\232\204\345\244\232\347\272\277\347\250\213\351\235\242\350\257\225\351\242\230.md" "b/docs/java/Multithread/BATJ\351\203\275\347\210\261\351\227\256\347\232\204\345\244\232\347\272\277\347\250\213\351\235\242\350\257\225\351\242\230.md" deleted file mode 100644 index 10d6177b040..00000000000 --- "a/docs/java/Multithread/BATJ\351\203\275\347\210\261\351\227\256\347\232\204\345\244\232\347\272\277\347\250\213\351\235\242\350\257\225\351\242\230.md" +++ /dev/null @@ -1,429 +0,0 @@ - - - -# 一 面试中关于 synchronized 关键字的 5 连击 - -### 1.1 说一说自己对于 synchronized 关键字的了解 - -synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 - -另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的 synchronized 效率低的原因。庆幸的是在 Java 6 之后 Java 官方对从 JVM 层面对synchronized 较大优化，所以现在的 synchronized 锁效率也优化得很不错了。JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。 - - -### 1.2 说说自己是怎么使用 synchronized 关键字，在项目中用到了吗 - -**synchronized关键字最主要的三种使用方式：** - -- **修饰实例方法，作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁** -- **修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁** 。也就是给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管new了多少个对象，只有一份，所以对该类的所有对象都加了锁）。所以如果一个线程A调用一个实例对象的非静态 synchronized 方法，而线程B需要调用这个实例对象所属类的静态 synchronized 方法，是允许的，不会发生互斥现象，**因为访问静态 synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁**。 -- **修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。** 和 synchronized 方法一样，synchronized(this)代码块也是锁定当前对象的。synchronized 关键字加到 static 静态方法和 synchronized(class)代码块上都是是给 Class 类上锁。这里再提一下：synchronized关键字加到非 static 静态方法上是给对象实例上锁。另外需要注意的是：尽量不要使用 synchronized(String a) 因为JVM中，字符串常量池具有缓冲功能！ - -下面我已一个常见的面试题为例讲解一下 synchronized 关键字的具体使用。 - -面试中面试官经常会说：“单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单例模式的原理呗！” - - - -**双重校验锁实现对象单例（线程安全）** - -```java -public class Singleton { - - private volatile static Singleton uniqueInstance; - - private Singleton() { - } - - public static Singleton getUniqueInstance() { - //先判断对象是否已经实例过，没有实例化过才进入加锁代码 - if (uniqueInstance == null) { - //类对象加锁 - synchronized (Singleton.class) { - if (uniqueInstance == null) { - uniqueInstance = new Singleton(); - } - } - } - return uniqueInstance; - } -} -``` -另外，需要注意 uniqueInstance 采用 volatile 关键字修饰也是很有必要。 - -uniqueInstance 采用 volatile 关键字修饰也是很有必要的， uniqueInstance = new Singleton(); 这段代码其实是分为三步执行： - -1. 为 uniqueInstance 分配内存空间 -2. 初始化 uniqueInstance -3. 将 uniqueInstance 指向分配的内存地址 - -但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出先问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。 - -使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。 - -### 1.3 讲一下 synchronized 关键字的底层原理 - -**synchronized 关键字底层原理属于 JVM 层面。** - -**① synchronized 同步语句块的情况** - -```java -public class SynchronizedDemo { - public void method() { - synchronized (this) { - System.out.println("synchronized 代码块"); - } - } -} - -``` - -通过 JDK 自带的 javap 命令查看 SynchronizedDemo 类的相关字节码信息：首先切换到类的对应目录执行 `javac SynchronizedDemo.java` 命令生成编译后的 .class 文件，然后执行`javap -c -s -v -l SynchronizedDemo.class`。 - -![synchronized 关键字原理](https://user-gold-cdn.xitu.io/2018/10/26/166add616a292bcf?w=917&h=633&f=png&s=21863) - -从上面我们可以看出： - -**synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。** 当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权.当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。 - -**② synchronized 修饰方法的的情况** - -```java -public class SynchronizedDemo2 { - public synchronized void method() { - System.out.println("synchronized 方法"); - } -} - -``` - -![synchronized 关键字原理](https://user-gold-cdn.xitu.io/2018/10/26/166add6169fc206d?w=875&h=421&f=png&s=16114) - -synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的确实是 ACC_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。 - - -### 1.4 说说 JDK1.6 之后的synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗 - -JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。 - -锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。 - -关于这几种优化的详细信息可以查看：[synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及 和ReenTrantLock 的对比](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484539&idx=1&sn=3500cdcd5188bdc253fb19a1bfa805e6&chksm=fd98521acaefdb0c5167247a1fa903a1a53bb4e050b558da574f894f9feda5378ec9d0fa1ac7&token=1604028915&lang=zh_CN#rd) - -### 1.5 谈谈 synchronized和ReenTrantLock 的区别 - - -**① 两者都是可重入锁** - -两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。 - -**② synchronized 依赖于 JVM 而 ReenTrantLock 依赖于 API** - -synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReenTrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。 - -**③ ReenTrantLock 比 synchronized 增加了一些高级功能** - -相比synchronized，ReenTrantLock增加了一些高级功能。主要来说主要有三点：**①等待可中断；②可实现公平锁；③可实现选择性通知（锁可以绑定多个条件）** - -- **ReenTrantLock提供了一种能够中断等待锁的线程的机制**，通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。 -- **ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。** ReenTrantLock默认情况是非公平的，可以通过 ReenTrantLock类的`ReentrantLock(boolean fair)`构造方法来制定是否是公平的。 -- synchronized关键字与wait()和notify/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），**线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。 在使用notify/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用ReentrantLock类结合Condition实例可以实现“选择性通知”** ，这个功能非常重要，而且是Condition接口默认提供的。而synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法 只会唤醒注册在该Condition实例中的所有等待线程。 - -如果你想使用上述功能，那么选择ReenTrantLock是一个不错的选择。 - -**④ 性能已不是选择标准** - -# 二 面试中关于线程池的 4 连击 - -### 2.1 讲一下Java内存模型 - - -在 JDK1.2 之前，Java的内存模型实现总是从**主存**（即共享内存）读取变量，是不需要进行特别的注意的。而在当前的 Java 内存模型下，线程可以把变量保存**本地内存**（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成**数据的不一致**。 - -![数据的不一致](https://user-gold-cdn.xitu.io/2018/10/30/166c46ede4423ba2?w=273&h=166&f=jpeg&s=7268) - -要解决这个问题，就需要把变量声明为 **volatile**，这就指示 JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。 - -说白了， **volatile** 关键字的主要作用就是保证变量的可见性然后还有一个作用是防止指令重排序。 - -![volatile关键字的可见性](https://user-gold-cdn.xitu.io/2018/10/30/166c46ede4b9f501?w=474&h=238&f=jpeg&s=9942) - - -### 2.2 说说 synchronized 关键字和 volatile 关键字的区别 - - synchronized关键字和volatile关键字比较 - -- **volatile关键字**是线程同步的**轻量级实现**，所以**volatile性能肯定比synchronized关键字要好**。但是**volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块**。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，**实际开发中使用 synchronized 关键字的场景还是更多一些**。 -- **多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞** -- **volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。** -- **volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。** - - -# 三 面试中关于 线程池的 2 连击 - - -### 3.1 为什么要用线程池？ - -线程池提供了一种限制和管理资源（包括执行一个任务）。 每个线程池还维护一些基本统计信息，例如已完成任务的数量。 - -这里借用《Java并发编程的艺术》提到的来说一下使用线程池的好处： - -- **降低资源消耗。** 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 -- **提高响应速度。** 当任务到达时，任务可以不需要的等到线程创建就能立即执行。 -- **提高线程的可管理性。** 线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 - - -### 3.2 实现Runnable接口和Callable接口的区别 - -如果想让线程池执行任务的话需要实现的Runnable接口或Callable接口。 Runnable接口或Callable接口实现类都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。两者的区别在于 Runnable 接口不会返回结果但是 Callable 接口可以返回结果。 - - **备注：** 工具类`Executors`可以实现`Runnable`对象和`Callable`对象之间的相互转换。（`Executors.callable（Runnable task）`或`Executors.callable（Runnable task，Object resule）`）。 - -### 3.3 执行execute()方法和submit()方法的区别是什么呢？ - - 1)**`execute()` 方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；** - - 2)**submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功**，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用 `get（long timeout，TimeUnit unit）`方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。 - - -### 3.4 如何创建线程池 - -《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险 - -> Executors 返回线程池对象的弊端如下： -> -> - **FixedThreadPool 和 SingleThreadExecutor** ： 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致OOM。 -> - **CachedThreadPool 和 ScheduledThreadPool** ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致OOM。 - -**方式一：通过构造方法实现** -![通过构造方法实现](https://user-gold-cdn.xitu.io/2018/10/30/166c4a5baac923e9?w=925&h=158&f=jpeg&s=29190) -**方式二：通过Executor 框架的工具类Executors来实现** -我们可以创建三种类型的ThreadPoolExecutor： - -- **FixedThreadPool** ： 该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。 -- **SingleThreadExecutor：** 方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。 -- **CachedThreadPool：** 该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。 - -对应Executors工具类中的方法如图所示： -![通过Executor 框架的工具类Executors来实现](https://user-gold-cdn.xitu.io/2018/10/30/166c4a5baa9ca5e9?w=645&h=222&f=jpeg&s=31710) - - -# 四 面试中关于 Atomic 原子类的 4 连击 - -### 4.1 介绍一下Atomic 原子类 - -Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 Atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。 - -所以，所谓原子类说简单点就是具有原子/原子操作特征的类。 - - -并发包 `java.util.concurrent` 的原子类都存放在`java.util.concurrent.atomic`下,如下图所示。 - -![ JUC 原子类概览](https://user-gold-cdn.xitu.io/2018/10/30/166c4ac08d4c5547?w=317&h=367&f=png&s=13267) - -### 4.2 JUC 包中的原子类是哪4类? - -**基本类型** - -使用原子的方式更新基本类型 - -- AtomicInteger：整形原子类 -- AtomicLong：长整型原子类 -- AtomicBoolean ：布尔型原子类 - -**数组类型** - -使用原子的方式更新数组里的某个元素 - - -- AtomicIntegerArray：整形数组原子类 -- AtomicLongArray：长整形数组原子类 -- AtomicReferenceArray ：引用类型数组原子类 - -**引用类型** - -- AtomicReference：引用类型原子类 -- AtomicStampedRerence：原子更新引用类型里的字段原子类 -- AtomicMarkableReference ：原子更新带有标记位的引用类型 - -**对象的属性修改类型** - -- AtomicIntegerFieldUpdater:原子更新整形字段的更新器 -- AtomicLongFieldUpdater：原子更新长整形字段的更新器 -- AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。 - - -### 4.3 讲讲 AtomicInteger 的使用 - - **AtomicInteger 类常用方法** - -```java -public final int get() //获取当前的值 -public final int getAndSet(int newValue)//获取当前的值，并设置新的值 -public final int getAndIncrement()//获取当前的值，并自增 -public final int getAndDecrement() //获取当前的值，并自减 -public final int getAndAdd(int delta) //获取当前的值，并加上预期的值 -boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update） -public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。 -``` - - **AtomicInteger 类的使用示例** - -使用 AtomicInteger 之后，不用对 increment() 方法加锁也可以保证线程安全。 -```java -class AtomicIntegerTest { - private AtomicInteger count = new AtomicInteger(); - //使用AtomicInteger之后，不需要对该方法加锁，也可以实现线程安全。 - public void increment() { - count.incrementAndGet(); - } - - public int getCount() { - return count.get(); - } -} - -``` - -### 4.4 能不能给我简单介绍一下 AtomicInteger 类的原理 - -AtomicInteger 线程安全原理简单分析 - -AtomicInteger 类的部分源码： - -```java - // setup to use Unsafe.compareAndSwapInt for updates（更新操作时提供“比较并替换”的作用） - private static final Unsafe unsafe = Unsafe.getUnsafe(); - private static final long valueOffset; - - static { - try { - valueOffset = unsafe.objectFieldOffset - (AtomicInteger.class.getDeclaredField("value")); - } catch (Exception ex) { throw new Error(ex); } - } - - private volatile int value; -``` - -AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。 - -CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址，返回值是 valueOffset。另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。 - -关于 Atomic 原子类这部分更多内容可以查看我的这篇文章：并发编程面试必备：[JUC 中的 Atomic 原子类总结](https://mp.weixin.qq.com/s/joa-yOiTrYF67bElj8xqvg) - -# 五 AQS - -### 5.1 AQS 介绍 - -AQS的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包下面。 - -![enter image description here](https://user-gold-cdn.xitu.io/2018/10/30/166c4bb575d4a690?w=317&h=338&f=png&s=14122) - -AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基于AQS的。当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器。 - -### 5.2 AQS 原理分析 - -AQS 原理这部分参考了部分博客，在5.2节末尾放了链接。 - -> 在面试中被问到并发知识的时候，大多都会被问到“请你说一下自己对于AQS原理的理解”。下面给大家一个示例供大家参加，面试不是背题，大家一定要假如自己的思想，即使加入不了自己的思想也要保证自己能够通俗的讲出来而不是背出来。 - -下面大部分内容其实在AQS类注释上已经给出了，不过是英语看着比较吃力一点，感兴趣的话可以看看源码。 - -#### 5.2.1 AQS 原理概览 - - - -**AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。** - -> CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS是将每条请求共享资源的线程封装成一个CLH锁队列的一个结点（Node）来实现锁的分配。 - -看个AQS(AbstractQueuedSynchronizer)原理图： - - -![enter image description here](https://user-gold-cdn.xitu.io/2018/10/30/166c4bbe4a9c5ae7?w=852&h=401&f=png&s=21797) - -AQS使用一个int成员变量来表示同步状态，通过内置的FIFO队列来完成获取资源线程的排队工作。AQS使用CAS对该同步状态进行原子操作实现对其值的修改。 - -```java -private volatile int state;//共享变量，使用volatile修饰保证线程可见性 -``` - -状态信息通过procted类型的getState，setState，compareAndSetState进行操作 - -```java - -//返回同步状态的当前值 -protected final int getState() { - return state; -} - // 设置同步状态的值 -protected final void setState(int newState) { - state = newState; -} -//原子地（CAS操作）将同步状态值设置为给定值update如果当前同步状态的值等于expect（期望值） -protected final boolean compareAndSetState(int expect, int update) { - return unsafe.compareAndSwapInt(this, stateOffset, expect, update); -} -``` - -#### 5.2.2 AQS 对资源的共享方式 - -**AQS定义两种资源共享方式** - -- **Exclusive**（独占）：只有一个线程能执行，如ReentrantLock。又可分为公平锁和非公平锁： - - 公平锁：按照线程在队列中的排队顺序，先到者先拿到锁 - - 非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的 -- **Share**（共享）：多个线程可同时执行，如Semaphore/CountDownLatch。Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。 - -ReentrantReadWriteLock 可以看成是组合式，因为ReentrantReadWriteLock也就是读写锁允许多个线程同时对某一资源进行读。 - -不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。 - -#### 5.2.3 AQS底层使用了模板方法模式 - -同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）： - -1. 使用者继承AbstractQueuedSynchronizer并重写指定的方法。（这些重写方法很简单，无非是对于共享资源state的获取和释放） -2. 将AQS组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。 - -这和我们以往通过实现接口的方式有很大区别，这是模板方法模式很经典的一个运用。 - -**AQS使用了模板方法模式，自定义同步器时需要重写下面几个AQS提供的模板方法：** - -```java -isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。 -tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。 -tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。 -tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。 -tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。 - -``` - -默认情况下，每个方法都抛出 `UnsupportedOperationException`。 这些方法的实现必须是内部线程安全的，并且通常应该简短而不是阻塞。AQS类中的其他方法都是final ，所以无法被其他类使用，只有这几个方法可以被其他类使用。 - -以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。 - -再以CountDownLatch以例，任务分为N个子线程去执行，state也初始化为N（注意N要与线程个数一致）。这N个子线程是并行执行的，每个子线程执行完后countDown()一次，state会CAS(Compare and Swap)减1。等到所有子线程都执行完后(即state=0)，会unpark()主调用线程，然后主调用线程就会从await()函数返回，继续后余动作。 - -一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现`tryAcquire-tryRelease`、`tryAcquireShared-tryReleaseShared`中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如`ReentrantReadWriteLock`。 - -推荐两篇 AQS 原理和相关源码分析的文章： - -- http://www.cnblogs.com/waterystone/p/4920797.html -- https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html - -### 5.3 AQS 组件总结 - -- **Semaphore(信号量)-允许多个线程同时访问：** synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。 -- **CountDownLatch （倒计时器）：** CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。 -- **CyclicBarrier(循环栅栏)：** CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。 - -关于AQS这部分的更多内容可以查看我的这篇文章:[并发编程面试必备：AQS 原理以及 AQS 同步组件总结](https://mp.weixin.qq.com/s/joa-yOiTrYF67bElj8xqvg) - -# Reference - -- 《深入理解 Java 虚拟机》 -- 《实战 Java 高并发程序设计》 -- 《Java并发编程的艺术》 -- http://www.cnblogs.com/waterystone/p/4920797.html -- https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html diff --git "a/docs/java/Multithread/ConcurrentProgramming1-\345\271\266\345\217\221\347\274\226\347\250\213\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/docs/java/Multithread/ConcurrentProgramming1-\345\271\266\345\217\221\347\274\226\347\250\213\345\237\272\347\241\200\347\237\245\350\257\206.md" deleted file mode 100644 index 0ae72071e0b..00000000000 --- "a/docs/java/Multithread/ConcurrentProgramming1-\345\271\266\345\217\221\347\274\226\347\250\213\345\237\272\347\241\200\347\237\245\350\257\206.md" +++ /dev/null @@ -1,269 +0,0 @@ -# Java 并发基础知识 - -Java 并发的基础知识，可能会在笔试中遇到，技术面试中也可能以并发知识环节提问的第一个问题出现。比如面试官可能会问你：“谈谈自己对于进程和线程的理解，两者的区别是什么？” - -**本节思维导图：** - -![Java 并发基础知识](http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-10-26/51390272.jpg) - -## 一 进程和线程 - -进程和线程的对比这一知识点由于过于基础，所以在面试中很少碰到，但是极有可能会在笔试题中碰到。 - -常见的提问形式是这样的：**“什么是线程和进程?，请简要描述线程与进程的关系、区别及优缺点？ ”**。 - -### 1.1. 何为进程? - -进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。 - -在Java中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。 - -如下图所示，在 windows 中通过查看任务管理器的方式，我们就可以清楚看到 window 当前运行的进程（.exe文件的运行）。 - -![进程](https://images.gitbook.cn/a0929b60-d133-11e8-88a4-5328c5b70145) - -### 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) - -![](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/JVM运行时数据区域.png) - -从上图可以看出：一个进程中可以有多个线程，多个线程共享进程的**堆**和**方法区**资源，但是每个线程有自己的**程序计数器**、**虚拟机栈** 和 **本地方法栈**。 - -下面来思考这样一个问题：为什么**程序计数器**、**虚拟机栈**和**本地方法栈**是线程私有的呢？为什么堆和方法区是线程共享的呢？ - -#### 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("运行结束"); - } - -} - -``` -运行结果： -![结果](https://user-gold-cdn.xitu.io/2018/3/20/16243e80f22a2d54?w=161&h=54&f=jpeg&s=7380) - -从上面的运行结果可以看出：线程是一个子任务，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("运行结束！"); - } - -} -``` -运行结果： -![运行结果](https://user-gold-cdn.xitu.io/2018/3/20/16243f4373c6141a?w=137&h=46&f=jpeg&s=7316) - -### 3.3 使用线程池的方式 - -使用线程池的方式也是最推荐的一种方式，另外，《阿里巴巴Java开发手册》在第一章第六节并发处理这一部分也强调到“线程资源必须通过线程池提供，不允许在应用中自行显示创建线程”。这里就不给大家演示代码了，线程池这一节会详细介绍到这部分内容。 - -## 四 线程的生命周期和状态 - -Java 线程在运行的生命周期中的指定时刻只可能处于下面6种不同状态的其中一个状态（图源《Java 并发编程艺术》4.1.4节）。 - -![Java线程的状态](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/19-1-29/Java%E7%BA%BF%E7%A8%8B%E7%9A%84%E7%8A%B6%E6%80%81.png) - -线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示（图源《Java 并发编程艺术》4.1.4节）： - -![Java线程状态变迁](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/19-1-29/Java%20%E7%BA%BF%E7%A8%8B%E7%8A%B6%E6%80%81%E5%8F%98%E8%BF%81.png) - - - -由上图可以看出： - -线程创建之后它将处于 **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（运行中）** 状态 。 - -![RUNNABLE-VS-RUNNING](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/RUNNABLE-VS-RUNNING.png) - -当线程执行 `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/ \ No newline at end of file diff --git a/docs/java/Multithread/JavaConcurrencyAdvancedCommonInterviewQuestions.md b/docs/java/Multithread/JavaConcurrencyAdvancedCommonInterviewQuestions.md new file mode 100644 index 00000000000..2fba760bb06 --- /dev/null +++ b/docs/java/Multithread/JavaConcurrencyAdvancedCommonInterviewQuestions.md @@ -0,0 +1,740 @@ +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 + + + +- [Java 并发进阶常见面试题总结](#java-并发进阶常见面试题总结) + - [1. synchronized 关键字](#1-synchronized-关键字) + - [1.1. 说一说自己对于 synchronized 关键字的了解](#11-说一说自己对于-synchronized-关键字的了解) + - [1.2. 说说自己是怎么使用 synchronized 关键字，在项目中用到了吗](#12-说说自己是怎么使用-synchronized-关键字在项目中用到了吗) + - [1.3. 讲一下 synchronized 关键字的底层原理](#13-讲一下-synchronized-关键字的底层原理) + - [1.4. 说说 JDK1.6 之后的synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗](#14-说说-jdk16-之后的synchronized-关键字底层做了哪些优化可以详细介绍一下这些优化吗) + - [1.5. 谈谈 synchronized和ReentrantLock 的区别](#15-谈谈-synchronized和reentrantlock-的区别) + - [2. volatile关键字](#2-volatile关键字) + - [2.1. 讲一下Java内存模型](#21-讲一下java内存模型) + - [2.2. 说说 synchronized 关键字和 volatile 关键字的区别](#22-说说-synchronized-关键字和-volatile-关键字的区别) + - [3. ThreadLocal](#3-threadlocal) + - [3.1. ThreadLocal简介](#31-threadlocal简介) + - [3.2. ThreadLocal示例](#32-threadlocal示例) + - [3.3. ThreadLocal原理](#33-threadlocal原理) + - [3.4. ThreadLocal 内存泄露问题](#34-threadlocal-内存泄露问题) + - [4. 线程池](#4-线程池) + - [4.1. 为什么要用线程池？](#41-为什么要用线程池) + - [4.2. 实现Runnable接口和Callable接口的区别](#42-实现runnable接口和callable接口的区别) + - [4.3. 执行execute()方法和submit()方法的区别是什么呢？](#43-执行execute方法和submit方法的区别是什么呢) + - [4.4. 如何创建线程池](#44-如何创建线程池) + - [5. Atomic 原子类](#5-atomic-原子类) + - [5.1. 介绍一下Atomic 原子类](#51-介绍一下atomic-原子类) + - [5.2. JUC 包中的原子类是哪4类?](#52-juc-包中的原子类是哪4类) + - [5.3. 讲讲 AtomicInteger 的使用](#53-讲讲-atomicinteger-的使用) + - [5.4. 能不能给我简单介绍一下 AtomicInteger 类的原理](#54-能不能给我简单介绍一下-atomicinteger-类的原理) + - [6. AQS](#6-aqs) + - [6.1. AQS 介绍](#61-aqs-介绍) + - [6.2. AQS 原理分析](#62-aqs-原理分析) + - [6.2.1. AQS 原理概览](#621-aqs-原理概览) + - [6.2.2. AQS 对资源的共享方式](#622-aqs-对资源的共享方式) + - [6.2.3. AQS底层使用了模板方法模式](#623-aqs底层使用了模板方法模式) + - [6.3. AQS 组件总结](#63-aqs-组件总结) + - [7 Reference](#7-reference) + + + +# Java 并发进阶常见面试题总结 + +## 1. synchronized 关键字 + +### 1.1. 说一说自己对于 synchronized 关键字的了解 + +synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 + +另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的 synchronized 效率低的原因。庆幸的是在 Java 6 之后 Java 官方对从 JVM 层面对synchronized 较大优化，所以现在的 synchronized 锁效率也优化得很不错了。JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。 + + +### 1.2. 说说自己是怎么使用 synchronized 关键字，在项目中用到了吗 + +**synchronized关键字最主要的三种使用方式：** + +- **修饰实例方法:** 作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁 +- **修饰静态方法:** 也就是给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管new了多少个对象，只有一份）。所以如果一个线程A调用一个实例对象的非静态 synchronized 方法，而线程B需要调用这个实例对象所属类的静态 synchronized 方法，是允许的，不会发生互斥现象，**因为访问静态 synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁**。 +- **修饰代码块:** 指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。 + +**总结：** synchronized 关键字加到 static 静态方法和 synchronized(class)代码块上都是是给 Class 类上锁。synchronized 关键字加到实例方法上是给对象实例上锁。尽量不要使用 synchronized(String a) 因为JVM中，字符串常量池具有缓存功能！ + +下面我以一个常见的面试题为例讲解一下 synchronized 关键字的具体使用。 + +面试中面试官经常会说：“单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单例模式的原理呗！” + +**双重校验锁实现对象单例（线程安全）** + +```java +public class Singleton { + + private volatile static Singleton uniqueInstance; + + private Singleton() { + } + + public static Singleton getUniqueInstance() { + //先判断对象是否已经实例过，没有实例化过才进入加锁代码 + if (uniqueInstance == null) { + //类对象加锁 + synchronized (Singleton.class) { + if (uniqueInstance == null) { + uniqueInstance = new Singleton(); + } + } + } + return uniqueInstance; + } +} +``` +另外，需要注意 uniqueInstance 采用 volatile 关键字修饰也是很有必要。 + +uniqueInstance 采用 volatile 关键字修饰也是很有必要的， uniqueInstance = new Singleton(); 这段代码其实是分为三步执行： + +1. 为 uniqueInstance 分配内存空间 +2. 初始化 uniqueInstance +3. 将 uniqueInstance 指向分配的内存地址 + +但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。 + +使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。 + +### 1.3. 讲一下 synchronized 关键字的底层原理 + +**synchronized 关键字底层原理属于 JVM 层面。** + +**① synchronized 同步语句块的情况** + +```java +public class SynchronizedDemo { + public void method() { + synchronized (this) { + System.out.println("synchronized 代码块"); + } + } +} + +``` + +通过 JDK 自带的 javap 命令查看 SynchronizedDemo 类的相关字节码信息：首先切换到类的对应目录执行 `javac SynchronizedDemo.java` 命令生成编译后的 .class 文件，然后执行`javap -c -s -v -l SynchronizedDemo.class`。 + +![synchronized关键字原理](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/synchronized关键字原理.png) + +从上面我们可以看出： + +**synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。** 当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权。当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。 + +**② synchronized 修饰方法的的情况** + +```java +public class SynchronizedDemo2 { + public synchronized void method() { + System.out.println("synchronized 方法"); + } +} + +``` + +![synchronized关键字原理](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/synchronized关键字原理2.png) + +synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的确实是 ACC_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。 + + +### 1.4. 说说 JDK1.6 之后的synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗 + +JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。 + +锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。 + +关于这几种优化的详细信息可以查看笔主的这篇文章： + +### 1.5. 谈谈 synchronized和ReentrantLock 的区别 + + +**① 两者都是可重入锁** + +两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。 + +**② synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API** + +synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。 + +**③ ReentrantLock 比 synchronized 增加了一些高级功能** + +相比synchronized，ReentrantLock增加了一些高级功能。主要来说主要有三点：**①等待可中断；②可实现公平锁；③可实现选择性通知（锁可以绑定多个条件）** + +- **ReentrantLock提供了一种能够中断等待锁的线程的机制**，通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。 +- **ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。** ReentrantLock默认情况是非公平的，可以通过 ReentrantLock类的`ReentrantLock(boolean fair)`构造方法来制定是否是公平的。 +- synchronized关键字与wait()和notify()/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），**线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。 在使用notify()/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用ReentrantLock类结合Condition实例可以实现“选择性通知”** ，这个功能非常重要，而且是Condition接口默认提供的。而synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法 只会唤醒注册在该Condition实例中的所有等待线程。 + +如果你想使用上述功能，那么选择ReentrantLock是一个不错的选择。 + +**④ 性能已不是选择标准** + +## 2. volatile关键字 + +### 2.1. 讲一下Java内存模型 + + +在 JDK1.2 之前，Java的内存模型实现总是从**主存**（即共享内存）读取变量，是不需要进行特别的注意的。而在当前的 Java 内存模型下，线程可以把变量保存**本地内存**（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成**数据的不一致**。 + +![数据不一致](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/数据不一致.png) + +要解决这个问题，就需要把变量声明为**volatile**，这就指示 JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。 + +说白了， **volatile** 关键字的主要作用就是保证变量的可见性然后还有一个作用是防止指令重排序。 + +![volatile关键字的可见性](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/volatile关键字的可见性.png) + + +### 2.2. 说说 synchronized 关键字和 volatile 关键字的区别 + + synchronized关键字和volatile关键字比较 + +- **volatile关键字**是线程同步的**轻量级实现**，所以**volatile性能肯定比synchronized关键字要好**。但是**volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块**。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，**实际开发中使用 synchronized 关键字的场景还是更多一些**。 +- **多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞** +- **volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。** +- **volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。** + +## 3. ThreadLocal + +### 3.1. ThreadLocal简介 + +通常情况下，我们创建的变量是可以被任何一个线程访问并修改的。**如果想实现每一个线程都有自己的专属本地变量该如何解决呢？** JDK中提供的`ThreadLocal`类正是为了解决这样的问题。 **`ThreadLocal`类主要解决的就是让每个线程绑定自己的值，可以将`ThreadLocal`类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。** + +**如果你创建了一个`ThreadLocal`变量，那么访问这个变量的每个线程都会有这个变量的本地副本，这也是`ThreadLocal`变量名的由来。他们可以使用 `get（）` 和 `set（）` 方法来获取默认值或将其值更改为当前线程所存的副本的值，从而避免了线程安全问题。** + +再举个简单的例子： + +比如有两个人去宝屋收集宝物，这两个共用一个袋子的话肯定会产生争执，但是给他们两个人每个人分配一个袋子的话就不会出现这样的问题。如果把这两个人比作线程的话，那么ThreadLocal就是用来避免这两个线程竞争的。 + +### 3.2. ThreadLocal示例 + +相信看了上面的解释，大家已经搞懂 ThreadLocal 类是个什么东西了。 + +```java +import java.text.SimpleDateFormat; +import java.util.Random; + +public class ThreadLocalExample implements Runnable{ + + // SimpleDateFormat 不是线程安全的，所以每个线程都要有自己独立的副本 + private static final ThreadLocal formatter = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMdd HHmm")); + + public static void main(String[] args) throws InterruptedException { + ThreadLocalExample obj = new ThreadLocalExample(); + for(int i=0 ; i<10; i++){ + Thread t = new Thread(obj, ""+i); + Thread.sleep(new Random().nextInt(1000)); + t.start(); + } + } + + @Override + public void run() { + System.out.println("Thread Name= "+Thread.currentThread().getName()+" default Formatter = "+formatter.get().toPattern()); + try { + Thread.sleep(new Random().nextInt(1000)); + } catch (InterruptedException e) { + e.printStackTrace(); + } + //formatter pattern is changed here by thread, but it won't reflect to other threads + formatter.set(new SimpleDateFormat()); + + System.out.println("Thread Name= "+Thread.currentThread().getName()+" formatter = "+formatter.get().toPattern()); + } + +} + +``` + +Output: + +``` +Thread Name= 0 default Formatter = yyyyMMdd HHmm +Thread Name= 0 formatter = yy-M-d ah:mm +Thread Name= 1 default Formatter = yyyyMMdd HHmm +Thread Name= 2 default Formatter = yyyyMMdd HHmm +Thread Name= 1 formatter = yy-M-d ah:mm +Thread Name= 3 default Formatter = yyyyMMdd HHmm +Thread Name= 2 formatter = yy-M-d ah:mm +Thread Name= 4 default Formatter = yyyyMMdd HHmm +Thread Name= 3 formatter = yy-M-d ah:mm +Thread Name= 4 formatter = yy-M-d ah:mm +Thread Name= 5 default Formatter = yyyyMMdd HHmm +Thread Name= 5 formatter = yy-M-d ah:mm +Thread Name= 6 default Formatter = yyyyMMdd HHmm +Thread Name= 6 formatter = yy-M-d ah:mm +Thread Name= 7 default Formatter = yyyyMMdd HHmm +Thread Name= 7 formatter = yy-M-d ah:mm +Thread Name= 8 default Formatter = yyyyMMdd HHmm +Thread Name= 9 default Formatter = yyyyMMdd HHmm +Thread Name= 8 formatter = yy-M-d ah:mm +Thread Name= 9 formatter = yy-M-d ah:mm +``` + +从输出中可以看出，Thread-0已经改变了formatter的值，但仍然是thread-2默认格式化程序与初始化值相同，其他线程也一样。 + +上面有一段代码用到了创建 `ThreadLocal` 变量的那段代码用到了 Java8 的知识，它等于下面这段代码，如果你写了下面这段代码的话，IDEA会提示你转换为Java8的格式(IDEA真的不错！)。因为ThreadLocal类在Java 8中扩展，使用一个新的方法`withInitial()`，将Supplier功能接口作为参数。 + +```java + private static final ThreadLocal formatter = new ThreadLocal(){ + @Override + protected SimpleDateFormat initialValue() + { + return new SimpleDateFormat("yyyyMMdd HHmm"); + } + }; +``` + +### 3.3. ThreadLocal原理 + +从 `Thread`类源代码入手。 + +```java +public class Thread implements Runnable { + ...... +//与此线程有关的ThreadLocal值。由ThreadLocal类维护 +ThreadLocal.ThreadLocalMap threadLocals = null; + +//与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护 +ThreadLocal.ThreadLocalMap inheritableThreadLocals = null; + ...... +} +``` + +从上面`Thread`类 源代码可以看出`Thread` 类中有一个 `threadLocals` 和 一个 `inheritableThreadLocals` 变量，它们都是 `ThreadLocalMap` 类型的变量,我们可以把 `ThreadLocalMap` 理解为`ThreadLocal` 类实现的定制化的 `HashMap`。默认情况下这两个变量都是null，只有当前线程调用 `ThreadLocal` 类的 `set`或`get`方法时才创建它们，实际上调用这两个方法的时候，我们调用的是`ThreadLocalMap`类对应的 `get()`、`set() `方法。 + +`ThreadLocal`类的`set()`方法 + +```java + public void set(T value) { + Thread t = Thread.currentThread(); + ThreadLocalMap map = getMap(t); + if (map != null) + map.set(this, value); + else + createMap(t, value); + } + ThreadLocalMap getMap(Thread t) { + return t.threadLocals; + } +``` + +通过上面这些内容，我们足以通过猜测得出结论：**最终的变量是放在了当前线程的 `ThreadLocalMap` 中，并不是存在 `ThreadLocal` 上，`ThreadLocal` 可以理解为只是`ThreadLocalMap`的封装，传递了变量值。** `ThrealLocal` 类中可以通过`Thread.currentThread()`获取到当前线程对象后，直接通过`getMap(Thread t)`可以访问到该线程的`ThreadLocalMap`对象。 + +**每个`Thread`中都具备一个`ThreadLocalMap`，而`ThreadLocalMap`可以存储以`ThreadLocal`为key的键值对。** 比如我们在同一个线程中声明了两个 `ThreadLocal` 对象的话，会使用 `Thread`内部都是使用仅有那个`ThreadLocalMap` 存放数据的，`ThreadLocalMap`的 key 就是 `ThreadLocal`对象，value 就是 `ThreadLocal` 对象调用`set`方法设置的值。`ThreadLocal` 是 map结构是为了让每个线程可以关联多个 `ThreadLocal`变量。这也就解释了 ThreadLocal 声明的变量为什么在每一个线程都有自己的专属本地变量。 + +`ThreadLocalMap`是`ThreadLocal`的静态内部类。 + +![ThreadLocal内部类](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/ThreadLocal内部类.png) + +### 3.4. ThreadLocal 内存泄露问题 + +`ThreadLocalMap` 中使用的 key 为 `ThreadLocal` 的弱引用,而 value 是强引用。所以，如果 `ThreadLocal` 没有被外部强引用的情况下，在垃圾回收的时候，key 会被清理掉，而 value 不会被清理掉。这样一来，`ThreadLocalMap` 中就会出现key为null的Entry。假如我们不做任何措施的话，value 永远无法被GC 回收，这个时候就可能会产生内存泄露。ThreadLocalMap实现中已经考虑了这种情况，在调用 `set()`、`get()`、`remove()` 方法的时候，会清理掉 key 为 null 的记录。使用完 `ThreadLocal`方法后 最好手动调用`remove()`方法 + +```java + static class Entry extends WeakReference> { + /** The value associated with this ThreadLocal. */ + Object value; + + Entry(ThreadLocal k, Object v) { + super(k); + value = v; + } + } +``` + +**弱引用介绍：** + +> 如果一个对象只具有弱引用，那就类似于**可有可无的生活用品**。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。 +> +> 弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。 + +## 4. 线程池 + +### 4.1. 为什么要用线程池？ + +> **池化技术相比大家已经屡见不鲜了，线程池、数据库连接池、Http 连接池等等都是对这个思想的应用。池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。** + +**线程池**提供了一种限制和管理资源（包括执行一个任务）。 每个**线程池**还维护一些基本统计信息，例如已完成任务的数量。 + +这里借用《Java 并发编程的艺术》提到的来说一下**使用线程池的好处**： + +- **降低资源消耗**。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 +- **提高响应速度**。当任务到达时，任务可以不需要的等到线程创建就能立即执行。 +- **提高线程的可管理性**。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 + +### 4.2. 实现Runnable接口和Callable接口的区别 + +`Runnable`自Java 1.0以来一直存在，但`Callable`仅在Java 1.5中引入,目的就是为了来处理`Runnable`不支持的用例。**`Runnable` 接口**不会返回结果或抛出检查异常，但是**`Callable` 接口**可以。所以，如果任务不需要返回结果或抛出异常推荐使用 **`Runnable` 接口**，这样代码看起来会更加简洁。 + +工具类 `Executors` 可以实现 `Runnable` 对象和 `Callable` 对象之间的相互转换。（`Executors.callable（Runnable task`）或 `Executors.callable（Runnable task，Object resule）`）。 + +`Runnable.java` + +```java +@FunctionalInterface +public interface Runnable { + /** + * 被线程执行，没有返回值也无法抛出异常 + */ + public abstract void run(); +} +``` + +`Callable.java` + +```java +@FunctionalInterface +public interface Callable { + /** + * 计算结果，或在无法这样做时抛出异常。 + * @return 计算得出的结果 + * @throws 如果无法计算结果，则抛出异常 + */ + V call() throws Exception; +} +``` + +### 4.3. 执行execute()方法和submit()方法的区别是什么呢？ + +1. **`execute()`方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；** +2. **`submit()`方法用于提交需要返回值的任务。线程池会返回一个 `Future` 类型的对象，通过这个 `Future` 对象可以判断任务是否执行成功**，并且可以通过 `Future` 的 `get()`方法来获取返回值，`get()`方法会阻塞当前线程直到任务完成，而使用 `get（long timeout，TimeUnit unit）`方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。 + +我们以**`AbstractExecutorService`**接口中的一个 `submit` 方法为例子来看看源代码： + +```java + public Future submit(Runnable task) { + if (task == null) throw new NullPointerException(); + RunnableFuture ftask = newTaskFor(task, null); + execute(ftask); + return ftask; + } +``` + +上面方法调用的 `newTaskFor` 方法返回了一个 `FutureTask` 对象。 + +```java + protected RunnableFuture newTaskFor(Runnable runnable, T value) { + return new FutureTask(runnable, value); + } +``` + +我们再来看看`execute()`方法： + +```java + public void execute(Runnable command) { + ... + } +``` + +### 4.4. 如何创建线程池 + +《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险 + +> Executors 返回线程池对象的弊端如下： +> +> - **FixedThreadPool 和 SingleThreadExecutor** ： 允许请求的队列长度为 Integer.MAX_VALUE ，可能堆积大量的请求，从而导致OOM。 +> - **CachedThreadPool 和 ScheduledThreadPool** ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致OOM。 + +**方式一：通过构造方法实现** +![ThreadPoolExecutor构造方法](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/ThreadPoolExecutor构造方法.png) +**方式二：通过Executor 框架的工具类Executors来实现** +我们可以创建三种类型的ThreadPoolExecutor： + +- **FixedThreadPool** ： 该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。 +- **SingleThreadExecutor：** 方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。 +- **CachedThreadPool：** 该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。 + +对应Executors工具类中的方法如图所示： +![Executor框架的工具类](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/Executor框架的工具类.png) + +### 4.5 ThreadPoolExecutor 类分析 + +`ThreadPoolExecutor` 类中提供的四个构造方法。我们来看最长的那个，其余三个都是在这个构造方法的基础上产生（其他几个构造方法说白点都是给定某些默认参数的构造方法比如默认制定拒绝策略是什么），这里就不贴代码讲了，比较简单。 + +```java + /** + * 用给定的初始参数创建一个新的ThreadPoolExecutor。 + */ + public ThreadPoolExecutor(int corePoolSize, + int maximumPoolSize, + long keepAliveTime, + TimeUnit unit, + BlockingQueue workQueue, + ThreadFactory threadFactory, + RejectedExecutionHandler handler) { + if (corePoolSize < 0 || + maximumPoolSize <= 0 || + maximumPoolSize < corePoolSize || + keepAliveTime < 0) + throw new IllegalArgumentException(); + if (workQueue == null || threadFactory == null || handler == null) + throw new NullPointerException(); + this.corePoolSize = corePoolSize; + this.maximumPoolSize = maximumPoolSize; + this.workQueue = workQueue; + this.keepAliveTime = unit.toNanos(keepAliveTime); + this.threadFactory = threadFactory; + this.handler = handler; + } +``` + +**下面这些对创建 非常重要，在后面使用线程池的过程中你一定会用到！所以，务必拿着小本本记清楚。** + +#### 4.5.1 `ThreadPoolExecutor`构造函数重要参数分析 + +**`ThreadPoolExecutor` 3 个最重要的参数：** + +- **`corePoolSize` :** 核心线程数线程数定义了最小可以同时运行的线程数量。 +- **`maximumPoolSize` :** 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。 +- **`workQueue`:** 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，信任就会被存放在队列中。 + +`ThreadPoolExecutor`其他常见参数: + +1. **`keepAliveTime`**:当线程池中的线程数量大于 `corePoolSize` 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 `keepAliveTime`才会被回收销毁； +2. **`unit`** : `keepAliveTime` 参数的时间单位。 +3. **`threadFactory`** :executor 创建新线程的时候会用到。 +4. **`handler`** :饱和策略。关于饱和策略下面单独介绍一下。 + +#### 4.5.2 `ThreadPoolExecutor` 饱和策略 + +**`ThreadPoolExecutor` 饱和策略定义:** + +如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任时，`ThreadPoolTaskExecutor` 定义一些策略: + +- **`ThreadPoolExecutor.AbortPolicy`**：抛出 `RejectedExecutionException`来拒绝新任务的处理。 +- **`ThreadPoolExecutor.CallerRunsPolicy`**：调用执行自己的线程运行任务。您不会任务请求。但是这种策略会降低对于新任务提交速度，影响程序的整体性能。另外，这个策略喜欢增加队列容量。如果您的应用程序可以承受此延迟并且你不能任务丢弃任何一个任务请求的话，你可以选择这个策略。 +- **`ThreadPoolExecutor.DiscardPolicy`：** 不处理新任务，直接丢弃掉。 +- **`ThreadPoolExecutor.DiscardOldestPolicy`：** 此策略将丢弃最早的未处理的任务请求。 + +举个例子： Spring 通过 `ThreadPoolTaskExecutor` 或者我们直接通过 `ThreadPoolExecutor` 的构造函数创建线程池的时候，当我们不指定 `RejectedExecutionHandler` 饱和策略的话来配置线程池的时候默认使用的是 `ThreadPoolExecutor.AbortPolicy`。在默认情况下，`ThreadPoolExecutor` 将抛出 `RejectedExecutionException` 来拒绝新来的任务 ，这代表你将丢失对这个任务的处理。 对于可伸缩的应用程序，建议使用 `ThreadPoolExecutor.CallerRunsPolicy`。当最大池被填满时，此策略为我们提供可伸缩队列。（这个直接查看 `ThreadPoolExecutor` 的构造函数源码就可以看出，比较简单的原因，这里就不贴代码了。） + +## 5. Atomic 原子类 + +### 5.1. 介绍一下Atomic 原子类 + +Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 Atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。 + +所以，所谓原子类说简单点就是具有原子/原子操作特征的类。 + + +并发包 `java.util.concurrent` 的原子类都存放在`java.util.concurrent.atomic`下,如下图所示。 + +![JUC原子类概览](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/JUC原子类概览.png) + +### 5.2. JUC 包中的原子类是哪4类? + +**基本类型** + +使用原子的方式更新基本类型 + +- AtomicInteger：整形原子类 +- AtomicLong：长整型原子类 +- AtomicBoolean：布尔型原子类 + +**数组类型** + +使用原子的方式更新数组里的某个元素 + + +- AtomicIntegerArray：整形数组原子类 +- AtomicLongArray：长整形数组原子类 +- AtomicReferenceArray：引用类型数组原子类 + +**引用类型** + +- AtomicReference：引用类型原子类 +- AtomicStampedReference：原子更新引用类型里的字段原子类 +- AtomicMarkableReference ：原子更新带有标记位的引用类型 + +**对象的属性修改类型** + +- AtomicIntegerFieldUpdater：原子更新整形字段的更新器 +- AtomicLongFieldUpdater：原子更新长整形字段的更新器 +- AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。 + + +### 5.3. 讲讲 AtomicInteger 的使用 + + **AtomicInteger 类常用方法** + +```java +public final int get() //获取当前的值 +public final int getAndSet(int newValue)//获取当前的值，并设置新的值 +public final int getAndIncrement()//获取当前的值，并自增 +public final int getAndDecrement() //获取当前的值，并自减 +public final int getAndAdd(int delta) //获取当前的值，并加上预期的值 +boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update） +public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。 +``` + + **AtomicInteger 类的使用示例** + +使用 AtomicInteger 之后，不用对 increment() 方法加锁也可以保证线程安全。 +```java +class AtomicIntegerTest { + private AtomicInteger count = new AtomicInteger(); + //使用AtomicInteger之后，不需要对该方法加锁，也可以实现线程安全。 + public void increment() { + count.incrementAndGet(); + } + + public int getCount() { + return count.get(); + } +} + +``` + +### 5.4. 能不能给我简单介绍一下 AtomicInteger 类的原理 + +AtomicInteger 线程安全原理简单分析 + +AtomicInteger 类的部分源码： + +```java + // setup to use Unsafe.compareAndSwapInt for updates（更新操作时提供“比较并替换”的作用） + private static final Unsafe unsafe = Unsafe.getUnsafe(); + private static final long valueOffset; + + static { + try { + valueOffset = unsafe.objectFieldOffset + (AtomicInteger.class.getDeclaredField("value")); + } catch (Exception ex) { throw new Error(ex); } + } + + private volatile int value; +``` + +AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。 + +CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址，返回值是 valueOffset。另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。 + +关于 Atomic 原子类这部分更多内容可以查看我的这篇文章：并发编程面试必备：[JUC 中的 Atomic 原子类总结](https://mp.weixin.qq.com/s/joa-yOiTrYF67bElj8xqvg) + +## 6. AQS + +### 6.1. AQS 介绍 + +AQS的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包下面。 + +![AQS类](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/AQS类.png) + +AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基于AQS的。当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器。 + +### 6.2. AQS 原理分析 + +AQS 原理这部分参考了部分博客，在5.2节末尾放了链接。 + +> 在面试中被问到并发知识的时候，大多都会被问到“请你说一下自己对于AQS原理的理解”。下面给大家一个示例供大家参加，面试不是背题，大家一定要加入自己的思想，即使加入不了自己的思想也要保证自己能够通俗的讲出来而不是背出来。 + +下面大部分内容其实在AQS类注释上已经给出了，不过是英语看着比较吃力一点，感兴趣的话可以看看源码。 + +#### 6.2.1. AQS 原理概览 + +**AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。** + +> CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS是将每条请求共享资源的线程封装成一个CLH锁队列的一个结点（Node）来实现锁的分配。 + +看个AQS(AbstractQueuedSynchronizer)原理图： + + +![AQS原理图](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/AQS原理图.png) + +AQS使用一个int成员变量来表示同步状态，通过内置的FIFO队列来完成获取资源线程的排队工作。AQS使用CAS对该同步状态进行原子操作实现对其值的修改。 + +```java +private volatile int state;//共享变量，使用volatile修饰保证线程可见性 +``` + +状态信息通过protected类型的getState，setState，compareAndSetState进行操作 + +```java + +//返回同步状态的当前值 +protected final int getState() { + return state; +} + // 设置同步状态的值 +protected final void setState(int newState) { + state = newState; +} +//原子地（CAS操作）将同步状态值设置为给定值update如果当前同步状态的值等于expect（期望值） +protected final boolean compareAndSetState(int expect, int update) { + return unsafe.compareAndSwapInt(this, stateOffset, expect, update); +} +``` + +#### 6.2.2. AQS 对资源的共享方式 + +**AQS定义两种资源共享方式** + +- **Exclusive**（独占）：只有一个线程能执行，如ReentrantLock。又可分为公平锁和非公平锁： + - 公平锁：按照线程在队列中的排队顺序，先到者先拿到锁 + - 非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的 +- **Share**（共享）：多个线程可同时执行，如Semaphore/CountDownLatch。Semaphore、CountDownLatch、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。 + +ReentrantReadWriteLock 可以看成是组合式，因为ReentrantReadWriteLock也就是读写锁允许多个线程同时对某一资源进行读。 + +不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。 + +#### 6.2.3. AQS底层使用了模板方法模式 + +同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）： + +1. 使用者继承AbstractQueuedSynchronizer并重写指定的方法。（这些重写方法很简单，无非是对于共享资源state的获取和释放） +2. 将AQS组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。 + +这和我们以往通过实现接口的方式有很大区别，这是模板方法模式很经典的一个运用。 + +**AQS使用了模板方法模式，自定义同步器时需要重写下面几个AQS提供的模板方法：** + +```java +isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。 +tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。 +tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。 +tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。 +tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。 + +``` + +默认情况下，每个方法都抛出 `UnsupportedOperationException`。 这些方法的实现必须是内部线程安全的，并且通常应该简短而不是阻塞。AQS类中的其他方法都是final ，所以无法被其他类使用，只有这几个方法可以被其他类使用。 + +以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。 + +再以CountDownLatch以例，任务分为N个子线程去执行，state也初始化为N（注意N要与线程个数一致）。这N个子线程是并行执行的，每个子线程执行完后countDown()一次，state会CAS(Compare and Swap)减1。等到所有子线程都执行完后(即state=0)，会unpark()主调用线程，然后主调用线程就会从await()函数返回，继续后余动作。 + +一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现`tryAcquire-tryRelease`、`tryAcquireShared-tryReleaseShared`中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如`ReentrantReadWriteLock`。 + +推荐两篇 AQS 原理和相关源码分析的文章： + +- http://www.cnblogs.com/waterystone/p/4920797.html +- https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html + +### 6.3. AQS 组件总结 + +- **Semaphore(信号量)-允许多个线程同时访问：** synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。 +- **CountDownLatch （倒计时器）：** CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。 +- **CyclicBarrier(循环栅栏)：** CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await()方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。 + +## 7 Reference + +- 《深入理解 Java 虚拟机》 +- 《实战 Java 高并发程序设计》 +- 《Java并发编程的艺术》 +- http://www.cnblogs.com/waterystone/p/4920797.html +- https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html +- + +## 公众号 + +如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 + +**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"面试突击"** 即可免费领取！ + +**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 + +![我的公众号](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/167598cd2e17b8ec.png) diff --git a/docs/java/Multithread/JavaConcurrencyBasicsCommonInterviewQuestionsSummary.md b/docs/java/Multithread/JavaConcurrencyBasicsCommonInterviewQuestionsSummary.md new file mode 100644 index 00000000000..ddf3e8805e1 --- /dev/null +++ b/docs/java/Multithread/JavaConcurrencyBasicsCommonInterviewQuestionsSummary.md @@ -0,0 +1,316 @@ +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 + + + +- [Java 并发基础常见面试题总结](#java-并发基础常见面试题总结) + - [1. 什么是线程和进程?](#1-什么是线程和进程) + - [1.1. 何为进程?](#11-何为进程) + - [1.2. 何为线程?](#12-何为线程) + - [2. 请简要描述线程与进程的关系,区别及优缺点？](#2-请简要描述线程与进程的关系区别及优缺点) + - [2.1. 图解进程和线程的关系](#21-图解进程和线程的关系) + - [2.2. 程序计数器为什么是私有的?](#22-程序计数器为什么是私有的) + - [2.3. 虚拟机栈和本地方法栈为什么是私有的?](#23-虚拟机栈和本地方法栈为什么是私有的) + - [2.4. 一句话简单了解堆和方法区](#24-一句话简单了解堆和方法区) + - [3. 说说并发与并行的区别?](#3-说说并发与并行的区别) + - [4. 为什么要使用多线程呢?](#4-为什么要使用多线程呢) + - [5. 使用多线程可能带来什么问题?](#5-使用多线程可能带来什么问题) + - [6. 说说线程的生命周期和状态?](#6-说说线程的生命周期和状态) + - [7. 什么是上下文切换?](#7-什么是上下文切换) + - [8. 什么是线程死锁?如何避免死锁?](#8-什么是线程死锁如何避免死锁) + - [8.1. 认识线程死锁](#81-认识线程死锁) + - [8.2. 如何避免线程死锁?](#82-如何避免线程死锁) + - [9. 说说 sleep() 方法和 wait() 方法区别和共同点?](#9-说说-sleep-方法和-wait-方法区别和共同点) + - [10. 为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？](#10-为什么我们调用-start-方法时会执行-run-方法为什么我们不能直接调用-run-方法) + + + +# Java 并发基础常见面试题总结 + +## 1. 什么是线程和进程? + +### 1.1. 何为进程? + +进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。 + +在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。 + +如下图所示，在 windows 中通过查看任务管理器的方式，我们就可以清楚看到 window 当前运行的进程（.exe 文件的运行）。 + +![进程示例图片-Windows](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/进程示例图片-Windows.png) + +### 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 线程和多个其他线程同时运行**。 + +## 2. 请简要描述线程与进程的关系,区别及优缺点？ + +**从 JVM 角度说进程和线程之间的关系** + +### 2.1. 图解进程和线程的关系 + +下图是 Java 内存区域，通过下图我们从 JVM 的角度来说一下线程和进程之间的关系。如果你对 Java 内存区域 (运行时数据区) 这部分知识不太了解的话可以阅读一下这篇文章：[《可能是把 Java 内存区域讲的最清楚的一篇文章》]() + +
+ +
+ +从上图可以看出：一个进程中可以有多个线程，多个线程共享进程的**堆**和**方法区 (JDK1.8 之后的元空间)**资源，但是每个线程有自己的**程序计数器**、**虚拟机栈** 和 **本地方法栈**。 + +**总结：** 线程 是 进程 划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。线程执行开销小，但不利于资源的管理和保护；而进程正相反 + +下面是该知识点的扩展内容！ + +下面来思考这样一个问题：为什么**程序计数器**、**虚拟机栈**和**本地方法栈**是线程私有的呢？为什么堆和方法区是线程共享的呢？ + +### 2.2. 程序计数器为什么是私有的? + +程序计数器主要有下面两个作用： + +1. 字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理。 +2. 在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。 + +需要注意的是，如果执行的是 native 方法，那么程序计数器记录的是 undefined 地址，只有执行的是 Java 代码时程序计数器记录的才是下一条指令的地址。 + +所以，程序计数器私有主要是为了**线程切换后能恢复到正确的执行位置**。 + +### 2.3. 虚拟机栈和本地方法栈为什么是私有的? + +- **虚拟机栈：** 每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。 +- **本地方法栈：** 和虚拟机栈所发挥的作用非常相似，区别是： **虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务。** 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。 + +所以，为了**保证线程中的局部变量不被别的线程访问到**，虚拟机栈和本地方法栈是线程私有的。 + +### 2.4. 一句话简单了解堆和方法区 + +堆和方法区是所有线程共享的资源，其中堆是进程中最大的一块内存，主要用于存放新创建的对象 (所有对象都在这里分配内存)，方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。 + +## 3. 说说并发与并行的区别? + +- **并发：** 同一时间段，多个任务都在执行 (单位时间内不一定同时执行)； +- **并行：** 单位时间内，多个任务同时执行。 + +## 4. 为什么要使用多线程呢? + +先从总体上来说： + +- **从计算机底层来说：** 线程可以比作是轻量级的进程，是程序执行的最小单位,线程间的切换和调度的成本远远小于进程。另外，多核 CPU 时代意味着多个线程可以同时运行，这减少了线程上下文切换的开销。 +- **从当代互联网发展趋势来说：** 现在的系统动不动就要求百万级甚至千万级的并发量，而多线程并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能。 + +再深入到计算机底层来探讨： + +- **单核时代：** 在单核时代多线程主要是为了提高 CPU 和 IO 设备的综合利用率。举个例子：当只有一个线程的时候会导致 CPU 计算时，IO 设备空闲；进行 IO 操作时，CPU 空闲。我们可以简单地说这两者的利用率目前都是 50%左右。但是当有两个线程的时候就不一样了，当一个线程执行 CPU 计算时，另外一个线程可以进行 IO 操作，这样两个的利用率就可以在理想情况下达到 100%了。 +- **多核时代:** 多核时代多线程主要是为了提高 CPU 利用率。举个例子：假如我们要计算一个复杂的任务，我们只用一个线程的话，CPU 只会一个 CPU 核心被利用到，而创建多个线程就可以让多个 CPU 核心被利用到，这样就提高了 CPU 的利用率。 + +## 5. 使用多线程可能带来什么问题? + +并发编程的目的就是为了能提高程序的执行效率提高程序运行速度，但是并发编程并不总是能提高程序运行速度的，而且并发编程可能会遇到很多问题，比如：内存泄漏、上下文切换、死锁还有受限于硬件和软件的资源闲置问题。 + +## 6. 说说线程的生命周期和状态? + +Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态（图源《Java 并发编程艺术》4.1.4 节）。 + +![Java 线程的状态 ](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/19-1-29/Java%E7%BA%BF%E7%A8%8B%E7%9A%84%E7%8A%B6%E6%80%81.png) + +线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示（图源《Java 并发编程艺术》4.1.4 节）： + +![Java 线程状态变迁 ](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/19-1-29/Java+%E7%BA%BF%E7%A8%8B%E7%8A%B6%E6%80%81%E5%8F%98%E8%BF%81.png) + + + +由上图可以看出：线程创建之后它将处于 **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（运行中）** 状态 。 + +![RUNNABLE-VS-RUNNING](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/RUNNABLE-VS-RUNNING.png) + +当线程执行 `wait()`方法之后，线程进入 **WAITING（等待）** 状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 **TIME_WAITING(超时等待)** 状态相当于在等待状态的基础上增加了超时限制，比如通过 `sleep（long millis）`方法或 `wait（long millis）`方法可以将 Java 线程置于 TIMED WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 **BLOCKED（阻塞）** 状态。线程在执行 Runnable 的` run() `方法之后将会进入到 **TERMINATED（终止）** 状态。 + +## 7. 什么是上下文切换? + +多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。 + +概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。**任务从保存到再加载的过程就是一次上下文切换**。 + +上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。 + +Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。 + +## 8. 什么是线程死锁?如何避免死锁? + +### 8.1. 认识线程死锁 + +多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。 + +如下图所示，线程 A 持有资源 2，线程 B 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。 + +![线程死锁示意图 ](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-4/2019-4%E6%AD%BB%E9%94%811.png) + +下面通过一个例子来说明线程死锁,代码模拟了上图的死锁的情况 (代码来源于《并发编程之美》)： + +```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. 互斥条件：该资源任意一个时刻只由一个线程占用。 +2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。 +3. 不剥夺条件:线程已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。 +4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。 + +### 8.2. 如何避免线程死锁? + +我们只要破坏产生死锁的四个条件中的其中一个就可以了。 + +**破坏互斥条件** + +这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。 + +**破坏请求与保持条件** + +一次性申请所有的资源。 + +**破坏不剥夺条件** + +占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。 + +**破坏循环等待条件** + +靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。 + +我们对线程 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 获取到就可以执行了。这样就破坏了破坏循环等待条件，因此避免了死锁。 + +## 9. 说说 sleep() 方法和 wait() 方法区别和共同点? + +- 两者最主要的区别在于：**sleep 方法没有释放锁，而 wait 方法释放了锁** 。 +- 两者都可以暂停线程的执行。 +- Wait 通常被用于线程间交互/通信，sleep 通常被用于暂停执行。 +- wait() 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的 notify() 或者 notifyAll() 方法。sleep() 方法执行完成后，线程会自动苏醒。或者可以使用wait(long timeout)超时后线程会自动苏醒。 + + +## 10. 为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？ + +这是另一个非常经典的 java 多线程面试问题，而且在面试中会经常被问到。很简单，但是很多人都会答不上来！ + +new 一个 Thread，线程进入了新建状态;调用 start() 方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 start() 会执行线程的相应准备工作，然后自动执行 run() 方法的内容，这是真正的多线程工作。 而直接执行 run() 方法，会把 run 方法当成一个 main 线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。 + +**总结： 调用 start 方法方可启动线程并使线程进入就绪状态，而 run 方法只是 thread 的一个普通方法调用，还是在主线程里执行。** + +## 公众号 + +如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 + +**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"面试突击"** 即可免费领取！ + +**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 + +![我的公众号](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/167598cd2e17b8ec.png) diff --git a/docs/java/Multithread/ThredLocal.md b/docs/java/Multithread/ThredLocal.md new file mode 100644 index 00000000000..84d619df728 --- /dev/null +++ b/docs/java/Multithread/ThredLocal.md @@ -0,0 +1,170 @@ +[ThreadLocal造成OOM内存溢出案例演示与原理分析](https://blog.csdn.net/xlgen157387/article/details/78298840) + +[深入理解 Java 之 ThreadLocal 工作原理]() + +## ThreadLocal + +### ThreadLocal简介 + +通常情况下，我们创建的变量是可以被任何一个线程访问并修改的。**如果想实现每一个线程都有自己的专属本地变量该如何解决呢？** JDK中提供的`ThreadLocal`类正是为了解决这样的问题。 **`ThreadLocal`类主要解决的就是让每个线程绑定自己的值，可以将`ThreadLocal`类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。** + +**如果你创建了一个`ThreadLocal`变量，那么访问这个变量的每个线程都会有这个变量的本地副本，这也是`ThreadLocal`变量名的由来。他们可以使用 `get（）` 和 `set（）` 方法来获取默认值或将其值更改为当前线程所存的副本的值，从而避免了线程安全问题。** + +再举个简单的例子： + +比如有两个人去宝屋收集宝物，这两个共用一个袋子的话肯定会产生争执，但是给他们两个人每个人分配一个袋子的话就不会出现这样的问题。如果把这两个人比作线程的话，那么ThreadLocal就是用来这两个线程竞争的。 + +### ThreadLocal示例 + +相信看了上面的解释，大家已经搞懂 ThreadLocal 类是个什么东西了。 + +```java +import java.text.SimpleDateFormat; +import java.util.Random; + +public class ThreadLocalExample implements Runnable{ + + // SimpleDateFormat 不是线程安全的，所以每个线程都要有自己独立的副本 + private static final ThreadLocal formatter = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMdd HHmm")); + + public static void main(String[] args) throws InterruptedException { + ThreadLocalExample obj = new ThreadLocalExample(); + for(int i=0 ; i<10; i++){ + Thread t = new Thread(obj, ""+i); + Thread.sleep(new Random().nextInt(1000)); + t.start(); + } + } + + @Override + public void run() { + System.out.println("Thread Name= "+Thread.currentThread().getName()+" default Formatter = "+formatter.get().toPattern()); + try { + Thread.sleep(new Random().nextInt(1000)); + } catch (InterruptedException e) { + e.printStackTrace(); + } + //formatter pattern is changed here by thread, but it won't reflect to other threads + formatter.set(new SimpleDateFormat()); + + System.out.println("Thread Name= "+Thread.currentThread().getName()+" formatter = "+formatter.get().toPattern()); + } + +} + +``` + +Output: + +``` +Thread Name= 0 default Formatter = yyyyMMdd HHmm +Thread Name= 0 formatter = yy-M-d ah:mm +Thread Name= 1 default Formatter = yyyyMMdd HHmm +Thread Name= 2 default Formatter = yyyyMMdd HHmm +Thread Name= 1 formatter = yy-M-d ah:mm +Thread Name= 3 default Formatter = yyyyMMdd HHmm +Thread Name= 2 formatter = yy-M-d ah:mm +Thread Name= 4 default Formatter = yyyyMMdd HHmm +Thread Name= 3 formatter = yy-M-d ah:mm +Thread Name= 4 formatter = yy-M-d ah:mm +Thread Name= 5 default Formatter = yyyyMMdd HHmm +Thread Name= 5 formatter = yy-M-d ah:mm +Thread Name= 6 default Formatter = yyyyMMdd HHmm +Thread Name= 6 formatter = yy-M-d ah:mm +Thread Name= 7 default Formatter = yyyyMMdd HHmm +Thread Name= 7 formatter = yy-M-d ah:mm +Thread Name= 8 default Formatter = yyyyMMdd HHmm +Thread Name= 9 default Formatter = yyyyMMdd HHmm +Thread Name= 8 formatter = yy-M-d ah:mm +Thread Name= 9 formatter = yy-M-d ah:mm +``` + +从输出中可以看出，Thread-0已经改变了formatter的值，但仍然是thread-2默认格式化程序与初始化值相同，其他线程也一样。 + +上面有一段代码用到了创建 `ThreadLocal` 变量的那段代码用到了 Java8 的知识，它等于下面这段代码，如果你写了下面这段代码的话，IDEA会提示你转换为Java8的格式(IDEA真的不错！)。因为ThreadLocal类在Java 8中扩展，使用一个新的方法`withInitial()`，将Supplier功能接口作为参数。 + +```java + private static final ThreadLocal formatter = new ThreadLocal(){ + @Override + protected SimpleDateFormat initialValue() + { + return new SimpleDateFormat("yyyyMMdd HHmm"); + } + }; +``` + +### ThreadLocal原理 + +从 `Thread`类源代码入手。 + +```java +public class Thread implements Runnable { + ...... +//与此线程有关的ThreadLocal值。由ThreadLocal类维护 +ThreadLocal.ThreadLocalMap threadLocals = null; + +//与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护 +ThreadLocal.ThreadLocalMap inheritableThreadLocals = null; + ...... +} +``` + +从上面`Thread`类 源代码可以看出`Thread` 类中有一个 `threadLocals` 和 一个 `inheritableThreadLocals` 变量，它们都是 `ThreadLocalMap` 类型的变量,我们可以把 `ThreadLocalMap` 理解为`ThreadLocal` 类实现的定制化的 `HashMap`。默认情况下这两个变量都是null，只有当前线程调用 `ThreadLocal` 类的 `set`或`get`方法时才创建它们，实际上调用这两个方法的时候，我们调用的是`ThreadLocalMap`类对应的 `get()`、`set() `方法。 + +`ThreadLocal`类的`set()`方法 + +```java + public void set(T value) { + Thread t = Thread.currentThread(); + ThreadLocalMap map = getMap(t); + if (map != null) + map.set(this, value); + else + createMap(t, value); + } + ThreadLocalMap getMap(Thread t) { + return t.threadLocals; + } +``` + +通过上面这些内容，我们足以通过猜测得出结论：**最终的变量是放在了当前线程的 `ThreadLocalMap` 中，并不是存在 `ThreadLocal` 上，ThreadLocal 可以理解为只是ThreadLocalMap的封装，传递了变量值。** + +**每个Thread中都具备一个ThreadLocalMap，而ThreadLocalMap可以存储以ThreadLocal为key的键值对。** 比如我们在同一个线程中声明了两个 `ThreadLocal` 对象的话，会使用 `Thread`内部都是使用仅有那个`ThreadLocalMap` 存放数据的，`ThreadLocalMap`的 key 就是 `ThreadLocal`对象，value 就是 `ThreadLocal` 对象调用`set`方法设置的值。`ThreadLocal` 是 map结构是为了让每个线程可以关联多个 `ThreadLocal`变量。这也就解释了ThreadLocal声明的变量为什么在每一个线程都有自己的专属本地变量。 + +```java +public class Thread implements Runnable { + ...... +//与此线程有关的ThreadLocal值。由ThreadLocal类维护 +ThreadLocal.ThreadLocalMap threadLocals = null; + +//与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护 +ThreadLocal.ThreadLocalMap inheritableThreadLocals = null; + ...... +} +``` + +`ThreadLocalMap`是`ThreadLocal`的静态内部类。 + +![ThreadLocal内部类](https://ws1.sinaimg.cn/large/006rNwoDgy1g2f47u9li2j30ka08cq43.jpg) + +### ThreadLocal 内存泄露问题 + +`ThreadLocalMap` 中使用的 key 为 `ThreadLocal` 的弱引用,而 value 是强引用。所以，如果 `ThreadLocal` 没有被外部强引用的情况下，在垃圾回收的时候会 key 会被清理掉，而 value 不会被清理掉。这样一来，`ThreadLocalMap` 中就会出现key为null的Entry。假如我们不做任何措施的话，value 永远无法被GC 回收，这个时候就可能会产生内存泄露。ThreadLocalMap实现中已经考虑了这种情况，在调用 `set()`、`get()`、`remove()` 方法的时候，会清理掉 key 为 null 的记录。使用完 `ThreadLocal`方法后 最好手动调用`remove()`方法 + +```java + static class Entry extends WeakReference> { + /** The value associated with this ThreadLocal. */ + Object value; + + Entry(ThreadLocal k, Object v) { + super(k); + value = v; + } + } +``` + +**弱引用介绍：** + +> 如果一个对象只具有弱引用，那就类似于**可有可无的生活用品**。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。 +> +> 弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。 \ No newline at end of file diff --git "a/docs/java/Multithread/java\347\272\277\347\250\213\346\261\240\345\255\246\344\271\240\346\200\273\347\273\223.md" "b/docs/java/Multithread/java\347\272\277\347\250\213\346\261\240\345\255\246\344\271\240\346\200\273\347\273\223.md" new file mode 100644 index 00000000000..91a7cbd43af --- /dev/null +++ "b/docs/java/Multithread/java\347\272\277\347\250\213\346\261\240\345\255\246\344\271\240\346\200\273\347\273\223.md" @@ -0,0 +1,781 @@ + + +- [一 使用线程池的好处](#一-使用线程池的好处) +- [二 Executor 框架](#二-executor-框架) + - [2.1 简介](#21-简介) + - [2.2 Executor 框架结构(主要由三大部分组成)](#22-executor-框架结构主要由三大部分组成) + - [1) 任务(`Runnable` /`Callable`)](#1-任务runnable-callable) + - [2) 任务的执行(`Executor`)](#2-任务的执行executor) + - [3) 异步计算的结果(`Future`)](#3-异步计算的结果future) + - [2.3 Executor 框架的使用示意图](#23-executor-框架的使用示意图) +- [三 (重要)ThreadPoolExecutor 类简单介绍](#三-重要threadpoolexecutor-类简单介绍) + - [3.1 ThreadPoolExecutor 类分析](#31-threadpoolexecutor-类分析) + - [3.2 推荐使用 `ThreadPoolExecutor` 构造函数创建线程池](#32-推荐使用-threadpoolexecutor-构造函数创建线程池) +- [四 (重要)ThreadPoolExecutor 使用示例](#四-重要threadpoolexecutor-使用示例) + - [4.1 示例代码:`Runnable`+`ThreadPoolExecutor`](#41-示例代码runnablethreadpoolexecutor) + - [4.2 线程池原理分析](#42-线程池原理分析) + - [4.3 几个常见的对比](#43-几个常见的对比) + - [4.3.1 `Runnable` vs `Callable`](#431-runnable-vs-callable) + - [4.3.2 `execute()` vs `submit()`](#432-execute-vs-submit) + - [4.3.3 `shutdown()`VS`shutdownNow()`](#433-shutdownvsshutdownnow) + - [4.3.2 `isTerminated()` VS `isShutdown()`](#432-isterminated-vs-isshutdown) + - [4.4 加餐:`Callable`+`ThreadPoolExecutor`示例代码](#44-加餐callablethreadpoolexecutor示例代码) +- [五 几种常见的线程池详解](#五-几种常见的线程池详解) + - [5.1 FixedThreadPool](#51-fixedthreadpool) + - [5.1.1 介绍](#511-介绍) + - [5.1.2 执行任务过程介绍](#512-执行任务过程介绍) + - [5.1.3 为什么不推荐使用`FixedThreadPool`？](#513-为什么不推荐使用fixedthreadpool) + - [5.2 SingleThreadExecutor 详解](#52-singlethreadexecutor-详解) + - [5.2.1 介绍](#521-介绍) + - [5.2.2 执行任务过程介绍](#522-执行任务过程介绍) + - [5.2.3 为什么不推荐使用`FixedThreadPool`？](#523-为什么不推荐使用fixedthreadpool) + - [5.3 CachedThreadPool 详解](#53-cachedthreadpool-详解) + - [5.3.1 介绍](#531-介绍) + - [5.3.2 执行任务过程介绍](#532-执行任务过程介绍) + - [5.3.3 为什么不推荐使用`CachedThreadPool`？](#533-为什么不推荐使用cachedthreadpool) +- [六 ScheduledThreadPoolExecutor 详解](#六-scheduledthreadpoolexecutor-详解) + - [6.1 简介](#61-简介) + - [6.2 运行机制](#62-运行机制) + - [6.3 ScheduledThreadPoolExecutor 执行周期任务的步骤](#63-scheduledthreadpoolexecutor-执行周期任务的步骤) +- [七 线程池大小确定](#七-线程池大小确定) +- [八 参考](#八-参考) +- [九 其他推荐阅读](#九-其他推荐阅读) + + + +## 一 使用线程池的好处 + +> **池化技术相比大家已经屡见不鲜了，线程池、数据库连接池、Http 连接池等等都是对这个思想的应用。池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。** + +**线程池**提供了一种限制和管理资源（包括执行一个任务）。 每个**线程池**还维护一些基本统计信息，例如已完成任务的数量。 + +这里借用《Java 并发编程的艺术》提到的来说一下**使用线程池的好处**： + +- **降低资源消耗**。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 +- **提高响应速度**。当任务到达时，任务可以不需要的等到线程创建就能立即执行。 +- **提高线程的可管理性**。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 + +## 二 Executor 框架 + +### 2.1 简介 + +Executor 框架是 Java5 之后引进的，在 Java 5 之后，通过 Executor 来启动线程比使用 Thread 的 start 方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免 this 逃逸问题。 + +> 补充：this 逃逸是指在构造函数返回之前其他线程就持有该对象的引用. 调用尚未构造完全的对象的方法可能引发令人疑惑的错误。 + +Executor 框架不仅包括了线程池的管理，还提供了线程工厂、队列以及拒绝策略等，Executor 框架让并发编程变得更加简单。 + +### 2.2 Executor 框架结构(主要由三大部分组成) + +#### 1) 任务(`Runnable` /`Callable`) + +执行任务需要实现的 **`Runnable` 接口** 或 **`Callable`接口**。**`Runnable` 接口**或 **`Callable` 接口** 实现类都可以被 **`ThreadPoolExecutor`** 或 **`ScheduledThreadPoolExecutor`** 执行。 + +#### 2) 任务的执行(`Executor`) + +如下图所示，包括任务执行机制的核心接口 **`Executor`** ，以及继承自 `Executor` 接口的 **`ExecutorService` 接口。`ThreadPoolExecutor`** 和 **`ScheduledThreadPoolExecutor`** 这两个关键类实现了 **ExecutorService 接口**。 + +**这里提了很多底层的类关系，但是，实际上我们需要更多关注的是 `ThreadPoolExecutor` 这个类，这个类在我们实际使用线程池的过程中，使用频率还是非常高的。** + +> **注意：** 通过查看 `ScheduledThreadPoolExecutor` 源代码我们发现 `ScheduledThreadPoolExecutor` 实际上是继承了 `ThreadPoolExecutor` 并实现了 ScheduledExecutorService ，而 `ScheduledExecutorService` 又实现了 `ExecutorService`，正如我们下面给出的类关系图显示的一样。 + +**`ThreadPoolExecutor` 类描述:** + +```java +//AbstractExecutorService实现了ExecutorService接口 +public class ThreadPoolExecutor extends AbstractExecutorService +``` + +**`ScheduledThreadPoolExecutor` 类描述:** + +```java +//ScheduledExecutorService实现了ExecutorService接口 +public class ScheduledThreadPoolExecutor + extends ThreadPoolExecutor + implements ScheduledExecutorService +``` + +![任务的执行相关接口](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-7/任务的执行相关接口.png) + +#### 3) 异步计算的结果(`Future`) + +**`Future`** 接口以及 `Future` 接口的实现类 **`FutureTask`** 类都可以代表异步计算的结果。 + +当我们把 **`Runnable`接口** 或 **`Callable` 接口** 的实现类提交给 **`ThreadPoolExecutor`** 或 **`ScheduledThreadPoolExecutor`** 执行。（调用 `submit()` 方法时会返回一个 **`FutureTask`** 对象） + +### 2.3 Executor 框架的使用示意图 + +![Executor 框架的使用示意图](https://imgconvert.csdnimg.cn/aHR0cDovL215LWJsb2ctdG8tdXNlLm9zcy1jbi1iZWlqaW5nLmFsaXl1bmNzLmNvbS8xOC01LTMwLzg0ODIzMzMwLmpwZw?x-oss-process=image/format,png) + +1. **主线程首先要创建实现 `Runnable` 或者 `Callable` 接口的任务对象。** +2. **把创建完成的实现 `Runnable`/`Callable`接口的 对象直接交给 `ExecutorService` 执行**: `ExecutorService.execute（Runnable command）`）或者也可以把 `Runnable` 对象或`Callable` 对象提交给 `ExecutorService` 执行（`ExecutorService.submit（Runnable task）`或 `ExecutorService.submit（Callable task）`）。 +3. **如果执行 `ExecutorService.submit（…）`，`ExecutorService` 将返回一个实现`Future`接口的对象**（我们刚刚也提到过了执行 `execute()`方法和 `submit()`方法的区别，`submit()`会返回一个 `FutureTask 对象）。由于 FutureTask` 实现了 `Runnable`，我们也可以创建 `FutureTask`，然后直接交给 `ExecutorService` 执行。 +4. **最后，主线程可以执行 `FutureTask.get()`方法来等待任务执行完成。主线程也可以执行 `FutureTask.cancel（boolean mayInterruptIfRunning）`来取消此任务的执行。** + +## 三 (重要)ThreadPoolExecutor 类简单介绍 + +**线程池实现类 `ThreadPoolExecutor` 是 `Executor` 框架最核心的类。** + +### 3.1 ThreadPoolExecutor 类分析 + +`ThreadPoolExecutor` 类中提供的四个构造方法。我们来看最长的那个，其余三个都是在这个构造方法的基础上产生（其他几个构造方法说白点都是给定某些默认参数的构造方法比如默认制定拒绝策略是什么），这里就不贴代码讲了，比较简单。 + +```java + /** + * 用给定的初始参数创建一个新的ThreadPoolExecutor。 + */ + public ThreadPoolExecutor(int corePoolSize,//线程池的核心线程数量 + int maximumPoolSize,//线程池的最大线程数 + long keepAliveTime,//当线程数大于核心线程数时，多余的空闲线程存活的最长时间 + TimeUnit unit,//时间单位 + BlockingQueue workQueue,//任务队列，用来储存等待执行任务的队列 + ThreadFactory threadFactory,//线程工厂，用来创建线程，一般默认即可 + RejectedExecutionHandler handler//拒绝策略，当提交的任务过多而不能及时处理时，我们可以定制策略来处理任务 + ) { + if (corePoolSize < 0 || + maximumPoolSize <= 0 || + maximumPoolSize < corePoolSize || + keepAliveTime < 0) + throw new IllegalArgumentException(); + if (workQueue == null || threadFactory == null || handler == null) + throw new NullPointerException(); + this.corePoolSize = corePoolSize; + this.maximumPoolSize = maximumPoolSize; + this.workQueue = workQueue; + this.keepAliveTime = unit.toNanos(keepAliveTime); + this.threadFactory = threadFactory; + this.handler = handler; + } +``` + +**下面这些对创建 非常重要，在后面使用线程池的过程中你一定会用到！所以，务必拿着小本本记清楚。** + +**`ThreadPoolExecutor` 3 个最重要的参数：** + +- **`corePoolSize` :** 核心线程数线程数定义了最小可以同时运行的线程数量。 +- **`maximumPoolSize` :** 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。 +- **`workQueue`:** 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，信任就会被存放在队列中。 + +`ThreadPoolExecutor`其他常见参数: + +1. **`keepAliveTime`**:当线程池中的线程数量大于 `corePoolSize` 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 `keepAliveTime`才会被回收销毁； +2. **`unit`** : `keepAliveTime` 参数的时间单位。 +3. **`threadFactory`** :executor 创建新线程的时候会用到。 +4. **`handler`** :饱和策略。关于饱和策略下面单独介绍一下。 + +下面这张图可以加深你对线程池中各个参数的相互关系的理解（图片来源：《Java性能调优实战》）： + +![线程池各个参数的关系](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-7/线程池各个参数的关系.jpg) + +**`ThreadPoolExecutor` 饱和策略定义:** + +如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任时，`ThreadPoolTaskExecutor` 定义一些策略: + +- **`ThreadPoolExecutor.AbortPolicy`**：抛出 `RejectedExecutionException`来拒绝新任务的处理。 +- **`ThreadPoolExecutor.CallerRunsPolicy`**：调用执行自己的线程运行任务。您不会任务请求。但是这种策略会降低对于新任务提交速度，影响程序的整体性能。另外，这个策略喜欢增加队列容量。如果您的应用程序可以承受此延迟并且你不能任务丢弃任何一个任务请求的话，你可以选择这个策略。 +- **`ThreadPoolExecutor.DiscardPolicy`：** 不处理新任务，直接丢弃掉。 +- **`ThreadPoolExecutor.DiscardOldestPolicy`：** 此策略将丢弃最早的未处理的任务请求。 + +举个例子： + +> Spring 通过 `ThreadPoolTaskExecutor` 或者我们直接通过 `ThreadPoolExecutor` 的构造函数创建线程池的时候，当我们不指定 `RejectedExecutionHandler` 饱和策略的话来配置线程池的时候默认使用的是 `ThreadPoolExecutor.AbortPolicy`。在默认情况下，`ThreadPoolExecutor` 将抛出 `RejectedExecutionException` 来拒绝新来的任务 ，这代表你将丢失对这个任务的处理。 对于可伸缩的应用程序，建议使用 `ThreadPoolExecutor.CallerRunsPolicy`。当最大池被填满时，此策略为我们提供可伸缩队列。（这个直接查看 `ThreadPoolExecutor` 的构造函数源码就可以看出，比较简单的原因，这里就不贴代码了。） + +### 3.2 推荐使用 `ThreadPoolExecutor` 构造函数创建线程池 + +**在《阿里巴巴 Java 开发手册》“并发处理”这一章节，明确指出线程资源必须通过线程池提供，不允许在应用中自行显示创建线程。** + +**为什么呢？** + +> **使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源开销，解决资源不足的问题。如果不使用线程池，有可能会造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。** + +**另外《阿里巴巴 Java 开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 构造函数的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险** + +> Executors 返回线程池对象的弊端如下： +> +> - **`FixedThreadPool` 和 `SingleThreadExecutor`** ： 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致 OOM。 +> - **CachedThreadPool 和 ScheduledThreadPool** ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致 OOM。 + +**方式一：通过`ThreadPoolExecutor`构造函数实现（推荐）** +![通过构造方法实现](https://imgconvert.csdnimg.cn/aHR0cDovL215LWJsb2ctdG8tdXNlLm9zcy1jbi1iZWlqaW5nLmFsaXl1bmNzLmNvbS8xOC00LTE2LzE3ODU4MjMwLmpwZw?x-oss-process=image/format,png) +**方式二：通过 Executor 框架的工具类 Executors 来实现** +我们可以创建三种类型的 ThreadPoolExecutor： + +- **FixedThreadPool** +- **SingleThreadExecutor** +- **CachedThreadPool** + +对应 Executors 工具类中的方法如图所示： +![通过Executor 框架的工具类Executors来实现](https://imgconvert.csdnimg.cn/aHR0cDovL215LWJsb2ctdG8tdXNlLm9zcy1jbi1iZWlqaW5nLmFsaXl1bmNzLmNvbS8xOC00LTE2LzEzMjk2OTAxLmpwZw?x-oss-process=image/format,png) + +## 四 (重要)ThreadPoolExecutor 使用示例 + +我们上面讲解了 `Executor`框架以及 `ThreadPoolExecutor` 类，下面让我们实战一下，来通过写一个 `ThreadPoolExecutor` 的小 Demo 来回顾上面的内容。 + +### 4.1 示例代码:`Runnable`+`ThreadPoolExecutor` + +首先创建一个 `Runnable` 接口的实现类（当然也可以是 `Callable` 接口，我们上面也说了两者的区别。） + +`MyRunnable.java` + +```java +import java.util.Date; + +/** + * 这是一个简单的Runnable类，需要大约5秒钟来执行其任务。 + * @author shuang.kou + */ +public class MyRunnable implements Runnable { + + private String command; + + public MyRunnable(String s) { + this.command = s; + } + + @Override + public void run() { + System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date()); + processCommand(); + System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date()); + } + + private void processCommand() { + try { + Thread.sleep(5000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + @Override + public String toString() { + return this.command; + } +} + +``` + +编写测试程序，我们这里以阿里巴巴推荐的使用 `ThreadPoolExecutor` 构造函数自定义参数的方式来创建线程池。 + +`ThreadPoolExecutorDemo.java` + +```java +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +public class ThreadPoolExecutorDemo { + + private static final int CORE_POOL_SIZE = 5; + private static final int MAX_POOL_SIZE = 10; + private static final int QUEUE_CAPACITY = 100; + private static final Long KEEP_ALIVE_TIME = 1L; + public static void main(String[] args) { + + //使用阿里巴巴推荐的创建线程池的方式 + //通过ThreadPoolExecutor构造函数自定义参数创建 + ThreadPoolExecutor executor = new ThreadPoolExecutor( + CORE_POOL_SIZE, + MAX_POOL_SIZE, + KEEP_ALIVE_TIME, + TimeUnit.SECONDS, + new ArrayBlockingQueue<>(QUEUE_CAPACITY), + new ThreadPoolExecutor.CallerRunsPolicy()); + + for (int i = 0; i < 10; i++) { + //创建WorkerThread对象（WorkerThread类实现了Runnable 接口） + Runnable worker = new MyRunnable("" + i); + //执行Runnable + executor.execute(worker); + } + //终止线程池 + executor.shutdown(); + while (!executor.isTerminated()) { + } + System.out.println("Finished all threads"); + } +} + +``` + +可以看到我们上面的代码指定了： + +1. `corePoolSize`: 核心线程数为 5。 +2. `maximumPoolSize` ：最大线程数 10 +3. `keepAliveTime` : 等待时间为 1L。 +4. `unit`: 等待时间的单位为 TimeUnit.SECONDS。 +5. `workQueue`：任务队列为 `ArrayBlockingQueue`，并且容量为 100; +6. `handler`:饱和策略为 `CallerRunsPolicy`。 + +**Output：** + +``` +pool-1-thread-2 Start. Time = Tue Nov 12 20:59:44 CST 2019 +pool-1-thread-5 Start. Time = Tue Nov 12 20:59:44 CST 2019 +pool-1-thread-4 Start. Time = Tue Nov 12 20:59:44 CST 2019 +pool-1-thread-1 Start. Time = Tue Nov 12 20:59:44 CST 2019 +pool-1-thread-3 Start. Time = Tue Nov 12 20:59:44 CST 2019 +pool-1-thread-5 End. Time = Tue Nov 12 20:59:49 CST 2019 +pool-1-thread-3 End. Time = Tue Nov 12 20:59:49 CST 2019 +pool-1-thread-2 End. Time = Tue Nov 12 20:59:49 CST 2019 +pool-1-thread-4 End. Time = Tue Nov 12 20:59:49 CST 2019 +pool-1-thread-1 End. Time = Tue Nov 12 20:59:49 CST 2019 +pool-1-thread-2 Start. Time = Tue Nov 12 20:59:49 CST 2019 +pool-1-thread-1 Start. Time = Tue Nov 12 20:59:49 CST 2019 +pool-1-thread-4 Start. Time = Tue Nov 12 20:59:49 CST 2019 +pool-1-thread-3 Start. Time = Tue Nov 12 20:59:49 CST 2019 +pool-1-thread-5 Start. Time = Tue Nov 12 20:59:49 CST 2019 +pool-1-thread-2 End. Time = Tue Nov 12 20:59:54 CST 2019 +pool-1-thread-3 End. Time = Tue Nov 12 20:59:54 CST 2019 +pool-1-thread-4 End. Time = Tue Nov 12 20:59:54 CST 2019 +pool-1-thread-5 End. Time = Tue Nov 12 20:59:54 CST 2019 +pool-1-thread-1 End. Time = Tue Nov 12 20:59:54 CST 2019 + +``` + +### 4.2 线程池原理分析 + +承接 5.1 节，我们通过代码输出结果可以看出：**线程池每次会同时执行 5 个任务，这 5 个任务执行完之后，剩余的 5 个任务才会被执行。** 大家可以先通过上面讲解的内容，分析一下到底是咋回事？（自己独立思考一会） + +现在，我们就分析上面的输出内容来简单分析一下线程池原理。 + +**为了搞懂线程池的原理，我们需要首先分析一下 `execute`方法。**在 5.1 节中的 Demo 中我们使用 `executor.execute(worker)`来提交一个任务到线程池中去，这个方法非常重要，下面我们来看看它的源码： + +```java + // 存放线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount) + private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); + + private static int workerCountOf(int c) { + return c & CAPACITY; + } + + private final BlockingQueue workQueue; + + public void execute(Runnable command) { + // 如果任务为null，则抛出异常。 + if (command == null) + throw new NullPointerException(); + // ctl 中保存的线程池当前的一些状态信息 + int c = ctl.get(); + + // 下面会涉及到 3 步 操作 + // 1.首先判断当前线程池中之行的任务数量是否小于 corePoolSize + // 如果小于的话，通过addWorker(command, true)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。 + if (workerCountOf(c) < corePoolSize) { + if (addWorker(command, true)) + return; + c = ctl.get(); + } + // 2.如果当前之行的任务数量大于等于 corePoolSize 的时候就会走到这里 + // 通过 isRunning 方法判断线程池状态，线程池处于 RUNNING 状态才会被并且队列可以加入任务，该任务才会被加入进去 + if (isRunning(c) && workQueue.offer(command)) { + int recheck = ctl.get(); + // 再次获取线程池状态，如果线程池状态不是 RUNNING 状态就需要从任务队列中移除任务，并尝试判断线程是否全部执行完毕。同时执行拒绝策略。 + if (!isRunning(recheck) && remove(command)) + reject(command); + // 如果当前线程池为空就新创建一个线程并执行。 + else if (workerCountOf(recheck) == 0) + addWorker(null, false); + } + //3. 通过addWorker(command, false)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。 + //如果addWorker(command, false)执行失败，则通过reject()执行相应的拒绝策略的内容。 + else if (!addWorker(command, false)) + reject(command); + } +``` + +通过下图可以更好的对上面这 3 步做一个展示，下图是我为了省事直接从网上找到，原地址不明。 + +![图解线程池实现原理](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-7/图解线程池实现原理.png) + +现在，让我们在回到 5.1 节我们写的 Demo， 现在应该是不是很容易就可以搞懂它的原理了呢？ + +没搞懂的话，也没关系，可以看看我的分析： + +> 我们在代码中模拟了 10 个任务，我们配置的核心线程数为 5 、等待队列容量为 100 ，所以每次只可能存在 5 个任务同时执行，剩下的 5 个任务会被放到等待队列中去。当前的 5 个任务之行完成后，才会之行剩下的 5 个任务。 + +### 4.3 几个常见的对比 + +#### 4.3.1 `Runnable` vs `Callable` + +`Runnable`自 Java 1.0 以来一直存在，但`Callable`仅在 Java 1.5 中引入,目的就是为了来处理`Runnable`不支持的用例。**`Runnable` 接口**不会返回结果或抛出检查异常，但是**`Callable` 接口**可以。所以，如果任务不需要返回结果或抛出异常推荐使用 **`Runnable` 接口**，这样代码看起来会更加简洁。 + +工具类 `Executors` 可以实现 `Runnable` 对象和 `Callable` 对象之间的相互转换。（`Executors.callable（Runnable task`）或 `Executors.callable（Runnable task，Object resule）`）。 + +`Runnable.java` + +```java +@FunctionalInterface +public interface Runnable { + /** + * 被线程执行，没有返回值也无法抛出异常 + */ + public abstract void run(); +} +``` + +`Callable.java` + +```java +@FunctionalInterface +public interface Callable { + /** + * 计算结果，或在无法这样做时抛出异常。 + * @return 计算得出的结果 + * @throws 如果无法计算结果，则抛出异常 + */ + V call() throws Exception; +} + +``` + +#### 4.3.2 `execute()` vs `submit()` + +1. **`execute()`方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；** +2. **`submit()`方法用于提交需要返回值的任务。线程池会返回一个 `Future` 类型的对象，通过这个 `Future` 对象可以判断任务是否执行成功**，并且可以通过 `Future` 的 `get()`方法来获取返回值，`get()`方法会阻塞当前线程直到任务完成，而使用 `get（long timeout，TimeUnit unit）`方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。 + +我们以**`AbstractExecutorService`**接口中的一个 `submit` 方法为例子来看看源代码： + +```java + public Future submit(Runnable task) { + if (task == null) throw new NullPointerException(); + RunnableFuture ftask = newTaskFor(task, null); + execute(ftask); + return ftask; + } +``` + +上面方法调用的 `newTaskFor` 方法返回了一个 `FutureTask` 对象。 + +```java + protected RunnableFuture newTaskFor(Runnable runnable, T value) { + return new FutureTask(runnable, value); + } +``` + +我们再来看看`execute()`方法： + +```java + public void execute(Runnable command) { + ... + } +``` + +#### 4.3.3 `shutdown()`VS`shutdownNow()` + +- **`shutdown（）`** :关闭线程池，线程池的状态变为 `SHUTDOWN`。线程池不再接受新任务了，但是队列里的任务得执行完毕。 +- **`shutdownNow（）`** :关闭线程池，线程的状态变为 `STOP`。线程池会终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的 List。 + +#### 4.3.2 `isTerminated()` VS `isShutdown()` + +- **`isShutDown`** 当调用 `shutdown()` 方法后返回为 true。 +- **`isTerminated`** 当调用 `shutdown()` 方法后，并且所有提交的任务完成后返回为 true + +### 4.4 加餐:`Callable`+`ThreadPoolExecutor`示例代码 + +`MyCallable.java` + +```java + +import java.util.concurrent.Callable; + +public class MyCallable implements Callable { + @Override + public String call() throws Exception { + Thread.sleep(1000); + //返回执行当前 Callable 的线程名字 + return Thread.currentThread().getName(); + } +} +``` + +`CallableDemo.java` + +```java + +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +public class CallableDemo { + + private static final int CORE_POOL_SIZE = 5; + private static final int MAX_POOL_SIZE = 10; + private static final int QUEUE_CAPACITY = 100; + private static final Long KEEP_ALIVE_TIME = 1L; + + public static void main(String[] args) { + + //使用阿里巴巴推荐的创建线程池的方式 + //通过ThreadPoolExecutor构造函数自定义参数创建 + ThreadPoolExecutor executor = new ThreadPoolExecutor( + CORE_POOL_SIZE, + MAX_POOL_SIZE, + KEEP_ALIVE_TIME, + TimeUnit.SECONDS, + new ArrayBlockingQueue<>(QUEUE_CAPACITY), + new ThreadPoolExecutor.CallerRunsPolicy()); + + List> futureList = new ArrayList<>(); + Callable callable = new MyCallable(); + for (int i = 0; i < 10; i++) { + //提交任务到线程池 + Future future = executor.submit(callable); + //将返回值 future 添加到 list，我们可以通过 future 获得 执行 Callable 得到的返回值 + futureList.add(future); + } + for (Future fut : futureList) { + try { + System.out.println(new Date() + "::" + fut.get()); + } catch (InterruptedException | ExecutionException e) { + e.printStackTrace(); + } + } + //关闭线程池 + executor.shutdown(); + } +} +``` + +Output: + +``` +Wed Nov 13 13:40:41 CST 2019::pool-1-thread-1 +Wed Nov 13 13:40:42 CST 2019::pool-1-thread-2 +Wed Nov 13 13:40:42 CST 2019::pool-1-thread-3 +Wed Nov 13 13:40:42 CST 2019::pool-1-thread-4 +Wed Nov 13 13:40:42 CST 2019::pool-1-thread-5 +Wed Nov 13 13:40:42 CST 2019::pool-1-thread-3 +Wed Nov 13 13:40:43 CST 2019::pool-1-thread-2 +Wed Nov 13 13:40:43 CST 2019::pool-1-thread-1 +Wed Nov 13 13:40:43 CST 2019::pool-1-thread-4 +Wed Nov 13 13:40:43 CST 2019::pool-1-thread-5 +``` + +##五 几种常见的线程池详解 + +### 5.1 FixedThreadPool + +#### 5.1.1 介绍 + +`FixedThreadPool` 被称为可重用固定线程数的线程池。通过 Executors 类中的相关源代码来看一下相关实现： + +```java + /** + * 创建一个可重用固定数量线程的线程池 + */ + public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) { + return new ThreadPoolExecutor(nThreads, nThreads, + 0L, TimeUnit.MILLISECONDS, + new LinkedBlockingQueue(), + threadFactory); + } +``` + +另外还有一个 `FixedThreadPool` 的实现方法，和上面的类似，所以这里不多做阐述： + +```java + public static ExecutorService newFixedThreadPool(int nThreads) { + return new ThreadPoolExecutor(nThreads, nThreads, + 0L, TimeUnit.MILLISECONDS, + new LinkedBlockingQueue()); + } +``` + +**从上面源代码可以看出新创建的 `FixedThreadPool` 的 `corePoolSize` 和 `maximumPoolSize` 都被设置为 nThreads，这个 nThreads 参数是我们使用的时候自己传递的。** + +#### 5.1.2 执行任务过程介绍 + +`FixedThreadPool` 的 `execute()` 方法运行示意图（该图片来源：《Java 并发编程的艺术》）： + +![FixedThreadPool的execute()方法运行示意图](https://imgconvert.csdnimg.cn/aHR0cDovL215LWJsb2ctdG8tdXNlLm9zcy1jbi1iZWlqaW5nLmFsaXl1bmNzLmNvbS8xOC00LTE2LzcxMzc1OTYzLmpwZw?x-oss-process=image/format,png) + +**上图说明：** + +1. 如果当前运行的线程数小于 corePoolSize， 如果再来新任务的话，就创建新的线程来执行任务； +2. 当前运行的线程数等于 corePoolSize 后， 如果再来新任务的话，会将任务加入 `LinkedBlockingQueue`； +3. 线程池中的线程执行完 手头的任务后，会在循环中反复从 `LinkedBlockingQueue` 中获取任务来执行； + +#### 5.1.3 为什么不推荐使用`FixedThreadPool`？ + +**`FixedThreadPool` 使用无界队列 `LinkedBlockingQueue`（队列的容量为 Intger.MAX_VALUE）作为线程池的工作队列会对线程池带来如下影响 ：** + +1. 当线程池中的线程数达到 `corePoolSize` 后，新任务将在无界队列中等待，因此线程池中的线程数不会超过 corePoolSize； +2. 由于使用无界队列时 `maximumPoolSize` 将是一个无效参数，因为不可能存在任务队列满的情况。所以，通过创建 `FixedThreadPool`的源码可以看出创建的 `FixedThreadPool` 的 `corePoolSize` 和 `maximumPoolSize` 被设置为同一个值。 +3. 由于 1 和 2，使用无界队列时 `keepAliveTime` 将是一个无效参数； +4. 运行中的 `FixedThreadPool`（未执行 `shutdown()`或 `shutdownNow()`）不会拒绝任务，在任务比较多的时候会导致 OOM（内存溢出）。 + +### 5.2 SingleThreadExecutor 详解 + +#### 5.2.1 介绍 + +`SingleThreadExecutor` 是只有一个线程的线程池。下面看看**SingleThreadExecutor 的实现：** + +```java + /** + *返回只有一个线程的线程池 + */ + public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) { + return new FinalizableDelegatedExecutorService + (new ThreadPoolExecutor(1, 1, + 0L, TimeUnit.MILLISECONDS, + new LinkedBlockingQueue(), + threadFactory)); + } +``` + +```java + public static ExecutorService newSingleThreadExecutor() { + return new FinalizableDelegatedExecutorService + (new ThreadPoolExecutor(1, 1, + 0L, TimeUnit.MILLISECONDS, + new LinkedBlockingQueue())); + } +``` + +从上面源代码可以看出新创建的 `SingleThreadExecutor` 的 `corePoolSize` 和 `maximumPoolSize` 都被设置为 1.其他参数和 `FixedThreadPool` 相同。 + +#### 5.2.2 执行任务过程介绍 + +**`SingleThreadExecutor` 的运行示意图（该图片来源：《Java 并发编程的艺术》）：** +![SingleThreadExecutor的运行示意图](https://imgconvert.csdnimg.cn/aHR0cDovL215LWJsb2ctdG8tdXNlLm9zcy1jbi1iZWlqaW5nLmFsaXl1bmNzLmNvbS8xOC00LTE2LzgyMjc2NDU4LmpwZw?x-oss-process=image/format,png) + +**上图说明;** + +1. 如果当前运行的线程数少于 corePoolSize，则创建一个新的线程执行任务； +2. 当前线程池中有一个运行的线程后，将任务加入 `LinkedBlockingQueue` +3. 线程执行完当前的任务后，会在循环中反复从` LinkedBlockingQueue` 中获取任务来执行； + +#### 5.2.3 为什么不推荐使用`FixedThreadPool`？ + +`SingleThreadExecutor` 使用无界队列 `LinkedBlockingQueue` 作为线程池的工作队列（队列的容量为 Intger.MAX_VALUE）。`SingleThreadExecuto`r 使用无界队列作为线程池的工作队列会对线程池带来的影响与 `FixedThreadPool` 相同。说简单点就是可能会导致 OOM， + +### 5.3 CachedThreadPool 详解 + +#### 5.3.1 介绍 + +`CachedThreadPool` 是一个会根据需要创建新线程的线程池。下面通过源码来看看 `CachedThreadPool` 的实现： + +```java + /** + * 创建一个线程池，根据需要创建新线程，但会在先前构建的线程可用时重用它。 + */ + public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) { + return new ThreadPoolExecutor(0, Integer.MAX_VALUE, + 60L, TimeUnit.SECONDS, + new SynchronousQueue(), + threadFactory); + } + +``` + +```java + public static ExecutorService newCachedThreadPool() { + return new ThreadPoolExecutor(0, Integer.MAX_VALUE, + 60L, TimeUnit.SECONDS, + new SynchronousQueue()); + } +``` + +`CachedThreadPool` 的` corePoolSize` 被设置为空（0），`maximumPoolSize `被设置为 Integer.MAX.VALUE，即它是无界的，这也就意味着如果主线程提交任务的速度高于 `maximumPool` 中线程处理任务的速度时，`CachedThreadPool` 会不断创建新的线程。极端情况下，这样会导致耗尽 cpu 和内存资源。 + +#### 5.3.2 执行任务过程介绍 + +**CachedThreadPool 的 execute()方法的执行示意图（该图片来源：《Java 并发编程的艺术》）：** +![CachedThreadPool的execute()方法的执行示意图](https://imgconvert.csdnimg.cn/aHR0cDovL215LWJsb2ctdG8tdXNlLm9zcy1jbi1iZWlqaW5nLmFsaXl1bmNzLmNvbS8xOC00LTE2LzE4NjExNzY3LmpwZw?x-oss-process=image/format,png) + +**上图说明：** + +1. 首先执行 `SynchronousQueue.offer(Runnable task)` 提交任务到任务队列。如果当前 `maximumPool` 中有闲线程正在执行 `SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)`，那么主线程执行 offer 操作与空闲线程执行的 `poll` 操作配对成功，主线程把任务交给空闲线程执行，`execute()`方法执行完成，否则执行下面的步骤 2； +2. 当初始 `maximumPool` 为空，或者 `maximumPool` 中没有空闲线程时，将没有线程执行 `SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)`。这种情况下，步骤 1 将失败，此时 `CachedThreadPool` 会创建新线程执行任务，execute 方法执行完成； + +#### 5.3.3 为什么不推荐使用`CachedThreadPool`？ + +`CachedThreadPool`允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致 OOM。 + +## 六 ScheduledThreadPoolExecutor 详解 + +**`ScheduledThreadPoolExecutor` 主要用来在给定的延迟后运行任务，或者定期执行任务。** 这个在实际项目中基本不会被用到，所以对这部分大家只需要简单了解一下它的思想。关于如何在Spring Boot 中 实现定时任务，可以查看这篇文章[《5分钟搞懂如何在Spring Boot中Schedule Tasks》](https://github.com/Snailclimb/springboot-guide/blob/master/docs/advanced/SpringBoot-ScheduleTasks.md)。 + +### 6.1 简介 + +**`ScheduledThreadPoolExecutor` 使用的任务队列 `DelayQueue` 封装了一个 `PriorityQueue`，`PriorityQueue` 会对队列中的任务进行排序，执行所需时间短的放在前面先被执行(`ScheduledFutureTask` 的 `time` 变量小的先执行)，如果执行所需时间相同则先提交的任务将被先执行(`ScheduledFutureTask` 的 `squenceNumber` 变量小的先执行)。** + +**`ScheduledThreadPoolExecutor` 和 `Timer` 的比较：** + +- `Timer` 对系统时钟的变化敏感，`ScheduledThreadPoolExecutor`不是； +- `Timer` 只有一个执行线程，因此长时间运行的任务可以延迟其他任务。 `ScheduledThreadPoolExecutor` 可以配置任意数量的线程。 此外，如果你想（通过提供 ThreadFactory），你可以完全控制创建的线程; +- 在`TimerTask` 中抛出的运行时异常会杀死一个线程，从而导致 `Timer` 死机:-( ...即计划任务将不再运行。`ScheduledThreadExecutor` 不仅捕获运行时异常，还允许您在需要时处理它们（通过重写 `afterExecute` 方法`ThreadPoolExecutor`）。抛出异常的任务将被取消，但其他任务将继续运行。 + +**综上，在 JDK1.5 之后，你没有理由再使用 Timer 进行任务调度了。** + +> **备注：** Quartz 是一个由 java 编写的任务调度库，由 OpenSymphony 组织开源出来。在实际项目开发中使用 Quartz 的还是居多，比较推荐使用 Quartz。因为 Quartz 理论上能够同时对上万个任务进行调度，拥有丰富的功能特性，包括任务调度、任务持久化、可集群化、插件等等。 + +### 6.2 运行机制 + +![ScheduledThreadPoolExecutor运行机制](https://imgconvert.csdnimg.cn/aHR0cDovL215LWJsb2ctdG8tdXNlLm9zcy1jbi1iZWlqaW5nLmFsaXl1bmNzLmNvbS8xOC00LTE2LzkyNTk0Njk4LmpwZw?x-oss-process=image/format,png) + +**`ScheduledThreadPoolExecutor` 的执行主要分为两大部分：** + +1. 当调用 `ScheduledThreadPoolExecutor` 的 **`scheduleAtFixedRate()`** 方法或者**`scheduleWirhFixedDelay()`** 方法时，会向 `ScheduledThreadPoolExecutor` 的 **`DelayQueue`** 添加一个实现了 **`RunnableScheduledFuture`** 接口的 **`ScheduledFutureTask`** 。 +2. 线程池中的线程从 `DelayQueue` 中获取 `ScheduledFutureTask`，然后执行任务。 + +**`ScheduledThreadPoolExecutor` 为了实现周期性的执行任务，对 `ThreadPoolExecutor `做了如下修改：** + +- 使用 **`DelayQueue`** 作为任务队列； +- 获取任务的方不同 +- 执行周期任务后，增加了额外的处理 + +### 6.3 ScheduledThreadPoolExecutor 执行周期任务的步骤 + +![ScheduledThreadPoolExecutor执行周期任务的步骤](https://imgconvert.csdnimg.cn/aHR0cDovL215LWJsb2ctdG8tdXNlLm9zcy1jbi1iZWlqaW5nLmFsaXl1bmNzLmNvbS8xOC01LTMwLzU5OTE2Mzg5LmpwZw?x-oss-process=image/format,png) + +1. 线程 1 从 `DelayQueue` 中获取已到期的 `ScheduledFutureTask（DelayQueue.take()）`。到期任务是指 `ScheduledFutureTask `的 time 大于等于当前系统的时间； +2. 线程 1 执行这个 `ScheduledFutureTask`； +3. 线程 1 修改 `ScheduledFutureTask` 的 time 变量为下次将要被执行的时间； +4. 线程 1 把这个修改 time 之后的 `ScheduledFutureTask` 放回 `DelayQueue` 中（`DelayQueue.add()`)。 + +## 七 线程池大小确定 + +**线程池数量的确定一直是困扰着程序员的一个难题，大部分程序员在设定线程池大小的时候就是随心而定。我们并没有考虑过这样大小的配置是否会带来什么问题，我自己就是这大部分程序员中的一个代表。** + +由于笔主对如何确定线程池大小也没有什么实际经验，所以，这部分内容参考了网上很多文章/书籍。 + +**首先，可以肯定的一点是线程池大小设置过大或者过小都会有问题。合适的才是最好，貌似在 95 % 的场景下都是合适的。** + +如果阅读过我的上一篇关于线程池的文章的话，你一定知道： + +**如果我们设置的线程池数量太小的话，如果同一时间有大量任务/请求需要处理，可能会导致大量的请求/任务在任务队列中排队等待执行，甚至会出现任务队列满了之后任务/请求无法处理的情况，或者大量任务堆积在任务队列导致 OOM。这样很明显是有问题的！ CPU 根本没有得到充分利用。** + +**但是，如果我们设置线程数量太大，大量线程可能会同时在争取 CPU 资源，这样会导致大量的上下文切换，从而增加线程的执行时间，影响了整体执行效率。** + +> 上下文切换： +> +> 多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。**任务从保存到再加载的过程就是一次上下文切换**。 +> +> 上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。 +> +> Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。 + +有一个简单并且适用面比较广的公式： + +- **CPU 密集型任务(N+1)：** 这种任务消耗的主要是 CPU 资源，可以将线程数设置为 N（CPU 核心数）+1，比 CPU 核心数多出来的一个线程是为了防止线程偶发的缺页中断，或者其它原因导致的任务暂停而带来的影响。一旦任务暂停，CPU 就会处于空闲状态，而在这种情况下多出来的一个线程就可以充分利用 CPU 的空闲时间。 +- **I/O 密集型任务(2N)：** 这种任务应用起来，系统会用大部分的时间来处理 I/O 交互，而线程在处理 I/O 的时间段内不会占用 CPU 来处理，这时就可以将 CPU 交出给其它线程使用。因此在 I/O 密集型任务的应用中，我们可以多配置一些线程，具体的计算方法是 2N。 + +## 八 参考 + +- 《Java 并发编程的艺术》 +- [Java Scheduler ScheduledExecutorService ScheduledThreadPoolExecutor Example](https://www.journaldev.com/2340/java-scheduler-scheduledexecutorservice-scheduledthreadpoolexecutor-example "Java Scheduler ScheduledExecutorService ScheduledThreadPoolExecutor Example") +- [java.util.concurrent.ScheduledThreadPoolExecutor Example](https://examples.javacodegeeks.com/core-java/util/concurrent/scheduledthreadpoolexecutor/java-util-concurrent-scheduledthreadpoolexecutor-example/ "java.util.concurrent.ScheduledThreadPoolExecutor Example") +- [ThreadPoolExecutor – Java Thread Pool Example](https://www.journaldev.com/1069/threadpoolexecutor-java-thread-pool-example-executorservice "ThreadPoolExecutor – Java Thread Pool Example") + +## 九 其他推荐阅读 + +- [Java 并发（三）线程池原理](https://www.cnblogs.com/warehouse/p/10720781.html "Java并发（三）线程池原理") +- [如何优雅的使用和理解线程池](https://github.com/crossoverJie/JCSprout/blob/master/MD/ThreadPoolExecutor.md "如何优雅的使用和理解线程池") \ No newline at end of file diff --git a/docs/java/synchronized.md b/docs/java/Multithread/synchronized.md similarity index 100% rename from docs/java/synchronized.md rename to docs/java/Multithread/synchronized.md diff --git "a/docs/java/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md" "b/docs/java/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md" index 22873b3d9fd..243001efe59 100644 --- "a/docs/java/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md" +++ "b/docs/java/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md" @@ -1,3 +1,4 @@ +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 @@ -37,12 +38,10 @@ JDK提供的这些容器大部分在 `java.util.concurrent` 包中。 所以就有了 HashMap 的线程安全版本—— ConcurrentHashMap 的诞生。在ConcurrentHashMap中，无论是读操作还是写操作都能保证很高的性能：在进行读操作时(几乎)不需要加锁，而在写操作时通过锁分段技术只对所操作的段加锁而不影响客户端对其它段的访问。 -关于 ConcurrentHashMap 相关问题，我在 [《这几道Java集合框架面试题几乎必问》](https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/Java%E9%9B%86%E5%90%88%E6%A1%86%E6%9E%B6%E5%B8%B8%E8%A7%81%E9%9D%A2%E8%AF%95%E9%A2%98%E6%80%BB%E7%BB%93.md) 这篇文章中已经提到过。下面梳理一下关于 ConcurrentHashMap 比较重要的问题： - -- [ConcurrentHashMap 和 Hashtable 的区别](https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/%E8%BF%99%E5%87%A0%E9%81%93Java%E9%9B%86%E5%90%88%E6%A1%86%E6%9E%B6%E9%9D%A2%E8%AF%95%E9%A2%98%E5%87%A0%E4%B9%8E%E5%BF%85%E9%97%AE.md#concurrenthashmap-%E5%92%8C-hashtable-%E7%9A%84%E5%8C%BA%E5%88%AB) -- [ConcurrentHashMap线程安全的具体实现方式/底层具体实现](https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/%E8%BF%99%E5%87%A0%E9%81%93Java%E9%9B%86%E5%90%88%E6%A1%86%E6%9E%B6%E9%9D%A2%E8%AF%95%E9%A2%98%E5%87%A0%E4%B9%8E%E5%BF%85%E9%97%AE.md#concurrenthashmap%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8%E7%9A%84%E5%85%B7%E4%BD%93%E5%AE%9E%E7%8E%B0%E6%96%B9%E5%BC%8F%E5%BA%95%E5%B1%82%E5%85%B7%E4%BD%93%E5%AE%9E%E7%8E%B0) - +关于 ConcurrentHashMap 相关问题，我在 [Java集合框架常见面试题](https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/Java%E9%9B%86%E5%90%88%E6%A1%86%E6%9E%B6%E5%B8%B8%E8%A7%81%E9%9D%A2%E8%AF%95%E9%A2%98.md) 这篇文章中已经提到过。下面梳理一下关于 ConcurrentHashMap 比较重要的问题： +- [ConcurrentHashMap 和 Hashtable 的区别](https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/Java%E9%9B%86%E5%90%88%E6%A1%86%E6%9E%B6%E5%B8%B8%E8%A7%81%E9%9D%A2%E8%AF%95%E9%A2%98.md#concurrenthashmap-%E5%92%8C-hashtable-%E7%9A%84%E5%8C%BA%E5%88%AB) +- [ConcurrentHashMap线程安全的具体实现方式/底层具体实现](https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/Java%E9%9B%86%E5%90%88%E6%A1%86%E6%9E%B6%E5%B8%B8%E8%A7%81%E9%9D%A2%E8%AF%95%E9%A2%98.md#concurrenthashmap%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8%E7%9A%84%E5%85%B7%E4%BD%93%E5%AE%9E%E7%8E%B0%E6%96%B9%E5%BC%8F%E5%BA%95%E5%B1%82%E5%85%B7%E4%BD%93%E5%AE%9E%E7%8E%B0) ## 三 CopyOnWriteArrayList @@ -214,10 +213,18 @@ PriorityBlockingQueue 并发控制采用的是 **ReentrantLock**，队列为无 使用跳表实现Map 和使用哈希算法实现Map的另外一个不同之处是：哈希并不会保存元素的顺序，而跳表内所有的元素都是排序的。因此在对跳表进行遍历时，你会得到一个有序的结果。所以，如果你的应用需要有序性，那么跳表就是你不二的选择。JDK 中实现这一数据结构的类是ConcurrentSkipListMap。 - - ## 七 参考 - 《实战Java高并发程序设计》 - https://javadoop.com/post/java-concurrent-queue - https://juejin.im/post/5aeebd02518825672f19c546 + +## 公众号 + +如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 + +**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"面试突击"** 即可免费领取！ + +**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 + +![我的公众号](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/167598cd2e17b8ec.png) diff --git "a/docs/java/Multithread/\345\271\266\345\217\221\347\274\226\347\250\213\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/docs/java/Multithread/\345\271\266\345\217\221\347\274\226\347\250\213\345\237\272\347\241\200\347\237\245\350\257\206.md" new file mode 100644 index 00000000000..68509cdc066 --- /dev/null +++ "b/docs/java/Multithread/\345\271\266\345\217\221\347\274\226\347\250\213\345\237\272\347\241\200\347\237\245\350\257\206.md" @@ -0,0 +1,407 @@ +# Java 并发基础知识 + +Java 并发的基础知识，可能会在笔试中遇到，技术面试中也可能以并发知识环节提问的第一个问题出现。比如面试官可能会问你：“谈谈自己对于进程和线程的理解，两者的区别是什么？” + +**本节思维导图：** + +## 一 进程和线程 + +进程和线程的对比这一知识点由于过于基础，所以在面试中很少碰到，但是极有可能会在笔试题中碰到。 + +常见的提问形式是这样的：**“什么是线程和进程?，请简要描述线程与进程的关系、区别及优缺点？ ”**。 + +### 1.1. 何为进程? + +进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。 + +在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。 + +如下图所示，在 windows 中通过查看任务管理器的方式，我们就可以清楚看到 window 当前运行的进程（.exe 文件的运行）。 + +![进程 ](https://images.gitbook.cn/a0929b60-d133-11e8-88a4-5328c5b70145) + +### 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 内存区域讲的最清楚的一篇文章》]() + +
+ +
+ + +从上图可以看出：一个进程中可以有多个线程，多个线程共享进程的**堆**和**方法区 (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("运行结束"); + } + +} + +``` +运行结果： +![结果 ](https://user-gold-cdn.xitu.io/2018/3/20/16243e80f22a2d54?w=161&h=54&f=jpeg&s=7380) + +从上面的运行结果可以看出：线程是一个子任务，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("运行结束！"); + } + +} +``` +运行结果： +![运行结果 ](https://user-gold-cdn.xitu.io/2018/3/20/16243f4373c6141a?w=137&h=46&f=jpeg&s=7316) + +### 3.3 使用线程池的方式 + +使用线程池的方式也是最推荐的一种方式，另外，《阿里巴巴 Java 开发手册》在第一章第六节并发处理这一部分也强调到“线程资源必须通过线程池提供，不允许在应用中自行显示创建线程”。这里就不给大家演示代码了，线程池这一节会详细介绍到这部分内容。 + +## 四 线程的生命周期和状态 + +Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态（图源《Java 并发编程艺术》4.1.4 节）。 + +![Java 线程的状态 ](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/19-1-29/Java%E7%BA%BF%E7%A8%8B%E7%9A%84%E7%8A%B6%E6%80%81.png) + +线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示（图源《Java 并发编程艺术》4.1.4 节）： + +![Java 线程状态变迁 ](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/19-1-29/Java%20%E7%BA%BF%E7%A8%8B%E7%8A%B6%E6%80%81%E5%8F%98%E8%BF%81.png) + + + +由上图可以看出：线程创建之后它将处于 **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（运行中）** 状态 。 + +![RUNNABLE-VS-RUNNING](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/RUNNABLE-VS-RUNNING.png) + +当线程执行 `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，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。 + +![线程死锁示意图 ](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-4/2019-4死锁1.png) + +下面通过一个例子来说明线程死锁,代码模拟了上图的死锁的情况 (代码来源于《并发编程之美》)： + +```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/ + + \ No newline at end of file diff --git "a/docs/java/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203-\351\235\231\346\200\201\343\200\201\351\273\230\350\256\244\346\226\271\346\263\225.md" "b/docs/java/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203-\351\235\231\346\200\201\343\200\201\351\273\230\350\256\244\346\226\271\346\263\225.md" deleted file mode 100644 index ee1dd8c2448..00000000000 --- "a/docs/java/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203-\351\235\231\346\200\201\343\200\201\351\273\230\350\256\244\346\226\271\346\263\225.md" +++ /dev/null @@ -1,163 +0,0 @@ -JDK8接口规范 -=== -在JDK8中引入了lambda表达式，出现了函数式接口的概念，为了在扩展接口时保持向前兼容性(比如泛型也是为了保持兼容性而失去了在一些别的语言泛型拥有的功能)，Java接口规范发生了一些改变。。 ---- -## 1.JDK8以前的接口规范 -- JDK8以前接口可以定义的变量和方法 - - 所有变量(Field)不论是否显式 的声明为```public static final```，它实际上都是```public static final```的。 - - 所有方法(Method)不论是否显示 的声明为```public abstract```，它实际上都是```public abstract```的。 -```java -public interface AInterfaceBeforeJDK8 { - int FIELD = 0; - void simpleMethod(); -} -``` -以上接口信息反编译以后可以看到字节码信息里Filed是public static final的，而方法是public abstract的，即是你没有显示的去声明它。 -```java -{ - public static final int FIELD; - descriptor: I - flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL - ConstantValue: int 0 - - public abstract void simpleMethod(); - descriptor: ()V - flags: (0x0401) ACC_PUBLIC, ACC_ABSTRACT -} -``` -## 2.JDK8之后的接口规范 -- JDK8之后接口可以定义的变量和方法 - - 变量(Field)仍然必须是 ```java public static final```的 - - 方法(Method)除了可以是public abstract之外，还可以是public static或者是default(相当于仅public修饰的实例方法)的。 -从以上改变不难看出，修改接口的规范主要是为了能在扩展接口时保持向前兼容。 -
下面是一个JDK8之后的接口例子 -```java -public interface AInterfaceInJDK8 { - int simpleFiled = 0; - static int staticField = 1; - - public static void main(String[] args) { - } - static void staticMethod(){} - - default void defaultMethod(){} - - void simpleMethod() throws IOException; - -} -``` -进行反编译(去除了一些没用信息) -```java -{ - public static final int simpleFiled; - flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL - - public static final int staticField; - flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL - - public static void main(java.lang.String[]); - flags: (0x0009) ACC_PUBLIC, ACC_STATIC - - public static void staticMethod(); - flags: (0x0009) ACC_PUBLIC, ACC_STATIC - - public void defaultMethod(); - flags: (0x0001) ACC_PUBLIC - - public abstract void simpleMethod() throws java.io.IOException; - flags: (0x0401) ACC_PUBLIC, ACC_ABSTRACT - Exceptions: - throws java.io.IOException -} -``` -可以看到 default关键字修饰的方法是像实例方法一样定义的，所以我们来定义一个只有default的方法并且实现一下试一试。 -```java -interface Default { - default int defaultMethod() { - return 4396; - } -} - -public class DefaultMethod implements Default { - public static void main(String[] args) { - DefaultMethod defaultMethod = new DefaultMethod(); - System.out.println(defaultMethod.defaultMethod()); - //compile error : Non-static method 'defaultMethod()' cannot be referenced from a static context - //! DefaultMethod.defaultMethod(); - } -} -``` -可以看到default方法确实像实例方法一样，必须有实例对象才能调用，并且子类在实现接口时，可以不用实现default方法，也可以覆盖该方法。 -这有点像子类继承父类实例方法。 -
-接口静态方法就像是类静态方法，唯一的区别是**接口静态方法只能通过接口名调用，而类静态方法既可以通过类名调用也可以通过实例调用** -```java -interface Static { - static int staticMethod() { - return 4396; - } -} - ... main(String...args) - //!compile error: Static method may be invoked on containing interface class only - //!aInstanceOfStatic.staticMethod(); - ... -``` -另一个问题是多继承问题，大家知道Java中类是不支持多继承的，但是接口是多继承和多实现(implements后跟多个接口)的， -那么如果一个接口继承另一个接口，两个接口都有同名的default方法会怎么样呢？答案是会像类继承一样覆写(@Override)，以下代码在IDE中可以顺利编译 -```java -interface Default { - default int defaultMethod() { - return 4396; - } -} -interface Default2 extends Default { - @Override - default int defaultMethod() { - return 9527; - } -} -public class DefaultMethod implements Default,Default2 { - public static void main(String[] args) { - DefaultMethod defaultMethod = new DefaultMethod(); - System.out.println(defaultMethod.defaultMethod()); - } -} - -输出 : 9527 -``` -出现上面的情况时，会优先找继承树上近的方法，类似于“短路优先”。 -
-那么如果一个类实现了两个没有继承关系的接口，且这两个接口有同名方法的话会怎么样呢？IDE会要求你重写这个冲突的方法，让你自己选择去执行哪个方法，因为IDE它 -还没智能到你不告诉它，它就知道你想执行哪个方法。可以通过```java 接口名.super```指针来访问接口中定义的实例(default)方法。 -```java -interface Default { - default int defaultMethod() { - return 4396; - } -} - -interface Default2 { - default int defaultMethod() { - return 9527; - } -} -//如果不重写 -//compile error : defaults.DefaultMethod inherits unrelated defaults for defaultMethod() from types defaults.Default and defaults.Default2 -public class DefaultMethod implements Default,Default2 { -@Override - public int defaultMethod() { - System.out.println(Default.super.defaultMethod()); - System.out.println(Default2.super.defaultMethod()); - return 996; - } - public static void main(String[] args) { - DefaultMethod defaultMethod = new DefaultMethod(); - System.out.println(defaultMethod.defaultMethod()); - } -} - -运行输出 : -4396 -9527 -996 -``` diff --git a/docs/java/What's New in JDK8/Java8Tutorial.md b/docs/java/What's New in JDK8/Java8Tutorial.md index cee4d4e4f0a..39d0224ebd5 100644 --- a/docs/java/What's New in JDK8/Java8Tutorial.md +++ b/docs/java/What's New in JDK8/Java8Tutorial.md @@ -1,3 +1,5 @@ +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 + 随着 Java 8 的普及度越来越高，很多人都提到面试中关于Java 8 也是非常常问的知识点。应各位要求和需要，我打算对这部分知识做一个总结。本来准备自己总结的，后面看到Github 上有一个相关的仓库，地址： [https://github.com/winterbe/java8-tutorial](https://github.com/winterbe/java8-tutorial)。这个仓库是英文的，我对其进行了翻译并添加和修改了部分内容，下面是正文了。 @@ -37,7 +39,7 @@ - [LocalDate\(本地日期\)](#localdate本地日期) - [LocalDateTime\(本地日期时间\)](#localdatetime本地日期时间) - [Annotations\(注解\)](#annotations注解) - - [Whete to go from here?](#whete-to-go-from-here) + - [Where to go from here?](#where-to-go-from-here) @@ -442,15 +444,15 @@ optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b" 首先看看Stream是怎么用，首先创建实例代码的用到的数据List： ```java -List stringCollection = new ArrayList<>(); -stringCollection.add("ddd2"); -stringCollection.add("aaa2"); -stringCollection.add("bbb1"); -stringCollection.add("aaa1"); -stringCollection.add("bbb3"); -stringCollection.add("ccc"); -stringCollection.add("bbb2"); -stringCollection.add("ddd1"); +List stringList = new ArrayList<>(); +stringList.add("ddd2"); +stringList.add("aaa2"); +stringList.add("bbb1"); +stringList.add("aaa1"); +stringList.add("bbb3"); +stringList.add("ccc"); +stringList.add("bbb2"); +stringList.add("ddd1"); ``` Java 8扩展了集合类，可以通过 Collection.stream() 或者 Collection.parallelStream() 来创建一个Stream。下面几节将详细解释常用的Stream操作： @@ -492,7 +494,7 @@ forEach 是为 Lambda 而设计的，保持了最紧凑的风格。而且 Lambda 中间操作 map 会将元素根据指定的 Function 接口来依次将元素转成另外的对象。 -下面的示例展示了将字符串转换为大写字符串。你也可以通过map来讲对象转换成其他类型，map返回的Stream类型是根据你map传递进去的函数的返回值决定的。 +下面的示例展示了将字符串转换为大写字符串。你也可以通过map来将对象转换成其他类型，map返回的Stream类型是根据你map传递进去的函数的返回值决定的。 ```java // 测试 Map 操作 @@ -916,9 +918,16 @@ System.out.println(hints2.length); // 2 @interface MyAnnotation {} ``` +## Where to go from here? +关于Java 8的新特性就写到这了，肯定还有更多的特性等待发掘。JDK 1.8里还有很多很有用的东西，比如`Arrays.parallelSort`, `StampedLock`和`CompletableFuture`等等。 -## Whete to go from here? +## 公众号 -关于Java 8的新特性就写到这了，肯定还有更多的特性等待发掘。JDK 1.8里还有很多很有用的东西，比如`Arrays.parallelSort`, `StampedLock`和`CompletableFuture`等等。 +如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 + +**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！ + +**Java工程师必备学习资源:** 一些Java工程师常用学习资源[公众号](#公众号)后台回复关键字 **“1”** 即可免费无套路获取。 +![我的公众号](https://user-gold-cdn.xitu.io/2018/11/28/167598cd2e17b8ec?w=258&h=258&f=jpeg&s=27334) diff --git "a/docs/java/What's New in JDK8/Java8foreach\346\214\207\345\215\227.md" "b/docs/java/What's New in JDK8/Java8foreach\346\214\207\345\215\227.md" new file mode 100644 index 00000000000..48cda3abfd9 --- /dev/null +++ "b/docs/java/What's New in JDK8/Java8foreach\346\214\207\345\215\227.md" @@ -0,0 +1,139 @@ +> 本文由 JavaGuide 翻译，原文地址：https://www.baeldung.com/foreach-java + +## 1 概述 + +在Java 8中引入的*forEach*循环为程序员提供了一种新的，简洁而有趣的迭代集合的方式。 + +在本文中，我们将看到如何将*forEach*与集合*一起*使用，它采用何种参数以及此循环与增强的*for*循环的不同之处。 + +## 2 基础知识 + +```Java +public interface Collection extends Iterable +``` + +Collection 接口实现了 Iterable 接口，而 Iterable 接口在 Java 8开始具有一个新的 API： + +```java +void forEach(Consumer action)//对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。 +``` + +使用*forEach*，我们可以迭代一个集合并对每个元素执行给定的操作，就像任何其他*迭代器一样。* + +例如，迭代和打印字符串集合*的*for循环版本： + +```java +for (String name : names) { + System.out.println(name); +} +``` + +我们可以使用*forEach*写这个 ： + +```java +names.forEach(name -> { + System.out.println(name); +}); +``` + +## 3.使用forEach方法 + +### 3.1 匿名类 + +我们使用 *forEach*迭代集合并对每个元素执行特定操作。**要执行的操作包含在实现Consumer接口的类中，并作为参数传递给forEach 。** + +所述*消费者*接口是一个功能接口(具有单个抽象方法的接口）。它接受输入并且不返回任何结果。 + +Consumer 接口定义如下： + +```java +@FunctionalInterface +public interface Consumer { + void accept(T t); +} +``` +任何实现，例如，只是打印字符串的消费者： + +```java +Consumer printConsumer = new Consumer() { + public void accept(String name) { + System.out.println(name); + }; +}; +``` + +可以作为参数传递给*forEach*： + +```java +names.forEach(printConsumer); +``` + +但这不是通过消费者和使用*forEach* API 创建操作的唯一方法。让我们看看我们将使用*forEach*方法的另外2种最流行的方式： + +### 3.2 Lambda表达式 + +Java 8功能接口的主要优点是我们可以使用Lambda表达式来实例化它们，并避免使用庞大的匿名类实现。 + +由于 Consumer 接口属于函数式接口，我们可以通过以下形式在Lambda中表达它： + +```java +(argument) -> { body } +name -> System.out.println(name) +names.forEach(name -> System.out.println(name)); +``` + +### 3.3 方法参考 + +我们可以使用方法引用语法而不是普通的Lambda语法，其中已存在一个方法来对类执行操作： + +```java +names.forEach(System.out::println); +``` + +## 4.forEach在集合中的使用 + +### 4.1.迭代集合 + +**任何类型Collection的可迭代 - 列表，集合，队列 等都具有使用forEach的相同语法。** + +因此，正如我们已经看到的，迭代列表的元素： + +```java +List names = Arrays.asList("Larry", "Steve", "James"); + +names.forEach(System.out::println); +``` + +同样对于一组： + +```java +Set uniqueNames = new HashSet<>(Arrays.asList("Larry", "Steve", "James")); + +uniqueNames.forEach(System.out::println); +``` + +或者让我们说一个*队列*也是一个*集合*： + +```java +Queue namesQueue = new ArrayDeque<>(Arrays.asList("Larry", "Steve", "James")); + +namesQueue.forEach(System.out::println); +``` + +### 4.2.迭代Map - 使用Map的forEach + +Map没有实现Iterable接口，但它**提供了自己的forEach 变体，它接受BiConsumer**。* + +```java +Map namesMap = new HashMap<>(); +namesMap.put(1, "Larry"); +namesMap.put(2, "Steve"); +namesMap.put(3, "James"); +namesMap.forEach((key, value) -> System.out.println(key + " " + value)); +``` + +### 4.3.迭代一个Map - 通过迭代entrySet + +```java +namesMap.entrySet().forEach(entry -> System.out.println(entry.getKey() + " " + entry.getValue())); +``` \ No newline at end of file diff --git "a/docs/java/What's New in JDK8/Java8\346\225\231\347\250\213\346\216\250\350\215\220.md" "b/docs/java/What's New in JDK8/Java8\346\225\231\347\250\213\346\216\250\350\215\220.md" index 43e4539ccac..7de58352a5f 100644 --- "a/docs/java/What's New in JDK8/Java8\346\225\231\347\250\213\346\216\250\350\215\220.md" +++ "b/docs/java/What's New in JDK8/Java8\346\225\231\347\250\213\346\216\250\350\215\220.md" @@ -1,5 +1,3 @@ - - ### 书籍 - **《Java8 In Action》** diff --git "a/docs/java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" "b/docs/java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" deleted file mode 100644 index 359c4714473..00000000000 --- "a/docs/java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" +++ /dev/null @@ -1,235 +0,0 @@ -JDK8--Lambda表达式 -=== -## 1.什么是Lambda表达式 -**Lambda表达式实质上是一个可传递的代码块，Lambda又称为闭包或者匿名函数，是函数式编程语法，让方法可以像普通参数一样传递** - -## 2.Lambda表达式语法 -```(参数列表) -> {执行代码块}``` -
参数列表可以为空```()->{}``` -
可以加类型声明比如```(String para1, int para2) -> {return para1 + para2;}```我们可以看到，lambda同样可以有返回值. -
在编译器可以推断出类型的时候，可以将类型声明省略，比如```(para1, para2) -> {return para1 + para2;}``` -
(lambda有点像动态类型语言语法。lambda在字节码层面是用invokedynamic实现的，而这条指令就是为了让JVM更好的支持运行在其上的动态类型语言) - -## 3.函数式接口 -在了解Lambda表达式之前，有必要先了解什么是函数式接口```(@FunctionalInterface)```
-**函数式接口指的是有且只有一个抽象(abstract)方法的接口**
-当需要一个函数式接口的对象时，就可以用Lambda表达式来实现，举个常用的例子: -
-```java - Thread thread = new Thread(() -> { - System.out.println("This is JDK8's Lambda!"); - }); -``` -这段代码和函数式接口有啥关系？我们回忆一下，Thread类的构造函数里是不是有一个以Runnable接口为参数的？ -```java -public Thread(Runnable target) {...} - -/** - * Runnable Interface - */ -@FunctionalInterface -public interface Runnable { - public abstract void run(); -} -``` -到这里大家可能已经明白了，**Lambda表达式相当于一个匿名类或者说是一个匿名方法**。上面Thread的例子相当于 -```java - Thread thread = new Thread(new Runnable() { - @Override - public void run() { - System.out.println("Anonymous class"); - } - }); -``` -也就是说，上面的lambda表达式相当于实现了这个run()方法，然后当做参数传入(个人感觉可以这么理解,lambda表达式就是一个函数，只不过它的返回值、参数列表都 -由编译器帮我们推断，因此可以减少很多代码量)。 -
Lambda也可以这样用 : -```java - Runnable runnable = () -> {...}; -``` -其实这和上面的用法没有什么本质上的区别。 -
至此大家应该明白什么是函数式接口以及函数式接口和lambda表达式之间的关系了。在JDK8中修改了接口的规范， -目的是为了在给接口添加新的功能时保持向前兼容(个人理解)，比如一个已经定义了的函数式接口，某天我们想给它添加新功能，那么就不能保持向前兼容了， -因为在旧的接口规范下，添加新功能必定会破坏这个函数式接口[(JDK8中接口规范)]() -
-除了上面说的Runnable接口之外，JDK中已经存在了很多函数式接口 -比如(当然不止这些): -- ```java.util.concurrent.Callable``` -- ```java.util.Comparator``` -- ```java.io.FileFilter``` -
**关于JDK中的预定义的函数式接口** - -- JDK在```java.util.function```下预定义了很多函数式接口 - - ```Function {R apply(T t);}``` 接受一个T对象，然后返回一个R对象，就像普通的函数。 - - ```Consumer {void accept(T t);}``` 消费者 接受一个T对象，没有返回值。 - - ```Predicate {boolean test(T t);}``` 判断，接受一个T对象，返回一个布尔值。 - - ```Supplier {T get();} 提供者(工厂)``` 返回一个T对象。 - - 其他的跟上面的相似，大家可以看一下function包下的具体接口。 -## 4.变量作用域 -```java -public class VaraibleHide { - @FunctionalInterface - interface IInner { - void printInt(int x); - } - public static void main(String[] args) { - int x = 20; - IInner inner = new IInner() { - int x = 10; - @Override - public void printInt(int x) { - System.out.println(x); - } - }; - inner.printInt(30); - - inner = (s) -> { - //Variable used in lambda expression should be final or effectively final - //!int x = 10; - //!x= 50; error - System.out.print(x); - }; - inner.printInt(30); - } -} -输出 : -30 -20 -``` -对于lambda表达式```java inner = (s) -> {System.out.print(x);};```,变量x并不是在lambda表达式中定义的，像这样并不是在lambda中定义或者通过lambda的参数列表()获取的变量成为自由变量，它是被lambda表达式捕获的。 -
lambda表达式和内部类一样，对外部自由变量捕获时，外部自由变量必须为final或者是最终变量(effectively final)的，也就是说这个变量初始化后就不能为它赋新值， -同时lambda不像内部类/匿名类，lambda表达式与外围嵌套块有着相同的作用域，因此对变量命名的有关规则对lambda同样适用。大家阅读上面的代码对这些概念应该 -不难理解。 -## 5.方法引用 -**只需要提供方法的名字，具体的调用过程由Lambda和函数式接口来确定，这样的方法调用成为方法引用。** -
下面的例子会打印list中的每个元素: -```java -List list = new ArrayList<>(); - for (int i = 0; i < 10; ++i) { - list.add(i); - } - list.forEach(System.out::println); -``` -其中```System.out::println```这个就是一个方法引用，等价于Lambda表达式 ```(para)->{System.out.println(para);}``` -
我们看一下List#forEach方法 ```default void forEach(Consumer action)```可以看到它的参数是一个Consumer接口，该接口是一个函数式接口 -```java -@FunctionalInterface -public interface Consumer { - void accept(T t); -``` -大家能发现这个函数接口的方法和```System.out::println```有什么相似的么？没错，它们有着相似的参数列表和返回值。 -
我们自己定义一个方法，看看能不能像标准输出的打印函数一样被调用 -```java -public class MethodReference { - public static void main(String[] args) { - List list = new ArrayList<>(); - for (int i = 0; i < 10; ++i) { - list.add(i); - } - list.forEach(MethodReference::myPrint); - } - - static void myPrint(int i) { - System.out.print(i + ", "); - } -} - -输出: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -``` -可以看到，我们自己定义的方法也可以当做方法引用。 -
到这里大家多少对方法引用有了一定的了解，我们再来说一下方法引用的形式。 -- 方法引用 - - 类名::静态方法名 - - 类名::实例方法名 - - 类名::new (构造方法引用) - - 实例名::实例方法名 -可以看出，方法引用是通过(方法归属名)::(方法名)来调用的。通过上面的例子已经讲解了一个`类名::静态方法名`的使用方法了，下面再依次介绍其余的几种 -方法引用的使用方法。
-**类名::实例方法名**
-先来看一段代码 -```java - String[] strings = new String[10]; - Arrays.sort(strings, String::compareToIgnoreCase); -``` -**上面的String::compareToIgnoreCase等价于(x, y) -> {return x.compareToIgnoreCase(y);}**
-我们看一下`Arrays#sort`方法`public static void sort(T[] a, Comparator c)`, -可以看到第二个参数是一个Comparator接口，该接口也是一个函数式接口，其中的抽象方法是`int compare(T o1, T o2);`，再看一下 -`String#compareToIgnoreCase`方法,`public int compareToIgnoreCase(String str)`，这个方法好像和上面讲方法引用中`类名::静态方法名`不大一样啊，它 -的参数列表和函数式接口的参数列表不一样啊，虽然它的返回值一样？ -
是的，确实不一样但是别忘了，String类的这个方法是个实例方法，而不是静态方法，也就是说，这个方法是需要有一个接收者的。所谓接收者就是 -instance.method(x)中的instance， -它是某个类的实例，有的朋友可能已经明白了。上面函数式接口的`compare(T o1, T o2)`中的第一个参数作为了实例方法的接收者，而第二个参数作为了实例方法的 -参数。我们再举一个自己实现的例子: -```java -public class MethodReference { - static Random random = new Random(47); - public static void main(String[] args) { - MethodReference[] methodReferences = new MethodReference[10]; - Arrays.sort(methodReferences, MethodReference::myCompare); - } - int myCompare(MethodReference o) { - return random.nextInt(2) - 1; - } -} -``` -上面的例子可以在IDE里通过编译，大家有兴趣的可以模仿上面的例子自己写一个程序，打印出排序后的结果。 -
**构造器引用**
-构造器引用仍然需要与特定的函数式接口配合使用，并不能像下面这样直接使用。IDE会提示String不是一个函数式接口 -```java - //compile error : String is not a functional interface - String str = String::new; -``` -下面是一个使用构造器引用的例子，可以看出构造器引用可以和这种工厂型的函数式接口一起使用的。 -```java - interface IFunctional { - T func(); -} - -public class ConstructorReference { - - public ConstructorReference() { - } - - public static void main(String[] args) { - Supplier supplier0 = () -> new ConstructorReference(); - Supplier supplier1 = ConstructorReference::new; - IFunctional functional = () -> new ConstructorReference(); - IFunctional functional1 = ConstructorReference::new; - } -} -``` -下面是一个JDK官方的例子 -```java - public static , DEST extends Collection> - DEST transferElements( - SOURCE sourceCollection, - Supplier collectionFactory) { - - DEST result = collectionFactory.get(); - for (T t : sourceCollection) { - result.add(t); - } - return result; - } - - ... - - Set rosterSet = transferElements( - roster, HashSet::new); -``` - -**实例::实例方法** -
-其实开始那个例子就是一个实例::实例方法的引用 -```java -List list = new ArrayList<>(); - for (int i = 0; i < 10; ++i) { - list.add(i); - } - list.forEach(System.out::println); -``` -其中System.out就是一个实例，println是一个实例方法。相信不用再给大家做解释了。 -## 总结 -Lambda表达式是JDK8引入Java的函数式编程语法，使用Lambda需要直接或者间接的与函数式接口配合，在开发中使用Lambda可以减少代码量， -但是并不是说必须要使用Lambda(虽然它是一个很酷的东西)。有些情况下使用Lambda会使代码的可读性急剧下降，并且也节省不了多少代码， -所以在实际开发中还是需要仔细斟酌是否要使用Lambda。和Lambda相似的还有JDK10中加入的var类型推断，同样对于这个特性需要斟酌使用。 diff --git a/docs/java/What's New in JDK8/README.md b/docs/java/What's New in JDK8/README.md deleted file mode 100644 index fa71e907410..00000000000 --- a/docs/java/What's New in JDK8/README.md +++ /dev/null @@ -1,556 +0,0 @@ -JDK8新特性总结 -====== -总结了部分JDK8新特性，另外一些新特性可以通过Oracle的官方文档查看，毕竟是官方文档，各种新特性都会介绍，有兴趣的可以去看。
-[Oracle官方文档:What's New in JDK8](https://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html) ------ -- [Java语言特性](#JavaProgrammingLanguage) - - [Lambda表达式是一个新的语言特性，已经在JDK8中加入。它是一个可以传递的代码块，你也可以把它们当做方法参数。 - Lambda表达式允许您更紧凑地创建单虚方法接口（称为功能接口）的实例。](#LambdaExpressions) - - - [方法引用为已经存在的具名方法提供易于阅读的Lambda表达式](#MethodReferences) - - - [默认方法允许将新功能添加到库的接口，并确保与为这些接口的旧版本编写的代码的二进制兼容性。](#DefaultMethods) - - - [改进的类型推断。](#ImprovedTypeInference) - - - [方法参数反射(通过反射获得方法参数信息)](#MethodParameterReflection) - -- [流(stream)](#stream) - - [新java.util.stream包中的类提供Stream API以支持对元素流的功能样式操作。流(stream)和I/O里的流不是同一个概念 - ，使用stream API可以更方便的操作集合。]() - -- [国际化]() - - 待办 -- 待办 -___ - - - - - - - -## 　　　　　　　　　　　　　Lambda表达式 -### 1.什么是Lambda表达式 -**Lambda表达式实质上是一个可传递的代码块，Lambda又称为闭包或者匿名函数，是函数式编程语法，让方法可以像普通参数一样传递** - -### 2.Lambda表达式语法 -```(参数列表) -> {执行代码块}``` -
参数列表可以为空```()->{}``` -
可以加类型声明比如```(String para1, int para2) -> {return para1 + para2;}```我们可以看到，lambda同样可以有返回值. -
在编译器可以推断出类型的时候，可以将类型声明省略，比如```(para1, para2) -> {return para1 + para2;}``` -
(lambda有点像动态类型语言语法。lambda在字节码层面是用invokedynamic实现的，而这条指令就是为了让JVM更好的支持运行在其上的动态类型语言) - -### 3.函数式接口 -在了解Lambda表达式之前，有必要先了解什么是函数式接口```(@FunctionalInterface)```
-**函数式接口指的是有且只有一个抽象(abstract)方法的接口**
-当需要一个函数式接口的对象时，就可以用Lambda表达式来实现，举个常用的例子: -
-```java - Thread thread = new Thread(() -> { - System.out.println("This is JDK8's Lambda!"); - }); -``` -这段代码和函数式接口有啥关系？我们回忆一下，Thread类的构造函数里是不是有一个以Runnable接口为参数的？ -```java -public Thread(Runnable target) {...} - -/** - * Runnable Interface - */ -@FunctionalInterface -public interface Runnable { - public abstract void run(); -} -``` -到这里大家可能已经明白了，**Lambda表达式相当于一个匿名类或者说是一个匿名方法**。上面Thread的例子相当于 -```java - Thread thread = new Thread(new Runnable() { - @Override - public void run() { - System.out.println("Anonymous class"); - } - }); -``` -也就是说，上面的lambda表达式相当于实现了这个run()方法，然后当做参数传入(个人感觉可以这么理解,lambda表达式就是一个函数，只不过它的返回值、参数列表都 -由编译器帮我们推断，因此可以减少很多代码量)。 -
Lambda也可以这样用 : -```java - Runnable runnable = () -> {...}; -``` -其实这和上面的用法没有什么本质上的区别。 -
至此大家应该明白什么是函数式接口以及函数式接口和lambda表达式之间的关系了。在JDK8中修改了接口的规范， -目的是为了在给接口添加新的功能时保持向前兼容(个人理解)，比如一个已经定义了的函数式接口，某天我们想给它添加新功能，那么就不能保持向前兼容了， -因为在旧的接口规范下，添加新功能必定会破坏这个函数式接口[(JDK8中接口规范)]() -
-除了上面说的Runnable接口之外，JDK中已经存在了很多函数式接口 -比如(当然不止这些): -- ```java.util.concurrent.Callable``` -- ```java.util.Comparator``` -- ```java.io.FileFilter``` -
**关于JDK中的预定义的函数式接口** - -- JDK在```java.util.function```下预定义了很多函数式接口 - - ```Function {R apply(T t);}``` 接受一个T对象，然后返回一个R对象，就像普通的函数。 - - ```Consumer {void accept(T t);}``` 消费者 接受一个T对象，没有返回值。 - - ```Predicate {boolean test(T t);}``` 判断，接受一个T对象，返回一个布尔值。 - - ```Supplier {T get();} 提供者(工厂)``` 返回一个T对象。 - - 其他的跟上面的相似，大家可以看一下function包下的具体接口。 -### 4.变量作用域 -```java -public class VaraibleHide { - @FunctionalInterface - interface IInner { - void printInt(int x); - } - public static void main(String[] args) { - int x = 20; - IInner inner = new IInner() { - int x = 10; - @Override - public void printInt(int x) { - System.out.println(x); - } - }; - inner.printInt(30); - - inner = (s) -> { - //Variable used in lambda expression should be final or effectively final - //!int x = 10; - //!x= 50; error - System.out.print(x); - }; - inner.printInt(30); - } -} -输出 : -30 -20 -``` -对于lambda表达式```java inner = (s) -> {System.out.print(x);};```,变量x并不是在lambda表达式中定义的，像这样并不是在lambda中定义或者通过lambda -的参数列表()获取的变量成为自由变量，它是被lambda表达式捕获的。 -
lambda表达式和内部类一样，对外部自由变量捕获时，外部自由变量必须为final或者是最终变量(effectively final)的，也就是说这个变量初始化后就不能为它赋新值，同时lambda不像内部类/匿名类，lambda表达式与外围嵌套块有着相同的作用域，因此对变量命名的有关规则对lambda同样适用。大家阅读上面的代码对这些概念应该不难理解。 - -### 5.方法引用 -**只需要提供方法的名字，具体的调用过程由Lambda和函数式接口来确定，这样的方法调用成为方法引用。** -
下面的例子会打印list中的每个元素: -```java -List list = new ArrayList<>(); - for (int i = 0; i < 10; ++i) { - list.add(i); - } - list.forEach(System.out::println); -``` -其中```System.out::println```这个就是一个方法引用，等价于Lambda表达式 ```(para)->{System.out.println(para);}``` -
我们看一下List#forEach方法 ```default void forEach(Consumer action)```可以看到它的参数是一个Consumer接口，该接口是一个函数式接口 -```java -@FunctionalInterface -public interface Consumer { - void accept(T t); -``` -大家能发现这个函数接口的方法和```System.out::println```有什么相似的么？没错，它们有着相似的参数列表和返回值。 -
我们自己定义一个方法，看看能不能像标准输出的打印函数一样被调用 -```java -public class MethodReference { - public static void main(String[] args) { - List list = new ArrayList<>(); - for (int i = 0; i < 10; ++i) { - list.add(i); - } - list.forEach(MethodReference::myPrint); - } - - static void myPrint(int i) { - System.out.print(i + ", "); - } -} - -输出: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -``` -可以看到，我们自己定义的方法也可以当做方法引用。 -
到这里大家多少对方法引用有了一定的了解，我们再来说一下方法引用的形式。 -- 方法引用 - - 类名::静态方法名 - - 类名::实例方法名 - - 类名::new (构造方法引用) - - 实例名::实例方法名 -可以看出，方法引用是通过(方法归属名)::(方法名)来调用的。通过上面的例子已经讲解了一个`类名::静态方法名`的使用方法了，下面再依次介绍其余的几种 -方法引用的使用方法。
-**类名::实例方法名**
-先来看一段代码 -```java - String[] strings = new String[10]; - Arrays.sort(strings, String::compareToIgnoreCase); -``` -**上面的String::compareToIgnoreCase等价于(x, y) -> {return x.compareToIgnoreCase(y);}**
-我们看一下`Arrays#sort`方法`public static void sort(T[] a, Comparator c)`, -可以看到第二个参数是一个Comparator接口，该接口也是一个函数式接口，其中的抽象方法是`int compare(T o1, T o2);`，再看一下 -`String#compareToIgnoreCase`方法,`public int compareToIgnoreCase(String str)`，这个方法好像和上面讲方法引用中`类名::静态方法名`不大一样啊，它 -的参数列表和函数式接口的参数列表不一样啊，虽然它的返回值一样？ -
是的，确实不一样但是别忘了，String类的这个方法是个实例方法，而不是静态方法，也就是说，这个方法是需要有一个接收者的。所谓接收者就是 -instance.method(x)中的instance， -它是某个类的实例，有的朋友可能已经明白了。上面函数式接口的`compare(T o1, T o2)`中的第一个参数作为了实例方法的接收者，而第二个参数作为了实例方法的 -参数。我们再举一个自己实现的例子: -```java -public class MethodReference { - static Random random = new Random(47); - public static void main(String[] args) { - MethodReference[] methodReferences = new MethodReference[10]; - Arrays.sort(methodReferences, MethodReference::myCompare); - } - int myCompare(MethodReference o) { - return random.nextInt(2) - 1; - } -} -``` -上面的例子可以在IDE里通过编译，大家有兴趣的可以模仿上面的例子自己写一个程序，打印出排序后的结果。 -
**构造器引用**
-构造器引用仍然需要与特定的函数式接口配合使用，并不能像下面这样直接使用。IDE会提示String不是一个函数式接口 -```java - //compile error : String is not a functional interface - String str = String::new; -``` -下面是一个使用构造器引用的例子，可以看出构造器引用可以和这种工厂型的函数式接口一起使用的。 -```java - interface IFunctional { - T func(); -} - -public class ConstructorReference { - - public ConstructorReference() { - } - - public static void main(String[] args) { - Supplier supplier0 = () -> new ConstructorReference(); - Supplier supplier1 = ConstructorReference::new; - IFunctional functional = () -> new ConstructorReference(); - IFunctional functional1 = ConstructorReference::new; - } -} -``` -下面是一个JDK官方的例子 -```java - public static , DEST extends Collection> - DEST transferElements( - SOURCE sourceCollection, - Supplier collectionFactory) { - - DEST result = collectionFactory.get(); - for (T t : sourceCollection) { - result.add(t); - } - return result; - } - - ... - - Set rosterSet = transferElements( - roster, HashSet::new); -``` - -**实例::实例方法** -
-其实开始那个例子就是一个实例::实例方法的引用 -```java -List list = new ArrayList<>(); - for (int i = 0; i < 10; ++i) { - list.add(i); - } - list.forEach(System.out::println); -``` -其中System.out就是一个实例，println是一个实例方法。相信不用再给大家做解释了。 -### 总结 -Lambda表达式是JDK8引入Java的函数式编程语法，使用Lambda需要直接或者间接的与函数式接口配合，在开发中使用Lambda可以减少代码量， -但是并不是说必须要使用Lambda(虽然它是一个很酷的东西)。有些情况下使用Lambda会使代码的可读性急剧下降，并且也节省不了多少代码， -所以在实际开发中还是需要仔细斟酌是否要使用Lambda。和Lambda相似的还有JDK10中加入的var类型推断，同样对于这个特性需要斟酌使用。 - - -___ - - -## 　　　　　　　　　　　　　JDK8接口规范 -### 在JDK8中引入了lambda表达式，出现了函数式接口的概念，为了在扩展接口时保持向前兼容性(JDK8之前扩展接口会使得实现了该接口的类必须实现添加的方法，否则会报错。为了保持兼容性而做出妥协的特性还有泛型，泛型也是为了保持兼容性而失去了在一些别的语言泛型拥有的功能)，Java接口规范发生了一些改变。 -### 1.JDK8以前的接口规范 -- JDK8以前接口可以定义的变量和方法 - - 所有变量(Field)不论是否显式 的声明为```public static final```，它实际上都是```public static final```的。 - - 所有方法(Method)不论是否显示 的声明为```public abstract```，它实际上都是```public abstract```的。 -```java -public interface AInterfaceBeforeJDK8 { - int FIELD = 0; - void simpleMethod(); -} -``` -以上接口信息反编译以后可以看到字节码信息里Filed是public static final的，而方法是public abstract的，即是你没有显示的去声明它。 -```java -{ - public static final int FIELD; - descriptor: I - flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL - ConstantValue: int 0 - - public abstract void simpleMethod(); - descriptor: ()V - flags: (0x0401) ACC_PUBLIC, ACC_ABSTRACT -} -``` -### 2.JDK8之后的接口规范 -- JDK8之后接口可以定义的变量和方法 - - 变量(Field)仍然必须是 ```java public static final```的 - - 方法(Method)除了可以是public abstract之外，还可以是public static或者是default(相当于仅public修饰的实例方法)的。 -从以上改变不难看出，修改接口的规范主要是为了能在扩展接口时保持向前兼容。 -
下面是一个JDK8之后的接口例子 -```java -public interface AInterfaceInJDK8 { - int simpleFiled = 0; - static int staticField = 1; - - public static void main(String[] args) { - } - static void staticMethod(){} - - default void defaultMethod(){} - - void simpleMethod() throws IOException; - -} -``` -进行反编译(去除了一些没用信息) -```java -{ - public static final int simpleFiled; - flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL - - public static final int staticField; - flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL - - public static void main(java.lang.String[]); - flags: (0x0009) ACC_PUBLIC, ACC_STATIC - - public static void staticMethod(); - flags: (0x0009) ACC_PUBLIC, ACC_STATIC - - public void defaultMethod(); - flags: (0x0001) ACC_PUBLIC - - public abstract void simpleMethod() throws java.io.IOException; - flags: (0x0401) ACC_PUBLIC, ACC_ABSTRACT - Exceptions: - throws java.io.IOException -} -``` -可以看到 default关键字修饰的方法是像实例方法(就是普通类中定义的普通方法)一样定义的，所以我们来定义一个只有default方法的接口并且实现一下这个接口试一 -试。 -```java -interface Default { - default int defaultMethod() { - return 4396; - } -} - -public class DefaultMethod implements Default { - public static void main(String[] args) { - DefaultMethod defaultMethod = new DefaultMethod(); - System.out.println(defaultMethod.defaultMethod()); - //compile error : Non-static method 'defaultMethod()' cannot be referenced from a static context - //! DefaultMethod.defaultMethod(); - } -} -``` -可以看到default方法确实像实例方法一样，必须有实例对象才能调用，并且子类在实现接口时，可以不用实现default方法，也可以选择覆盖该方法。 -这有点像子类继承父类实例方法。 -
-接口静态方法就像是类静态方法，唯一的区别是**接口静态方法只能通过接口名调用，而类静态方法既可以通过类名调用也可以通过实例调用** -```java -interface Static { - static int staticMethod() { - return 4396; - } -} - ... main(String...args) - //!compile error: Static method may be invoked on containing interface class only - //!aInstanceOfStatic.staticMethod(); - ... -``` -另一个问题是多继承问题，大家知道Java中类是不支持多继承的，但是接口是多继承和多实现(implements后跟多个接口)的， -那么如果一个接口继承另一个接口，两个接口都有同名的default方法会怎么样呢？答案是会像类继承一样覆写(@Override)，以下代码在IDE中可以顺利编译 -```java -interface Default { - default int defaultMethod() { - return 4396; - } -} -interface Default2 extends Default { - @Override - default int defaultMethod() { - return 9527; - } -} -public class DefaultMethod implements Default,Default2 { - public static void main(String[] args) { - DefaultMethod defaultMethod = new DefaultMethod(); - System.out.println(defaultMethod.defaultMethod()); - } -} - -输出 : 9527 -``` -出现上面的情况时，会优先找继承树上近的方法，类似于“短路优先”。 -
-那么如果一个类实现了两个没有继承关系的接口，且这两个接口有同名方法的话会怎么样呢？IDE会要求你重写这个冲突的方法，让你自己选择去执行哪个方法，因为IDE它还没智能到你不告诉它，它就知道你想执行哪个方法。可以通过```java 接口名.super```指针来访问接口中定义的实例(default)方法。 -```java -interface Default { - default int defaultMethod() { - return 4396; - } -} - -interface Default2 { - default int defaultMethod() { - return 9527; - } -} -//如果不重写 -//compile error : defaults.DefaultMethod inherits unrelated defaults for defaultMethod() from types defaults.Default and defaults.Default2 -public class DefaultMethod implements Default,Default2 { -@Override - public int defaultMethod() { - System.out.println(Default.super.defaultMethod()); - System.out.println(Default2.super.defaultMethod()); - return 996; - } - public static void main(String[] args) { - DefaultMethod defaultMethod = new DefaultMethod(); - System.out.println(defaultMethod.defaultMethod()); - } -} - -运行输出 : -4396 -9527 -996 -``` - - -___ - - -## 　　　　　　　　　　　　　改进的类型推断 -### 1.什么是类型推断 -类型推断就像它的字面意思一样，编译器根据你显示声明的已知的信息 推断出你没有显示声明的类型，这就是类型推断。 -看过《Java编程思想 第四版》的朋友可能还记得里面讲解泛型一章的时候，里面很多例子是下面这样的: -```java - Map map = new Map(); -``` -而我们平常写的都是这样的: -```java - Map map = new Map<>(); -``` -这就是类型推断，《Java编程思想 第四版》这本书出书的时候最新的JDK只有1.6(JDK7推出的类型推断)，在Java编程思想里Bruce Eckel大叔还提到过这个问题 -(可能JDK的官方人员看了Bruce Eckel大叔的Thinking in Java才加的类型推断，☺)，在JDK7中推出了上面这样的类型推断，可以减少一些无用的代码。 -(Java编程思想到现在还只有第四版，是不是因为Bruce Eckel大叔觉得Java新推出的语言特性“然并卵”呢？/滑稽) -
-在JDK7中，类型推断只有上面例子的那样的能力，即只有在使用**赋值语句**时才能自动推断出泛型参数信息(即<>里的信息)，下面的官方文档里的例子在JDK7里会编译 -错误 -```java - List stringList = new ArrayList<>(); - stringList.add("A"); - //error : addAll(java.util.Collection)in List cannot be applied to (java.util.List) - stringList.addAll(Arrays.asList()); -``` -但是上面的代码在JDK8里可以通过，也就说，JDK8里，类型推断不仅可以用于赋值语句，而且可以根据代码中上下文里的信息推断出更多的信息，因此我们需要些的代码 -会更少。加强的类型推断还有一个就是用于Lambda表达式了。 -
-大家其实不必细究类型推断，在日常使用中IDE会自动判断，当IDE自己无法推断出足够的信息时，就需要我们额外做一下工作，比如在<>里添加更多的类型信息， -相信随着Java的进化，这些便利的功能会越来越强大。 - - -____ - - -## 　　　　　　　　　　　　　通过反射获得方法的参数信息 -JDK8之前 .class文件是不会存储方法参数信息的，因此也就无法通过反射获取该信息(想想反射获取类信息的入口是什么？当然就是Class类了)。即是是在JDK11里 -也不会默认生成这些信息，可以通过在javac加上-parameters参数来让javac生成这些信息(javac就是java编译器，可以把java文件编译成.class文件)。生成额外 -的信息(运行时非必须信息)会消耗内存并且有可能公布敏感信息(某些方法参数比如password，JDK文档里这么说的)，并且确实很多信息javac并不会为我们生成，比如 -LocalVariableTable，javac就不会默认生成，需要你加上 -g:vars来强制让编译器生成，同样的，方法参数信息也需要加上 --parameters来让javac为你在.class文件中生成这些信息，否则运行时反射是无法获取到这些信息的。在讲解Java语言层面的方法之前，先看一下javac加上该 -参数和不加生成的信息有什么区别(不感兴趣想直接看运行代码的可以跳过这段)。下面是随便写的一个类。 -```java -public class ByteCodeParameters { - public String simpleMethod(String canUGetMyName, Object yesICan) { - return "9527"; - } -} -``` -先来不加参数编译和反编译一下这个类javac ByteCodeParameters.java , javap -v ByteCodeParameters: -```java - //只截取了部分信息 - public java.lang.String simpleMethod(java.lang.String, java.lang.Object); - descriptor: (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String; - flags: (0x0001) ACC_PUBLIC - Code: - stack=1, locals=3, args_size=3 - 0: ldc #2 // String 9527 - 2: areturn - LineNumberTable: - line 5: 0 - //这个方法的描述到这里就结束了 -``` -接下来我们加上参数javac -parameters ByteCodeParameters.java 再来看反编译的信息: -```java - public java.lang.String simpleMethod(java.lang.String, java.lang.Object); - descriptor: (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String; - flags: (0x0001) ACC_PUBLIC - Code: - stack=1, locals=3, args_size=3 - 0: ldc #2 // String 9527 - 2: areturn - LineNumberTable: - line 8: 0 - MethodParameters: - Name Flags - canUGetMyName - yesICan -``` -可以看到.class文件里多了一个MethodParameters信息，这就是参数的名字，可以看到默认是不保存的。 -
下面看一下在Intelj Idea里运行的这个例子，我们试一下通过反射获取方法名 : -```java -public class ByteCodeParameters { - public String simpleMethod(String canUGetMyName, Object yesICan) { - return "9527"; - } - - public static void main(String[] args) throws NoSuchMethodException { - Class clazz = ByteCodeParameters.class; - Method simple = clazz.getDeclaredMethod("simpleMethod", String.class, Object.class); - Parameter[] parameters = simple.getParameters(); - for (Parameter p : parameters) { - System.out.println(p.getName()); - } - } -} -输出 : -arg0 -arg1 -``` -？？？说好的方法名呢？？？？别急，哈哈。前面说了，默认是不生成参数名信息的，因此我们需要做一些配置，我们找到IDEA的settings里的Java Compiler选项，在 -Additional command line parameters:一行加上-parameters(Eclipse 也是找到Java Compiler选中Stoer information about method parameters)，或者自 -己编译一个.class文件放在IDEA的out下，然后再来运行 : -```java -输出 : -canUGetMyName -yesICan -``` -这样我们就通过反射获取到参数信息了。想要了解更多的同学可以自己研究一下 [官方文档] -(https://docs.oracle.com/javase/tutorial/reflect/member/methodparameterreflection.html) -
-## 总结与补充 -在JDK8之后，可以通过-parameters参数来让编译器生成参数信息然后在运行时通过反射获取方法参数信息，其实在SpringFramework -里面也有一个LocalVariableTableParameterNameDiscoverer对象可以获取方法参数名信息，有兴趣的同学可以自行百度(这个类在打印日志时可能会比较有用吧，个人感觉)。 - -____ - - - - -___ diff --git a/docs/java/What's New in JDK8/Stream.md b/docs/java/What's New in JDK8/Stream.md deleted file mode 100644 index de7c86e3f2e..00000000000 --- a/docs/java/What's New in JDK8/Stream.md +++ /dev/null @@ -1,75 +0,0 @@ -Stream API 旨在让编码更高效率、干净、简洁。 - -### 从迭代器到Stream操作 - -当使用 `Stream` 时，我们一般会通过三个阶段建立一个流水线： - -1. 创建一个 `Stream`； -2. 进行一个或多个中间操作; -3. 使用终止操作产生一个结果,`Stream` 就不会再被使用了。 - -**案例1：统计 List 中的单词长度大于6的个数** - -```java -/** -* 案例1：统计 List 中的单词长度大于6的个数 -*/ -ArrayList wordsList = new ArrayList(); -wordsList.add("Charles"); -wordsList.add("Vincent"); -wordsList.add("William"); -wordsList.add("Joseph"); -wordsList.add("Henry"); -wordsList.add("Bill"); -wordsList.add("Joan"); -wordsList.add("Linda"); -int count = 0; -``` -Java8之前我们通常用迭代方法来完成上面的需求： - -```java -//迭代（Java8之前的常用方法） -//迭代不好的地方：1. 代码多；2 很难被并行运算。 -for (String word : wordsList) { - if (word.length() > 6) { - count++; - } -} -System.out.println(count);//3 -``` -Java8之前我们使用 `Stream` 一行代码就能解决了，而且可以瞬间转换为并行执行的效果： - -```java -//Stream -//将stream()改为parallelStream()就可以瞬间将代码编程并行执行的效果 -long count2=wordsList.stream() - .filter(w->w.length()>6) - .count(); -long count3=wordsList.parallelStream() - .filter(w->w.length()>6) - .count(); -System.out.println(count2); -System.out.println(count3); -``` - -### `distinct()` - -去除 List 中重复的 String - -```java -List list = list.stream() - .distinct() - .collect(Collectors.toList()); -``` - -### `map` - -map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应的平方数： - -```java -List numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); -// 获取 List 中每个元素对应的平方数并去重 -List squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList()); -System.out.println(squaresList.toString());//[9, 4, 49, 25] -``` - diff --git "a/docs/java/What's New in JDK8/\346\224\271\350\277\233\347\232\204\347\261\273\345\236\213\346\216\250\346\226\255.md" "b/docs/java/What's New in JDK8/\346\224\271\350\277\233\347\232\204\347\261\273\345\236\213\346\216\250\346\226\255.md" deleted file mode 100644 index b5cff7bb0c0..00000000000 --- "a/docs/java/What's New in JDK8/\346\224\271\350\277\233\347\232\204\347\261\273\345\236\213\346\216\250\346\226\255.md" +++ /dev/null @@ -1,30 +0,0 @@ -## 　　　　　　　　　　　　　改进的类型推断 -### 1.什么是类型推断 -类型推断就像它的字面意思一样，编译器根据你显示声明的已知的信息 推断出你没有显示声明的类型，这就是类型推断。 -看过《Java编程思想 第四版》的朋友可能还记得里面讲解泛型一章的时候，里面很多例子是下面这样的: -```java - Map map = new Map(); -``` -而我们平常写的都是这样的: -```java - Map map = new Map<>(); -``` -这就是类型推断，《Java编程思想 第四版》这本书出书的时候最新的JDK只有1.6(JDK7推出的类型推断)，在Java编程思想里Bruce Eckel大叔还提到过这个问题 -(可能JDK的官方人员看了Bruce Eckel大叔的Thinking in Java才加的类型推断，☺)，在JDK7中推出了上面这样的类型推断，可以减少一些无用的代码。 -(Java编程思想到现在还只有第四版，是不是因为Bruce Eckel大叔觉得Java新推出的语言特性“然并卵”呢？/滑稽) -
-在JDK7中，类型推断只有上面例子的那样的能力，即只有在使用**赋值语句**时才能自动推断出泛型参数信息(即<>里的信息)，下面的官方文档里的例子在JDK7里会编译 -错误 -```java - List stringList = new ArrayList<>(); - stringList.add("A"); - //error : addAll(java.util.Collection)in List cannot be applied to (java.util.List) - stringList.addAll(Arrays.asList()); -``` -但是上面的代码在JDK8里可以通过，也就说，JDK8里，类型推断不仅可以用于赋值语句，而且可以根据代码中上下文里的信息推断出更多的信息，因此我们需要些的代码 -会更少。加强的类型推断还有一个就是用于Lambda表达式了。 -
-大家其实不必细究类型推断，在日常使用中IDE会自动判断，当IDE自己无法推断出足够的信息时，就需要我们额外做一下工作，比如在<>里添加更多的类型信息， -相信随着Java的进化，这些便利的功能会越来越强大。 - - diff --git "a/docs/java/What's New in JDK8/\351\200\232\350\277\207\345\217\215\345\260\204\350\216\267\345\276\227\346\226\271\346\263\225\347\232\204\345\217\202\346\225\260\344\277\241\346\201\257.md" "b/docs/java/What's New in JDK8/\351\200\232\350\277\207\345\217\215\345\260\204\350\216\267\345\276\227\346\226\271\346\263\225\347\232\204\345\217\202\346\225\260\344\277\241\346\201\257.md" deleted file mode 100644 index a1d91c4b2fe..00000000000 --- "a/docs/java/What's New in JDK8/\351\200\232\350\277\207\345\217\215\345\260\204\350\216\267\345\276\227\346\226\271\346\263\225\347\232\204\345\217\202\346\225\260\344\277\241\346\201\257.md" +++ /dev/null @@ -1,79 +0,0 @@ -## 　　　　　　　　　　　　　通过反射获得方法的参数信息 -JDK8之前 .class文件是不会存储方法参数信息的，因此也就无法通过反射获取该信息(想想反射获取类信息的入口是什么？当然就是Class类了)。即是是在JDK11里 -也不会默认生成这些信息，可以通过在javac加上-parameters参数来让javac生成这些信息(javac就是java编译器，可以把java文件编译成.class文件)。生成额外 -的信息(运行时非必须信息)会消耗内存并且有可能公布敏感信息(某些方法参数比如password，JDK文档里这么说的)，并且确实很多信息javac并不会为我们生成，比如 -LocalVariableTable，javac就不会默认生成，需要你加上 -g:vars来强制让编译器生成，同样的，方法参数信息也需要加上 --parameters来让javac为你在.class文件中生成这些信息，否则运行时反射是无法获取到这些信息的。在讲解Java语言层面的方法之前，先看一下javac加上该 -参数和不加生成的信息有什么区别(不感兴趣想直接看运行代码的可以跳过这段)。下面是随便写的一个类。 -```java -public class ByteCodeParameters { - public String simpleMethod(String canUGetMyName, Object yesICan) { - return "9527"; - } -} -``` -先来不加参数编译和反编译一下这个类javac ByteCodeParameters.java , javap -v ByteCodeParameters: -```java - //只截取了部分信息 - public java.lang.String simpleMethod(java.lang.String, java.lang.Object); - descriptor: (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String; - flags: (0x0001) ACC_PUBLIC - Code: - stack=1, locals=3, args_size=3 - 0: ldc #2 // String 9527 - 2: areturn - LineNumberTable: - line 5: 0 - //这个方法的描述到这里就结束了 -``` -接下来我们加上参数javac -parameters ByteCodeParameters.java 再来看反编译的信息: -```java - public java.lang.String simpleMethod(java.lang.String, java.lang.Object); - descriptor: (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String; - flags: (0x0001) ACC_PUBLIC - Code: - stack=1, locals=3, args_size=3 - 0: ldc #2 // String 9527 - 2: areturn - LineNumberTable: - line 8: 0 - MethodParameters: - Name Flags - canUGetMyName - yesICan -``` -可以看到.class文件里多了一个MethodParameters信息，这就是参数的名字，可以看到默认是不保存的。 -
下面看一下在Intelj Idea里运行的这个例子，我们试一下通过反射获取方法名 : -```java -public class ByteCodeParameters { - public String simpleMethod(String canUGetMyName, Object yesICan) { - return "9527"; - } - - public static void main(String[] args) throws NoSuchMethodException { - Class clazz = ByteCodeParameters.class; - Method simple = clazz.getDeclaredMethod("simpleMethod", String.class, Object.class); - Parameter[] parameters = simple.getParameters(); - for (Parameter p : parameters) { - System.out.println(p.getName()); - } - } -} -输出 : -arg0 -arg1 -``` -？？？说好的方法名呢？？？？别急，哈哈。前面说了，默认是不生成参数名信息的，因此我们需要做一些配置，我们找到IDEA的settings里的Java Compiler选项，在 -Additional command line parameters:一行加上-parameters(Eclipse 也是找到Java Compiler选中Stoer information about method parameters)，或者自 -己编译一个.class文件放在IDEA的out下，然后再来运行 : -```java -输出 : -canUGetMyName -yesICan -``` -这样我们就通过反射获取到参数信息了。想要了解更多的同学可以自己研究一下 [官方文档] -(https://docs.oracle.com/javase/tutorial/reflect/member/methodparameterreflection.html) -
-## 总结与补充 -在JDK8之后，可以通过-parameters参数来让编译器生成参数信息然后在运行时通过反射获取方法参数信息，其实在SpringFramework -里面也有一个LocalVariableTableParameterNameDiscoverer对象可以获取方法参数名信息，有兴趣的同学可以自行百度(这个类在打印日志时可能会比较有用吧，个人感觉)。 diff --git a/docs/java/ArrayList-Grow.md b/docs/java/collection/ArrayList-Grow.md similarity index 99% rename from docs/java/ArrayList-Grow.md rename to docs/java/collection/ArrayList-Grow.md index 6dd4cc93daf..06fa5388d76 100644 --- a/docs/java/ArrayList-Grow.md +++ b/docs/java/collection/ArrayList-Grow.md @@ -270,7 +270,6 @@ public class ArrayscopyOfTest { 10 ``` - ### 3.3 两者联系和区别 **联系：** @@ -281,8 +280,6 @@ public class ArrayscopyOfTest { `arraycopy()` 需要目标数组，将原数组拷贝到你自己定义的数组里或者原数组，而且可以选择拷贝的起点和长度以及放入新数组中的位置 `copyOf()` 是系统自动在内部新建一个数组，并返回该数组。 - - ## 四 `ensureCapacity`方法 ArrayList 源码中有一个 `ensureCapacity` 方法不知道大家注意到没有，这个方法 ArrayList 内部没有被调用过，所以很显然是提供给用户调用的，那么这个方法有什么作用呢？ @@ -341,7 +338,6 @@ public class EnsureCapacityTest { ``` 使用ensureCapacity方法前：4637 使用ensureCapacity方法后：241 - ``` 通过运行结果，我们可以很明显的看出向 ArrayList 添加大量元素之前最好先使用`ensureCapacity` 方法，以减少增量重新分配的次数 diff --git a/docs/java/ArrayList.md b/docs/java/collection/ArrayList.md similarity index 98% rename from docs/java/ArrayList.md rename to docs/java/collection/ArrayList.md index c3e8dd47896..f6578a7a784 100644 --- a/docs/java/ArrayList.md +++ b/docs/java/collection/ArrayList.md @@ -660,7 +660,7 @@ public class ArrayList extends AbstractList (3)private class SubList extends AbstractList implements RandomAccess (4)static final class ArrayListSpliterator implements Spliterator ``` -　　ArrayList有四个内部类，其中的**Itr是实现了Iterator接口**，同时重写了里面的**hasNext()**，**next()**，**remove()**等方法；其中的**ListItr**继承**Itr**，实现了**ListIterator接口**，同时重写了**hasPrevious()**，**nextIndex()**，**previousIndex()**，**previous()**，**set(E e)**，**add(E e)**等方法，所以这也可以看出了 **Iterator和ListIterator的区别:**ListIterator在Iterator的基础上增加了添加对象，修改对象，逆向遍历等方法，这些是Iterator不能实现的。 +　　ArrayList有四个内部类，其中的**Itr是实现了Iterator接口**，同时重写了里面的**hasNext()**， **next()**， **remove()** 等方法；其中的**ListItr** 继承 **Itr**，实现了**ListIterator接口**，同时重写了**hasPrevious()**， **nextIndex()**， **previousIndex()**， **previous()**， **set(E e)**， **add(E e)** 等方法，所以这也可以看出了 **Iterator和ListIterator的区别:** ListIterator在Iterator的基础上增加了添加对象，修改对象，逆向遍历等方法，这些是Iterator不能实现的。 ### ArrayList经典Demo ```java diff --git a/docs/java/HashMap.md b/docs/java/collection/HashMap.md similarity index 97% rename from docs/java/HashMap.md rename to docs/java/collection/HashMap.md index 45fad50cdb3..3c47fe38402 100644 --- a/docs/java/HashMap.md +++ b/docs/java/collection/HashMap.md @@ -18,7 +18,7 @@ ## HashMap 简介 HashMap 主要用来存放键值对，它基于哈希表的Map接口实现，是常用的Java集合之一。 -JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）.JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树，以减少搜索时间。 +JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）.JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树），以减少搜索时间，具体可以参考 `treeifyBin`方法。 ## 底层数据结构分析 ### JDK1.8之前 @@ -56,7 +56,7 @@ static int hash(int h) { 所谓 **“拉链法”** 就是：将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。 -![jdk1.8之前的内部结构](https://user-gold-cdn.xitu.io/2018/3/20/16240dbcc303d872?w=348&h=427&f=png&s=10991) +![jdk1.8之前的内部结构](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-7/jdk1.8之前的内部结构.png) ### JDK1.8之后 相比于之前的版本，jdk1.8在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。 @@ -170,7 +170,9 @@ static final class TreeNode extends LinkedHashMap.Entry { ``` ## HashMap源码分析 ### 构造方法 -![四个构造方法](https://user-gold-cdn.xitu.io/2018/3/20/162410d912a2e0e1?w=336&h=90&f=jpeg&s=26744) + +HashMap 中有四个构造方法，它们分别如下： + ```java // 默认构造函数。 public HashMap() { @@ -235,11 +237,9 @@ HashMap只提供了put用于添加元素，putVal方法只是给put方法调用 **对putVal方法添加元素的分析如下：** - ①如果定位到的数组位置没有元素 就直接插入。 -- ②如果定位到的数组位置有元素就和要插入的key比较，如果key相同就直接覆盖，如果key不相同，就判断p是否是一个树节点，如果是就调用`e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value)`将元素添加进入。如果不是就遍历链表插入。 - - +- ②如果定位到的数组位置有元素就和要插入的key比较，如果key相同就直接覆盖，如果key不相同，就判断p是否是一个树节点，如果是就调用`e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value)`将元素添加进入。如果不是就遍历链表插入(插入的是链表尾部)。 -![put方法](https://user-gold-cdn.xitu.io/2018/9/2/16598bf758c747e6?w=999&h=679&f=png&s=54486) +![put方法](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-7/put方法.png) ```java public V put(K key, V value) { diff --git "a/docs/java/collection/Java\351\233\206\345\220\210\346\241\206\346\236\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230.md" "b/docs/java/collection/Java\351\233\206\345\220\210\346\241\206\346\236\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230.md" new file mode 100644 index 00000000000..c5280d539e5 --- /dev/null +++ "b/docs/java/collection/Java\351\233\206\345\220\210\346\241\206\346\236\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230.md" @@ -0,0 +1,456 @@ +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 + + + +- [剖析面试最常见问题之Java集合框架](#剖析面试最常见问题之java集合框架) + - [说说List,Set,Map三者的区别？](#说说listsetmap三者的区别) + - [Arraylist 与 LinkedList 区别?](#arraylist-与-linkedlist-区别) + - [补充内容:RandomAccess接口](#补充内容randomaccess接口) + - [补充内容:双向链表和双向循环链表](#补充内容双向链表和双向循环链表) + - [ArrayList 与 Vector 区别呢?为什么要用Arraylist取代Vector呢？](#arraylist-与-vector-区别呢为什么要用arraylist取代vector呢) + - [说一说 ArrayList 的扩容机制吧](#说一说-arraylist-的扩容机制吧) + - [HashMap 和 Hashtable 的区别](#hashmap-和-hashtable-的区别) + - [HashMap 和 HashSet区别](#hashmap-和-hashset区别) + - [HashSet如何检查重复](#hashset如何检查重复) + - [HashMap的底层实现](#hashmap的底层实现) + - [JDK1.8之前](#jdk18之前) + - [JDK1.8之后](#jdk18之后) + - [HashMap 的长度为什么是2的幂次方](#hashmap-的长度为什么是2的幂次方) + - [HashMap 多线程操作导致死循环问题](#hashmap-多线程操作导致死循环问题) + - [ConcurrentHashMap 和 Hashtable 的区别](#concurrenthashmap-和-hashtable-的区别) + - [ConcurrentHashMap线程安全的具体实现方式/底层具体实现](#concurrenthashmap线程安全的具体实现方式底层具体实现) + - [JDK1.7（上面有示意图）](#jdk17上面有示意图) + - [JDK1.8 （上面有示意图）](#jdk18-上面有示意图) + - [comparable 和 Comparator的区别](#comparable-和-comparator的区别) + - [Comparator定制排序](#comparator定制排序) + - [重写compareTo方法实现按年龄来排序](#重写compareto方法实现按年龄来排序) + - [集合框架底层数据结构总结](#集合框架底层数据结构总结) + - [Collection](#collection) + - [1. List](#1-list) + - [2. Set](#2-set) + - [Map](#map) + - [如何选用集合?](#如何选用集合) + + + +# 剖析面试最常见问题之Java集合框架 + +## 说说List,Set,Map三者的区别？ + +- **List(对付顺序的好帮手)：** List接口存储一组不唯一（可以有多个元素引用相同的对象），有序的对象 +- **Set(注重独一无二的性质):** 不允许重复的集合。不会有多个元素引用相同的对象。 +- **Map(用Key来搜索的专家):** 使用键值对存储。Map会维护与Key有关联的值。两个Key可以引用相同的对象，但Key不能重复，典型的Key是String类型，但也可以是任何对象。 + +## Arraylist 与 LinkedList 区别? + +- **1. 是否保证线程安全：** `ArrayList` 和 `LinkedList` 都是不同步的，也就是不保证线程安全； + +- **2. 底层数据结构：** `Arraylist` 底层使用的是 **`Object` 数组**；`LinkedList` 底层使用的是 **双向链表** 数据结构（JDK1.6之前为循环链表，JDK1.7取消了循环。注意双向链表和双向循环链表的区别，下面有介绍到！） + +- **3. 插入和删除是否受元素位置的影响：** ① **`ArrayList` 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。** 比如：执行`add(E e) `方法的时候， `ArrayList` 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是O(1)。但是如果要在指定位置 i 插入和删除元素的话（`add(int index, E element) `）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ② **`LinkedList` 采用链表存储，所以对于`add(E e)`方法的插入，删除元素时间复杂度不受元素位置的影响，近似 O（1），如果是要在指定位置`i`插入和删除元素的话（`(add(int index, E element)`） 时间复杂度近似为`o(n))`因为需要先移动到指定位置再插入。** + +- **4. 是否支持快速随机访问：** `LinkedList` 不支持高效的随机元素访问，而 `ArrayList` 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于`get(int index) `方法)。 + +- **5. 内存空间占用：** ArrayList的空 间浪费主要体现在在list列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）。 + +### **补充内容:RandomAccess接口** + +```java +public interface RandomAccess { +} +``` + +查看源码我们发现实际上 `RandomAccess` 接口中什么都没有定义。所以，在我看来 `RandomAccess` 接口不过是一个标识罢了。标识什么？ 标识实现这个接口的类具有随机访问功能。 + +在 `binarySearch（`）方法中，它要判断传入的list 是否 `RamdomAccess` 的实例，如果是，调用`indexedBinarySearch（）`方法，如果不是，那么调用`iteratorBinarySearch（）`方法 + +```java + public static + int binarySearch(List> list, T key) { + if (list instanceof RandomAccess || list.size() MAXIMUM_CAPACITY) + initialCapacity = MAXIMUM_CAPACITY; + if (loadFactor <= 0 || Float.isNaN(loadFactor)) + throw new IllegalArgumentException("Illegal load factor: " + + loadFactor); + this.loadFactor = loadFactor; + this.threshold = tableSizeFor(initialCapacity); + } + public HashMap(int initialCapacity) { + this(initialCapacity, DEFAULT_LOAD_FACTOR); + } +``` + +下面这个方法保证了 HashMap 总是使用2的幂作为哈希表的大小。 + +```java + /** + * Returns a power of two size for the given target capacity. + */ + static final int tableSizeFor(int cap) { + int n = cap - 1; + n |= n >>> 1; + n |= n >>> 2; + n |= n >>> 4; + n |= n >>> 8; + n |= n >>> 16; + return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; + } +``` + +## HashMap 和 HashSet区别 + +如果你看过 `HashSet` 源码的话就应该知道：HashSet 底层就是基于 HashMap 实现的。（HashSet 的源码非常非常少，因为除了 `clone() `、`writeObject()`、`readObject()`是 HashSet 自己不得不实现之外，其他方法都是直接调用 HashMap 中的方法。 + +| HashMap | HashSet | +| :------------------------------: | :----------------------------------------------------------: | +| 实现了Map接口 | 实现Set接口 | +| 存储键值对 | 仅存储对象 | +| 调用 `put（）`向map中添加元素 | 调用 `add（）`方法向Set中添加元素 | +| HashMap使用键（Key）计算Hashcode | HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性， | + +## HashSet如何检查重复 + +当你把对象加入`HashSet`时，HashSet会先计算对象的`hashcode`值来判断对象加入的位置，同时也会与其他加入的对象的hashcode值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同hashcode值的对象，这时会调用`equals（）`方法来检查hashcode相等的对象是否真的相同。如果两者相同，HashSet就不会让加入操作成功。（摘自我的Java启蒙书《Head fist java》第二版） + +**hashCode（）与equals（）的相关规定：** + +1. 如果两个对象相等，则hashcode一定也是相同的 +2. 两个对象相等,对两个equals方法返回true +3. 两个对象有相同的hashcode值，它们也不一定是相等的 +4. 综上，equals方法被覆盖过，则hashCode方法也必须被覆盖 +5. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）。 + +**==与equals的区别** + +1. ==是判断两个变量或实例是不是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是不是相同 +2. ==是指对内存地址进行比较 equals()是对字符串的内容进行比较 +3. ==指引用是否相同 equals()指的是值是否相同 + +## HashMap的底层实现 + +### JDK1.8之前 + +JDK1.8 之前 `HashMap` 底层是 **数组和链表** 结合在一起使用也就是 **链表散列**。**HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 (n - 1) & hash 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。** + +**所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使用扰动函数之后可以减少碰撞。** + +**JDK 1.8 HashMap 的 hash 方法源码:** + +JDK 1.8 的 hash方法 相比于 JDK 1.7 hash 方法更加简化，但是原理不变。 + +```java + static final int hash(Object key) { + int h; + // key.hashCode()：返回散列值也就是hashcode + // ^ ：按位异或 + // >>>:无符号右移，忽略符号位，空位都以0补齐 + return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); + } +``` + +对比一下 JDK1.7的 HashMap 的 hash 方法源码. + +```java +static int hash(int h) { + // This function ensures that hashCodes that differ only by + // constant multiples at each bit position have a bounded + // number of collisions (approximately 8 at default load factor). + + h ^= (h >>> 20) ^ (h >>> 12); + return h ^ (h >>> 7) ^ (h >>> 4); +} +``` + +相比于 JDK1.8 的 hash 方法 ，JDK 1.7 的 hash 方法的性能会稍差一点点，因为毕竟扰动了 4 次。 + +所谓 **“拉链法”** 就是：将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。 + +![jdk1.8之前的内部结构-HashMap](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/jdk1.8之前的内部结构-HashMap.jpg) + +### JDK1.8之后 + +相比于之前的版本， JDK1.8之后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。 + +![jdk1.8之后的内部结构-HashMap](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/JDK1.8之后的HashMap底层数据结构.jpg) + +> TreeMap、TreeSet以及JDK1.8之后的HashMap底层都用到了红黑树。红黑树就是为了解决二叉查找树的缺陷，因为二叉查找树在某些情况下会退化成一个线性结构。 + +**推荐阅读：** + +- 《Java 8系列之重新认识HashMap》 ： + +## HashMap 的长度为什么是2的幂次方 + +为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀。我们上面也讲到了过了，Hash 值的范围值-2147483648到2147483647，前后加起来大概40亿的映射空间，只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。但问题是一个40亿长度的数组，内存是放不下的。所以这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算，得到的余数才能用来要存放的位置也就是对应的数组下标。这个数组下标的计算方法是“ `(n - 1) & hash`”。（n代表数组长度）。这也就解释了 HashMap 的长度为什么是2的幂次方。 + +**这个算法应该如何设计呢？** + +我们首先可能会想到采用%取余的操作来实现。但是，重点来了：**“取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作（也就是说 hash%length==hash&(length-1)的前提是 length 是2的 n 次方；）。”** 并且 **采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是2的幂次方。** + +## HashMap 多线程操作导致死循环问题 + +主要原因在于 并发下的Rehash 会造成元素之间会形成一个循环链表。不过，jdk 1.8 后解决了这个问题，但是还是不建议在多线程下使用 HashMap,因为多线程下使用 HashMap 还是会存在其他问题比如数据丢失。并发环境下推荐使用 ConcurrentHashMap 。 + +详情请查看： + +## ConcurrentHashMap 和 Hashtable 的区别 + +ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。 + +- **底层数据结构：** JDK1.7的 ConcurrentHashMap 底层采用 **分段的数组+链表** 实现，JDK1.8 采用的数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树。Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 **数组+链表** 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的； +- **实现线程安全的方式（重要）：** ① **在JDK1.7的时候，ConcurrentHashMap（分段锁）** 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。 **到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6以后 对 synchronized锁做了很多优化）** 整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② **Hashtable(同一把锁)** :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。 + +**两者的对比图：** + +图片来源： + +**HashTable:** + +![HashTable全表锁](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/HashTable全表锁.png) + +**JDK1.7的ConcurrentHashMap：** + +![JDK1.7的ConcurrentHashMap](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/ConcurrentHashMap分段锁.jpg) + +**JDK1.8的ConcurrentHashMap（TreeBin: 红黑二叉树节点 Node: 链表节点）：** + +![JDK1.8的ConcurrentHashMap](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/JDK1.8-ConcurrentHashMap-Structure.jpg) + +## ConcurrentHashMap线程安全的具体实现方式/底层具体实现 + +### JDK1.7（上面有示意图） + +首先将数据分为一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据时，其他段的数据也能被其他线程访问。 + +**ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成**。 + +Segment 实现了 ReentrantLock,所以 Segment 是一种可重入锁，扮演锁的角色。HashEntry 用于存储键值对数据。 + +```java +static class Segment extends ReentrantLock implements Serializable { +} +``` + +一个 ConcurrentHashMap 里包含一个 Segment 数组。Segment 的结构和HashMap类似，是一种数组和链表结构，一个 Segment 包含一个 HashEntry 数组，每个 HashEntry 是一个链表结构的元素，每个 Segment 守护着一个HashEntry数组里的元素，当对 HashEntry 数组的数据进行修改时，必须首先获得对应的 Segment的锁。 + +### JDK1.8 （上面有示意图） + +ConcurrentHashMap取消了Segment分段锁，采用CAS和synchronized来保证并发安全。数据结构跟HashMap1.8的结构类似，数组+链表/红黑二叉树。Java 8在链表长度超过一定阈值（8）时将链表（寻址时间复杂度为O(N)）转换为红黑树（寻址时间复杂度为O(log(N))） + +synchronized只锁定当前链表或红黑二叉树的首节点，这样只要hash不冲突，就不会产生并发，效率又提升N倍。 + +## comparable 和 Comparator的区别 + +- comparable接口实际上是出自java.lang包 它有一个 `compareTo(Object obj)`方法用来排序 +- comparator接口实际上是出自 java.util 包它有一个`compare(Object obj1, Object obj2)`方法用来排序 + +一般我们需要对一个集合使用自定义排序时，我们就要重写`compareTo()`方法或`compare()`方法，当我们需要对某一个集合实现两种排序方式，比如一个song对象中的歌名和歌手名分别采用一种排序方法的话，我们可以重写`compareTo()`方法和使用自制的Comparator方法或者以两个Comparator来实现歌名排序和歌星名排序，第二种代表我们只能使用两个参数版的 `Collections.sort()`. + +### Comparator定制排序 + +```java + ArrayList arrayList = new ArrayList(); + arrayList.add(-1); + arrayList.add(3); + arrayList.add(3); + arrayList.add(-5); + arrayList.add(7); + arrayList.add(4); + arrayList.add(-9); + arrayList.add(-7); + System.out.println("原始数组:"); + System.out.println(arrayList); + // void reverse(List list)：反转 + Collections.reverse(arrayList); + System.out.println("Collections.reverse(arrayList):"); + System.out.println(arrayList); + + // void sort(List list),按自然排序的升序排序 + Collections.sort(arrayList); + System.out.println("Collections.sort(arrayList):"); + System.out.println(arrayList); + // 定制排序的用法 + Collections.sort(arrayList, new Comparator() { + + @Override + public int compare(Integer o1, Integer o2) { + return o2.compareTo(o1); + } + }); + System.out.println("定制排序后："); + System.out.println(arrayList); +``` + +Output: + +``` +原始数组: +[-1, 3, 3, -5, 7, 4, -9, -7] +Collections.reverse(arrayList): +[-7, -9, 4, 7, -5, 3, 3, -1] +Collections.sort(arrayList): +[-9, -7, -5, -1, 3, 3, 4, 7] +定制排序后： +[7, 4, 3, 3, -1, -5, -7, -9] +``` + +### 重写compareTo方法实现按年龄来排序 + +```java +// person对象没有实现Comparable接口，所以必须实现，这样才不会出错，才可以使treemap中的数据按顺序排列 +// 前面一个例子的String类已经默认实现了Comparable接口，详细可以查看String类的API文档，另外其他 +// 像Integer类等都已经实现了Comparable接口，所以不需要另外实现了 + +public class Person implements Comparable { + private String name; + private int age; + + public Person(String name, int age) { + super(); + this.name = name; + this.age = age; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + /** + * TODO重写compareTo方法实现按年龄来排序 + */ + @Override + public int compareTo(Person o) { + // TODO Auto-generated method stub + if (this.age > o.getAge()) { + return 1; + } else if (this.age < o.getAge()) { + return -1; + } + return age; + } +} + +``` + +```java + public static void main(String[] args) { + TreeMap pdata = new TreeMap(); + pdata.put(new Person("张三", 30), "zhangsan"); + pdata.put(new Person("李四", 20), "lisi"); + pdata.put(new Person("王五", 10), "wangwu"); + pdata.put(new Person("小红", 5), "xiaohong"); + // 得到key的值的同时得到key所对应的值 + Set keys = pdata.keySet(); + for (Person key : keys) { + System.out.println(key.getAge() + "-" + key.getName()); + + } + } +``` + +Output： + +``` +5-小红 +10-王五 +20-李四 +30-张三 +``` + +## 集合框架底层数据结构总结 + +### Collection + +#### 1. List + +- **Arraylist：** Object数组 +- **Vector：** Object数组 +- **LinkedList：** 双向链表(JDK1.6之前为循环链表，JDK1.7取消了循环) + +#### 2. Set + +- **HashSet（无序，唯一）:** 基于 HashMap 实现的，底层采用 HashMap 来保存元素 +- **LinkedHashSet：** LinkedHashSet 继承于 HashSet，并且其内部是通过 LinkedHashMap 来实现的。有点类似于我们之前说的LinkedHashMap 其内部是基于 HashMap 实现一样，不过还是有一点点区别的 +- **TreeSet（有序，唯一）：** 红黑树(自平衡的排序二叉树) + +### Map + +- **HashMap：** JDK1.8之前HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。JDK1.8以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间 +- **LinkedHashMap：** LinkedHashMap 继承自 HashMap，所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外，LinkedHashMap 在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序相关逻辑。详细可以查看：[《LinkedHashMap 源码详细分析（JDK1.8）》](https://www.imooc.com/article/22931) +- **Hashtable：** 数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的 +- **TreeMap：** 红黑树（自平衡的排序二叉树） + +## 如何选用集合? + +主要根据集合的特点来选用，比如我们需要根据键值获取到元素值时就选用Map接口下的集合，需要排序时选择TreeMap,不需要排序时就选择HashMap,需要保证线程安全就选用ConcurrentHashMap.当我们只需要存放元素值时，就选择实现Collection接口的集合，需要保证元素唯一时选择实现Set接口的集合比如TreeSet或HashSet，不需要就选择实现List接口的比如ArrayList或LinkedList，然后再根据实现这些接口的集合的特点来选用。 + +## 公众号 + +如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。 + +**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！ + +**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。 + +![我的公众号](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/167598cd2e17b8ec.png) diff --git a/docs/java/LinkedList.md b/docs/java/collection/LinkedList.md similarity index 99% rename from docs/java/LinkedList.md rename to docs/java/collection/LinkedList.md index 983c1fae0d0..d26bc752267 100644 --- a/docs/java/LinkedList.md +++ b/docs/java/collection/LinkedList.md @@ -458,7 +458,7 @@ public class LinkedListDemo { linkedList.add(3); linkedList.removeFirstOccurrence(3); // 从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表） System.out.println("After removeFirstOccurrence(3):" + linkedList); - linkedList.removeLastOccurrence(3); // 从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表） + linkedList.removeLastOccurrence(3); // 从此列表中移除最后一次出现的指定元素（从尾部到头部遍历列表） System.out.println("After removeFirstOccurrence(3):" + linkedList); /************************** 遍历操作 ************************/ diff --git "a/docs/java/jvm/JDK\347\233\221\346\216\247\345\222\214\346\225\205\351\232\234\345\244\204\347\220\206\345\267\245\345\205\267\346\200\273\347\273\223.md" "b/docs/java/jvm/JDK\347\233\221\346\216\247\345\222\214\346\225\205\351\232\234\345\244\204\347\220\206\345\267\245\345\205\267\346\200\273\347\273\223.md" new file mode 100644 index 00000000000..8a8ec160182 --- /dev/null +++ "b/docs/java/jvm/JDK\347\233\221\346\216\247\345\222\214\346\225\205\351\232\234\345\244\204\347\220\206\345\267\245\345\205\267\346\200\273\347\273\223.md" @@ -0,0 +1,337 @@ +点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。 + + + +- [JDK 监控和故障处理工具总结](#jdk-监控和故障处理工具总结) + - [JDK 命令行工具](#jdk-命令行工具) + - [`jps`:查看所有 Java 进程](#jps查看所有-java-进程) + - [`jstat`: 监视虚拟机各种运行状态信息](#jstat-监视虚拟机各种运行状态信息) + - [` jinfo`: 实时地查看和调整虚拟机各项参数](#-jinfo-实时地查看和调整虚拟机各项参数) + - [`jmap`:生成堆转储快照](#jmap生成堆转储快照) + - [**`jhat`**: 分析 heapdump 文件](#jhat-分析-heapdump-文件) + - [**`jstack`** :生成虚拟机当前时刻的线程快照](#jstack-生成虚拟机当前时刻的线程快照) + - [JDK 可视化分析工具](#jdk-可视化分析工具) + - [JConsole:Java 监视与管理控制台](#jconsolejava-监视与管理控制台) + - [连接 Jconsole](#连接-jconsole) + - [查看 Java 程序概况](#查看-java-程序概况) + - [内存监控](#内存监控) + - [线程监控](#线程监控) + - [Visual VM:多合一故障处理工具](#visual-vm多合一故障处理工具) + + + +# JDK 监控和故障处理工具总结 + +## JDK 命令行工具 + +这些命令在 JDK 安装目录下的 bin 目录下： + +- **`jps`** (JVM Process Status）: 类似 UNIX 的 `ps` 命令。用户查看所有 Java 进程的启动类、传入参数和 Java 虚拟机参数等信息； +- **`jstat`**（ JVM Statistics Monitoring Tool）: 用于收集 HotSpot 虚拟机各方面的运行数据; +- **`jinfo`** (Configuration Info for Java) : Configuration Info forJava,显示虚拟机配置信息; +- **`jmap`** (Memory Map for Java) :生成堆转储快照; +- **`jhat`** (JVM Heap Dump Browser ) : 用于分析 heapdump 文件，它会建立一个 HTTP/HTML 服务器，让用户可以在浏览器上查看分析结果; +- **`jstack`** (Stack Trace for Java):生成虚拟机当前时刻的线程快照，线程快照就是当前虚拟机内每一条线程正在执行的方法堆栈的集合。 + +### `jps`:查看所有 Java 进程 + +`jps`(JVM Process Status) 命令类似 UNIX 的 `ps` 命令。 + +`jps`：显示虚拟机执行主类名称以及这些进程的本地虚拟机唯一 ID（Local Virtual Machine Identifier,LVMID）。`jps -q` ：只输出进程的本地虚拟机唯一 ID。 + +```powershell +C:\Users\SnailClimb>jps +7360 NettyClient2 +17396 +7972 Launcher +16504 Jps +17340 NettyServer +``` + +`jps -l`:输出主类的全名，如果进程执行的是 Jar 包，输出 Jar 路径。 + +```powershell +C:\Users\SnailClimb>jps -l +7360 firstNettyDemo.NettyClient2 +17396 +7972 org.jetbrains.jps.cmdline.Launcher +16492 sun.tools.jps.Jps +17340 firstNettyDemo.NettyServer +``` + +`jps -v`：输出虚拟机进程启动时 JVM 参数。 + +`jps -m`：输出传递给 Java 进程 main() 函数的参数。 + +### `jstat`: 监视虚拟机各种运行状态信息 + +jstat（JVM Statistics Monitoring Tool） 使用于监视虚拟机各种运行状态信息的命令行工具。 它可以显示本地或者远程（需要远程主机提供 RMI 支持）虚拟机进程中的类信息、内存、垃圾收集、JIT 编译等运行数据，在没有 GUI，只提供了纯文本控制台环境的服务器上，它将是运行期间定位虚拟机性能问题的首选工具。 + +**`jstat` 命令使用格式：** + +```powershell +jstat -