[
{
"path": ".gitattributes",
"content": "*.js linguist-language=java\n*.css linguist-language=java\n*.html linguist-language=java\n"
},
{
"path": ".github/FUNDING.yml",
"content": "# These are supported funding model platforms\n\ngithub: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]\npatreon: # Replace with a single Patreon username\nopen_collective: # Replace with a single Open Collective username\nko_fi: # Replace with a single Ko-fi username\ntidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel\ncommunity_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry\nliberapay: # Replace with a single Liberapay username\nissuehunt: # Replace with a single IssueHunt username\notechie: # Replace with a single Otechie username\ncustom: https://raw.githubusercontent.com/frank-lam/fullstack-tutorial/master/assets/wechat/wx-green.png\n"
},
{
"path": ".travis.yml",
"content": "sudo: required\nscript: bash ./assets/deploy/deploy.sh\nbranches:\n only:\n - master\nnotifications:\n email: true"
},
{
"path": "README.md",
"content": "\nTODO LIST \n\n- HTML5\n\n- CSS3\n\n- CSS 预处理\n\n - sass(scss)\n - less\n - stylus\n\n- CSS 框架\n\n - BootStarp\n - LayUI\n\n- JavaScript \n\n 基础语法、进阶、ES6\n\n- JavaScript 框架\n\n - Vue\n - React\n - Angular\n - jQuery\n\n- Node\n\n 常用 api、对象池、异常处理、进程通信、高并发\n\n- 静态类型检查\n\n - TypeScript\n - Flow\n\n- 构建/打包工具\n\n - webpack\n - gulp\n - rollup\n\n- 包管理工具\n\n - npm\n - yarn\n \n- 服务端渲染\n\n - koa2\n - express\n - nuxt\n - next\n\n \n\n\n\n## 五、数据库\n\n- [MySQL](notes/MySQL.md)\n\n 存储引擎、事务隔离级别、索引、主从复制\n\n- [Redis](notes/Redis.md)\n\n Redis 核心知识\n\n- [SQL](notes/SQL.md)\n\n 常用 SQL 语句\n\n- [PostgreSQL](notes/PostgreSQL.md)\n\n 一个开源的关系数据库，是从伯克利写的 POSTGRES 软件包发展而来的\n\n- [InfluxDB](https://www.frankfeekr.cn/2019/07/24/influxdb-tutorial-start/)\n\n 玩转时序数据库\n\n\n\n## 六、操作系统\n\n- [操作系统原理](notes/操作系统.md)\n\n 进程管理、死锁、内存管理、磁盘设备\n\n- [Linux](notes/Linux.md)\n\n 基础核心概念、常用命令使用\n\n\n\n## 七、网络通信\n\n- [计算机网络](notes/计算机网络.md)\n\n 传输层、应用层（HTTP）、网络层、网络安全\n\n- [RESTful API](notes/RESTful%20API.md)\n\n 软件架构风格、格设计原则和约束条件\n\n- [Web网络安全](notes/网络安全.md)\n\n web前后端漏洞分析与防御，XSS 攻击、CSRF 攻击、DDoS 攻击、SQL 注入\n\n\n\n\n## 八、分布式\n\n- [Docker](notes/Docker基础.md)\n\n 容器化引擎服务\n\n- [微服务](notes/微服务.md)\n\n 微服务简介、API 网关、服务注册发现、服务通信\n\n- [Zookeeper](notes/分布式/Zookeeper.md)\n\n 分布式协调服务，服务注册发现\n\n- [Kafka](notes/MicroService/kafka/README.md)\n\n 深入浅出 Kafka，将用最极简的语言带你走进 Kafka 的消息中间件世界\n\n\n\n【说明】**分布式专题** 笔者也在学习中，这里列举了一些技能列表，笔者将局部更新。敬请期待\n\n\n\n\n\nTODO LIST \n\n- Kubernetes（k8s）\n\n 容器化部署，管理云平台中多个主机上的容器化的应用\n\n- 云计算\n\n SaaS（软件即服务） 、PaaS（平台即服务） 、IaaS（基础架构即服务）\n\n- Zookeeper\n\n 分布式协调服务，服务注册发现\n\n- Dubbo、Thrift（RPC 框架）\n\n 分布式服务治理\n\n- 分布式事务解决方案\n\n- ActiveMQ、Kafka、RabbitMQ\n\n 分布式消息通信\n\n- 熔断，限流，降级机制\n\n- Redis\n\n 分布式缓存\n\n- Mycat\n\n 数据库路由\n\n- Nginx\n\n 反向代理\n\n- Tomcat\n\n Web Server 服务\n\n- DevOps\n\n 自动化运维，持续集成、持续交付、持续部署\n\n\n- 分布式锁\n\n 基于 Redis、MySQL、Zookeeper 的分布式锁实现\n\n- FastDFS\n\n 轻量级分布式文件管理系统\n \n- Go\n\n 并发的、带垃圾回收的、快速编译的语言\n\n \n\n\n\n## 九、机器学习\n\n- [深度学习初识](notes/DeepLearning/深度学习初识.md)\n\n- 经典机器学习算法\n\n K 近邻算法、线性回归、梯度下降法、逻辑回归、支持向量机、决策树、集成学习\n\n\n\n\n## 十、工具\n\n- [Git](notes/git-tutorial.md)\n\n 学习指引，将用最极简的语言带你进入 Git 版本控制的世界\n\n- [Git 工作流](notes/Git工作流.md)\n\n 集中式工作流，功能分支工作流， GitFlow 工作流，Forking 工作流，Pull Requests\n\n- [正则表达式](notes/正则表达式.md)\n\n 常见符号含义，速查表\n\n- [手把手教你搭建内网穿透服务](https://github.com/frank-lam/lanproxy-nat)\n\n 基于 lanproxy 穿透服务，为你定了一键启动的服务端和客户端 Docker 镜像\n\n- [基于 SpringBoot & IDEA & JRebel 玩转远程热部署与远程调试](https://www.frankfeekr.cn/2019/07/17/springboot-idea-jrebel-hotswap/)\n\n 手把手带你玩转，远程调试与远程热部署\n\n- [什么是 TDD 及常见的测试方法](notes/软件测试.md)\n\n\n\n## Learn 📖\n\n- [LEARN_LIST](notes/LEARNLIST.md)\n\n 包含阅读清单，学习课程两部分\n\n- [web应用开发标准流程](notes/web应用开发标准流程.md)\n\n\n\n## Talking :bulb:\n\n本仓库致力于成为一个全栈开发爱好者的学习指南，给初学者一个更明确的学习方向，同时也是对自己技能的强化和巩固。在架构师这条路上，希望和大家一起成长，帮助更多的计算机爱好者能够有一个明确的学习路径。持续不间断的维护本仓库，也欢迎有更多的极客们加入。\n\n都说好记性不如烂笔头，定期的学习和整理必然对学习巩固有所帮助，这里通过索引的方式对全栈开发技术做一个系统分类，方便随时巩固和学习，当然还有面试。在学习这条路上难免会有很多盲点和学不完的知识。有道无术，术尚可求，掌握好思维能力才能应对千变万化的技术。不要把大脑当成硬盘，也不要做高速运转的 CPU，而修行自己的大脑成为一个搜索引擎，学会分析解决问题。\n\nSince 20,May,2018\n\n\n\n## Reference\n\n个人的能力有限，在编写的过程中引用了诸多优秀的 GitHub 仓库。本项目的启发来自 [@CyC2018](https://github.com/CyC2018) 的学习笔记，是一个非常优秀的开源项目，在本仓库中部分内容引用文字和图例；引用了 [@计算所的小鼠标](https://github.com/CarpenterLee) 中对于 JCF 的源码分析和理解；引用了 [阿里面试题总结](https://www.nowcoder.com/discuss/5949) 中全部的面试题，并对面经进行了整理勘误，并进行了知识拓展和修改；引用了 [牛客网](https://www.nowcoder.com) 上的面试经验贴。也引用了知乎上的热门回答和优秀博客的回答。在这里特别鸣谢，我将每篇文章中做外链引用说明。\n\n文中我也推荐了学习的书籍和学习课程，都将附着上最高清、最形象的配图进行讲解。在文中的配图都来自自己绘制的、博客、Github、PDF书籍等等，这里没法一一感谢，谢谢你们。\n\n推荐一些优秀的开源项目，供大家参考，[reference](notes/reference.md)。\n\n\n\n## Contributors\n\nThank you to all the people who already contributed to fullstack-tutorial !\n\nPlease make sure to read the [Contributing Guide/如何给我的仓库贡献](notes/docs/如何给我的仓库贡献.md) before making a pull request. \n\n \n
\n 在颠覆世界的同时，也要好好关照自己。\n
\n
\n
\n
\n
\n
\n from zero to hero.\n
\n
\n\n"
},
{
"path": "assets/deploy/deploy.sh",
"content": "#!/usr/bin/env sh\n\n# 确保脚本抛出遇到的错误\nset -e\n\n\nrm gh-pages -rf; mkdir gh-pages; cp -r notes/* gh-pages/;\ncd gh-pages;\n\n\n# 将子目录的所有图片全部复制到文档根目录中，解决docsify图片索引不到的问题\nrm assets/ -rf\nmkdir assets\n\nrm pics/ -rf\nmkdir pics\n\n\nfor f in $(find ../notes/ -type f -print | grep assets)\n do\n cp $f ./assets\n done\n\nfor f in $(find ../notes/ -type f -print | grep pics)\n do\n cp $f ./pics\n done\n\n# 进入生成的文件夹\n\n#创建.nojekyll 防止Github Pages build错误\ntouch .nojekyll\n\ngit init\ngit add -A\ngit commit -m 'deploy'\n\ngit push -f \"https://${GH_TOKEN}@github.com/frank-lam/fullstack-tutorial.git\" master:gh-pages\n\ncd -"
},
{
"path": "course/01 玩转数据结构.md",
"content": "## 刘宇波《玩转数据结构》学习记录\n\n| 章节 | 记录 |\n| ------------------------------------------- | ---- |\n| **第1章 欢迎学习《玩转数据结构》** | |\n| 1-1 欢迎学习《玩转数据结构》 | |\n| 1-2 学习数据结构（和算法）到底有没有用？ | |\n| 1-3 关于课程学习的更多注意事项 | |\n| 1-4 课程编程环境搭建 | |\n| | |\n| **第2章 不要小瞧数组** | |\n| 2-1 使用Java中的数组 | |\n| 2-2 二次封装属于我们自己的数组 | |\n| 2-3 向数组中添加元素 | |\n| 2-4 数组中查询元素和修改元素 | |\n| 2-5 包含，搜索和删除 | |\n| 2-6 使用泛型 | |\n| 2-7 动态数组 | |\n| 2-8 简单的复杂度分析 | |\n| 2-9 均摊复杂度和防止复杂度的震荡 | |\n| | |\n| **第3章 栈和队列** | |\n| 3-1 栈和栈的应用：撤销操作和系统栈 | 5/21 |\n| 3-2 栈的基本实现 | 5/21 |\n| 3-3 栈的另一个应用：括号匹配 | 5/21 |\n| 3-4 关于Leetcode的更多说明 | 5/21 |\n| 3-5 数组队列 | 5/21 |\n| 3-6 循环队列 | 5/21 |\n| 3-7 循环队列的实现 | 5/21 |\n| 3-8 数组队列和循环队列的比较 | 5/21 |\n| | |\n| **第4章 最基础的动态数据结构：链表** | |\n| 4-1 什么是链表 | |\n| 4-2 在链表中添加元素 | |\n| 4-3 使用链表的虚拟头结点 | |\n| 4-4 链表的遍历，查询和修改 | |\n| 4-5 从链表中删除元素 | |\n| 4-6 使用链表实现栈 | |\n| 4-7 带有尾指针的链表：使用链表实现队列 | |\n| | |\n| **第5章 链表和递归** | |\n| 5-1 Leetcode中和链表相关的问题 | |\n| 5-2 测试自己的Leetcode链表代码 | |\n| 5-3 递归基础与递归的宏观语意 | |\n| 5-4 链表的天然递归结构性质 | |\n| 5-5 递归运行的机制：递归的微观解读 | |\n| 5-6 递归算法的调试 | |\n| 5-7 更多和链表相关的问题 | |\n| | |\n| **第6章 二分搜索树** | |\n| 6-1 为什么要研究树结构 | 6/29 |\n| 6-2 二分搜索树基础 | 6/29 |\n| 6-3 向二分搜索树中添加元素 | 6/29 |\n| 6-4 改进添加操作：深入理解递归终止条件 | 6/30 |\n| 6-5 二分搜索树的查询操作 | 6/30 |\n| 6-6 二分搜索树的前序遍历 | 6/30 |\n| 6-7 二分搜索树的中序遍历和后序遍历 | 6/30 |\n| 6-8 深入理解二分搜索树的前中后序遍历 | 6/30 |\n| 6-9 二分搜索树前序遍历的非递归实现——**通过栈实现** | 6/30 |\n| 6-10 二分搜索树的层序遍历——**通过队列实现** | 6/30 |\n| 6-11 删除二分搜索树的最大元素和最小元素 | 6/30 |\n| 6-12 删除二分搜索树的任意元素 | 6/30 |\n| 6-13 更多二分搜索树相关话题 | 6/30 |\n| | |\n| **第7章 集合和映射** | |\n| 7-1 集合基础和基于二分搜索树的集合实现 | |\n| 7-2 基于链表的集合实现 | |\n| 7-3 集合类的复杂度分析 | |\n| 7-4 _Leetcode中的集合问题和更多集合相关问题 | |\n| 7-5 映射基础 | |\n| 7-6 基于链表的映射实现 | |\n| 7-7 基于二分搜索树的映射实现 | |\n| 7-8 映射的复杂度分析和更多映射相关问题 | |\n| 7-9 Leetcode上更多集合和映射的问题 | |\n| | |\n| **第8章 优先队列和堆** | |\n| 8-1 什么是优先队列 | |\n| 8-2 堆的基础表示 | |\n| 8-3 向堆中添加元素和Sift Up | |\n| 8-4 从堆中取出元素和Sift Down | |\n| 8-5 Heapify 和 Replace | |\n| 8-6 基于堆的优先队列 | |\n| 8-7 Leetcode上优先队列相关问题 | |\n| 8-8 Java中的PriorityQueue | |\n| 8-9 和堆相关的更多话题和广义队列 | |\n| ||\n| **第9章 线段树** ||\n| 9-1 什么是线段树 ||\n| 9-2 线段树基础表示 ||\n| 9-3 创建线段树 ||\n| 9-4 线段树中的区间查询 ||\n| 9-5 Leetcode上线段树相关的问题 ||\n| 9-6 线段树中的更新操作 ||\n| 9-7 更多线段树相关的话题 ||\n| ||\n| **第10章 Trie** ||\n| 10-1 什么是Trie字典树 ||\n| 10-2 Trie字典树基础 ||\n| 10-3 Trie字典树的查询 ||\n| 10-4 Trie字典树的前缀查询 ||\n| 10-5 Trie字典树和简单的模式匹配 ||\n| 10-6 Trie字典树和字符串映射 ||\n| 10-7 更多和Trie字典树相关的话题 ||\n| ||\n| **第11章 并查集** ||\n| 11-1 什么是并查集 ||\n| 11-2 Quick Find ||\n| 11-3 Quick Union ||\n| 11-4 基于size的优化 ||\n| 11-5 基于rank的优化 ||\n| 11-6 路径压缩 ||\n| 11-7 更多和并查集相关的话题 ||\n| ||\n| **第12章 AVL** ||\n| 12-1 平衡树和AVL ||\n| 12-2 计算节点的高度和平衡因子 ||\n| 12-3 检查二分搜索树性质和平衡性 ||\n| 12-4 旋转操作的基本原理 ||\n| 12-5 左旋转和右旋转的实现 ||\n| 12-6 LR 和 RL ||\n| 12-7 从AVL树中删除元素 ||\n| 12-8 基于AVL树的集合和映射 ||\n| | |\n| **第13章 红黑树** | |\n| 13-1 红黑树与2-3树 | |\n| 13-2 2-3树的绝对平衡性 | |\n| 13-3 红黑树与2-3树的等价性 | |\n| 13-4 红黑树的基本性质和复杂度分析 | |\n| 13-5 保持根节点为黑色和左旋转 | |\n| 13-6 颜色翻转和右旋转 | |\n| 13-7 红黑树中添加新元素 | |\n| 13-8 红黑树的性能测试 | |\n| 13-9 更多和红黑树相关的话题 | |\n| 13-10 对于红黑树，任何不平衡都会在三次旋转内解决？ | |\n| | |\n| **第14章 哈希表** | |\n| 14-1 哈希表基础 | |\n| 14-2 哈希函数的设计 | |\n| 14-3 Java中的 hashCode 方法 | |\n| 14-4 链地址法 Seperate Chaining | |\n| 14-5 实现属于我们自己的哈希表 | |\n| 14-6 哈希表的动态空间处理与复杂度分析。 | |\n| 14-7 哈希表更复杂的动态空间处理方法 | |\n| 14-8 更多哈希冲突的处理方法 | |\n| | |\n| **第15章 结尾语** | |\n| 15-1 更广阔的数据结构的世界，大家加油！ | |\n\n**2018年7月10日完结**"
},
{
"path": "course/02 玩转算法面试.md",
"content": "## 刘宇波《玩转算法面试》学习记录\n\n| 章节 | 记录 |\n| ------------------------------------------------------------ | ---- |\n| **第1章 算法面试到底是什么鬼?** | |\n| 1-1 算法面试不仅仅是正确的回答问题 | |\n| 1-2 算法面试只是面试的一部分 | |\n| 1-3 如何准备算法面试 | |\n| 1-4 如何回答算法面试问题 | |\n| | |\n| **第2章 面试中的复杂度分析** | |\n| 2-1 究竟什么是大O（Big O） | |\n| 2-2 对数据规模有一个概念 | |\n| 2-3 简单的复杂度分析 | |\n| 2-4 亲自试验自己算法的时间复杂度 | |\n| 2-5 递归算法的复杂度分析 | |\n| 2-6 均摊时间复杂度分析（Amortized Time Analysis） | |\n| 2-7 避免复杂度的震荡 | |\n| | |\n| **第3章 数组中的问题其实最常见** | |\n| 3-1 从二分查找法看如何写出正确的程序 | |\n| 3-2 改变变量定义，依然可以写出正确的算法 | |\n| 3-3 在LeetCode上解决第一个问题 Move Zeros | |\n| 3-4 即使简单的问题，也有很多优化的思路 | |\n| 3-5 三路快排partition思路的应用 Sort Color | |\n| 3-6 对撞指针 Two Sum II - Input Array is Sorted | |\n| 3-7 滑动窗口 Minimum Size Subarray Sum | |\n| 3-8 在滑动窗口中做记录 Longest Substring Without Repeating Characters | |\n| | |\n| **第4章 查找表相关问题** | |\n| 4-1 set的使用 Intersection of Two Arrays | |\n| 4-2 map的使用 Intersection of Two Arrays II | |\n| 4-3 set和map不同底层实现的区别 | |\n| 4-4 使用查找表的经典问题 Two Sum | |\n| 4-5 灵活选择键值 4Sum II | |\n| 4-6 灵活选择键值 Number of Boomerangs | |\n| 4-7 查找表和滑动窗口 Contain Duplicate II | |\n| 4-8 二分搜索树底层实现的顺序性 Contain Duplicate III | |\n| | |\n| **第5章 在链表中穿针引线** | |\n| 5-1 链表，在节点间穿针引线 Reverse Linked List | |\n| 5-2 测试你的链表程序 | |\n| 5-3 设立链表的虚拟头结点 Remove Linked List Elements | |\n| 5-4 复杂的穿针引线 Swap Nodes in Pairs | |\n| 5-5 不仅仅是穿针引线 Delete Node in a Linked List | |\n| 5-6 链表与双指针 Remove Nth Node Form End of List | |\n| | |\n| **第6章 栈，队列，优先队列** | |\n| 6-1 栈的基础应用 Valid Parentheses | |\n| 6-2 栈和递归的紧密关系 Binary Tree Preorder, Inorder and Postorder Traversal | |\n| 6-3 运用栈模拟递归 | |\n| 6-4 队列的典型应用 Binary Tree Level Order Traversal | |\n| 6-5 BFS和图的最短路径 Perfect Squares | |\n| 6-6 优先队列 | |\n| 6-7 优先队列相关的算法问题 Top K Frequent Elements | |\n| | |\n| **第7章 二叉树和递归** | |\n| 7-1 二叉树天然的递归结构 | |\n| 7-2 一个简单的二叉树问题引发的血案 Invert Binary Tree | |\n| 7-3 注意递归的终止条件 Path Sum | |\n| 7-4 定义递归问题 Binary Tree Path | |\n| 7-5 稍复杂的递归逻辑 Path Sum III | |\n| 7-6 二分搜索树中的问题 Lowest Common Ancestor of a Binary Search Tree | |\n| | |\n| **第8章 递归和回溯法** | |\n| 8-1 树形问题 Letter Combinations of a Phone Number | 7/19 |\n| 8-2 什么是回溯 | |\n| 8-3 排列问题 Permutations | |\n| 8-4 组合问题 Combinations | |\n| 8-5 回溯法解决组合问题的优化 | |\n| 8-6 二维平面上的回溯法 Word Search | |\n| 8-7 floodfill算法，一类经典问题 Number of Islands- | |\n| 8-8 回溯法是经典人工智能的基础 N Queens | |\n| | |\n| **第9章 动态规划基础** | |\n| 9-1 什么是动态规划 | |\n| 9-2 第一个动态规划问题 Climbing Stairs | |\n| 9-3 发现重叠子问题 Integer Break | |\n| 9-4 状态的定义和状态转移 House Robber | |\n| 9-5 0-1背包问题 | |\n| 9-6 0-1背包问题的优化和变种 | |\n| 9-7 面试中的0-1背包问题 Partition Equal Subset Sum | |\n| 9-8 LIS问题 Longest Increasing Subsequence | |\n| 9-9 LCS，最短路，求动态规划的具体解以及更多 | |\n| | |\n| **第10章 贪心算法** | |\n| 10-1 贪心基础 Assign Cookies | |\n| 10-2 贪心算法与动态规划的关系 Non-overlapping Intervals | |\n| 10-3 贪心选择性质的证明 | |\n| | |\n| **第11章 课程结语** | |\n| 11-1 结语 | |"
},
{
"path": "course/03 算法与数据结构.md",
"content": "## 刘宇波《算法与数据结构》学习记录\n\n| 章节 | 记录 |\n| ------------------------------------------------------------ | ---- |\n| **第1章 当我们在讨论算法的时候，我们在讨论什么？** ||\n| 1-1 我们究竟为什么要学习算法 ||\n| 1-2 课程介绍 ||\n| ||\n| **第2章 排序基础** ||\n| 2-1 选择排序法 ||\n| 2-2 使用模板（泛型）编写算法 ||\n| 2-3 随机生成算法测试用例 ||\n| 2-4 测试算法的性能 ||\n| 2-5 插入排序法 ||\n| 2-6 插入排序法的改进 ||\n| 2-7 更多关于O（n*2）排序算法的思考 ||\n| ||\n| **第3章 高级排序问题** ||\n| 3-1 归并排序法 ||\n| 3-2 归并排序法的实现 ||\n| 3-3 归并排序法的优化 ||\n| 3-4 自底向上的归并排序算法 ||\n| 3-5 快速排序法 ||\n| 3-6 随机化快速排序法 ||\n| 3-7 双路快速排序法 ||\n| 3-8 三路快速排序法 ||\n| 3-9 归并排序和快速排序的衍生问题 ||\n| ||\n| **第4章 堆和堆排序** ||\n| 4-1 为什么使用堆 ||\n| 4-2 堆的基本存储 ||\n| 4-3 Shift Up ||\n| 4-4 Shift Down ||\n| 4-5 基础堆排序和Heapify ||\n| 4-6 优化的堆排序 ||\n| 4-7 排序算法总结 ||\n| 4-8 索引堆 ||\n| 4-9 索引堆的优化 ||\n| 4-10 和堆相关的其他问题 ||\n| ||\n| **第5章 二分搜索树** ||\n| 5-1 二分查找法 ||\n| 5-2 二分搜索树基础 ||\n| 5-3 二分搜索树的节点插入 ||\n| 5-4 二分搜索书的查找 ||\n| 5-5 二分搜索树的遍历（深度优先遍历） ||\n| 5-6 层序遍历（广度优先遍历） ||\n| 5-7 删除最大值，最小值 ||\n| 5-8 二分搜索树的删除 ||\n| 5-9 二分搜索树的顺序性 ||\n| 5-10 二分搜索树的局限性 ||\n| 5-11 树形问题和更多树。 ||\n| ||\n| **第6章 并查集** ||\n| 6-1 并查集基础 ||\n| 6-2 Qucik Find ||\n| 6-3 Quick Union ||\n| 6-4 基于size的优化 ||\n| 6-5 基于rank的优化 ||\n| 6-6 路径压缩 ||\n| ||\n| **第7章 图的基础** ||\n| 7-1 图论基础 ||\n| 7-2 图的表示 ||\n| 7-3 相邻点迭代器 ||\n| 7-4 图的算法框架 ||\n| 7-5 深度优先遍历和联通分量 ||\n| 7-6 寻路 ||\n| 7-7 广度优先遍历和最短路径 ||\n| 7-8 迷宫生成，ps抠图--更多无权图的应用 ||\n| ||\n| **第8章 最小生成树** ||\n| 8-1 有权图 ||\n| 8-2 最小生成树问题和切分定理 ||\n| 8-3 Prim算法的第一个实现 ||\n| 8-4 Prim算法的优化 ||\n| 8-5 优化后的Prim算法的实现 ||\n| 8-6 Krusk算法 ||\n| 8-7 最小生成树算法的思考 ||\n| ||\n| **第9章 最短路径** ||\n| 9-1 最短路径问题和松弛操作 ||\n| 9-2 Dijkstra算法的思想 ||\n| 9-3 实现Dijkstra算法 ||\n| 9-4 负权边和Bellman-Ford算法 ||\n| 9-5 实现Bellman-Ford算法 ||\n| 9-6 更多和最短路径相关的思考 ||\n| ||\n| **第10章 结束语** ||\n| 10-1 总结，算法思想，大家加油！ ||\n\n"
},
{
"path": "course/04 Nginx从入门到实战.md",
"content": "## 《Nginx从入门到实践》学习记录\n\n\n\nFebruary 2018 Web Server Survey | Netcraft\nhttps://news.netcraft.com/archives/2018/02/13/february-2018-web-server-survey.html\n\n| 章节 | 记录 |\n| ------------------------------------------------------------ | ---- |\n| **第1章 课程前言** | |\n| 1-1 课程介绍 | |\n| 1-2 学习环境准备 | |\n| | |\n| **第2章 基础篇** | |\n| 2-1 什么是Nginx | |\n| 2-2 常见的中间件服务 | |\n| 2-3 Nginx特性_实现优点1 | |\n| 2-4 Nginx特性_实现优点2 | |\n| 2-5 Nginx特性_实现优点3 | |\n| 2-6 Nginx特性_实现优点4 | |\n| 2-7 Nginx快速安装 | |\n| 2-8 Nginx的目录和配置语法_Nginx安装目录 | |\n| 2-9 Nginx的目录和配置语法_Nginx编译配置参数 | |\n| 2-10 Nginx的目录和配置语法_默认配置语法 | |\n| 2-11 Nginx的目录和配置语法_默认配置与默认站点启动 | |\n| 2-12 HTTP请求 | |\n| 2-13 Nginx日志_log_format1 | |\n| 2-14 Nginx日志_log_format2 | |\n| 2-15 Nginx模块讲解_模块介绍 | |\n| 2-16 Nginx模块讲解_sub_status | |\n| 2-17 Nginx模块讲解_random_index | |\n| 2-18 Nginx模块讲解_sub_module | |\n| 2-19 Nginx模块讲解_sub_module配置演示 | |\n| 2-20 Nginx的请求限制_配置语法与原理1 | |\n| 2-21 Nginx的请求限制_配置语法与原理2 | |\n| 2-22 Nginx的请求限制_配置语法与原理3 | |\n| 2-23 Nginx的访问控制_介绍实现访问控制的基本方式 | |\n| 2-24 Nginx的访问控制—access_module配置语法介绍 | |\n| 2-25 Nginx的访问控制—access_module配置 | |\n| 2-26 Nginx的访问控制—access_module局限性 | |\n| 2-27 Nginx的访问控制—auth_basic_module配置 | |\n| 2-28 Nginx的访问控制—auth_basic_module局限性 | |\n| | |\n| **第3章 场景实践篇** | |\n| 3-1 场景实践篇内容介绍 | |\n| 3-2 Nginx作为静态资源web服务_静态资源类型 | |\n| 3-3 Nginx作为静态资源web服务_CDN场景 | |\n| 3-4 Nginx作为静态资源web服务_配置语法 | |\n| 3-5 Nginx作为静态资源web服务_场景演示 | |\n| 3-6 Nginx作为静态资源web服务_浏览器缓存原理 | |\n| 3-7 Nginx作为静态资源web服务_浏览器缓存场景演示 | |\n| 3-8 Nginx作为静态资源web服务_跨站访问 | |\n| 3-9 Nginx作为静态资源web服务_跨域访问场景配置 | |\n| 3-10 Nginx作为静态资源web服务_防盗链(1) | |\n| 3-11 Nginx作为静态资源web服务_防盗链(2) | |\n| 3-12 Nginx作为代理服务_代理服务 | |\n| 3-13 Nginx作为代理服务_配置语法及反向代理场景 | |\n| 3-14 Nginx作为代理服务_正向代理配置场景(1) | |\n| 3-15 Nginx作为代理服务_正向代理配置场景(2) | |\n| 3-16 Nginx作为代理服务_代理配置语法补充 | |\n| 3-17 Nginx作为代理服务_代理补充配置和规范 | |\n| 3-18 Nginx作为负载均衡服务_负载均衡与Nginx | |\n| 3-19 Nginx作为负载均衡服务_配置语法 | |\n| 3-20 Nginx作为负载均衡服务_配置场景 | |\n| 3-21 Nginx作为负载均衡服务_server参数讲解 | |\n| 3-22 Nginx作为负载均衡服务_backup状态演示 | |\n| 3-23 Nginx作为负载均衡服务_轮询策略与加权轮询 | |\n| 3-24 Nginx作为负载均衡服务_负载均衡策略ip_hash方式 | |\n| 3-25 Nginx作为负载均衡服务_负载均衡策略url_hash策略 | |\n| 3-26 Nginx作为缓存服务_Nginx作为缓存服务 | |\n| 3-27 Nginx作为缓存服务_缓存服务配置语法 | |\n| 3-28 Nginx作为缓存服务_场景配置演示 | |\n| 3-29 Nginx作为缓存服务_场景配置补充说明 | |\n| 3-30 Nginx作为缓存服务_分片请求 | |\n| | |\n| **第4章 深度学习篇** | |\n| 4-1 Nginx动静分离_动静分离场景演示 | |\n| 4-2 Nginx动静分离_动静分离场景演示(1) | |\n| 4-3 Nginx动静分离_动静分离场景演示(2) | |\n| 4-4 Rewrite规则_rewrite规则作用 | |\n| 4-5 Rewrite规则_rewrite配置语法 | |\n| 4-6 Rewrite规则_rewrite正则表达式 | |\n| 4-7 Rewrite规则_rewrite规则中的flag | |\n| 4-8 Rewrite规则_redirect和permanent区别 | |\n| 4-9 Rewrite规则_rewrite规则场景(1) | |\n| 4-10 Rewrite规则_rewrite规则场景(2) | |\n| 4-11 Rewrite规则_rewrite规则书写 | |\n| 4-12 Nginx进阶高级模块_secure_link模块作用原理 | |\n| 4-13 Nginx进阶高级模块_secure_link模块实现请求资源验证 | |\n| 4-14 Nginx进阶高级模块_Geoip读取地域信息模块介绍 | |\n| 4-15 Nginx进阶高级模块_Geoip读取地域信息场景展示 | |\n| 4-16 基于Nginx的HTTPS服务_HTTPS原理和作用1 | |\n| 4-17 基于Nginx的HTTPS服务_HTTPS原理和作用2 | |\n| 4-18 基于Nginx的HTTPS服务_证书签名生成CA证书 | |\n| 4-19 基于Nginx的HTTPS服务_证书签名生成和Nginx的HTTPS服务场景演示1 | |\n| 4-20 基于Nginx的HTTPS服务_证书签名生成和Nginx的HTTPS服务场景演示2 | |\n| 4-21 基于Nginx的HTTPS服务_实战场景配置苹果要求的openssl后台HTTPS服务1 | |\n| 4-22 基于Nginx的HTTPS服务_实战场景配置苹果要求的openssl后台HTTPS服务2 | |\n| 4-23 基于Nginx的HTTPS服务_实战场景配置苹果要求的openssl后台HTTPS服务3 | |\n| 4-24 基于Nginx的HTTPS服务_HTTPS服务优化 | |\n| 4-25 Nginx与Lua的开发_Nginx与Lua特性与优势 | |\n| 4-26 Nginx与Lua的开发_Lua基础开发语法1 | |\n| 4-27 Nginx与Lua的开发_Lua基础开发语法2 | |\n| 4-28 Nginx与Lua的开发_Nginx与Lua的开发环境 | |\n| 4-29 Nginx与Lua的开发_Nginx调用Lua的指令及Nginx的Luaapi接口 | |\n| 4-30 Nginx与Lua的开发_实战场景灰度发布 | |\n| 4-31 Nginx与Lua的开发_实战场景灰度发布场景演示1 | |\n| 4-32 Nginx与Lua的开发_实战场景灰度发布场景演示2 | |\n| 4-33 Nginx与Lua的开发_实战场景灰度发布场景演示3 | |\n| 4-34 Nginx与Lua的开发_实战场景灰度发布场景演示4 | |\n| | |\n| **第5章 Nginx架构篇** | |\n| 5-1 Nginx常见问题_架构篇介绍 | |\n| 5-2 Nginx常见问题__多个server_name中虚拟主机读取的优先级 | |\n| 5-3 Nginx常见问题_多个location匹配的优先级1 | |\n| 5-4 Nginx常见问题_多个location匹配的优先级2 | |\n| 5-5 Nginx常见问题_try_files使用 | |\n| 5-6 Nginx常见问题_alias和root的使用区别 | |\n| 5-7 Nginx常见问题_如何获取用户真实的ip信息 | |\n| 5-8 Nginx常见问题_Nginx中常见错误码 | |\n| 5-9 Nginx的性能优化_内容介绍及性能优化考虑 | |\n| 5-10 Nginx的性能优化_ab压测工具 | |\n| 5-11 Nginx的性能优化_ab压测工具1 | |\n| 5-12 Nginx的性能优化_ab压测工具2 | |\n| 5-13 Nginx的性能优化_ab压测工具3 | |\n| 5-14 Nginx的性能优化_系统与Nginx性能优化 | |\n| 5-15 Nginx的性能优化_文件句柄设置 | |\n| 5-16 Nginx的性能优化_CPU亲和配置1 | |\n| 5-17 Nginx的性能优化_CPU亲和配置2 | |\n| 5-18 Nginx的性能优化_Nginx通用配置优化 | |\n| 5-19 Nginx安全_基于Nginx的安全章节内容介绍 | |\n| 5-20 Nginx安全_恶意行为控制手段 | |\n| 5-21 Nginx安全_攻击手段之暴力破解 | |\n| 5-22 Nginx安全_文件上传漏洞 | |\n| 5-23 Nginx安全_SQL注入 | |\n| 5-24 Nginx安全_SQL注入场景说明 | |\n| 5-25 Nginx安全_场景准备mariadb和lnmp环境 | |\n| 5-26 Nginx安全_模拟SQL注入场景 | |\n| 5-27 Nginx安全_Nginx+LUA防火墙功能 | |\n| 5-28 Nginx安全_Nginx+LUA防火墙防sql注入场景演示 | |\n| 5-29 Nginx安全_复杂的访问攻击中CC攻击方式 | |\n| 5-30 Nginx安全_Nginx版本更新和本身漏洞 | |\n| 5-31 Nginx架构总结_静态资源服务的功能设计 | |\n| 5-32 Nginx架构总结_Nginx作为代理服务的需求 | |\n| 5-33 Nginx架构总结_需求设计评估 | |\n| 5-34 完结散花 | |"
},
{
"path": "course/05 Java并发编程与高并发解决方案.md",
"content": "## 《Java并发编程与高并发解决方案》学习记录\n\n时长：12小时30分钟\n\n| 章节 | 记录 |\n| ------------------------------------------ | ---- |\n| **第1章 课程准备** | |\n| 1-1 课程导学 | |\n| 1-2 并发编程初体验 | |\n| 1-3 并发与高并发基本概念 | |\n| | |\n| **第2章 并发基础** | |\n| 2-1 CPU多级缓存-缓存一致性 | |\n| 2-2 CPU多级缓存-乱序执行优化 | |\n| 2-3 JAVA内存模型 | |\n| 2-4 并发的优势与风险 | |\n| | |\n| **第3章 项目准备** | |\n| 3-1 案例环境初始化 | |\n| 3-2 案例准备工作 | |\n| 3-3 并发模拟-工具 | |\n| 3-4 并发模拟-代码 | |\n| | |\n| **第4章 线程安全性** | |\n| 4-1 线程安全性-原子性-atomic-1 | |\n| 4-2 线程安全性-原子性-atomic-2 | |\n| 4-3 线程安全性-原子性-synchronized | |\n| 4-4 线程安全性-可见性 | |\n| 4-5 线程安全性-有序性与总结 | |\n| | |\n| **第5章 安全发布对象** | |\n| 5-1 安全发布对象-发布与逸出 | |\n| 5-2 安全发布对象-四种方法-1 | |\n| 5-3 安全发布对象-四种方法-2 | |\n| | |\n| **第6章 线程安全策略** | |\n| 6-1 不可变对象-1 | |\n| 6-2 不可变对象-2 | |\n| 6-3 线程封闭-1 | |\n| 6-4 线程封闭-2 | |\n| 6-5 线程不安全类与写法-1 | |\n| 6-6 线程不安全类与写法-2 | |\n| 6-7 同步容器-1 | |\n| 6-8 同步容器-2 | |\n| 6-9 并发容器及安全共享策略总结 | |\n| | |\n| **第7章 J.U.C之AQS** | |\n| 7-1 J.U.C之AQS-介绍 | |\n| 7-2 J.U.C之AQS-CountDownLatch | |\n| 7-3 J.U.C之AQS-Semaphore | |\n| 7-4 J.U.C之AQS-CyclicBarrier | |\n| 7-5 J.U.C之AQS-ReentrantLock与锁-1 | |\n| 7-6 J.U.C之AQS-ReentrantLock与锁-2 | |\n| | |\n| **第8章 J.U.C组件拓展** | |\n| 8-1 J.U.C-FutureTask-1 | |\n| 8-2 J.U.C-FutureTask-2 | |\n| 8-3 J.U.C-ForkJoin | |\n| 8-4 J.U.C-BlockingQueue | |\n| | |\n| **第9章 线程调度-线程池** | |\n| 9-1 线程池-1 | |\n| 9-2 线程池-2 | |\n| 9-3 线程池-3 | |\n| | |\n| **第10章 多线程并发拓展** | |\n| 10-1 死锁 | |\n| 10-2 并发最佳实践 | |\n| 10-3 Spring与线程安全 | |\n| 10-4 HashMap与ConcurrentHashMap解析 | |\n| 10-5 多线程并发与线程安全总结 | |\n| | |\n| **第11章 高并发之扩容思路** | |\n| 11-1 高并发之扩容思路 | |\n| | |\n| **第12章 高并发之缓存思路** | |\n| 12-1 高并发之缓存-特征、场景及组件介绍-1 | |\n| 12-2 高并发之缓存-特征、场景及组件介绍-2 | |\n| 12-3 高并发之缓存-redis的使用 | |\n| 12-4 高并发之缓存-高并发场景问题及实战讲解 | |\n| | |\n| **第13章 高并发之消息队列思路** | |\n| 13-1 高并发之消息队列-1 | |\n| 13-2 高并发之消息队列-2 | |\n| 13-3 高并发之消息队列-3 | |\n| | |\n| **第14章 高并发之应用拆分思路** | |\n| 14-1 高并发之应用拆分-1 | |\n| 14-2 高并发之应用拆分-2 | |\n| | |\n| **第15章 高并发之应用限流思路** | |\n| 15-1 高并发之应用限流-1 | |\n| 15-2 高并发之应用限流-2 | |\n| | |\n| **第16章 高并发之服务降级与服务熔断思路** | |\n| 16-1 高并发之服务降级与服务熔断思路 | |\n| | |\n| **第17章 高并发之数据库切库分库分表思路** | |\n| 17-1 高并发之数据库切库分库分表 | |\n| | |\n| **第18章 高并发之高可用手段介绍** | |\n| 18-1 高并发之高可用一些手段 | |\n| | |\n| **第19章 课程总结** | |\n| 19-1 课程总结 | |"
},
{
"path": "course/06 HTTP协议原理+实践 Web开发工程师必学.md",
"content": "## 《HTTP协议原理+实践 Web开发工程师必学》学习记录\n\n| 章节 | 记录 |\n| ----------------------------------------- | ---- |\n| **第1章 课程导学** | |\n| 1-1 导学 | |\n| 1-2 内容介绍 | |\n| | |\n| **第2章 HTTP协议基础及发展历史** | |\n| 2-1 5层网络模型介绍 | |\n| 2-2 HTTP协议的发展历史 | |\n| 2-3 HTTP的三次握手 | |\n| 2-4 URI-URL和URN | |\n| 2-5 HTTP报文格式 | |\n| 2-6 创建一个最简单的web服务 | |\n| | |\n| **第3章 HTTP各种特性总览** | |\n| 3-1 认识HTTP客户端 | |\n| 3-2 CORS跨域请求的限制与解决 | |\n| 3-3 CORS跨域限制以及预请求验证 | |\n| 3-4 缓存头Cache-Control的含义和使用 | |\n| 3-5 缓存验证Last-Modified和Etag的使用 | |\n| 3-6 cookie和session | |\n| 3-7 HTTP长连接 | |\n| 3-8 数据协商 | |\n| 3-9 Redirect | |\n| 3-10 CSP | |\n| | |\n| **第4章 Nginx代理以及面向未来的HTTP** | |\n| 4-1 Nginx安装和基础代理配置 | |\n| 4-2 Nginx代理配置和代理缓存的用处 | |\n| 4-3 HTTPS解析 | |\n| 4-4 使用Nginx部署HTTPS服务 | |\n| 4-5 HTTP2的优势和Nginx配置HTTP2的简单使用 | |\n| | |\n| **第5章 课程总结** | |\n| 5-1 课程总结 | |"
},
{
"path": "course/07 SpringBoot微信点餐.md",
"content": "## 《Spring Boot企业微信点餐系统 》学习记录\n\n| 章节 | 记录 | |\n| ----------------------------------- | ---- | ---- |\n| **01章 课程介绍** | | |\n| 01-01 课程介绍 | | |\n| | | |\n| **02章 项目设计** | | |\n| 02-01 项目设计 | | |\n| 02-02 架构和基础框架 | | |\n| 02-03 数据库设计 | | |\n| | | |\n| **03章 项目起步** | | |\n| 03-01 开发环境搭建 | | |\n| 03-02 日志的使用 | | |\n| 03-03 源码下载及使用 | | |\n| | | |\n| **04章 买家端类目** | | |\n| 04-01 买家类目-dao（上） | | |\n| 04-02 买家类目-dao（下） | | |\n| 04-03 买家类目-service | | |\n| | | |\n| **05章 买家端商品** | | |\n| 05-01 买家商品-dao | 5/22 | |\n| 05-02 买家商品-service | 5/22 | |\n| 05-03 买家商品-api（上） | 5/22 | |\n| 05-04 买家商品-api（下） | 5/22 | |\n| | | |\n| **06章 买家端订单** | | |\n| 06-01 买家订单-dao(上) | | |\n| 06-02 买家订单-dao(下) | | |\n| 06-03 买家订单-service创建_A | | |\n| 06-04 买家订单-service创建_B | | |\n| 06-05 买家订单-service创建_C | | |\n| 06-06 买家订单-service创建_D | | |\n| 06-07 买家订单-service查询 | | |\n| 06-08 买家订单-service取消 | | |\n| 06-09 买家订单-service finish和paid | | |\n| 06-10 买家订单-api_A | | |\n| 06-11 买家订单-api_B | | |\n| 06-12 买家订单-api_C | | |\n| 06-13 买家订单-api_D | | |\n| | | |\n| **07章 微信授权** | | |\n| 07-01 设置域名 | | |\n| 07-02 获取code | | |\n| 07-03 换取access_token | | |\n| 07-04 使用sdk方式（上） | | |\n| 07-05 使用sdk方式（下） | | |\n| 07-06 微信网页授权前端调试 | | |\n| | | |\n| **08章 微信支付和退款** | | |\n| 08-01 发起微信支付-后端（上） | | |\n| 08-02 发起微信支付-后端（下） | | |\n| 08-03 在网页发起支付 | | |\n| 08-04 动态注入参数发起支付 | | |\n| 08-05 微信异步通知（上） | | |\n| 08-06 微信异步通知（下） | | |\n| 08-07 微信退款 | | |\n| 08-08 补充：使用测试号实现授权 | | |\n| | | |\n| **09章 卖家端订单** | | |\n| 09-01 卖家订单-service | | |\n| 09-02 卖家-订单-controller（上） | | |\n| 09-03 卖家-订单-controller（下） | | |\n| 09-04 卖家订单-controller-翻页 | | |\n| 09-05 卖家订单-controller-取消订单 | | |\n| 09-06 卖家订单-controller-订单详情 | | |\n| 09-07 卖家订单-controller-完结订单 | | |\n| | | |\n| **10章 卖家端通用功能和上下架** | | |\n| 10-01 关于模版的小技巧 | | |\n| 10-02 实现边栏 | | |\n| 10-03 实现商品列表 | | |\n| 10-04 商品上下架-service | | |\n| 10-05 商品上下架-controller | | |\n| | | |\n| **11章 卖家端新增商品和类目** | | |\n| 11-01 卖家商品-新增修改页面 | | |\n| 11-02 卖家商品-修改表单提交 | | |\n| 11-03 卖家商品-新增功能 | | |\n| 11-04 卖家类目功能开发 | | |\n| | | |\n| **12章 买家和卖家端联通** | | |\n| 12-01 分布式session理论(上) | | |\n| 12-02 分布式session理论(下) | | |\n| 12-03 卖家信息表-dao开发 | | |\n| 12-04 卖家扫码登录service开发 | | |\n| 12-05 卖家扫码登录获取openid | | |\n| 12-06 登录成功 | | |\n| 12-07 登出成功 | | |\n| 12-08 AOP实现身份验证 | | |\n| 12-09 微信模版消息推送 | | |\n| 12-10 webSocket消息推送 | | |\n| | | |\n| **13章 项目优化** | | |\n| 13-01 异常捕获 | | |\n| 13-02 mybatis注解方式使用_A | | |\n| 13-03 mybatis注解方式使用_B | | |\n| 13-04 mybatis xml方式使用 | | |\n| 13-05 jpa和mybatis的选择 | | |\n| 13-06 ab压测介绍 | | |\n| 13-07 synchronized处理并发 | | |\n| 13-08 redis分布式锁 | | |\n| 13-09 redis缓存的使用(上) | | |\n| 13-10 redis缓存的使用(下) | | |\n| | | |\n| **14章 项目部署** | | |\n| 14-01 项目部署 | | |\n| | | |\n| **15章 课程总结** | | |\n| 15-01 13.总结 | | |"
},
{
"path": "course/08 廖雪峰的Java教程.md",
"content": "## 《廖雪峰的Java教程》学习记录\n\n| 章节 | 小节 | 记录 |\n| ------------------------ | ---------------------- | ---- |\n| **1-Java快速入门** | | |\n| 01-Java入门 | | |\n| | 01-Java简介 | |\n| | 02-安装JDK | |\n| | 03-第一个Java程序 | |\n| | 04-安装并使用Eclipse | |\n| | 05-安装Eclipse插件 | |\n| 02-Java程序基础 | | |\n| | 01-Java程序基本结构 | |\n| | 02-变量和数据类型 | |\n| | 03-整数运算 | |\n| | 05-浮点数运算 | |\n| | 07-布尔运算 | |\n| | 08-字符和字符串 | |\n| | 09-数组类型 | |\n| 03-流程控制 | | |\n| | 01-输入和输出 | |\n| | 03-if判断 | |\n| | 04-switch多重选择 | |\n| | 05-while循环 | |\n| | 06-do-while循环 | |\n| | 07-for循环 | |\n| | 09-break和continue | |\n| 04-数组操作 | | |\n| | 1-遍历数组 | |\n| | 2-数组排序 | |\n| | 4-多维数组 | |\n| | 5-命令行参数 | |\n| | | |\n| **2-Java面向对象编程** | | |\n| 1-面向对象的概念 | | |\n| | 面向对象基础 | |\n| 2-数据封装 | | |\n| | 1-方法 | |\n| | 2-构造方法 | |\n| | 3-方法重载 | |\n| 3-继承和多态 | | |\n| | 1-继承 | |\n| | 2-多态 | |\n| 4-抽象类和接口 | | |\n| | 1-抽象类 | |\n| | 2-接口 | |\n| 5-包和classpath | | |\n| | 1-静态字段和方法 | |\n| | 2-包 | |\n| | 3-作用域 | |\n| | 4-classpath和jar | |\n| 6-Java核心类 | | |\n| | 1-字符串和编码 | |\n| | 2-StringBuilder | |\n| | 3-包装类型 | |\n| | 4-JavaBean | |\n| | 5-枚举类 | |\n| | 6-常用工具类 | |\n| | | |\n| **3-Java异常处理** | | |\n| 1-错误处理 | | |\n| | 1-Java的异常 | |\n| | 2-捕获异常 | |\n| | 3-抛出异常 | |\n| | 4-自定义异常 | |\n| 2-断言和日志 | | |\n| | 1-使用断言 | |\n| | 2-使用JDK Logging | |\n| | 3-使用Commons Logging | |\n| | 4-使用Log4j | |\n| | | |\n| **4-Java反射与泛型** | | |\n| 1-反射 | | |\n| | 1-Class类 | |\n| | 2-访问字段 | |\n| | 3-调用方法 | |\n| | 4-调用构造方法 | |\n| | 5-获取继承关系 | |\n| 2-注解 | | |\n| | 1-使用注解 | |\n| | 2-定义注解 | |\n| | 3-处理注解 | |\n| 3-泛型 | | |\n| | 1-什么是泛型 | |\n| | 2-使用泛型 | |\n| | 3-编写泛型 | |\n| | 4-擦拭法 | |\n| | 5-extends通配符 | |\n| | 6-super通配符 | |\n| | 7-泛型和反射 | |\n| | | |\n| **5-Java集合** | | |\n| 1-Java集合简介 | | |\n| | Java集合简介 | |\n| 2-List | | |\n| | 1-使用List | |\n| | 2-编写equals方法 | |\n| 3-Map | | |\n| | 1-使用Map | |\n| | 2-编写equals和hashCode | |\n| | 3-使用Properties | |\n| 4-Set | | |\n| | 使用Set | |\n| | | |\n| 5-Queue | | |\n| | 1-使用Queue | |\n| | 2-使用PriorityQueue | |\n| | 3-使用Deque | |\n| 6-Stack | | |\n| | 使用Stack | |\n| | | |\n| 7-最佳实践 | | |\n| | 1-使用Iterator | |\n| | 2-使用Collections | |\n| | | |\n| **6-Java IO编程** | | |\n| 1-IO基础 | | |\n| | 1-IO简介 | |\n| | 2-File对象 | |\n| 2-Input和Output | | |\n| | 1-InputStream | |\n| | 2-OutputStream | |\n| | 4-Filter模式 | |\n| | 6-classpath资源 | |\n| | 7-序列化 | |\n| 3-Reader和Writer | | |\n| | 1-Reader | |\n| | 2-Writer | |\n| | | |\n| **7-Java处理日期和时间** | | |\n| 1-概念 | | |\n| | 日期和时间 | |\n| 2-Date和Calendar | | |\n| | 1-Date | |\n| | 2-Calendar | |\n| 3-java.time的API | | |\n| | 1-LocalDateTime | |\n| | 2-ZonedDateTime | |\n| 4-最佳实践 | | |\n| | 最佳实践 | |\n| | | |\n| **8-JUnit单元测试** | | |\n| 1-JUnit简介 | | |\n| | JUnit测试 | |\n| | | |\n| 2-使用JUnit | | |\n| | 1-使用Before和After | |\n| | 2-异常测试 | |\n| | 3-参数化测试 | |\n| | 4-超时测试 | |\n| | | |\n| **9-Java正则表达式** | | |\n| 1-正则表达式入门 | | |\n| | 1-正则表达式简介 | |\n| | 2-匹配规则 | |\n| 2-正则表达式进阶 | | |\n| | 1-复杂匹配规则 | |\n| | 3-分组匹配规则 | |\n| | 5-非贪婪匹配 | |\n| | 6-搜索和替换 | |\n| | | |\n| **10-Java加密与安全** | | |\n| 1-数据安全简介 | | |\n| | 加密与安全 | |\n| 2-编码算法 | | |\n| | 1-URL编码 | |\n| | 2-Base64编码 | |\n| 3-摘要算法 | | |\n| | 1-MD5 | |\n| | 3-SHA1 | |\n| | 4-BouncyCastle | |\n| | 5-Hmac | |\n| 4-加密算法 | | |\n| | 1-对称加密算法 | |\n| | 2-口令加密算法 | |\n| | 4-密钥交换算法 | |\n| | 5-非对称加密算法 | |\n| 5-签名算法 | | |\n| | 1-RSA签名算法 | |\n| | 2-DSA签名算法 | |\n| 6-数字证书 | | |\n| | 数字证书 | |\n| | | |\n| **11-Java多线程编程** | | |\n| 1-线程的概念 | | |\n| | 1-多线程简介 | |\n| | 2-创建新线程 | |\n| | 3-线程的状态 | |\n| | 5-中断线程 | |\n| | 6-守护线程 | |\n| 2-线程同步 | | |\n| | 1-线程同步 | |\n| | 2-synchronized方法 | |\n| | 3-死锁 | |\n| | 4-wait和notify | |\n| 3-高级concurrent包 | | |\n| | 1-ReentrantLock | |\n| | 2-ReadWriteLock | |\n| | 3-Condition | |\n| | 4-Concurrent集合 | |\n| | 5-Atomic | |\n| | 6-ExecutorService | |\n| | 7-Future | |\n| | 8-CompletableFuture | |\n| | 9-Fork_Join | |\n| 4-线程工具类 | | |\n| | ThreadLocal | |\n| | | |\n| **12-Maven基础** | | |\n| 1-Maven入门 | | |\n| | 1-Maven介绍 | |\n| | 2-依赖管理 | |\n| | 3-构建流程 | |\n| 2-Maven进阶 | | |\n| | 1-使用插件 | |\n| | 2-模块管理 | |\n| | | |\n| **13-Java网络编程** | | |\n| 1-Socket编程 | | |\n| | 1-网络编程概念 | |\n| | 2-TCP编程 | |\n| | 3-TCP多线程编程 | |\n| | 5-UDP编程 | |\n| 2-Email编程 | | |\n| | 1-发送Email | |\n| | 2-接收Email | |\n| 3-其他 | | |\n| | 1-HTTP编程 | |\n| | 2-RMI远程调用 | |\n| | | |\n| **14-Java操作XML和JSON** | | |\n| 1-XML | | |\n| | 1-XML介绍 | |\n| | 2-DOM | |\n| | 3-SAX | |\n| | 4-第三方XML库 | |\n| 2-JSON | | |\n| | 1-JSON介绍 | |\n| | 2-处理JSON | |\n| | | |\n| **15-Java JDBC编程** | | |\n| 1-关系数据库基础 | | |\n| | 1-关系数据库简介 | |\n| | 2-安装MySQL | |\n| 2-SQL入门 | | |\n| | 1-SQL介绍 | |\n| | 2-Insert语句 | |\n| | 3-Select语句 | |\n| | 4-Update语句 | |\n| | 5-Delete语句 | |\n| 3-JDBC接口 | | |\n| | 1-JDBC简介 | |\n| | 2-JDBC查询 | |\n| | 3-JDBC更新 | |\n| | 4-JDBC事务 | |\n| | 5-JDBC连接池 | |\n| | | |\n| **16-Java函数式编程** | | |\n| 1-Lambda表达式 | | |\n| | 1-Lambda基础 | |\n| | 3-Method Reference | |\n| 2-Stream | | |\n| | 1-Stream简介 | |\n| | 2-创建Stream | |\n| | 4-map | |\n| | 5-filter | |\n| | 6-reduce | |\n| | 7-其他操作 | |"
},
{
"path": "course/09 Spring学习框架.md",
"content": "Spring框架2016-黑马程序员_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili\nhttps://www.bilibili.com/video/av27640334?from=search&seid=15898343232092137971\n\n\n\n黑马程序员springmvc_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili\nhttps://www.bilibili.com/video/av18288362?from=search&seid=11826156096511418277\n\n\n\n尚硅谷好评如潮【SpringBoot】视频_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili\nhttps://www.bilibili.com/video/av20965295?from=search&seid=5610749687546975866\n\n\n\n尚硅谷-SpringBoot整合篇_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili\nhttps://www.bilibili.com/video/av23284778/\n\n\n\n\n\n\n\n\n\n最好的JavaWeb教程 - 搜索结果 - 哔哩哔哩弹幕视频网 - ( ゜- ゜)つロ 乾杯~ - bilibili\nhttps://search.bilibili.com/all?keyword=%E6%9C%80%E5%A5%BD%E7%9A%84JavaWeb%E6%95%99%E7%A8%8B\n\n\n\n\n\n\n\n\n\n\n\n| 类型 | 课程 | 时长 |\n| ---------- | ------------------------------------------------------------ | ---- |\n| Spring AOP | [【慕课在线】探秘Spring AOP-慕课网](https://www.imooc.com/learn/869) | |\n| 基础课程 | [【黑马】Struts2 ](https://www.bilibili.com/video/av13748042) | |\n| 基础课程 | [【黑马】Spring](https://www.bilibili.com/video/av14839030?from=search&seid=7226271969404706912) | |\n| 基础课程 | [【黑马】Hibernate](https://www.bilibili.com/video/av14626440) | |\n| | | |\n| | | |\n| | | |\n| | | |\n| | | |\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
},
{
"path": "course/10 Redis.md",
"content": "## 《一站式学习Redis 从入门到高可用分布式实践》 学习记录\n\n- ##### 第1章 Redis初识\n\n 带领听众进入Redis的世界，了解它的前世今生、众多特性、应用场景、安装配置、简单使用，可以让听众对Redis有一个全面的认识。\n\n - 1-1 导学\n - 1-2 Redis初识\n - 1-3 谁在使用Redis\n - 1-4 redis特性目录\n - 1-5 特性1-速度快\n - 1-6 特性2-持久化\n - 1-7 特性3-数据结构\n - 1-8 特性4-多语言客户端\n - 1-9 特性5-功能丰富\n - 1-10 特性6-简单\n - 1-11 特性7-复制\n - 1-12 特性8-高可用分布式\n - 1-13 redis典型使用场景\n - 1-14 redis三种启动方式介绍\n - 1-15 redis常用配置\n - 1-16 redis安装启动演示\n\n \n\n- ##### 第2章 API的理解和使用\n\n 全面介绍了Redis提供的5种数据结构字符串（string）、哈希（hash）、列表（list）、集合（set）、有序集合（zset）的数据模型、常用命令、典型应用场景。同时本章还会对Redis的单线程处理机制、键值管理做一个全面介绍，通过对这些原理的理解，听众可以在合适的应用场景选择合适的数据结构。 ...\n\n - 2-1 -课程目录\n - 2-2 -通用命令\n - 2-3 数据结构和内部编码\n - 2-4 单线程\n - 2-5 字符串\n - 2-6 hash (1)\n - 2-7 hash (2)\n - 2-8 list(1)\n - 2-9 list(2)\n - 2-10 set\n - 2-11 zset\n\n \n\n- ##### 第3章 Redis客户端的使用\n\n 本章重点关注Redis客户端的开发，介绍了详细讲解了Java客户端Jedis,简单介绍下Python和Go语言的Redis客户端的选择和使用。\n\n - 3-1 课程目录\n - 3-2 Java客户端：Jedis\n - 3-3 Python客户端：redis-py\n - 3-4 Go客户端：redigo简介\n - 3-5 Jedis配置优化（上）\n - 3-6 Jedis配置优化（下）\n\n \n\n- ##### 第4章 瑞士军刀Redis其他功能\n\n 除了5种数据结构外，Redis还提供了诸如慢查询、Pipeline、Bitmap、HyperLogLog、发布订阅、GEO等附加功能，在这些功能的帮助下，Redis的应用场景更加丰富。\n\n - 4-1 课程目录\n - 4-2 慢查询\n - 4-3 pipeline\n - 4-4 发布订阅\n - 4-5 bitmap\n - 4-6 hyperloglog\n - 4-7 geo\n\n \n\n- ##### 第5章 Redis持久化的取舍和选择\n\n Redis的持久化功能有效避免因进程退出造成的数据丢失问题，本章将介绍介绍RDB和AOF两种持久化配置和运行流程，以及选择策略\n\n - 5-1 目录\n - 5-2 持久化的作用\n - 5-3 RDB(1)\n - 5-4 RDB(2)\n - 5-5 RDB(3)\n - 5-6 AOF(1)\n - 5-7 AOF(2)\n - 5-8 AOF实验\n - 5-9 RDB和AOF抉择\n\n \n\n- ##### 第6章 常见的持久化开发运维问题\n\n 本章探讨了常见的持久化问题进行定位和优化，最后结合Redis常见的单机多实例部署场景进行优化\n\n - 6-1 常见问题目录\n - 6-2 fork\n - 6-3 子进程开销和优化\n - 6-4 AOF阻塞\n\n \n\n- ##### 第7章 Redis复制的原理与优化\n\n 复制是实现高可用的基石，但复制同样是运维的痛点，本部分详细分析复制的原理，讲解运维过程中可能遇到的问题。\n\n - 7-1 目录\n - 7-2 什么是主从复制\n - 7-3 主从复制配置-介绍\n - 7-4 主从复制配置-操作\n - 7-5 runid和复制偏移量\n - 7-6 全量复制\n - 7-7 全量复制开销 + 部分复制\n - 7-8 故障处理\n - 7-9 主从复制常见问题\n\n \n\n- ##### 第8章 Redis Sentinel\n\n 本章将一步步解析Redis Sentinel的相关概念、安装部署、配置、客户端路由、原理解析，最后分析了Redis Sentinel运维中的一些问题。\n\n - 8-1 sentinel-目录\n - 8-2 主从复制高可用？\n - 8-3 redis sentinel架构\n - 8-4 redis sentinel安装与配置\n - 8-5 redis sentinel安装演示-1\n - 8-6 redis sentinel安装演示-2\n - 8-7 java客户端\n - 8-8 python客户端\n - 8-9 实现原理-1-故障转移演练\n - 8-10 实现原理-2.故障转移演练(客户端)\n - 8-11 实现原理-3.故障演练(日志分析)\n - 8-12 三个定时任务\n - 8-13 主观下线和客观下线\n - 8-14 领导者选举\n - 8-15 故障转移\n - 8-16 常见开发运维问题-目录\n - 8-17 节点运维\n - 8-18 高可用读写分离\n - 8-19 本章总结\n\n \n\n- ##### 第9章 初识Redis Cluster\n\n Redis Cluster是Redis 3提供的分布式解决方案，有效解决了Redis分布式方面的需求，同时它也是学习分布式存储的绝佳案例。本章将针对Redis Cluster的数据分布，搭建集群进行分析说明。\n\n - 9-1 本章目录\n - 9-2 呼唤集群\n - 9-3 数据分布概论\n - 9-4 节点取余分区\n - 9-5 一致性哈希分区\n - 9-6 虚拟槽哈希分布\n - 9-7 基本架构\n - 9-8 原生安装\n - 9-9 原生安装-1.准备节点\n - 9-10 原生安装-2.节点握手\n - 9-11 原生安装-3.分配槽\n - 9-12 原生安装-4.分配主从\n - 9-13 ruby环境准备-说明\n - 9-14 ruby环境准备-操作\n - 9-15 redis-trib构建集群\n - 9-16 原生命令和redis-trib.rb对比\n\n \n\n- ##### 第10章 深入Redis Cluster\n\n 本章将针对Redis Cluster的集群伸缩，请求路由，故障转移等方面进行分析说明。\n\n - 10-1 集群伸缩目录\n - 10-2 集群伸缩原理\n - 10-3 扩展集群-1.加入节点\n - 10-4 扩展集群-2.加入集群\n - 10-5 扩展集群-3.迁移槽和数据\n - 10-6 集群扩容演示-1\n - 10-7 集群扩容演示-2\n - 10-8 集群缩容-说明\n - 10-9 集群缩容-操作\n - 10-10 客户端路由-目录\n - 10-11 moved异常说明和操作\n - 10-12 ask重定向\n - 10-13 smart客户端实现原理\n - 10-14 JedisCluster执行源码分析\n - 10-15 smart客户端JedisCluster-目录\n - 10-16 JedisCluster基本使用\n - 10-17 整合spring-1\n - 10-18 整合spring-2\n - 10-19 多节点操作命令\n - 10-20 批量操作优化\n - 10-21 故障转移-目录\n - 10-22 故障发现\n - 10-23 故障恢复\n - 10-24 故障模拟\n - 10-25 Redis Cluster常见开发运维问题-目录\n - 10-26 集群完整性\n - 10-27 带宽消耗\n - 10-28 PubSub广播\n - 10-29 集群倾斜-目录\n - 10-30 数据倾斜\n - 10-31 请求倾斜\n - 10-32 读写分离\n - 10-33 数据迁移\n - 10-34 集群vs单机\n - 10-35 本章总结\n\n \n\n- ##### 第11章 缓存设计与优化\n\n 讲解将缓存加入应用架构后带来的一些问题，这些问题常常会成为应用的致命点。\n\n - 11-1 目录\n - 11-2 缓存的受益和成本\n - 11-3 缓存的更新策略\n - 11-4 缓存粒度问题\n - 11-5 缓存穿透问题\n - 11-6 缓存雪崩优化\n - 11-7 无底洞问题\n - 11-8 热点key的重建优化\n - 11-9 本章总结\n\n \n\n- ##### 第12章 Redis云平台CacheCloud\n\n 本章结合前面的知识介绍redis规模化后使用云平台如何进行机器部署、应用接入、用户相关功能维护等问题\n\n - 12-1 _目录\n - 12-2 _Redis规模化困扰\n - 12-3 _快速构建\n - 12-4 机器部署\n - 12-5 应用接入\n - 12-6 用户功能\n - 12-7 运维功能\n\n \n\n- ##### 第13章 课程总结\n\n 课程总结\n\n - 13-1 _课程总结\n\n \n\n- ##### 第14章 增补：Redis布隆过滤器\n\n 现有50亿电话号码，如何快速判断10w个电话号码是否在其中？利用之前学习的bitmap和redis cluster构建分布式布隆过滤器\n\n - 14-1 _目录_\n - 14-2 引出布隆过滤器\n - 14-3 布隆过滤器基本原理\n - 14-4 布隆过滤器误差率\n - 14-5 本地布隆过滤器\n - 14-6 Redis布隆过器\n - 14-7 Redis分布式布隆过滤器\n\n \n\n- ##### 第15章 Redis开发规范\n\n 本章介绍键值的设计、命令的优化、连接池优化、客户端使用规范及客户端常见问题，带领用户全面梳理Redis开发规范。\n\n - 15-1 key设计\n - 15-2 value设计\n - 15-3 发现bigkey的方法\n - 15-4 bigkey的删除\n - 15-5 选择合理的数据结构\n - 15-6 键值生命周期的管理\n - 15-7 命令优化技巧\n - 15-8 java客户端优化\n - 15-9 连接池参数优化1\n - 15-10 连接池参数优化2\n - 15-11 连接池参数优化3\n\n \n\n- ##### 第16章 内存管理\n\n 本章主要讲解Redis内存消耗、组成分析、Redis内存管理设置及内存优化技巧。\n\n - 16-1 Redis内存优化介绍\n - 16-2 Redis内存消耗\n - 16-3 客户端缓冲区\n - 16-4 缓冲内存\n - 16-5 对象内存\n - 16-6 内存设置上限\n - 16-7 内存回收策略\n - 16-8 内存优化\n - 16-9 客户端缓冲区优化\n\n \n\n- ##### 第17章 开发运维常见坑\n\n 本章介绍Linux针对Redis的内核参数优化、Redis安全七个方法以及Redis热点key的发现方法。\n\n - 17-1 redis开发运维那些坑\n - 17-2 overcommit_memory参数讲解和演示\n - 17-3 其它参数的讲解\n - 17-4 安全的redis\n - 17-5 安全七法则\n - 17-6 热点key"
},
{
"path": "course/11 SpringMVC.md",
"content": "## 黑马程序员 SpringMVC 学习记录\n\n时长：10小时04分钟\n\n\n| 章节 | 记录 |\n| ----------------------------------------------------------- | ---- |\n| **day01** | |\n| 01 spring第一天课程安排 | |\n| 02 springmvc架构-mvc设计模式在bs系统下的应用 | |\n| 03 springmvc架构-springmvc架构原理分析 | |\n| 04 springmvc入门程序-环境搭建 | |\n| 05 springmvc入门程序-前端控制器配置 | |\n| 06 springmvc入门程序-Handler编写调试 | |\n| 07 springmvc入门程序-非注解映射器和适配器 | |\n| 08 springmvc入门程序-注解映射器和适配器配置 | |\n| 09 springmvc入门程序-注解映射器和适配器 | |\n| 10 springmvc入门程序-前端控制器源代码分析 | |\n| 11 springmvc入门程序-视图解析器配置前缀和后缀 | |\n| 12 springmvc和mybaits整合-整合思路 | |\n| 13 springmvc和mybaits整合-工程结构 | |\n| 14 springmvc和mybaits整合-商品查询mapper | |\n| 15 springmvc和mybaits整合-商品查询service | |\n| 16 springmvc和mybaits整合-商品查询controller | |\n| 17 springmvc和mybaits整合-商品查询调试 | |\n| 18 springmvc注解开发-商品修改功能分析 | |\n| 19 springmvc注解开发-商品修改功能开发service | |\n| 20 springmvc注解开发-商品修改功能开发controller | |\n| 21 springmvc注解开发-RequestMapping注解 | |\n| 22 springmvc注解开发-controller方法返回值 | |\n| 23 springmvc注解开发-springmvc参数绑定过程 | |\n| 24 springmvc注解开发-springmvc参数绑定-简单类型绑定 | |\n| 25 springmvc注解开发-springmvc参数绑定-pojo绑定 | |\n| 26 springmvc注解开发-springmvc参数绑定-自定义参数绑定 | |\n| 27 springmvc和struts2的区别 | |\n| | |\n| **day02** | |\n| 01 springmvc第一天课程复习 | |\n| 02 springmvc注解开发-springmvc参数绑定-包装类型pojo参数绑定 | |\n| 03 springmvc注解开发-springmvc参数绑定-数组 | |\n| 04 springmvc注解开发-springmvc参数绑定-list | |\n| 05 springmvc注解开发-validation校验-商品修改校验 | |\n| 06 springmvc注解开发-validation校验-分组校验 | |\n| 07 springmvc注解开发-数据回显 | |\n| 08 springmvc异常处理-全局异常处理器开发 | |\n| 09 springmvc异常处理-抛出异常 | |\n| 10 springmvc上传图片 | |\n| 11 springmvc实现json交互-requestBody和responseBody | |\n| 12 springmvc实现json交互-准备环境 | |\n| 13 springmvc实现json交互-json交互测试 | |\n| 14 springmvc对RESTful支持 | |\n| 15 springmvc拦截器-定义和配置 | |\n| 16 springmvc拦截器-多拦截器测试 | |\n| 17 springmvc拦截器-实现登陆认证 | |\n"
},
{
"path": "course/12 Mybatis.md",
"content": "## 黑马程序员 Mybatis 学习记录\n\n时长：10小时23分钟\n\n| 章节 | 记录 |\n| ------------------------------------------------- | ---- |\n| **day-01** | |\n| 01 mybatis第一天课程安排 | |\n| 02 原生态jdbc编程中的问题总结 | |\n| 03 mybatis框架原理 | |\n| 04 mybatis入门程序-工程结构 | |\n| 05 mybatis入门程序-根据id查询用户-映射文件 | |\n| 06 mybatis入门程序-根据id查询用户-程序代码 | |\n| 07 mybatis入门程序-根据id查询用户-程序调试 | |\n| 08 mybatis入门程序-根据名称查询用户 | |\n| 09 mybatis入门程序-查询用户小结 | |\n| 10 mybatis入门程序-添加用户 | |\n| 11 mybatis入门程序-添加用户-主键返回 | |\n| 12 mybatis入门程序-删除用户和更新用户 | |\n| 13 mybatis入门程序-小结 | |\n| 14 mybatis和hibernate的本质区别和应用场景 | |\n| 15 mybatis开发dao方法-sqlSession应用场合 | |\n| 16 mybatis开发dao方法-原始dao开发方法 | |\n| 17 mybatis开发dao方法-原始dao开发方法-问题总结 | |\n| 18 mybatis开发dao方法-mapper代理开发方法-开发规范 | |\n| 19 mybatis开发dao方法-mapper代理开发方法-实现 | |\n| 20 SqlMapConfig-properties定义 | |\n| 21 SqlMapConfig-settings | |\n| 22 SqlMapConfig-别名定义 | |\n| 23 SqlMapConfig-类型处理器 | |\n| 24 SqlMapConfig-mapper加载 | |\n| 25 输入映射-pojo包装类型-定义pojo包装类型 | |\n| 26 输入映射-pojo包装类型-实现 | |\n| 27 输出映射-resultType | |\n| 28 输出映射-resultMap | |\n| 29 动态sql-if判断 | |\n| 30 动态sql-sql片段 | |\n| 31 动态sql-foreach | |\n| **day-02** | |\n| 01 第一天课程复习及第二天课程安排 | |\n| 02 订单商品数据模型-分析思路 | |\n| 03 订单商品数据模型-分析 | |\n| 04 高级映射-一对一查询-使用resultType | |\n| 05 高级映射-一对一查询-使用resultMap | |\n| 06 高级映射-一对多查询 | |\n| 07 高级映射-多对多查询 | |\n| 08 高级映射-resultMap总结 | |\n| 09 高级映射-延迟加载 | |\n| 10 查询缓存-一级缓存原理 | |\n| 11 查询缓存-一级缓存测试 | |\n| 12 查询缓存-一级缓存实际应用 | |\n| 13 查询缓存-二级缓存-二级缓存测试 | |\n| 14 查询缓存-二级缓存-整合ehcache | |\n| 15 查询缓存-二级缓存-应用场景和局限性 | |\n| 16 mybatis和spring整合-sqlSessionFactory配置 | |\n| 17 mybatis和spring整合-原始dao开发 | |\n| 18 mybatis和spring整合-mapper代理开发 | |\n| 19 mybatis逆向工程自动生成代码 | |"
},
{
"path": "course/13 韩立刚计算机网络.md",
"content": "## 《韩立刚计算机网络》学习记录\n| 章节 | 记录 |\n| ------------------------------------------------- | ---- |\n| **第1章 计算机网络概述** | |\n| 01 课程介绍 | |\n| 02 局域网 | |\n| 03 Intenet和广域网 | |\n| 04 规划IP地址介绍MAC地址 | |\n| 05 数据包和数据帧 | |\n| 06 访问网站数据传输过程 | |\n| 07 OSI参考模型 | |\n| 08 理解OSI参考模型分层思想 | |\n| 09 OSI参考模型和网络排错 | |\n| 10 OSI参考模型和网络安全 | |\n| 11 OSI参考模型和TCP_IP协议 | |\n| 12 计算机网络性能指标1 | |\n| 13 计算机网络性能指标2 | |\n| | |\n| **第2章 物理层** | |\n| 14 物理层定义的标准 | |\n| 15 数据通信基础知识 | |\n| 16 常用编码 | |\n| 17 奈氏准则和香农公式 | |\n| 18 数据通信基础知识总结 | |\n| 19 物理层下面的传输介质 | |\n| 20 信道复用技术 | |\n| 21 数字传输系统 | |\n| 22 宽带接入技术 | |\n| | |\n| **第3章 数据链路层** | |\n| 23 数据链路层基本概念 | |\n| 24 封装成帧和透明传输 | |\n| 25 差错检测 | |\n| 26 点到点通信数据链路层协议PPP | |\n| 27 配置路由器使用PPP协议 | |\n| 28 广播信道的数据链路层 | |\n| 29 CSMA_CD协议技术细节 | |\n| 30 什么是以太网 | |\n| 31 以太网帧格式 | |\n| 32 抓包分析数据帧格式 | |\n| 33 使用网桥和交换机优化以太网 | |\n| 34 查看思科交换机MAC地址表 | |\n| 35 快速以太网和G比特以太网 | |\n| | |\n| **第4章 网络层** | |\n| 36 网络层提供的服务 | |\n| 37 验证网络层功能 | |\n| 38 准备发送数据 | |\n| 39 发送数据的过程 | |\n| 40 ARP协议 | |\n| 41 ARP欺骗 | |\n| 42 网络执法官和ARP防火墙 | |\n| 43 ICMP协议和ping命令 | |\n| 44 ping和pathping排除网络故障 | |\n| 45 IGMP协议和多播组播 | |\n| 46 访问多播视频节目 | |\n| 47 抓包分析数据包首部 | |\n| 48 数据包总长度和数据包分片 | |\n| 49 抓包分析分片数据包 | |\n| 50 数据包TTL和协议号 | |\n| 51 使用抓包工具排除网络故障 | |\n| 52 网络畅通的条件 | |\n| 53 静态路由 | |\n| 54 动态路由 | |\n| | |\n| **第5章 传输层** | |\n| 55 TCP和UDP的应用场景 | |\n| 56 传输层协议和应用层协议之间关系 | |\n| 57 服务和应用层协议之间的关系 | |\n| 58 服务和端口 端口和安全 | |\n| 59 传输层功能和端口范围 | |\n| 60 UDP首部 | |\n| 61 TCP协议概述 | |\n| 62 TCP如何实现可靠传输 | |\n| 63 TCP首部 端口序号确认号数据偏移 | |\n| 64 抓包分析TCP首部 | |\n| 65 TCP首部标记位 | |\n| 66 接收窗口和发送窗口 | |\n| 67 TCP滑动窗口技术实现可靠传输 | |\n| 68 TCP流量控制 | |\n| 69 TCP拥塞避免 | |\n| 70 TCP传输连接管理 | |\n| | |\n| **第6章 应用层** | |\n| 71 什么是域名 | |\n| 72 安装和配置DNS服务器 | |\n| 73 安装和配置DHCP服务器 | |\n| 74 跨网段配置IP地址 | |\n| 75 FTP协议主动模式被动模式 | |\n| 76 安装和配置FTP服务器 | |\n| 77 telnet协议 | |\n| 78 远程桌面协议RDP | |\n| 79 HTTP协议和网站 | |\n| 80 使用Web代理服务访问网站 | |\n| 81 Internet发送和接收电子邮件的过程 | |\n| 82 准备邮件服务器实验环境 | |\n| 83 安装和配置邮件服务器 | |\n| | |\n| **第7章 网络安全** | |\n| 84 网络安全介绍 | |\n| 85 网络安全面临的威胁 | |\n| 86 篡改和伪造 | |\n| 87 病毒和木马 | |\n| 88 对称加密 | |\n| 89 非对称加密和数字签名 | |\n| 90 证书颁发机构CA | |\n| 91 安装CA并申请证书和邮箱 | |\n| 92 发送签名加密电子邮件 | |\n| 93 安全套接字SSL功能 | |\n| 94 配置网站使用SSL通信 | |\n| 95 介绍网络层安全IPSec | |\n| 96 搭建IPSec实验环境 | |\n| 97 配置IPSec实现安全通信 | |\n| 98 数据链路层安全 | |\n| | |\n| **第8章 Internet上的音频视频** | |\n| 99 互联网音频视频面临的问题 | |\n| 100 安装流媒体服务 | |\n| 101 通过网站观看流媒体节目 | |\n| 102 流媒体实现现场直播 | |\n| 103 IP电话和QoS | |\n| | |\n| **第9章 无线网络** | |\n| 104 无线局域网 | |\n| 105 创建临时无线网络 | |\n\n"
},
{
"path": "course/14 韩立刚计算机网络2.md",
"content": "## 《韩立刚计算机网络(v2) 》学习记录\n| 章节 | 记录 |\n| ------------------------------------------------- | ---- |\n| **第1章 计算机网络概述** | |\n| 001 课程介绍 | |\n| 002 计算机网络在信息时代的作用 | |\n| 003 Internet概述 | |\n| 004 Internet组成 | |\n| 005 计算机网络类别 | |\n| 006 计算机网络的性能指标 | |\n| 007 回顾 | |\n| 008 性能指标2 | |\n| 009 OSI参考模型 | |\n| 010 理解OSI参考模型 | |\n| 011 OSI和网络排错 | |\n| 012 OSI参考模型与网络安全 | |\n| 013 计算机网络的体系结构 | |\n| 014 虚拟机的网络设置 | |\n| | |\n| **第2章 物理层** | |\n| 015 物理层基本概念 | |\n| 016 数据通信基础知识 | |\n| 017 奈氏准则和香农公式 | |\n| 018 物理层下面的物理媒体 | |\n| 019 回顾 | |\n| 020 频分复用技术 | |\n| 021 时分复用技术 | |\n| 022 码分复用技术 | |\n| 023 数字传输系统 | |\n| 024 宽带接入技术 | |\n| | |\n| **第3章 数据链路层** | |\n| 025 数据链路层几个基本概念 | |\n| 026 三个基本问题 | |\n| 027 CRC差错检测技术 | |\n| 028 PPP协议介绍 | |\n| 029 PPP协议实现透明传输的2种方法 | |\n| 030 PPP协议的工作状态 | |\n| 031 配置路由器接口使用PPP协议封装 | |\n| 032 回顾 | |\n| 033 以太网特点 | |\n| 034 CSMA CD | |\n| 035 以太网冲突检测和避让机制 | |\n| 036 以太网 | |\n| 037 集线器 | |\n| 038 无冲突时以太网信道最大利用率 | |\n| 039 以太网MAC地址 | |\n| 040 回顾 | |\n| 041 更改和查看MAC地址 | |\n| 042 以太网帧格式 | |\n| 043 抓包工具排除网络故障 | |\n| 044 以太网帧格式2 | |\n| 045 网桥和交换机优化以太网 | |\n| 046 查看交换机ＭＡＣ地址表 | |\n| 047 生成树过程 | |\n| 048 更改交换机生成树的根 优先级 | |\n| 049 远程重启服务器 | |\n| 050 验证VLAN | |\n| 051 VLAN干道链路和访问链路 | |\n| 052 扩展以太网 | |\n| 053 交换机上实现的接入安全 | |\n| | |\n| **第4章 网络层** | |\n| 054 网络的两种服务 虚电路和数据报服务 | |\n| 055 虚电路和数据报服务的对比 | |\n| 056 虚拟互联网 | |\n| 057 IP地址 网络部分和主机部分 | |\n| 058 IP地址 ABCDE类IP地址 | |\n| 059 IP地址 十进制和二进制关系 | |\n| 060 IP地址 ABCD类网络和默认子网掩码 | |\n| 061 IP地址 保留的地址 | |\n| 062 子网掩码的作用 | |\n| 063 IP地址 将一个C类网络等分成两个子网 | |\n| 064 IP地址 将一个C类网络等分成四个子网 | |\n| 065 IP地址 将一个C类网络等分成八个子网 | |\n| 066 IP地址 点到点网络的子网掩码最好是252 | |\n| 067 IP地址 划分子网的规律 | |\n| 068 IP地址 变长子网划分 | |\n| 069 IP地址 变长子网练习 | |\n| 070 IP地址 子网划分回顾 | |\n| 071 IP地址 B类网络子网划分 | |\n| 072 IP地址 利用超网合并网段 | |\n| 073 数据包转发过程 MAC地址和IP地址 | |\n| 074 基于MAC地址控制代理服务器只能控制本网段计算机 | |\n| 075 ARP协议工作机制 | |\n| 076 arp欺骗的应用 | |\n| 077 如何断定ARP欺骗 | |\n| 078 逆向ARP 就是计算机请求IP地址的过程 | |\n| 079 数据包首部 | |\n| 080 数据包首部生存时间TTL | |\n| 081 数据包首部 首部校验和 | |\n| 082 通过抓包工具分析数据包首部 | |\n| 083 网络畅通的条件和静态路由 | |\n| 084 添加静态路由 | |\n| 085 Windows网关就是默认路由 | |\n| 086 网络负载均衡 | |\n| 087 ICMP协议ping和pathping | |\n| 088 RIP协议工作原理 | |\n| 089 配置动态路由RIP协议 | |\n| 090 回顾 | |\n| 091 配置OSPF协议 | |\n| 092 OSPF协议特点 | |\n| 093 BGP协议实现自制系统之间最佳路径选择 | |\n| 094 VPN的功能 | |\n| 095 验证VPN拨号 | |\n| 096 创建VPN拨号连接 | |\n| 097 站点间VPN | |\n| 098 NAT和PAT | |\n| 099 NAT的端口映射 | |\n| 100 回顾 | |\n| 101 虚拟机的网络设置 | |\n| | |\n| **第5章 传输层** | |\n| 102 TCPIP协议分层 | |\n| 103 TCP和UDP的应用场景 | |\n| 104 传输层协议和应用层协议之间的关系 | |\n| 105 服务和应用层协议之间的关系 | |\n| 106 安装telnet客户端 | |\n| 107 更改服务器的默认端口 | |\n| 108 TCPIP筛选实现服务器安全 | |\n| 109 Windows防火墙的作用 | |\n| 110 Windows防火墙不能防控灰鸽子木马程序 | |\n| 111 IPSec严格控制网络流量 | |\n| 112 UDP协议 | |\n| 113 TCP协议概述 | |\n| 114 TCP如何实现可靠传输 | |\n| 115 TCP首部 | |\n| 116 抓包分析TCP首部 | |\n| 117 TCP首部标记位 | |\n| 118 接收窗口确定发送窗口 | |\n| 119 TCP滑动窗口技术实现可靠传输 | |\n| 120 避免拥塞 | |\n| 121 TCP连接管理 | |\n| | |\n| **第6章 应用层** | |\n| 122 域名解析过程 | |\n| 123 安装和配置DNS服务器 | |\n| 124 DHCP协议 | |\n| 125 跨网段分配IP地址 | |\n| 126 FTP协议主动模式和被动模式 | |\n| 127 安装和配置FTP服务器 | |\n| 128 Telnet协议 | |\n| 129 远程桌面协议RDP | |\n| 130 HTTP协议 | |\n| 131 Web代理服务器 | |\n| 132 Internet发送和接收电子邮件的过程 | |\n| 133 准备邮件服务器实验环境 | |\n| 134 安装和配置邮件服务器 | |\n| | |\n| **第7章 网络安全** | |\n| 135 网络安全介绍 | |\n| 136 网络安全面临的4种威胁 | |\n| 137 篡改和伪造攻击 | |\n| 138 病毒和木马 | |\n| 139 对称加密 | |\n| 140 非对称加密和数字签名 | |\n| 141 证书颁发机构CA | |\n| 142 安装CA并申请证书和邮箱 | |\n| 143 发送签名和加密电子邮件 | |\n| 144 安全套接字SSL功能 | |\n| 145 配置网站使用SSL通信 | |\n| 146 网络层安全IPSec介绍 | |\n| 147 搭建IPSec实验环境 | |\n| 148 配置IPSec实现网络安全 | |\n| 149 数据链路层安全 | |\n| | |\n| **第8章 Internet上的音频视频** | |\n| 150 互联网音频视频面临的问题 | |\n| 151 安装流媒体服务 | |\n| 152 通过网站观看流媒体节目 | |\n| 153 流媒体实现现场直播 | |\n| 154 IP电话 | |\n| | |\n| **第9章 无线网络** | |\n| 155 无线局域网 | |\n| 156 创建临时无线网络 | |"
},
{
"path": "course/15 咕泡学院-公开课.md",
"content": "## 咕泡学院 公开课\n\n| 章节 | 记录 |\n| ------------------------------------------------------------ | ---- |\n| 2018_03_05如何从源码copy经验并武装自己 | |\n| 2018_03_07面试Mysql底层要准备这些 | |\n| 2018_04_11_深入浅出JVM | |\n| 2018_04_18_轻松搞定面试中各种并发问题 | |\n| 2018_04_20_魔鬼式分析NIO通信架构原理 | |\n| 2018_04_23_垂直打击之JVM剖析 | |\n| 2018_05_08(下午)_一张图完美还原HashMap(JDK1.8)源码 | |\n| 2018_05_08_434_BAT面试必问的JVM到底怎么学 | |\n| 2018_05_11_阿里面试必备之分析IO及NIO的底层原理 | |\n| 2018_05_13_千万级流量的优化策略实战 | |\n| 2018_05_14_漫谈Mysql索引 | |\n| 2018_05_16_synchronized的底层原理分析 | |\n| 2018_05_23面试必问之JVM | |\n| 2018_05_28_一小时搞定阿里核心面试题 | |\n| Jack_20180427_今晚谁再说看不懂HashMap源码算我输 | |\n| Jack_20180430_后来的我们学会了这样看源码 | |\n| Jack_20180501_Tomcat8源码邀你乘坐五一假期末班车 | |\n| Jack_20180504_Professional Analysis of NIO | |\n| Jack_20180511_阿里面试必备之分析IO及NIO的底层原理 | |\n| James_0430高效程序员如何优雅落地需求 | |\n| James_0506程序员的职业生涯及面试指南 | |\n| James_0523面试必问之JVM | |\n| James_0719Mysql底层索引剖析 | |\n| Mic_20180428_分布式服务Dubbo的前世今生 | |\n| Mic_20180502_深入分析https的底层原理 | |\n| Mic_20180718_分布式集群及动态负载均衡实战 | |\n| Tom_20180429_以ElasticSearch为例，论学习方法的重要性 | |\n| Tom_20180503_巧用工具，解放双手，架构师都是这样思考问题的 | |\n| Tom_20180720_一口气写完Spring核心代码，不信你就来 | |\n| 咕泡学院 - Java 9 异步并发编程 | |\n| 咕泡学院 - Java 9 新特性之核心库（上） | |\n| 咕泡学院 - Java 9 新特性之核心库（下） | |\n| 咕泡学院 - Reactor Streams 并发编程之 Reactor | |\n| 咕泡学院 - 微服务实践之路 | |\n| 咕泡学院 - 深入浅出 Spring Boot 日志 | |\n| 咕泡学院 - 深入浅出 Spring Boot 管控 | |\n| 大神带你剖析Mysql索引底层数据结构 | |\n| | |\n| 20180803_理解 Spring 技术栈或许没有那么难 | |\n| Mic_20180802_并发编程的原理 | |\n| Tom_20180801_不修改代码、不新增配置和，1小时快速搭建可视化监控系统 | |\n| Tom_20180805_10W条记录，只需0.1秒快速搜索到附近的人 | |\n"
},
{
"path": "course/16 咕泡学院-JAVA开发中的热点技术剖析.md",
"content": "## 咕泡学院 JAVA开发中的热点技术剖析\n\n| 章节 | 记录 |\n| ----------------------------------------------- | ---- |\n| **PART1** | |\n| Bad smell 内存泄露和内存溢出 | |\n| JVM难吗？听听一本正经的James老师怎么说 | |\n| mybatis源码分析及手写实现 | |\n| 爱一个人需要一万个理由，学习Nginx只需要一个 | |\n| | |\n| **PART2** | |\n| 分布式环境下session跨域共享原理 | |\n| 带你装B带你飞，手把手教你学docker | |\n| 纯手写系列之Dubbo RPC实现原理 | |\n| | |\n| **PART3** | |\n| 分布式全局ID生成器介绍 | |\n| 深入底层解读网络通信 | |\n| 高阶程序员必须要知道的多线程并发编程 | |\n| | |\n| **PART4** | |\n| 深入分析ThreadLocal的底层实现原理 | |\n| 深入分析动态代理的实现原理 | |\n| 深入分析热部署底层原理 | |\n| | |\n| **PART5** | |\n| 一道面试题引发的思考 | |\n| 做一个合格的程序员你必须掌握的linux性能工具集锦 | |\n| 系统设计方法论之监控系统设计 | |\n| 系统设计方法论初探之Redis实现监控系统设计 | |"
},
{
"path": "course/17 咕泡学院-BAT面试课程.md",
"content": "## 咕泡学院 BAT面试课程\n\n| 章节 | 记录 |\n| -------------------------------------------------------- | ---- |\n| 7.1 如何控制多线程执行顺序 | |\n| 7.2 深入底层研究volatile和synchronized的区别 | |\n| 7.3 深入底层lock接口和synchronized的区别和优势 | |\n| 7.4 多线程并发编程的总结和梳理 | |\n| 7.5 分布式锁的实现原理 | |\n| 7.6 剖析一道不简单的面试题 | |\n| 7.7 图解阻塞io和非阻塞io及多路复用机制 | |\n| 7.8 mysql中binlog的底层原理分析 | |\n| 7.9 cookie和session的联系和区别 | |\n| 7.10 tom_面试题_aop的底层实现原理，动态代理的动如何体现 | |\n| 7.11 tom_面试题_javaweb开发中解决跨域问题的n种方案 | |\n| 7.12 tom_面试题_从数据库底层来分析事务的提交与回滚全过程 | |\n| 7.13 james_vip_要不要跳槽，怎么成长 | |\n| 7.14 小马哥-技术人成长之路（上） | |\n| 7.15 小马哥-技术人成长之路（下） | |"
},
{
"path": "course/18 咕泡学院-性能优化.md",
"content": "## 咕泡学院 性能优化\n\n| 章节 | 记录 |\n| --------------------------------- | ---- |\n| 1.1 性能优化专题-什么是性能优化一 | |\n| 1.1 性能优化专题-什么是性能优化二 | |\n| 2.1 性能测试与优化（一） | |\n| 2.1 性能测试与优化（二） | |\n| 3.1 jvm介绍 一 | |\n| 3.1 jvm介绍 二 | |\n| 3.2 jvm垃圾回收一 | |\n| 3.2 jvm垃圾回收二 | |\n| 3.3 jvm案例分析一 | |\n| 3.3 jvm案例分析二 | |\n| 4.1 tomcat 架构（上） | |\n| 4.1 tomcat 架构（下） | |\n| 4.2 嵌入式 tomcat（下） | |\n| 4.2 嵌入式 tomcat（上） | |\n| 4.3 tomcat 性能优化（下） | |\n| 4.3 tomcat 性能优化（中） | |\n| 4.3 tomcat 性能优化（上） | |\n| 5.1 性能优化之mysql介绍一 | |\n| 5.1 性能优化之mysql介绍二 | |\n| 5.2 性能优化之mysql优化一 | |\n| 5.2 性能优化之mysql优化二 | |"
},
{
"path": "course/19 并发编程原理.md",
"content": "## 《Java并发编程原理与实战》学习记录\n官网：[【龙果学院】Java并发编程原理与实战](https://www.roncoo.com/course/view/b6f89747a8284f44838b2c4da6c8677b)\n\n| 课程大纲 | 记录 |\n| ---------------------------------------------------------- | ---- |\n| 1 你真的了解并发吗？ | |\n| 2 理解多线程与并发的之间的联系与区别 | |\n| 3 解析多线程与多进程的联系以及上下文切换所导致资源浪费问题 | |\n| 4 学习并发的四个阶段并推荐学习并发的资料 | |\n| 5 线程的状态以及各状态之间的转换详解 | |\n| 6 线程的初始化，中断以及其源码讲解 | |\n| 7 多种创建线程的方式案例演示（一）带返回值的方式 | |\n| 8 多种创建线程的方式案例演示（二）使用线程池 | |\n| 9 Spring对并发的支持：Spring的异步任务 | |\n| 10 使用jdk8提供的lambda进行并行计算 | |\n| 11 了解多线程所带来的安全风险 | |\n| 12 从线程的优先级看饥饿问题 | |\n| 13 从Java字节码的角度看线程安全性问题 | |\n| 14 synchronized保证线程安全的原理（理论层面） | |\n| 15 synchronized保证线程安全的原理（jvm层面） | |\n| 16 单例问题与线程安全性深入解析 | |\n| 17 理解自旋锁，死锁与重入锁 | |\n| 18 深入理解volatile原理与使用 | |\n| 19 JDK5提供的原子类的操作以及实现原理 | |\n| 20 Lock接口认识与使用 | |\n| 21 手动实现一个可重入锁 | |\n| 22 AbstractQueuedSynchronizer(AQS)详解 | |\n| 23 使用AQS重写自己的锁 | |\n| 24 重入锁原理与演示 | |\n| 25 读写锁认识与原理 | |\n| 26 细读ReentrantReadWriteLock源码 | |\n| 27 ReentrantReadWriteLock锁降级详解 | |\n| 28 线程安全性问题简单总结 | |\n| 29 线程之间的通信之wait/notify | |\n| 30 通过生产者消费者模型理解等待唤醒机制 | |\n| 31 Condition的使用及原理解析 | |\n| 32 使用Condition重写wait/notify案例并实现一个有界队列 | |\n| 33 深入解析Condition源码 | |\n| 34 实战：简易数据连接池 | |\n| 35 线程之间通信之join应用与实现原理剖析 | |\n| 36 ThreadLocal 使用及实现原理 | |\n| 37 并发工具类CountDownLatch详解 | |\n| 38 并发工具类CyclicBarrier 详解 | |\n| 39 并发工具类Semaphore详解 | |\n| 40 并发工具类Exchanger详解 | |\n| 41 CountDownLatch,CyclicBarrier,Semaphore源码解析 | |\n| 42 提前完成任务之FutureTask使用 | |\n| 43 Future设计模式实现（实现类似于JDK提供的Future） | |\n| 44 Future源码解读 | |\n| 45 Fork/Join框架详解 | |\n| 46 同步容器与并发容器 | |\n| 47 并发容器CopyOnWriteArrayList原理与使用 | |\n| 48 并发容器ConcurrentLinkedQueue原理与使用 | |\n| 49 Java中的阻塞队列原理与使用 | |\n| 50 实战：简单实现消息队列 | |\n| 51 并发容器ConcurrentHashMap原理与使用 | |\n| 52 线程池的原理与使用 | |\n| 53 Executor框架详解 | |\n| 54 实战：简易web服务器（一） | |\n| 55 实战：简易web服务器（二） | |\n| 56 JDK8的新增原子操作类LongAddr原理与使用 | |\n| 57 JDK8新增锁StampedLock详解 | |\n| 58 重排序问题 | |\n| 59 happens-before简单概述 | |\n| 60 锁的内存语义 | |\n| 61 volatile内存语义 | |\n| 62 final域的内存语义 | |\n| 63 实战：问题定位 | |"
},
{
"path": "course/20 MySQL性能管理及架构设计.md",
"content": "## 《MySQL性能管理及架构设计》学习记录\n\n| 章节 | 记录 |\n| ------------------------------------------------------------ | ---- |\n| **第1章 实例和故事** | |\n| *决定电商11大促成败的各个关键因素。* | |\n| | |\n| 1-1 什么决定了电商双11大促的成败 | |\n| 1-2 在双11大促中的数据库服务器 | |\n| 1-3 在大促中什么影响了数据库性能 | |\n| 1-4 大表带来的问题 | |\n| 1-5 大事务带来的问题 | |\n| | |\n| **第2章 什么影响了MySQL性能** | |\n| *详细介绍影响性能各个因素，包括硬件、操作系统等等。* | |\n| | |\n| 2-1 影响性能的几个方面 | |\n| 2-2 CPU资源和可用内存大小 | |\n| 2-3 磁盘的配置和选择 | |\n| 2-4 使用RAID增加传统机器硬盘的性能 | |\n| 2-5 使用固态存储SSD或PCIe卡 | |\n| 2-6 使用网络存储SAN和NAS | |\n| 2-7 总结：服务器硬件对性能的影响 | |\n| 2-8 操作系统对性能的影响-MySQL适合的操作系统 | |\n| 2-9 CentOS系统参数优化 | |\n| 2-10 文件系统对性能的影响 | |\n| 2-11 MySQL体系结构 | |\n| 2-12 MySQL常用存储引擎之MyISAM | |\n| 2-13 MySQL常用存储引擎之Innodb | |\n| 2-14 Innodb存储引擎的特性(1) | |\n| 2-15 Innodb存储引擎的特性(2) | |\n| 2-16 MySQL常用存储引擎之CSV | |\n| 2-17 MySQL常用存储引擎之Archive | |\n| 2-18 MySQL常用存储引擎之Memory | |\n| 2-19 MySQL常用存储引擎之Federated | |\n| 2-20 如何选择存储引擎 | |\n| 2-21 MySQL服务器参数介绍 | |\n| 2-22 内存配置相关参数 | |\n| 2-23 IO相关配置参数 | |\n| 2-24 安全相关配置参数 | |\n| 2-25 其它常用配置参数 | |\n| 2-26 数据库设计对性能的影响 | |\n| 2-27 总结 | |\n| | |\n| **第3章 MySQL基准测试** | |\n| *了解基准测试,MySQL基准测试工具介绍及实例演示。* | |\n| | |\n| 3-1 什么是基准测试 | |\n| 3-2 如何进行基准测试 | |\n| 3-3 基准测试演示实例 | |\n| 3-4 Mysql基准测试工具之mysqlslap | |\n| 3-5 Mysql基准测试工具之sysbench | |\n| 3-6 sysbench基准测试演示实例 | |\n| | |\n| **第4章 MySQL数据库结构优化** | |\n| *详细介绍数据库结构设计、范式和反范式设计、物理设计等等。* | |\n| | |\n| 4-1 数据库结构优化介绍 | |\n| 4-2 数据库结构设计 | |\n| 4-3 需求分析及逻辑设计 | |\n| 4-4 需求分析及逻辑设计-反范式化设计 | |\n| 4-5 范式化设计和反范式化设计优缺点 | |\n| 4-6 物理设计介绍 | |\n| 4-7 物理设计-数据类型的选择 | |\n| 4-8 物理设计-如何存储日期类型 | |\n| 4-9 物理设计-总结 | |\n| | |\n| **第5章 MySQL高可用架构设计** | |\n| *详细介绍二进制日志及其对复制的影响、GTID的复制、MMM、MHA等等。* | |\n| | |\n| 5-1 mysql复制功能介绍 | |\n| 5-2 mysql二进制日志 | |\n| 5-3 mysql二进制日志格式对复制的影响 | |\n| 5-4 mysql复制工作方式 | |\n| 5-5 基于日志点的复制 | |\n| 5-6 基于GTID的复制 | |\n| 5-7 MySQL复制拓扑 | |\n| 5-8 MySQL复制性能优化 | |\n| 5-9 MySQL复制常见问题处理 | |\n| 5-10 什么是高可用架构 | |\n| 5-11 MMM架构介绍 | |\n| 5-12 MMM架构实例演示（上） | |\n| 5-13 MMM架构实例演示（下） | |\n| 5-14 MMM架构的优缺点 | |\n| 5-15 MHA架构介绍 | |\n| 5-16 MHA架构实例演示(1) | |\n| 5-17 MHA架构实例演示(2) | |\n| 5-18 MHA架构优缺点 | |\n| 5-19 读写分离和负载均衡介绍 | |\n| 5-20 MaxScale实例演示 | |\n| | |\n| **第6章 数据库索引优化** | |\n| *介绍BTree索引和Hash索引，详细介绍索引的优化策略等等。* | |\n| | |\n| 6-1 Btree索引和Hash索引 | |\n| 6-2 安装演示数据库 | |\n| 6-3 索引优化策略（上） | |\n| 6-4 索引优化策略（中） | |\n| 6-5 索引优化策略（下） | |\n| | |\n| **第7章 SQL查询优化** | |\n| *详细介绍慢查询日志及示例演示,MySQL查询优化器介绍及特定SQL的查询优化等。* | |\n| | |\n| 7-1 获取有性能问题SQL的三种方法 | |\n| 7-2 慢查询日志介绍 | |\n| 7-3 慢查询日志实例 | |\n| 7-4 实时获取性能问题SQL | |\n| 7-5 SQL的解析预处理及生成执行计划 | |\n| 7-6 如何确定查询处理各个阶段所消耗的时间 | |\n| 7-7 特定SQL的查询优化 | |\n| | |\n| **第8章 数据库的分库分表** | |\n| *详细介绍数据库分库分表的实现原理及演示案例等。* | |\n| | |\n| 8-1 数据库分库分表的几种方式 | |\n| 8-2 数据库分片前的准备 | |\n| 8-3 数据库分片演示(上) | |\n| 8-4 数据库分片演示(下) | |\n| | |\n| **第9章 数据库监控** | |\n| *介绍数据库可用性监控、性能监控、MySQL主从复制监控等* | |\n| | |\n| 9-1 数据库监控介绍 | |\n| 9-2 数据库可用性监控 | |\n| 9-3 数据库性能监控 | |\n| 9-4 MySQL主从复制监控 | |"
},
{
"path": "course/21 JVM.md",
"content": "## 《深入理解Java虚拟机》学习记录\n\n[深入理解Java虚拟机（jvm性能调优+内存模型+虚拟机原理）](https://www.roncoo.com/course/view/0ec92a81e8764b838e86c4febe7a5b17)\n\n\n| 章节 | 记录 |\n| ---------------------------------------------------- | ---- |\n| 1 说在前面的话 | |\n| 2 整个部分要讲的内容说明 | |\n| 3 环境搭建以及jdk,jre,jvm的关系 | |\n| 4 jvm初体验-内存溢出问题的分析与解决 | |\n| 5 jvm再体验-jvm可视化监控工具 | |\n| 6 杂谈 | |\n| 7 Java的发展历史 | |\n| 8 Java的发展历史续 | |\n| 9 Java技术体系 | |\n| 10 jdk8的新特性 | |\n| 11 lanmbda表达式简介 | |\n| 12 Java虚拟机-classic vm | |\n| 13 Java虚拟机-ExactVM | |\n| 14 Java虚拟机-HotSpotVM | |\n| 15 Java虚拟机-kvm | |\n| 16 Java虚拟机-JRockit | |\n| 17 Java虚拟机-j9 | |\n| 18 Java虚拟机-dalvik | |\n| 19 Java虚拟机-MicrosoftJVM | |\n| 20 Java虚拟机-高性能Java虚拟机 | |\n| 21 Java虚拟机-TaobaoVM | |\n| 22 Java内存区域-简介 | |\n| 23 Java内存区域-Java虚拟机栈 | |\n| 24 Java内存区域-程序计数器 | |\n| 25 Java内存区域-本地方法栈 | |\n| 26 Java内存区域-堆内存 | |\n| 27 Java内存区域-方法区 | |\n| 28 Java内存区域-直接内存和运行时常量池 | |\n| 29 对象在内存中的布局-对象的创建 | |\n| 30 探究对象的结构 | |\n| 31 深入理解对象的访问定位 | |\n| 32 垃圾回收-概述 | |\n| 33 垃圾回收-判断对象是否存活算法-引用计数法详解 | |\n| 34 垃圾回收-判断对象是否存活算法-可达性分析法详解 | |\n| 35 垃圾回收算法-标记清除算法 | |\n| 36 垃圾回收算法-复制算法 | |\n| 37 垃圾回收算法-标记整理算法和分代收集算法 | |\n| 38 垃圾收集器-serial收集器详解 | |\n| 39 垃圾收集器-parnew收集器详解 | |\n| 40 垃圾收集器-parallel收集器详解 | |\n| 41 垃圾收集器-cms收集器详解 | |\n| 42 最牛的垃圾收集器-g1收集器详解 | |\n| 43 内存分配-概述 | |\n| 44 内存分配-Eden区域 | |\n| 45 内存分配-大对象直接进老年代 | |\n| 46 内存分配-长期存活的对象进入老年代 | |\n| 47 内存分配-空间分配担保 | |\n| 48 内存分配-逃逸分析与栈上分配 | |\n| 49 虚拟机工具介绍 | |\n| 50 虚拟机工具-jps详解 | |\n| 51 虚拟机工具-jstat详解 | |\n| 52 虚拟机工具-jinfo详解 | |\n| 53 虚拟机工具-jmap详解 | |\n| 54 虚拟机工具-jhat详解 | |\n| 55 虚拟机工具-jstack详解 | |\n| 56 可视化虚拟机工具-Jconsole内存监控 | |\n| 57 可视化虚拟机工具-Jconsole线程监控 | |\n| 58 死锁原理以及可视化虚拟机工具-Jconsole线程死锁监控 | |\n| 59 VisualVM使用详解 | |\n| 60 性能调优概述 | |\n| 61 性能调优-案例1 | |\n| 62 性能调优-案例2 | |\n| 63 性能调优-案例3 | |\n| 64 前半部分内容整体回顾 | |\n| 65 Class文件简介和发展历史 | |\n| 66 Class文件结构概述 | |\n| 67 Class文件设计理念以及意义 | |\n| 68 文件结构-魔数 | |\n| 69 文件结构-常量池 | |\n| 70 文件结构-访问标志 | |\n| 71 文件结构-类索引 | |\n| 72 文件结构-字段表集合 | |\n| 73 文件结构-方法表集合 | |\n| 74 文件结构-属性表集合 | |\n| 75 字节码指令简介 | |\n| 76 字节码与数据类型 | |\n| 77 加载指令 | |\n| 78 运算指令 | |\n| 79 类型转换指令 | |\n| 80 对象创建与访问指令 | |\n| 81 操作树栈指令 | |\n| 82 控制转移指令 | |\n| 83 方法调用和返回指令 | |\n| 84 异常处理指令 | |\n| 85 同步指令 | |\n| 86 类加载机制概述 | |\n| 87 类加载时机 | |\n| 88 类加载的过程-加载 | |\n| 89 类加载的过程-验证 | |\n| 90 类加载的过程-准备 | |\n| 91 类加载的过程-解析 | |\n| 92 类加载的过程-初始化 | |\n| 93 类加载器 | |\n| 94 双亲委派模型 | |\n| 95 运行时栈帧结构 | |\n| 96 局部变量表 | |\n| 97 操作数栈 | |\n| 98 动态连接 | |\n| 99 方法返回地址和附加信息 | |\n| 100 方法调用-解析调用 | |\n| 101 方法调用-静态分派调用 | |\n| 102 方法调用-动态分派调用 | |\n| 103 动态类型语言支持 | |\n| 104 字节码执行引擎小结 | |\n| 105 总结与回顾 | |\n| 106 happens-before简单概述 | |\n| 107 重排序问题 | |\n| 108 锁的内存语义 | |\n| 109 volatile的内存语义 | |\n| 110 final域内存语义 | |"
},
{
"path": "course/22 白鹤翔_JVM虚拟机优化.md",
"content": "## 尚学堂-白鹤翔_jvm虚拟机优化 学习记录\n| 章节 | 记录 |\n| ------------------------------- | ------------------------------- |\n| 1 jvm_虚拟机概念1 | |\n| 2 jvm_虚拟机概念2 | |\n| 3 jvm_虚拟机组成部分概述 | |\n| 4 jvm_堆栈永久区详细讲解 | |\n| 5 jvm_虚拟机参数讲解（一）1 | |\n| 6 jvm_虚拟机参数讲解（一）2 | |\n| 7 jvm_虚拟机参数讲解（二）1 | |\n| 8 jvm_虚拟机参数讲解（二）2 | |\n| 9 jvm_虚拟机参数讲解（三）1 | |\n| 10 jvm_虚拟机参数讲解（三）2 | |\n| 11 jvm_虚拟机参数讲解（三）3 | |\n| 12 jvm_垃圾收集算法讲解（一）1 | |\n| 13 jvm_垃圾收集算法讲解（一）2 | |\n| 14 jvm_垃圾收集算法讲解（二） | |\n| 15 jvm_关于一些编辑器工具使用 | |\n| 16 虚拟机介绍 | |\n| 17 垃圾回收 | |"
},
{
"path": "course/23 MySQL大型分布式集群.md",
"content": "## 《MySQL大型分布式集群》 学习记录\n\n官网：[【龙果学院】MySQL大型分布式集群](https://www.roncoo.com/course/view/658088f6e77541f5835b61800314083e)\n\n### 课程介绍\n\n本套课程将通过分布式集群和分库分表两部分内容进行讲解\n\n1. 主要解决针对大型网站架构中持久化部分中，大量数据存储以及高并发访问所带来是数据读写问题。分布式是将一个业务拆分为多个子业务，部署在不同的服务器上。集群是同一个业务，部署在多个服务器上。\n\n2. 着重对数据切分做了细致丰富的讲解，从数据切分的原理出发，一步一步深入理解数据的切分，通过深入理解各种切分策略来设计和优化我们的系统。这部分中我们还用到了数据库中间件和客户端组件来进行数据的切分，让广大网友能够对数据的切分从理论到实战都会有一个质的飞跃。\n\n学完本套课程以后能够达到的效果：\n\n 期望通过本课程能帮助大家学习到如何通过分布式+集群的方式来提高io的吞吐量，以及数据库的主从复制，主主复制，负载均衡，高可用，分库分表以及数据库中间件的使用。希望能够帮助大家更加清楚了解架构的工作模式，从而写出更高质量的代码。对于企业的架构人员可以优化企业架构。对于兴趣爱好者，可以作为一个很好的入门。\n\n 课程讲解过程中尽可能用简单的语言描述其中的原理，通过实例来帮助初学者快速上手。案例中代码全部手写，实例全部现场真实环境演示。\n\n 教程样例项目中用到的技术及相应的环境\n\n MySQL5.7 CentOS6.9 Vmware Spring3.x以上 JDK8 Maven XShell Xftp\n\n 教程中所有的与编程相关均使用Java来进行演示，但与编程语言无关，可使用任何编程语言进行测试。 \n\n\n\n| 章节 | 记录 |\n| ---------------------------------------------------- | ---- |\n| 1 课程概述 | |\n| 2 课程背景 | |\n| 3 纵观大型网站架构发展，总结持久化部分需要应对的问题 | |\n| 4 操作系统安装以及配置 | |\n| 5 在CentOS上通过yum安装mysql5.7 | |\n| 6 mysql初次见面-mysql5.7的用户以及安全策略 | |\n| 7 mysql初次见面续-mysql基本操作 | |\n| 8 认识主从复制 | |\n| 9 主从复制的准备工作01-mysql用户以及权限 | |\n| 10 主从复制的准备工作02-binlog日志详解 | |\n| 11 主从实战01-准备环境 | |\n| 12 主从实战02-主节点配置 | |\n| 13 主从实战03-从节点配置 | |\n| 14 java操作主从01 | |\n| 15 java操作主从02 | |\n| 16 主主复制 | |\n| 17 负载均衡概述以及环境准备 | |\n| 18 搭建负载均衡-01 | |\n| 19 搭建负载均衡-02 | |\n| 20 启动haproxy的监控功能 | |\n| 21 高可用以及环境准备 | |\n| 22 搭建keepalived | |\n| 23 Keepalived配置简介 | |\n| 24 Keepalived配置邮件 | |\n| 25 Keepalived其他配置 | |\n| 26 分库分表概述 | |\n| 27 逻辑分表01-水平分表 | |\n| 28 逻辑分表02-水平分表续及垂直分表 | |\n| 29 表分区 | |\n| 30 数据库中间件01-认识mycat | |\n| 31 数据库中间件02-mycat安装 | |\n| 32 数据库中间件03-mycat的helloworld | |\n| 33 数据库中间件04-mycat的初识 | |\n| 34 数据库中间件05-mycat的数据切分 | |\n| 35 数据库中间件06-mycat的读写分离-01 | |\n| 36 数据库中间件06-mycat的读写分离-02 | |\n| 37 数据库中间件06-mycat的读写分离03-读写分离补充 | |\n| 38 数据库中间件07-mycat的高可用-01 | |\n| 39 数据库中间件08-mycat的高可用-02 | |\n| 40 数据库中间件09-mycat集群 | |\n| 41 mysql查询缓存 | |\n| 42 数据库切分概述 | |\n| 43 java环境配置 | |\n| 44 水平切分原理及单表切分后的操作 | |\n| 45 水平切分原理及单表切分后的操作-2 | |\n| 46 水平切分多表关联操作 | |\n| 47 垂直切分原理及操作 | |\n| 48 全局序列号 | |\n| 49 数据库切分策略-分片枚举 | |\n| 50 数据库切分策略-hash | |\n| 51 数据库切分策略-范围约定 | |\n| 52 数据库切分策略-取模 | |\n| 53 数据库切分策略-按日期分片 | |\n| 54 全局表 | |\n| 55 认识MyCat | |\n| 56 部署MyCat | |\n| 57 使用MyCat完成简单的数据库分片 | |\n| 58 MyCat分片策略 | |\n| 59 MyCat全局表配置 | |\n| 60 MyCatER表配置 | |\n| 61 另外一种切分方式-使用客户端组件的方式实现数据库分 | |\n| 62 课程总结 | |\n\n"
},
{
"path": "course/24 操作系统（清华大学）.md",
"content": "## 操作系统_清华大学(向勇、陈渝) \n\n| 章节 | 记录 |\n| ------------------------------------------ | ---- |\n| 1.1 课程概述 | |\n| 1.2 什么是操作系统 | |\n| 1.3 为什么学习操作系统 | |\n| 1.4 如何学习操作系统 | |\n| 1.5 操作系统实例 | |\n| 1.6 操作系统的历史 | |\n| 1.7 操作系统结构 | |\n| 1.8 小结 | |\n| | |\n| 2.1 操作系统的启动 | |\n| 2.2 操作系统的终端、异常、和系统调用 | |\n| | |\n| 3.1 计算机体系结构及内存分层体系 | |\n| 3.2 地址空间与地址生成 | |\n| 3.3 连续内存分配：内存碎片与分区的动态分配 | |\n| 3.4 连续内存分配：压缩式与交换式碎片整理 | |\n| | |\n| 4.1 非连续内存分配：分段 | |\n| 4.2 非连续内存分配：分页 | |\n| 4.3 非连续内存分配：页表－概述、TLB | |\n| 4.4 非连续内存分配：页表－二级，多级页表 | |\n| 4.5 非连续内存分配：页表－反向页表 | |\n| | |\n| 5.1 虚拟内存的起因 | |\n| 5.2 覆盖技术 | |\n| 5.3 交换技术 | |\n| 5.4 虚存技术（上） | |\n| 5.5 虚存技术（下） | |\n| | |\n| 6.1 最优页面置换算法 | |\n| 6.2 先进先出算法 | |\n| 6.3 最近最久未使用算法 | |\n| 6.4 时钟页面置换算法 | |\n| 6.5 二次机会法 | |\n| 6.6 最不常用法 | |\n| 6.7 Belady现象、LRU、FIFO、Clock的比较 | |\n| 6.8 局部页替换算法的问题、工作集模型 | |\n| 6.9 两个全局置换算法 | |\n| 6.10 抖动问题 | |\n| | |\n| 7.1 进程的定义 | |\n| 7.2 进程的组成 | |\n| 7.3 进程的特点 | |\n| 7.4 进程控制结构 | |\n| 7.5 进程的生命期原理 | |\n| 7.6 进程状态变化模型 | |\n| 7.7 进程挂起 | |\n| 7.8 为什么使用线程 | |\n| 7.9 什么是线程 | |\n| 7.10 线程的实现 | |\n| 7.11 上下文切换 | |\n| 7.12 进程控制——创建进程 | |\n| 7.13 进程控制——加载和执行进程 | |\n| 7.14 进程控制——等待和终止进程 | |\n| | |\n| 8.1 背景 | |\n| 8.2 调度原则 | |\n| 8.3 调度算法1 | |\n| 8.4 调度算法2 | |\n| 8.5 实时调度 | |\n| 8.6 多处理器调度与优先级反转 | |\n| | |\n| 9.1 背景知识 | |\n| 9.2 一些概念part1 | |\n| 9.3 一些概念part2 | |\n| 9.4 一些概念part3 | |\n| 9.5 临界区 | |\n| 9.6 方法1：禁用硬件中断 | |\n| 9.7 方法2：基于软件的解决方案 | |\n| 9.8 方法3：更高级的抽象 | |\n| | |\n| 10.1 背景 | |\n| 10.2 信号量 | |\n| 10.3 信号量的使用 | |\n| 10.4 信号量的实现 | |\n| 10.5 管程 | |\n| 10.6 经典同步问题-1 | |\n| 10.7 经典同步问题-2 | |\n| 10.8 经典同步问题-3 | |\n| 10.9 经典同步问题-4 | |\n| 10.10 经典同步问题-5 | |\n| 10.11 景点同步问题-6 | |\n| | |\n| 11.1 死锁问题 | |\n| 11.2 系统模型 | |\n| 11.3 死锁特征 | |\n| 11.4 死锁处理办法 | |\n| 11.5 死锁预防和死锁避免 | |\n| 11.6 银行家算法 | |\n| 11.7 死锁检测和死锁恢复 | |\n| 11.8 IPC概述 | |\n| 11.9 信号、管道、消息队列和共享内存 | |\n| | |\n| 12.1 文件系统：总体介绍 | |\n| 12.2 基本概念 | |\n| 12.3 基本概念——文件系统和文件 | |\n| 12.4 基本概念——文件系统的功能 | |\n| 12.5 基本概念——文件和块 | |\n| 12.6 基本概念——文件描述符 | |\n| 12.7 基本概念——目录 | |\n| 12.8 基本概念——文件别名 | |\n| 12.9 基本概念——文件系统种类 | |\n| 12.10 虚拟文件系统 | |\n| 12.11 数据缓存 | |\n| 12.12 打开文件的数据结构 | |\n| 12.13 文件分配 | |\n| 12.14 空闲空间列表 | |\n| 12.15 多磁盘管理-RAID | |\n| 12.16 磁盘调度 | |\n\n"
},
{
"path": "course/25 Linux达人养成计划 I.md",
"content": "## 《Linux达人养成计划 I》学习记录\n\n时长：8小时58分钟\n\n| 章节 | 记录 |\n| ------------------------------------------ | ---- |\n| 1-1 Linux简介 | |\n| 1-2 开源软件简介 | |\n| 1-3 Linux应用领域 | |\n| 1-4 Linux学习方法 | |\n| 1-5 Linux与Windows的不同 | |\n| 1-6 字符界面的优势 | |\n| | |\n| 2-1 虚拟机的安装 | |\n| 2-2 虚拟机使用 | |\n| 2-3 系统分区之分区与格式化 | |\n| 2-4 分区之分区设备文件名与挂载 | |\n| 2-5 Linux系统安装 | |\n| 2-6 XShell的安装和使用 | |\n| | |\n| 3-1 命令格式（命令基本格式及文件处理命令） | |\n| 3-2 目录处理命令（上） | |\n| 3-3 目录处理命令（下） | |\n| 3-4 常见目录作用 | |\n| 3-5 链接命令 | |\n| | |\n| 4-1 文件搜索命令locate | |\n| 4-2 命令搜索命令 | |\n| 4-3 find命令 | |\n| 4-4 grep命令 | |\n| | |\n| 5-1 帮助命令 | |\n| 5-2 其他帮助命令 | |\n| | |\n| 6-1 压缩命令1 | |\n| 6-2 压缩命令2 | |\n| | |\n| 7-1 关机与重启命令 | |\n| | |\n| 8-1 挂载命令 | |\n| 8-2 用户登录查看命令 | |\n| | |\n| 9-1 shell概述 | |\n| 9-2 脚本执行方式 | |\n| 9-3 别名与快捷键 | |\n| 9-4 历史命令 | |\n| 9-5 输出重定向 | |\n| 9-6 管道符 | |\n| 9-7 通配符 | |"
},
{
"path": "course/26 Linux 达人养成计划 II.md",
"content": "## 《Linux 达人养成计划 II》学习记录\n\n时长：2小时30分 \n\n| 章节 | 记录 |\n| --------------------------------- | ---- |\n| 第1章 VIM文本编辑器 | |\n| 1-1 VIM编辑器概述 | |\n| 1-2 VIM编辑器的操作模式 | |\n| 1-3 VIM编辑器的命令模式 | |\n| 1-4 底行模式和命令模式常用指令 | |\n| 1-5 练习题 | |\n| | |\n| 第2章 磁盘管理 | |\n| 2-1 Linux 磁盘管理基本命令 | |\n| 2-2 Linux 硬盘分区和格式化概述 | |\n| 2-3 Linux 在VM虚拟机中添加硬盘 | |\n| 2-4 Linux中MBR分区 | |\n| 2-5 Linux中GPT分区 | |\n| 2-6 Linux中分区的格式化 | |\n| 2-7 Linux中挂载分区 | |\n| 2-8 Linux中swap分区 | |\n| 2-9 练习题 | |\n| | |\n| 第3章 用户管理 | |\n| 3-1 Linux中用户和用户组的概念 | |\n| 3-2 Linux中用户和用户组的基本命令 | |\n| 3-3 Linux中用户和用户组进阶命令 | |\n| 3-4 Linux中用户管理其他命令 | |"
},
{
"path": "course/27 快速上手Linux 玩转典型应用.md",
"content": "## 快速上手 Linux 玩转典型应用\n\n时长：10小时\n\n| 章节 | 记录 |\n| ------------------------------------------ | ---- |\n| 第1章 课程介绍 | |\n| 1-1 导学 | |\n| | |\n| 第2章 Linux简介 | |\n| 2-1 什么是 Linux | |\n| 2-2 Linux能够做什么事情 | |\n| 2-3 Linux的学习方法 | |\n| 2-4 忘掉 window的所有东西 | |\n| | |\n| 第3章 CentOs 的安装 | |\n| 3-1 虚拟机是什么 | |\n| 3-2 在虚拟机中安装CentOs | |\n| 3-3 云服务器介绍 | |\n| | |\n| 第4章 准备工作 | |\n| 4-1 课前准备工作 | |\n| | |\n| 第5章 远程连接SSH专题 | |\n| 5-1 认识SSH | |\n| 5-2 服务器安装SSH服务 | |\n| 5-3 客户端安装SSH工具 | |\n| 5-4 客户端链接SSH服务 | |\n| 5-5 SSH config 命令讲解 | |\n| 5-6 SSH免密登录 | |\n| | |\n| 第6章 Linux常用命令讲解 | |\n| 6-1 Linux常用命令 | |\n| 6-2 服务器硬件资源信息 | |\n| 6-3 文件操作命令 | |\n| 6-4 Linux文本编辑神器--VIM | |\n| 6-5 系统用户操作命令 | |\n| 6-6 防火墙的设置 | |\n| 6-7 提权和文件上传下载的操作 | |\n| | |\n| 第7章 WebServer安装和配置讲解 | |\n| 7-1 Apache的安装 | |\n| 7-2 Apache的虚拟主机配置及伪静态操作 | |\n| 7-3 Nginx的基本操作 | |\n| 7-4 Nginx伪静态的实现 | |\n| 7-5 实例演示反向代理和负载均衡 | |\n| | |\n| 第8章 数据库服务 | |\n| 8-1 Mysql安装及链接 | |\n| 8-2 远程链接 | |\n| 8-3 开启genelog | |\n| | |\n| 第9章 缓存服务 | |\n| 9-1 Redis、Memcache介绍及安装 | |\n| 9-2 Redis的基本操作 | |\n| | |\n| 第10章 Git安装和使用 | |\n| 10-1 git版本管理工具(上) | |\n| 10-2 git版本管理工具（下） | |\n| | |\n| 第11章 Php框架TP5，Lavaral Yii2.0 环境配置 | |\n| 11-1 PHP基础运行环境搭建 | |\n| 11-2 Laravel运行环境配置(上) | |\n| 11-3 Laravel运行环境配置(下) | |\n| 11-4 yii2.0 TP 5.0 框架配置 | |\n| 11-5 PhpMyadmin的配置安装 | |\n| 11-6 PhpRedisAdmin的配置安装 | |\n| | |\n| 第12章 Java运行环境配置 | |\n| 12-1 Java运行环境配置 | |\n| 12-2 maven高级使用 | |\n| | |\n| 第13章 Python运行环境 | |\n| 13-1 Python 运行环境配置 | |\n| 13-2 Python flask 高级应用 | |\n| | |\n| 第14章 服务管理 | |\n| 14-1 Linux常见服务-Crontba、Ntpdate | |\n| 14-2 Linux常见服务--Logrotate.Supervisor | |\n| | |\n| 第15章 监控神器Zabbix | |\n| 15-1 监控系统Zabbix （上） | |\n| 15-2 监控系统Zabbix (下) | |\n| | |\n| 第16章 课程总结 | |\n| 16-1 课程总结 | |"
},
{
"path": "course/28 系统学习Docker 践行DevOps理念.md",
"content": "## 系统学习Docker 践行DevOps理念\n\n时长：15小时\n\n| 章节 | 记录 |\n| --------------------------------------------------- | ---- |\n| 第1章 容器技术和Docker简介 | |\n| 1-1 Docker导学 | |\n| 1-2 容器技术概述 | |\n| 1-3 Docker魅力初体验 | |\n| 1-4 课程源码获取和注意事项 | |\n| | |\n| 第2章 Docker环境的各种搭建方法 | |\n| 2-1 Docker安装简介 | |\n| 2-2 在MAC系统上安装Docker | |\n| 2-3 在Windows系统上安装Docker | |\n| 2-4 Vagrant&VirtualBox for Mac | |\n| 2-5 Vagrant&VirtualBox for Windows | |\n| 2-6 在CentOS上安装Docker | |\n| 2-7 Docker Machine的本地使用 | |\n| 2-8 Docker Machine在阿里云上的使用 | |\n| 2-9 Docker Machine在亚马逊AWS云上的使用 | |\n| 2-10 Docker Playground | |\n| 2-11 本章总结 | |\n| | |\n| 第3章 Docker的镜像和容器 | |\n| 3-1 Docker架构和底层技术简介 | |\n| 3-2 Docker Image概述 | |\n| 3-3 DIY一个Base Image | |\n| 3-4 初识Container | |\n| 3-5 构建自己的Docker镜像 | |\n| 3-6 Dockerfile语法梳理及最佳实践 | |\n| 3-7 RUN vs CMD vs Entrypoint | |\n| 3-8 镜像的发布 | |\n| 3-9 Dockerfile实战 | |\n| 3-10 容器的操作 | |\n| 3-11 Dockerfile实战(2) | |\n| 3-12 容器的资源限制 | |\n| | |\n| 第4章 Docker的网络 | |\n| 4-1 本章概述和实验环境介绍 | |\n| 4-2 网络基础回顾 | |\n| 4-3 Linux网络命名空间 | |\n| 4-4 Docker bridge0详解 | |\n| 4-5 容器之间的link | |\n| 4-6 容器的端口映射 | |\n| 4-7 容器网络之host和none | |\n| 4-8 多容器复杂应用的部署演示 | |\n| 4-9 Overlay和Underlay的通俗解释 | |\n| 4-10 Docker Overlay网络和etcd实现多机容器通信 | |\n| | |\n| 第5章 Docker的持久化存储和数据共享 | |\n| 5-1 本章介绍 | |\n| 5-2 本章实验环境介绍 | |\n| 5-3 数据持久化之Data Volume | |\n| 5-4 数据持久化之Bind Mouting | |\n| 5-5 开发者利器-Docker+Bind Mout | |\n| | |\n| 第6章 Docker Compose多容器部署 | |\n| 6-1 根据前面所学部署一个wordpress | |\n| 6-2 Docker Compose到底是什么 | |\n| 6-3 Docker Compose的安装和基本使用 | |\n| 6-4 水平扩展和负载均衡 | |\n| 6-5 部署一个复杂的投票应用 | |\n| | |\n| 第7章 容器编排Docker Swarm | |\n| 7-1 容器编排Swarm介绍 | |\n| 7-2 创建一个三节点的swarm集群 | |\n| 7-3 Service的创建维护和水平扩展 | |\n| 7-4 在swarm集群里通过service部署wordpress | |\n| 7-5 集群服务间通信之Routing Mesh | |\n| 7-6 Routing Mesh之Ingress负载均衡 | |\n| 7-7 Docker Stack部署Wordpress | |\n| 7-8 作业解答之部署投票应用 | |\n| 7-9 Docker Secret管理和使用 | |\n| 7-10 Docker Secret在Stack中的使用 | |\n| 7-11 Service更新 | |\n| | |\n| 第8章 DevOps初体验——Docker Cloud和Docker企业版 | |\n| 8-1 谈钱不伤感情-Docker的收费模式 | |\n| 8-2 Docker Cloud简介 | |\n| 8-3 Docker Cloud之自动build Docker image | |\n| 8-4 Docker Cloud之持续集成和持续部署 | |\n| 8-5 Docker企业版的在线免费体验 | |\n| 8-6 Docker企业版本地安装之UCP | |\n| 8-7 Docker企业版本地安装之DTR | |\n| 8-8 Docker企业版UCP的基本使用演示 | |\n| 8-9 体验阿里云的容器服务 | |\n| 8-10 在阿里云上安装Docker企业版.mp4 | |\n| 8-11 Docker企业版DTR的基本使用演示 | |\n| | |\n| 第9章 容器编排Kubernetes | |\n| 9-1 Kubenetes简介 | |\n| 9-2 Minikube快速搭建K8S单节点环境 | |\n| 9-3 K8S最小调度单位Pod | |\n| 9-4 ReplicaSet和ReplicationController | |\n| 9-5 Deployment_.mp4 | |\n| 9-6 使用Tectonic在本地搭建多节点K8S集群 | |\n| 9-7 k8s基础网络Cluster Network | |\n| 9-8 Service简介和演示 | |\n| 9-9 NodePort类型Service以及Label的简单实用_音频.mp4 | |\n| 9-10 准备工作——使用kops在亚马逊AWS上搭建k8s集群 | |\n| 9-11 使用kops在亚马逊AWS上搭建k8s集群.mp4 | |\n| 9-12 LoadBlancer类型Service以及AWS的DNS服务配置 | |\n| 9-13 在亚马逊k8s集群上部署wordpress | |\n| | |\n| 第10章 容器的的运维和监控 | |\n| 10-1 容器的基本监控 | |\n| 10-2 k8s集群运行资源监控——Heapster+Grafana+InfluxDB | |\n| 10-3 根据资源占用自动横向伸缩 | |\n| 10-4 k8s集群Log的采集和展示——ELK+Fluentd | |\n| 10-5 k8s集群监控方案Prometheus | |\n| | |\n| 第11章 Docker+DevOps实战——过程和工具 | |\n| 11-1 本章简介 | |\n| 11-2 搭建GitLab服务器 | |\n| 11-3 搭建GitLab CI服务器和Pipeline演示 | |\n| 11-4 基于真实Python项目的CI演示 | |\n| 11-5 简单Java项目的CI演示 | |\n| 11-6 使用Python项目演示的CICD流程 | |\n| 11-7 CI实现版本自动发布 | |\n| 11-8 本章总结和如何继续学习 | |\n| | |\n| 第12章 课程总结 | |\n| 12-1 不是总结的总结 | |"
},
{
"path": "course/30 Python Flask构建可扩展的RESTful API.md",
"content": "## Python Flask构建可扩展的RESTful API\n\n时长：6小时25分钟\n\n| 章节 | 记录 |\n| ------------------------------------------------------------ | ---- |\n| **第1章 随便聊聊** | |\n| 聊聊Flask与Django，聊聊代码的创造性 | |\n| | |\n| 1-1 Flask VS Django | |\n| 1-2 课程更新维护说明 | |\n| | |\n| **第2章 起步与红图** | |\n| 本章我们初始化项目，探讨与研究Flask的默认层级结构。当我们遇到层级结构不合理时，我们将模仿蓝图自己定义一个“红图”来扩展Flask层级体系 | |\n| | |\n| 2-1 环境、开发工具与flask1.0 | |\n| 2-2 初始化项目 | |\n| 2-3 新建入口文件 | |\n| 2-4 蓝图分离视图函数的缺陷 | |\n| 2-5 打开思维，创建自己的Redprint——红图 | |\n| 2-6 实现Redprint | |\n| 2-7 优化Redprint | |\n| | |\n| **第3章 REST基本特征** | |\n| 本章我们将探讨REST的基本特征，并结合实际情况给出REST的适用范围与优劣势 | |\n| | |\n| 3-1 REST的最基本特征（可选观看） | |\n| 3-2 为什么标准REST不适合内部开发（可选观看） | |\n| | |\n| **第4章 自定义异常对象** | |\n| 异常处理其实是一个非常严肃而又麻烦的事情，这直接涉及到前端如何对用户做出响应。本章我们将重写HTTPException并建立全局异常处理机制，统一处理框架内的异常，向前端返回统一而标准的异常信息，简化前端的开发流程 | |\n| | |\n| 4-1 关于“用户”的思考 | |\n| 4-2 构建Client验证器 | |\n| 4-3 处理不同客户端注册的方案 | |\n| 4-4 创建User模型 | |\n| 4-5 完成客户端注册 | |\n| 4-6 生成用户数据 | |\n| 4-7 自定义异常对象 | |\n| 4-8 浅谈异常返回的标准与重要性 | |\n| 4-9 自定义APIException | |\n| | |\n| **第5章 理解WTForms并灵活改造她** | |\n| WTForms其实是非常强大的验证插件。但很多同学对WTForms的理解仅仅停留在“验证表单”上。那WTForms可以用来做API的参数验证码？完全可以，但这需要你灵活的使用它，对它做出一些“改变” | |\n| | |\n| 5-1 重写WTForms 一 | |\n| 5-2 重写WTForms 二 | |\n| 5-3 可以接受定义的复杂，但不能接受调用的复杂 | |\n| 5-4 已知异常与未知异常 | |\n| 5-5 全局异常处理 | |\n| | |\n| **第6章 Token与HTTPBasic验证 —— 用令牌来管理用户** | |\n| 在我的TP5课程里，我们使用令牌的方式是服务器缓存的方式。那么在Python Flask中我们换一种令牌的发放方式。我们将用户的信息加密后作为令牌返回到客户端，客户端在访问服务器API时必须以HTTP Basic的方式携带令牌，我们再读取令牌信息后，将用户信息存入到g变量中，共业务代码全局使用... | |\n| | |\n| 6-1 Token概述 | |\n| 6-2 获取Token令牌 | |\n| 6-3 Token的用处 | |\n| 6-4 @auth拦截器执行流程 | |\n| 6-5 HTTPBasicAuth基本原理 | |\n| 6-6 以BasicAuth的方式发送Token | |\n| 6-7 验证Token | |\n| 6-8 重写first_or_404与get_or_404 | |\n| | |\n| **第7章 模型对象的序列化** | |\n| 最适合Python JSON序列化的是dict字典类型，每一种语言都有其对应的数据结构用来对应JSON对象，比如在PHP中是它的数组数据结构。而Python是用字典来对应JSON的。如果我们想直接序列化一个对象或者模型对象，那么最笨的办法是把对象的属性读取出来，然后组装成一个字典再序列化。这实在是太麻烦了。本章节我们将深入了解JSO... | |\n| | |\n| 7-1 鸡汤？ | |\n| 7-2 理解序列化时的default函数 | |\n| 7-3 不完美的对象转字典 | |\n| 7-4 深入理解dict的机制 | |\n| 7-5 一个元素的元组要特别注意 | |\n| 7-6 序列化SQLAlchemy模型 | |\n| 7-7 完善序列化 | |\n| 7-8 ViewModel对于API有意义吗 | |\n| | |\n| **第8章 权限控制** | |\n| 我看过太多同学编写的API在互联网上疯狂的裸奔了。殊不知这太危险了。API必须提供分层保护机制，根据不同用户的种类来限制其可以访问的API，从而保护接口。比如管理员可以访问哪些接口，普通用户可以访问哪些接口，小程序可以访问哪些，APP又能够访问哪些？灵活而强大的可配置Scope，可以帮助你事半功倍... | |\n| | |\n| 8-1 删除模型注意事项 | |\n| 8-2 g变量中读取uid防止超权 | |\n| 8-3 生成超级管理员账号 | |\n| 8-4 不太好的权限管理方案 | |\n| 8-5 比较好的权限管理方案 | |\n| 8-6 实现Scope权限管理 一 | |\n| 8-7 globals()实现“反射” | |\n| 8-8 实现Scope权限管理 二 | |\n| 8-9 Scope优化一 支持权限相加 | |\n| 8-10 Scope优化 二 支持权限链式相加 | |\n| 8-11 Scope优化 三 所有子类支持相加 | |\n| 8-12 Scope优化 四 运算符重载 | |\n| 8-13 Scope 优化 探讨模块级别的Scope | |\n| 8-14 Scope优化 实现模块级别的Scope | |\n| 8-15 Scope优化 七 支持排除 | |\n| | |\n| **第9章 实现部分鱼书小程序功能** | |\n| 理论必须结合实践，我们提供一个简单的鱼书小程序，编写他的业务接口，并用小程序来进行API的检验 | |\n| | |\n| 9-1 小程序演示API调用效果 | |\n| 9-2 模糊搜索书籍 | |\n| 9-3 再谈严格型REST的缺陷 | |\n| 9-4 实现hide方法 | |\n| 9-5 @orm.reconstructor 解决模型对象实例化问题 | |\n| 9-6 重构hide与append | |\n| 9-7 赠送礼物接口 | |\n| 9-8 实现获取令牌信息接口 | |"
},
{
"path": "course/31 学习Scala 进击大数据Spark生态圈.md",
"content": "学习Scala_进击大数据Spark生态圈-课程章节\nhttps://coding.imooc.com/class/chapter/215.html#Anchor\n\n\n\n"
},
{
"path": "course/32 10小时入门大数据.md",
"content": ""
},
{
"path": "course/Java 架构师成长之路/01 Java 单体应用.md",
"content": "## Java 单体应用\n\n| **章节** | **记录** |\n| --------------------------------------------------------- | -------- |\n| **开篇** | |\n| 1 开篇-程序员的玄学与佛学-1 | |\n| 2 开篇-程序员的玄学与佛学-2 | |\n| 3 开篇-程序员的玄学与佛学-3 | |\n| | |\n| **第01章** | |\n| 4 第01章-使用 Intellij IDEA-IDEA 简介 | |\n| 5 第01章-使用 Intellij IDEA-第一个 IDEA 应用程 | |\n| 6 小知识-使用 Markdown 记笔记 | |\n| | |\n| **第02章** | |\n| 7 第02章-使用 Maven 构建应用-Maven 简介 | |\n| 8 第02章-使用 Maven 构建应用-Maven 安装配置 | |\n| 9 第02章-使用 Maven 构建应用-Maven 本地仓库 | |\n| 10 第02章-使用 Maven 构建应用-Maven 中央仓库 | |\n| 11 第02章-使用 Maven 构建应用-Maven 依赖机制 | |\n| 12 第02章-使用 Maven 构建应用-Maven POM | |\n| 13 第02章-使用 Maven 构建应用-Maven 快照 | |\n| 14 第02章-使用 Maven 构建应用-第一个 Maven 应用程序 | |\n| | |\n| **第03章** | |\n| 15 第03章-三层架构+MVC-什么是三层架构 | |\n| 16 第03章-三层架构+MVC-什么是 MVC 模式 | |\n| 17 小知识-高内聚，低耦合 | |\n| 18 课后练习-三层架构-1 | 12/27 |\n| 19 课后练习-三层架构-2 | |\n| 20 小知识-关于如何自学的一些心得 | |\n| | |\n| **第04章** | |\n| 21 第04章-使用 Bootstrap-Bootstrap 简介 | |\n| 22 第04章-使用 Bootstrap-Bootstrap 环境安装 | |\n| 23 第04章-使用 Bootstrap-Bootstrap 网格布局 | |\n| 24 第04章-使用 Bootstrap-媒体查询的用法 | |\n| 25 第04章-使用 Bootstrap-Bootstrap 表格 | |\n| 26 第04章-使用 Bootstrap-Bootstrap 字体图标 | |\n| | |\n| **第05章** | |\n| 27 第05章-基础框架入门-Spring-Spring 简介 | |\n| 28 第05章-基础框架入门-Spring-Spring 体系结构 | |\n| 29 第05章-基础框架入门-Spring-Spring 的特点 | |\n| 30 第05章-基础框架入门-Spring-Spring 与 IoC | |\n| 31 第05章-基础框架入门-Spring-第一个 Spring 应用程 | |\n| 32 小知识-什么是 TDD 及常见的测试方式 | |\n| 33 第05章-基础框架入门-JUnit-JUnit 简介 | |\n| 34 第05章-基础框架入门-JUnit-第一个 JUnit 单元测试 | |\n| 35 第05章-基础框架入门-JUnit-JUnit 断言 | |\n| 36 第05章-基础框架入门-Log4j-Log4j 简介 | |\n| 37 第05章-基础框架入门-Log4j-Log4j 日志级别 | |\n| 38 第05章-基础框架入门-Log4j-Log4j 日志输出控制文件 | |\n| 39 第05章-基础框架入门-Log4j-第一个 Log4j 日志文件 | |\n| 40 综合复习-本周知识总结 | |\n| 41 综合复习-创建项目 | |\n| 42 综合复习-Bootstrap 管理模板-AdminLTE | |\n| 43 综合复习-Bootstrap 管理模板-创建登录页 | |\n| 44 综合复习-实现登录功能-完成后台编码 | |\n| 45 综合复习-实现登录功能-增强用户体验 | |\n| | |\n| **第06章** | |\n| 46 第06章-Spring Web 与 Bean 装配-Spring | |\n| 47 第06章-Spring Web 与 Bean 装配-容器中 Bea | |\n| 48 第06章-Spring Web 与 Bean 装配-基于注解的装配 | |\n| 49 课后作业-记住我 | |\n| | |\n| **第07章** | |\n| 50 第07章-Spring MVC 与 Maven 模块化开发-Spr | |\n| 51 第07章-Spring MVC 与 Maven 模块化开发-Spr | |\n| 52 第07章-Spring MVC 与 Maven 模块化开发-第一个 | |\n| 53 第07章-Spring MVC 与 Maven 模块化开发-Spr | |\n| 54 第07章-Spring MVC 与 Maven 模块化开发-Mav | |\n| 55 课后练习-重新完善功能代码 | |\n| | |\n| **第08章** | |\n| 56 第08章-MyBatis 数据持久化-MyBatis 简介 | |\n| 57 第08章-MyBatis 数据持久化-Druid 简介 | |\n| 58 第08章-MyBatis 数据持久化-Spring 整合 Drui | |\n| 59 第08章-MyBatis 数据持久化-Spring 整合 MyBa | |\n| 60 小知识-utf8 与 utf8mb4 字符集 | |\n| 61 第08章-MyBatis 数据持久化-第一个 MyBatis 对象 | |\n| | |\n| **第09章** | |\n| 62 第09章-MyBatis 表操作-单表 CRUD 操作 | |\n| 63 项目实战-MyShop-实现用户登录功能 | |\n| 64 项目实战-MyShop-实现首页布局 | |\n| 65 项目实战-MyShop-用户管理功能-用户列表展示 | |\n| 66 项目实战-MyShop-用户管理功能-实现新增用户功能 | |\n| 67 项目实战-MyShop-用户管理功能-使用 Spring MVC | |\n| 68 项目实战-MyShop-用户管理功能-使用 jQuery Vali | |\n| 69 项目实战-MyShop-用户管理功能-使用动态 SQL 实现搜索功 | |\n| 70 项目实战-MyShop-用户管理功能-优化搜索功能 | |\n| 71 项目实战-MyShop-用户管理功能-使用 jQuery iChe | |\n| 72 项目实战-MyShop-用户管理功能-实现批量删除功能1 | |\n| 73 项目实战-MyShop-用户管理功能-实现批量删除功能2 | |\n| 74 项目实战-MyShop-用户管理功能-使用 DataTables | |\n| 75 项目实战-MyShop-用户管理功能-使用 DataTables | |\n| 76 项目实战-MyShop-用户管理功能-实现编辑和查看功能 | |\n| 77 项目实战-MyShop-用户管理功能-重新实现搜索功能 | |\n| 78 项目实战-MyShop-用户管理功能-最后的收尾工作 | |\n| 79 项目实战-MyShop-内容管理功能-内容分类功能准备 | |\n| 80 项目实战-MyShop-内容管理功能-使用 TreeTable 展 | |\n| 81 项目实战-MyShop-内容管理功能-内容列表功能准备 | |\n| 82 项目实战-MyShop-内容管理功能-使用 zTree 展示内容分 | |\n| 83 项目实战-MyShop-使用 Lombok 插件简化 Bean 代 | |\n| 84 项目实战-MyShop-使用 Spring Validation | |\n| 85 项目实战-MyShop-内容管理功能-Spring MVC + D | |\n| 86 项目实战-MyShop-内容管理功能-封装 Dropzone 插件 | |\n| 87 项目实战-MyShop-内容管理功能-使用 wangEditor | |\n| 88 项目实战-MyShop-内容管理功能-实现 wangEditor | |\n| 89 项目实战-MyShop-内容管理功能-实现关联关系查询 | |\n| 90 项目实战-MyShop-重构代码-提取统一的数据访问和业务接口 | |\n| 91 项目实战-MyShop-内容管理功能-实现内容分类的新增功能 | |\n| 92 项目实战-MyShop-重构代码-深度封装业务逻辑层1 | |\n| 93 项目实战-MyShop-重构代码-深度封装业务逻辑层2 | |\n| 94 项目实战-MyShop-重构代码-封装控制器层 | |\n| | |\n| **第11章** | |\n| 95 第11章-Spring 的事务管理-Spring 事务管理简介 | |\n| 96 第11章-Spring 的事务管理-使用 AspectJ 的 AO | |\n| 97 项目实战-MyShop-使用 Spring 注解管理事务 | |\n| | |\n| **第12章** | |\n| 98 第12章-解决模块间的通信问题-项目改动说明 | |\n| 99 第12章-解决模块间的通信问题-后台管理与门户数据展示说明 | |\n| 100 第12章-解决模块间的通信问题-为什么存在通信问题 | |\n| 101 第12章-解决模块间的通信问题-Apache HttpClien | |\n| 102 第12章-解决模块间的通信问题-Apache HttpClien | |\n| 103 第12章-解决模块间的通信问题-使用 Jackson 处理 JS | |\n| 104 第12章-解决模块间的通信问题-创建 API 接口模块 | |\n| 105 小知识-POJO、VO、DTO、Entity、Domain 的区 | |\n| 106 第12章-解决模块间的通信问题-RESTful 风格的 API | |\n| 107 第12章-解决模块间的通信问题-使用 Spirng MVC 实现 | |\n| | |\n| 108 项目实战-MyShop-创建 Web UI 门户模块 | |\n| 109 项目实战-MyShop-实现 UI 模块与 API 模块的通信 | |\n| 110 项目实战-MyShop-实现门户首页的幻灯片展示 | |\n| 111 项目实战-MyShop-实现门户登录-实现 API | |\n| 112 项目实战-MyShop-实现门户登录-对接 API | |\n| 113 项目实战-MyShop-实现门户登录-使用拦截器禁止重复登录 | |\n| 114 小知识-验证码的作用与如何打码 | |\n| 115 项目实战-MyShop-解决 Maven 无法下载依赖的问题 | |\n| 116 项目实战-MyShop-实现门户登录-增加 Kaptcha 验证 | |\n| 117 项目实战-MyShop-使用 Apache Commons Em | |\n| 118 课程完结-阶段总结，撒花，撒花，可喜可贺，可喜可贺 | |\n\n"
},
{
"path": "course/Java 架构师成长之路/02 Java 微服务架构.md",
"content": "## Java 微服务架构\n\n| 章节 | 记录 |\n| ----------------------------------------------------- | ---- |\n| 1 关于博客改版的一些说明 | |\n| 2 第01章-微服务简介-构建单体应用模型 | |\n| 3 第01章-微服务简介-走向单体地狱 | |\n| 4 第01章-微服务简介-微服务解决复杂问题 | |\n| 5 第01章-微服务简介-微服务的优点 | |\n| 6 第01章-微服务简介-微服务的缺点 | |\n| | |\n| 7 第02章-基础设施即服务-Linux-简介 | |\n| 8 第02章-基础设施即服务-Linux-关于操作系统的选型 | |\n| 9 第02章-基础设施即服务-Linux-安装 Ubuntu Serve | |\n| 10 第02章-基础设施即服务-Linux-服务器远程控制 | |\n| 11 第02章-基础设施即服务-Linux-目录结构说明 | |\n| 12 第02章-基础设施即服务-Linux-操作文件目录命令 | |\n| 13 第02章-基础设施即服务-Linux-系统管理命令 | |\n| 14 第02章-基础设施即服务-Linux-重启与压缩命令 | |\n| 15 第02章-基础设施即服务-Linux-编辑器的使用 | |\n| 16 第02章-基础设施即服务-Linux-软件的安装与卸载 | |\n| 17 第02章-基础设施即服务-Linux-用户和组管理 | |\n| 18 第02章-基础设施即服务-Linux-文件权限管理 | |\n| 19 第02章-基础设施即服务-Linux-安装 Java | |\n| 20 第02章-基础设施即服务-Linux-安装 Tomcat | |\n| 21 第02章-基础设施即服务-Linux-安装 MySQL | |\n| 22 第02章-基础设施即服务-Linux-部署应用到生成环境 | |\n| 23 第02章-基础设施即服务-Docker-什么是 Docker | |\n| 24 第02章-基础设施即服务-Docker-为什么要用 Docker | |\n| 25 第02章-基础设施即服务-Docker-引擎 | |\n| 26 第02章-基础设施即服务-Docker-架构 | |\n| 27 第02章-基础设施即服务-Docker-镜像与容器 | |\n| 28 第02章-基础设施即服务-Docker-仓库 | |\n| 29 第02章-基础设施即服务-Docker-安装 | |\n| 30 第02章-基础设施即服务-Docker-加速器 | |\n| 31 第02章-基础设施即服务-Docker-镜像-获取镜像 | |\n| 32 第02章-基础设施即服务-Docker-镜像-列出镜像 | |\n| 33 第02章-基础设施即服务-Docker-镜像-删除镜像 | |\n| 34 第02章-基础设施即服务-Docker-镜像-Dockerfile | |\n| 35 第02章-基础设施即服务-Docker-镜像-Dockerfile | |\n| 36 第02章-基础设施即服务-Docker-镜像-Dockerfile | |\n| 37 第02章-基础设施即服务-Docker-镜像-Dockerfile | |\n| 38 第02章-基础设施即服务-Docker-镜像-Dockerfile | |\n| 39 第02章-基础设施即服务-Docker-守护态运行容器 | |\n| 40 第02章-基础设施即服务-Docker-容器数据持久化 | |\n| 41 第02章-基础设施即服务-Docker-部署数据库 | |\n| 42 第02章-基础设施即服务-Docker-部署项目到容器 | |\n| 43 第02章-基础设施即服务-Docker Compose-简介与安装 | |\n| 44 第02章-基础设施即服务-Docker Compose-基本使用 | |\n| 45 第02章-基础设施即服务-Docker Compose-部署项目到 | |\n| 46 第02章-基础设施即服务-Docker Compose-YAML | |\n| | |\n| 47 第03章-平台即服务-GitLab-使用 Git 托管代码 | |\n| 48 第03章-平台即服务-GitLab-简介与安装 | |\n| 49 第03章-平台即服务-GitLab-基本设置 | |\n| 50 第03章-平台即服务-GitLab-第一个托管项目 | |\n| 51 第03章-平台即服务-GitLab-使用 SSH 免密登录 | |\n| 52 第03章-平台即服务-Nexus-简介与安装 | |\n| 53 第03章-平台即服务-Nexus-在项目中使用 Maven 私服 | |\n| 54 第03章-平台即服务-Registry-简介与安装 | |\n| 55 第03章-平台即服务-Registry-配置 WebUI 与客户端 | |\n| 56 Docker-真正实现：一次构建，到处运行 | |\n| | |\n| 57 第04章-再谈微服务-传统架构与微服务架构的区别 | |\n| 58 第04章-再谈微服务-微服务的特征 | |\n| 59 第04章-再谈微服务-微服务的实践1 | |\n| 60 第04章-再谈微服务-微服务的实践2 | |\n| 61 小知识-单点故障与分布式锁 | |\n| 62 第04章-再谈微服务-微服务架构设计模式 | |\n| | |\n| 63 第05章-微服务框架-SpringBoot-简史 | |\n| 64 第05章-微服务框架-SpringBoot-简介 | |\n| 65 第05章-微服务框架-SpringBoot-优缺点 | |\n| 66 第05章-微服务框架-SpringBoot-第一个应用程序 | |\n| 67 第05章-微服务框架-SpringBoot-单元测试 | |\n| 68 第05章-微服务框架-SpringBoot-常用配置 | |\n| 69 第05章-微服务框架-SpringBoot-Thymeleaf-简 | |\n| 70 第05章-微服务框架-SpringBoot-Thymeleaf-为 | |\n| 71 第05章-微服务框架-SpringBoot-Thymeleaf-第 | |\n| 72 第05章-微服务框架-SpringBoot-MyBatis-整合 | |\n| 73 第05章-微服务框架-SpringBoot-MyBatis-测试 | |\n| 74 第05章-微服务框架-SpringCloud-简介 | |\n| 75 第05章-微服务框架-SpringCloud-创建统一的依赖管理 | |\n| 76 第05章-微服务框架-SpringCloud-服务注册与发现 | |\n| 77 第05章-微服务框架-SpringCloud-创建服务提供者 | |\n| 78 第05章-微服务框架-SpringCloud-创建服务消费者（Ri | |\n| 79 第05章-微服务框架-SpringCloud-创建服务消费者（Fe | |\n| 80 第05章-微服务框架-SpringCloud-使用熔断器防止服务雪 | |\n| 81 第05章-微服务框架-SpringCloud-使用熔断器仪表盘监控 | |\n| 82 第05章-微服务框架-SpringCloud-使用路由网关统一访问 | |\n| 83 第05章-微服务框架-SpringCloud-使用路由网关的服务过 | |\n| 84 第05章-微服务框架-SpringCloud-分布式配置中心-服务 | |\n| 85 第05章-微服务框架-SpringCloud-分布式配置中心-客户 | |\n| 86 第05章-微服务框架-SpringCloud-服务链路追踪 | |\n| 87 第05章-微服务框架-SpringCloud-服务监控-服务端 | |\n| 88 第05章-微服务框架-SpringCloud-服务监控-客户端 | |"
},
{
"path": "course/Java 架构师成长之路/03 Java 微服务实战.md",
"content": "## Java 微服务实战\n| 章节 | 记录 |\n| ------------------------------------------- | ---- |\n| 1 开篇-倾力打造互联网 Java 全栈工程师 | |\n| 2 白皮书 | |\n| 3 项目简介 | |\n| 4 开发前的准备-了解敏捷开发 | |\n| 5 开发前的准备-了解 XP 极限编程 | |\n| 6 开发前的准备-创建 GitLab 项目组 | |\n| 7 开发前的准备-完善各服务配置 | |\n| 8 开发前的准备-部署服务到容器1 | |\n| 9 开发前的准备-部署服务到容器2 | |\n| 10 部署持续集成-持续集成的基本概念 | |\n| 11 部署持续集成-持续集成的操作流程 | |\n| 12 部署持续集成-使用 GitLab 持续集成 | |\n| 13 部署持续集成-使用 GitLab Runn | |\n| 14 部署持续集成-使用 GitLab Runn | |\n| 15 部署持续集成-第一个 GitLab Run | |\n| 16 部署持续集成-实战分布式配置中心 | |\n| 17 部署持续集成-实战服务注册与发现 | |\n| 18 管理员服务-提供者1 | |\n| 19 管理员服务-提供者2 | |\n| 20 管理员服务-提供者3 | |\n| 21 管理员服务-消费者 | |\n| 22 反向代理负载均衡-Nginx 简介 | |\n| 23 反向代理负载均衡-Nginx 虚拟主机 | |\n| 24 小知识-Nginx 惊群问题 | |\n| 25 反向代理负载均衡-Nginx 反向代理 | |\n| 26 反向代理负载均衡-Nginx 负载均衡 | |\n| 27 反向代理负载均衡-Nginx 搭建伪 CD | |\n| 28 数据缓存服务-Redis 简介 | |\n| 29 数据缓存服务-Redis 高可用方案 | |\n| 30 数据缓存服务-Redis Sentinel | |\n| 31 数据缓存服务-提供者 | |\n| 32 单点登录服务-单点登录系统机制 | |\n| 33 单点登录服务-多系统登录的复杂性 | |\n| 34 单点登录服务-单点登录系统流程 | |\n| 35 单点登录服务-实战单点登录1 | |\n| 36 单点登录服务-实战单点登录2 | |\n| 37 单点登录服务-实战单点登录3 | |\n| 38 单点登录服务-实战单点登录4 | |\n| 39 单点登录服务-实战单点登录5 | |\n| 40 单点登录服务-使用 Nginx 反向代理解 | |\n| 41 单点登录服务-实战单点登录完结篇 | |\n| 42 进入下半场的准备工作 | |\n| 43 番外篇-重构改善既有代码的设计-数据库 | |\n| 44 番外篇-重构改善既有代码的设计-领域模型 | |\n| 45 番外篇-重构改善既有代码的设计-业务逻辑层 | |\n| 46 番外篇-重构改善既有代码的设计-管理员服务 | |\n| 47 番外篇-重构改善既有代码的设计-管理员分页 | |\n| 48 文章服务-提供者 | |\n| 49 文章服务-配置 MyBatis Redis | |\n| 50 文章服务-配置 Swagger2 接口文档 | |\n| 51 文章服务-消费者 | |\n| 52 文章服务-消费者-分页功能 | |\n| 53 文章服务-消费者-提取 Thymeleaf | |\n| 54 文章服务-消费者-保存功能 | |\n| 55 文件上传服务-FastDFS | |\n| 56 文件上传服务-提供者 | |\n| 57 文章服务-消费者-文件上传功能 | |\n| 58 后台服务聚合-页面拆分1 | |\n| 59 后台服务聚合-页面拆分2 | |\n| 60 后台服务聚合-页面聚合1 | |\n| 61 后台服务聚合-页面聚合2 | |\n| 62 数字货币服务-前言 | |\n| 63 消息队列-消息队列的流派 | |\n| 64 消息队列-Actor 模型 | |\n| 65 消息队列-RabbitMQ 简介 | |\n| 66 消息队列-RabbitMQ 安装 | |\n| 67 消息队列-RabbitMQ 使用 | |\n| 68 任务调度-Quartz | |"
},
{
"path": "course/Java 架构师成长之路/04 Java 微服务架构 Dubbo 篇.md",
"content": "## Java 微服务架构 Dubbo 篇\n\n| 章节 | 记录 |\n| --------------------------------------------------- | ---- |\n| 01 实现微服务架构-课程回顾-微服务架构需要解决的问题 | |\n| 02 实现微服务架构-Zookeeper-什么是分布式协调服务 | |\n| 03 实现微服务架构-Zookeeper-什么是分布式锁1 | |\n| 04 实现微服务架构-Zookeeper-什么是分布式锁2 | |\n| 05 实现微服务架构-Zookeeper-什么是分布式锁3 | |\n| 06 实现微服务架构-Zookeeper-服务注册与发现 | |\n| 07 实现微服务架构-Zookeeper-集群崩溃恢复1 | |\n| 08 实现微服务架构-Zookeeper-集群崩溃恢复2 | |\n| 09 实现微服务架构-Zookeeper-集群数据同步 | |\n| 10 实现微服务架构-Zookeeper-如何实现分布式锁 | |\n| 11 实现微服务架构-Zookeeper-基于 Docker | |\n| 12 实现微服务架构-Zookeeper-配置说明 | |\n| | |\n| 13 实现微服务架构-Dubbo-简介1 | |\n| 14 实现微服务架构-Dubbo-简介2 | |\n| 15 实现微服务架构-Dubbo-服务治理 | |\n| 16 实现微服务架构-Dubbo-核心功能与组件角色 | |\n| 17 实现微服务架构-Dubbo-管理控制台 | |\n| 18 实现微服务架构-Dubbo-服务提供者 | |\n| 19 实现微服务架构-Dubbo-服务消费者 | |\n| 20 实现微服务架构-Dubbo-负载均衡 | |\n| 21 实现微服务架构-Dubbo-使用 Kryo 实现高速序 | |\n| 22 实现微服务架构-Dubbo-使用 Hystrix 实现 | |\n| 23 实现微服务架构-Dubbo-使用 Hystrix 熔断 | |\n| 24 实现微服务架构-Dubbo-系统架构的演进 | |\n| | |\n| 25 实现微服务架构-项目实战-搭建通用模块项目 | |\n| 26 实现微服务架构-项目实战-搭建用户管理服务 | |\n| | |\n| 27 实现微服务架构-持续集成-GitLab Runner | |\n| 28 实现微服务架构-持续集成-实战服务提供者 | |\n| 29 实现微服务架构-持续集成-实战服务消费者 | |\n| | |\n| 30 实现微服务架构-持续交付-基于 Docker 安装 J | |\n| 31 实现微服务架构-持续交付-配置 Jenkins | |\n| 32 实现微服务架构-持续交付-创建第一个任务 | |\n| 33 实现微服务架构-持续交付-实战服务提供者 | |\n| | |\n| 34 实现微服务架构-用户管理服务-Metronic 模板介 | |\n| 35 实现微服务架构-用户管理服务-实现基本布局 | |\n| 36 实现微服务架构-用户管理服务-PageHelper分页 | |\n| 37 实现微服务架构-用户管理服务-PageHelper分页 | |\n| | |\n| 38 实现微服务架构-内容管理服务-实现基本功能 | |\n| | |\n| 39 实现微服务架构-服务聚合-API 网关1 | |\n| 40 实现微服务架构-服务聚合-API 网关2 | |\n| | |\n| 41 实现微服务架构-分布式文件系统-什么是 FastDFS | |\n| 42 实现微服务架构-分布式文件系统-基于 Docker 安 | |\n| 43 实现微服务架构-分布式文件系统-FastDFS Jav | |\n| | |\n| 44 实现微服务架构-使用 Nginx 解决跨域问题-跨域现 | |\n| 45 实现微服务架构-使用 Nginx 解决跨域问题-Ngi | |\n| 46 实现微服务架构-使用 Nginx 解决跨域问题-Ngi | |\n| 47 实现微服务架构-使用 Nginx 解决跨域问题-Ngi | |\n| 48 实现微服务架构-使用 Nginx 解决跨域问题-Ngi | |\n| 49 实现微服务架构-使用 Nginx 解决跨域问题-COR | |\n| 50 实现微服务架构-使用 Nginx 解决跨域问题-假请求 | |\n| | |\n| 51 实现微服务架构-使用 Redis 实现数据缓存-创建缓 | |\n| 52 实现微服务架构-使用 Redis 实现数据缓存-MyB | |\n| | |\n| 53 实现微服务架构-使用 Solr 实现全文检索-Solr | |\n| 54 实现微服务架构-使用 Solr 实现全文检索-搜索引擎 | |\n| 55 实现微服务架构-使用 Solr 实现全文检索-基于 D | |\n| 56 实现微服务架构-使用 Solr 实现全文检索-Solr | |\n| 57 实现微服务架构-使用 Solr 实现全文检索-Spri | |"
},
{
"path": "course/LEARN.md",
"content": "## PART2：学习记录\n\n\n\n★2018年6月-7月学习计划\n\n【慕课网】玩转数据结构 从入门到进阶\n\n【慕课网】程序员的内功修炼，学好算法与数据结构\n\n【慕课网】玩转算法面试 leetcode题库分门别类详细解析 \n\n【慕课网】HTTP协议原理+实践 Web开发工程师必学\n\n【慕课网】Java并发编程与高并发解决方案\n\n\n\n\n\n### 学习课程（精简版）\n\n以下清单是需要学习的课程\n\n| 专题 | 类型 | 课程 | 进展 |\n| --------- | ------------------ | ------------------------------------------------------------ | :-------------: |\n| **专题1** | **数据结构与算法** | | |\n| | | :gem:【慕课网】程序员的内功修炼，学好算法与数据结构 | |\n| | | :gem:【慕课网】玩转算法面试 leetcode题库分门别类详细解析 | |\n| | | :gem:【慕课网】玩转数据结构 从入门到进阶 | |\n| | | 【牛客网】算法高频题目精讲 | |\n| | | 【牛客网】直通BAT — 求职算法精品课 | |\n| **专题2** | **后端技术栈** | | |\n| | 00 Web基础 | | |\n| | | 【表严肃】讲正则表达式 | 完成 |\n| | 01 Java | | |\n| | | 【翁凯】Java基础 | 完成 |\n| | | 【慕课网】Java零基础入门 | |\n| | | :gem:【极客学院】极客学院23种设计模式 | |\n| | | :gem:【炼数成金】深入JVM内核—原理、诊断与优化 | |\n| | | :gem:【炼数成金】实战Java高并发程序设计 | |\n| | | 【慕课网】Java并发编程与高并发解决方案 | **🚴** |\n| | | 【慕课网】Google面试官亲授 升级Java面试 | |\n| | | 【慕课网】Java读源码之Netty深入剖析 | 有时间回来学习 |\n| | | 【慕课在线】Netty入门之WebSocket初体验 \\| [慕课网](https://www.imooc.com/learn/941) | |\n| | 02 Java web | | |\n| | | [【慕课网在线】Spring Boot热部署](https://www.imooc.com/learn/915) \\| [参考文档](https://www.cnblogs.com/magicalSam/p/7196355.html) | 进行中 |\n| | | 【慕课网】ZooKeeper分布式专题与Dubbo微服务入门 | |\n| | | :gem:【慕课网】Spring Cloud微服务实战_廖师兄 | |\n| | | :gem:【慕课网】Spring Boot企业微信点餐系统 | 完成 |\n| | | 【神马小风】Spring MVC4入门 | 完成 |\n| | | ~~【极客学院】JavaWeb工程师(全套)~~ \\| 部分可以学习 | |\n| | | 神码小风：SpringMVC4从入门到实战视频教程 \\| [腾讯课堂](https://ke.qq.com/course/263024) | 完成 |\n| | 03 Web Server | | |\n| | | :gem:【慕课网】Nginx从入门到实践 | |\n| | 04 Linux | | |\n| | | 【慕课网】大数据的Linux基础 | |\n| | | 【慕课网】快速上手Linux 玩转典型应用 | |\n| | | 【莫烦】Linux 简易教学 | |\n| | | 【慕课网在线】[Crontab不知疲倦的时间表](https://www.imooc.com/learn/1009) | |\n| | 05 网络 | | |\n| | | **:gem:【慕课网】HTTP协议原理+实践 Web开发工程师必学** | **:bicyclist:** |\n| | 06 数据库 | | |\n| | | 【慕课网】MySQL性能管理及架构设计 | |\n| | | 【慕课网】Redis从入门到高可用，分布式实践 | |\n| | 07 Git | | |\n| | | 【表严肃】讲Git | 完成 |\n| | | 【莫烦】01 Git 版本管理 | |\n| | 08 docker | | |\n| | | :gem:【慕课网】系统学习Docker 践行DevOps理念 | |\n| | | 【慕课网】Docker环境下的前后端分离项目部署与运维 | |\n| **专题3** | **机器学习** | | |\n| | | :gem:【慕课网—刘宇波】Python3入门机器学习 经典算法与应用 | |\n| | | ~~【慕课网】机器学习入门 Scikit-learn实现经典小案例~~ | |\n| | | ~~【慕课网】基于Python玩转人工智能最火框架 TensorFlow应用实践~~ | |\n| **专题4** | **Python** | | |\n| | | ~~【慕课网】Python3入门与进阶~~ | |\n| | | ~~【莫烦】Python+机器学习系列~~ | |\n| | | 【慕课网】Python Flask构建可扩展的RESTful API | |\n| | | | |\n| **专题5** | **PHP** | | |\n| | | 【慕课网】360大牛全面解读PHP面试 | 完成 |\n| | | 【网易云课堂】thinkphp5开发restful-api接口 | 完成 |\n| **专题6** | 工具篇 | | |\n| | | [【慕课网在线】IntelliJ IDEA神器使用技巧](https://www.imooc.com/learn/924) | 完成 |\n| | | | |\n| | | | |\n| | | | |\n| | | | |\n| | | | |\n| | | | |\n\n\n\n\n\n### 学习图书（精简版）\n\n以下是需要学习的清单\n\n| 编号 | 类型 | 图书 | 进展 |\n| ---- | ----------------- | ----------------------------------- | ---- |\n| 1 | 面试宝典 | **:gem:《Java程序员面试笔试宝典》** | |\n| 2 | 面试宝典 | 《程序员代码面试指南》结合Leetcode | |\n| 3 | Java | **《Java并发编程实战》** | |\n| 4 | Java | 《深入理解Java虚拟机》 | |\n| 5 | Java（设计模式） | **《设计模式之禅》** | |\n| 6 | Java Web | 《Spring实战》 | |\n| 7 | Java Web | 《深入分析Java Web技术内幕》 | |\n| 8 | 数据库 | 《高性能MySQL》 | |\n| 9 | 计算机网络 | **《图解HTTP》** | |\n| 10 | 数据结构与算法 | 《计算机考研——机试指南》 | |\n| 11 | 数据结构与算法 | 《数据结构高分笔记》 | |\n| 12 | 操作系统（Linux） | 《快乐的Linux命令行（书）》 | |\n\n深入理解计算机系统\n\n自顶向下计算机网络\n\n\n\nNginx阿里巴巴文档\n\n\n\n### 课程与图书总览\n\n以下是所有待学习图书，仅作为全文预览检索\n\n详情转向 [course/LEARN_FULL.md](LEARN_FULL.md)\n\n"
},
{
"path": "course/LEARNLIST.md",
"content": "# 阅读清单与学习课程\n\n在这部分，我将对阅读书籍和学习课程进程推荐，在课程中我将附带官网链接，图书则附京东的链接。\n\n正在整理，未完待续\n\n\n\n## 一、数据结构与算法\n\n包含数据结构与算法两部分。\n\n### :books:阅读清单\n\n- [《算法4》](https://item.jd.com/11098789.html)\n- [《剑指Offer》](https://item.jd.com/12163054.html)\n- [《程序员面试指南》](https://item.jd.com/11770838.html)\n\n### :tv:学习课程\n\n- [【慕课网】刘宇波：玩转数据结构，从入门到进阶](https://coding.imooc.com/class/207.html)\n- [【慕课网】刘宇波：程序员的内功修炼，学好算法与数据结构](https://coding.imooc.com/class/71.html)\n- [【慕课网】刘宇波：玩转算法面试 leetcode题库分门别类详细解析](https://coding.imooc.com/class/82.html)\n\n\n\n\n\n## 二、Java\n\n包含 Java 核心知识和 Java Web 框架。\n\n### :books:阅读清单\n\n- [《Java并发编程实战》](https://item.jd.com/10922250.html) \n- \n- [《深入分析Java Web技术内幕》](https://item.jd.com/11520670.html)\n- 《阿里巴巴Java开发手册》\n- 《Java程序员面试笔试宝典》\n- 《Java网络编程》\n- 《Spring实战》\n- [《Spring MVC+MyBatis开发从入门到项目实战》](https://item.jd.com/12308496.html)\n- 《深入理解Java虚拟机》\n- 《Java核心技术 卷Ⅰ / Ⅱ》\n\n### :tv:学习课程\n\n- 【廖雪峰】Java教程\n- 【龙果学院】Java并发编程原理与实战\n- 【龙果学院】深入理解Java虚拟机（jvm性能调优+内存模型+虚拟机原理）\n- 【慕课网】Java零基础入门\n- 【尚学堂】白鹤翔_jvm虚拟机优化\n- 【网易云课堂】Java开发工程师（Web方向）翁凯\n- 【慕课网】Spring Cloud微服务实战_廖师兄\n- 【黑马程序员】SSH框架_王泽\n- 【黑马程序员】SpringMVC+Mybatis\n- 【牛客网】初中高Python+Java项目实战_叶神\n\n\n\n## 三、Web Server\n\n- 【网易云课堂】thinkphp5开发restful-api接口\n\n\n\n## 四、面向对象\n\n- [《设计模式之禅》](https://item.jd.com/11414555.html)\n\n- 【极客学院】极客学院23种设计模式\n\n\n\n## 五、数据库\n\n### :books:阅读清单\n\n- 《高性能MySQL》\n- 《Redis实战》\n\n### :tv:学习课程\n\n- 【慕课网】MySQL性能管理及架构设计\n- 【慕课网】Redis从入门到高可用，分布式实践\n\n\n\n## 六、操作系统\n\n### :books:阅读清单\n\n- 《Linux+C程序设计大全》\n- 《快乐的Linux命令行》\n- 《深入理解计算机系统》\n\n### :tv:学习课程\n\n- [【慕课网】快速上手Linux 玩转典型应用](https://coding.imooc.com/class/154.html)\n- [【慕课在线】Linux达人养成计划 I-Linux的入门级课程！](https://www.imooc.com/learn/175)\n- [【慕课在线】Linux 达人养成计划 II VIM+磁盘管理+用户权限！](https://www.imooc.com/learn/111)\n- 【小甲鱼】零基础入门学习汇编语言\n- 操作系统_清华大学(向勇、陈渝)\n\n\n\n## 七、计算机网络\n\n### :books:阅读清单\n\n- 《图解HTTP》\n- 《计算机网络原理创新教程》韩立刚主编\n\n### :tv:学习课程\n\n- 【51CTO】韩老师-计算机网络原理-156讲\n- 【慕课网】HTTP协议原理+实践 Web开发工程师必学\n\n\n\n\n\n## 八、系统架构\n\n### :books:阅读清单\n\n### :tv:学习课程\n\n- 【慕课网】Nginx从入门到实践\n- 【咕泡学院】架构师系列课程\n\n\n\n## 九、面试\n\n- 【慕课网】360大牛全面解读PHP面试\n\n- 【慕课网】Google面试官亲授 升级Java面试\n\n\n\n## 十、机器学习\n\n### :books:阅读清单\n\n- 《机器学习实战》\n\n### :tv:学习课程\n\n- 【慕课网】Python3入门机器学习 经典算法与应用\n- 【莫烦Python】机器学习系列\n\n\n\n## 十一、工具\n\n### :tv:学习课程\n\n- 【表严肃】讲正则表达式\n- 【表严肃】讲Git\n- 【慕课网】系统学习Docker 践行DevOps理念\n- [【慕课在线】IntelliJ IDEA神器使用技巧](https://www.imooc.com/learn/924)\n\n"
},
{
"path": "course/LEARN_FULL.md",
"content": "## PART2：学习总览\n\n\n\n### 学习课程总览\n\n| 专题 | 类型 | 课程 | 进展 |\n| --------- | :----------------- | ------------------------------------------------------------ | ---- |\n| **专题1** | **数据结构与算法** | | |\n| | | 【慕课网】程序员的内功修炼，学好算法与数据结构 | |\n| | | 【慕课网】玩转算法面试 leetcode题库分门别类详细解析 | |\n| | | 【慕课网】玩转数据结构 | |\n| | | 【牛客网】算法高频题目精讲 | |\n| | | 【牛客网】直通BAT — 求职算法精品课 | |\n| | | 【小甲鱼】数据结构与算法 | |\n| | | 【慕课网】看得见的算法 7个经典应用诠释算法精髓 | |\n| **专题2** | **后端技术栈** | | |\n| | 00 Web基础 | | |\n| | | 【表严肃】讲正则表达式 | |\n| | 01 Java | | |\n| | | 【翁凯】Java基础 | |\n| | | 【慕课网】Java零基础入门 | |\n| | | 【极客学院】极客学院23种设计模式 | |\n| | | 【炼数成金】深入JVM内核—原理、诊断与优化 | |\n| | | 【炼数成金】实战Java高并发程序设计 | |\n| | | 【龙果学院】深入理解Java虚拟机 | |\n| | | 【慕课网】Google面试官亲授 升级Java面试 | |\n| | 02 Java web | | |\n| | | 【慕课网】ZooKeeper分布式专题与Dubbo微服务入门 | |\n| | | 【慕课网】Spring Cloud微服务实战_廖师兄 | |\n| | | 【慕课网】Spring Boot企业微信点餐系统 | |\n| | | 【慕课网】Java秒杀系统方案优化 高性能高并发实战 | |\n| | | 【慕课网】IT段子手详解MyBatis遇到Spring 秒学Java SSM开发大众点评 | |\n| | | 【慕课网】Docker+Kubernetes(k8s)微服务容器化实践 | |\n| | | 【极客学院】JavaWeb工程师(全套) | |\n| | | ~~【传智播客】Springmvc+Mybatis由浅入深全套视频教程~~ | |\n| | | ~~【传智播客】孔浩Java课程~~ | |\n| | | ~~【慕课网】Java Spring带前后端开发完整电商平台~~ | |\n| | | ~~【慕课网】Java从零到企业级电商项目实战~~ | |\n| | | ~~【慕课网】Spring Boot企业级博客系统实战视频教程~~ | |\n| | 03 Web Server | | |\n| | | 【慕课网】Nginx从入门到实践 | |\n| | 04 Linux | | |\n| | | 【慕课网】大数据的Linux基础 | |\n| | | 【慕课网】快速上手Linux 玩转典型应用 | |\n| | | 【莫烦】Linux 简易教学 | |\n| | 05 网络 | | |\n| | | 【慕课网】HTTP协议原理+实践 Web开发工程师必学 | |\n| | 06 数据库 | | |\n| | | 【慕课网】MySQL性能管理及架构设计 | |\n| | | 【慕课网】Redis从入门到高可用，分布式实践 | |\n| | 07 Git | | |\n| | | 【表严肃】讲Git | |\n| | | 【莫烦】01 Git 版本管理 | |\n| | 08 docker | | |\n| | | 【极客学院】docker | |\n| | | 【慕课网】系统学习Docker 践行DevOps理念 | |\n| **专题3** | **机器学习** | | |\n| | | 【麦子学院】机器学习系列 × 3 | |\n| | | 【慕课网】机器学习入门 Scikit-learn实现经典小案例 | |\n| | | 【慕课网】基于Python玩转人工智能最火框架 TensorFlow应用实践 | |\n| | | 【慕课网—刘宇波】Python3入门机器学习 经典算法与应用 | |\n| | | 【斯坦福】Andrew Ng机器学习 | |\n| **专题4** | **Python** | | |\n| | | 【慕课网】Python3入门与进阶 | |\n| | | 【慕课网】2017 Vue+Django API前后端分离开发电商新技术跨域项目实战 | |\n| | | 【慕课网】Python高级编程和异步IO并发编程 | |\n| | | 【慕课网】Python升级3.6 强力Django+杀手级Xadmin打造在线教育平台 | |\n| | | 【慕课网】Vue+Django REST framework 打造生鲜电商项目 | |\n| | | 【莫烦】Python+机器学习系列 | |\n| **专题5** | **PHP** | | |\n| | | 【慕课网】360大牛全面解读PHP面试 | |\n| | | 【慕课网】PHP接口开发 | |\n| | | 【网易云课堂】thinkphp5开发restful-api接口 | |\n\n\n\n\n\n### 学习书籍总览\n\n以下是所有待学习图书，仅作为全文预览检索\n\n| 类型 | 图书 | 进展 |\n| ----------------- | -------------------------------------------- | ---- |\n| 面试宝典 | 《Java程序员面试笔试宝典》 | |\n| 面试宝典 | 《程序员代码面试指南》 | |\n| 面试宝典 | ~~《剑指Offer》~~ | |\n| 面试宝典 | ~~《技术之瞳》~~ | |\n| 面试宝典 | 《Java程序员面试面试笔试真题与解析》 | |\n| Java | 《Java并发编程实战》 | |\n| Java | 《深入理解Java虚拟机》 | |\n| Java | ~~《Java核心技术 卷Ⅰ / Ⅱ》~~ | |\n| Java（设计模式） | 《设计模式之禅》 | |\n| Java Web | 《Spring实战》 | |\n| Java Web | 《深入分析Java Web技术内幕》 | |\n| 数据库 | 《高性能MySQL》 | |\n| 计算机网络 | 《图解HTTP》 | |\n| 数据结构与算法 | 《计算机考研——机试指南》 | |\n| 数据结构与算法 | 《数据结构高分笔记》 | |\n| 操作系统（Linux） | 《快乐的Linux命令行（书）》 | |\n| 操作系统 | ~~《操作系统高分笔记》~~ | |\n| 机器学习 | ~~《机器学习实战》~~ | |\n| 机器学习 | ~~《终极算法》~~ | |\n| 机器学习 | ~~《机器学习在线——解析阿里云机器学习平台》~~ | |\n| 计算机视觉 | ~~《OpenCV3编程入门》~~ | |\n| 阿里丛书 | ~~《尽在双十一》~~ | |\n\n\n\n"
},
{
"path": "course/LEARN_RECORD.md",
"content": "## PART2：学习记录\n\n### 已完成的课程\n\n| 课程 | 进展 |\n| ------------------------------------------------------------ | --------------- |\n| [SpringBoot+MyBatis搭建迷你小程序教程](https://www.imooc.com/learn/945) | 2018/05/06 完成 |\n| [IntelliJ IDEA神器使用技巧](https://www.imooc.com/learn/924) | 2018/05/14 完成 |\n| [表严肃讲正则表达式](http://biaoyansu.com/28.x) | 2018/06/05 完成 |\n| [表严肃讲Git](http://biaoyansu.com/27.x) | 2018/06/05 完成 |\n| [第一个docker化的java应用](https://www.imooc.com/learn/824) | 2018/06/06 完成 |\n\n\n\n### 学习课程\n\n| 课程 | 进展 |\n| ------------------------------------------------------------ | ---------------------------- |\n| ★★★刘宇波：玩转数据结构 \\| [代码仓库](https://github.com/liuyubobobo/Play-with-Algorithms) \\| [学习笔记](course\\01 玩转数据结构.md ) | 2018/05/06 学习至 第三章\n\n \n\n2. 版本\n\nhttp://api.gupaoedu.com/v1/user/1\n\nheader里面维护版本\n\n\n\n3. 路径\n\nhttp://api.gupaoedu.com/v1/users_list //获取用户列表\n\n \n\nhttp://api.gupaoedu.com/v1/goods-list //商品列表\n\n \n\nhttp://api.gupaoedu.com/v1/users/{id}\n\n\n\n4. 过滤信息\n\n\n\n \n\n\n\n5. 状态码\n\n- 业务状态码\n\n- http状态码"
},
{
"path": "notes/Docker.md",
"content": "\n\n- [前言](#前言)\n- [1. Docker 简介](#1-docker-简介)\n - [1.1 什么是 Docker](#11-什么是-docker)\n - [1.2 为什么要使用 Docker](#12-为什么要使用-docker)\n- [2. Docker 基本概念](#2-docker-基本概念)\n - [2.1 Docker 引擎](#21-docker-引擎)\n - [2.2 Docker 架构](#22-docker-架构)\n - [2.3 Docker 镜像](#23-docker-镜像)\n - [2.4 Docker 容器](#24-docker-容器)\n - [2.5 Docker 仓库](#25-docker-仓库)\n- [3. 安装 Docker](#3-安装-docker)\n - [3.1 Ubuntu 安装 Docker](#31-ubuntu-安装-docker)\n - [准备工作](#准备工作)\n - [系统要求](#系统要求)\n - [卸载旧版本](#卸载旧版本)\n - [Ubuntu 14.04 可选内核模块](#ubuntu-1404-可选内核模块)\n - [Ubuntu 16.04 +](#ubuntu-1604-)\n - [使用 APT 安装](#使用-apt-安装)\n - [安装必要的一些系统工具](#安装必要的一些系统工具)\n - [安装 GPG 证书](#安装-gpg-证书)\n - [写入软件源信息](#写入软件源信息)\n - [更新并安装 Docker CE](#更新并安装-docker-ce)\n - [使用脚本自动安装](#使用脚本自动安装)\n - [特别说明](#特别说明)\n - [启动 Docker CE](#启动-docker-ce)\n - [建立 docker 用户组](#建立-docker-用户组)\n - [测试 Docker 是否安装正确](#测试-docker-是否安装正确)\n - [镜像加速](#镜像加速)\n - [参考文档](#参考文档)\n - [3.2 CentOS 安装 Docker](#32-centos-安装-docker)\n - [准备工作](#准备工作-1)\n - [系统要求](#系统要求-1)\n - [卸载旧版本](#卸载旧版本-1)\n - [使用 yum 安装](#使用-yum-安装)\n - [安装 Docker CE](#安装-docker-ce)\n - [使用脚本自动安装](#使用脚本自动安装-1)\n - [启动 Docker CE](#启动-docker-ce-1)\n - [建立 docker 用户组](#建立-docker-用户组-1)\n - [测试 Docker 是否安装正确](#测试-docker-是否安装正确-1)\n - [镜像加速](#镜像加速-1)\n - [添加内核参数](#添加内核参数)\n - [参考文档](#参考文档-1)\n - [3.3 树莓派卡片电脑安装 Docker](#33-树莓派卡片电脑安装-docker)\n - [系统要求](#系统要求-2)\n - [使用 APT 安装](#使用-apt-安装-1)\n - [安装 Docker CE](#安装-docker-ce-1)\n - [使用脚本自动安装](#使用脚本自动安装-2)\n - [启动 Docker CE](#启动-docker-ce-2)\n - [建立 docker 用户组](#建立-docker-用户组-2)\n - [测试 Docker 是否安装正确](#测试-docker-是否安装正确-2)\n - [镜像加速](#镜像加速-2)\n - [3.4 macOS 安装 Docker](#34-macos-安装-docker)\n - [系统要求](#系统要求-3)\n - [安装](#安装)\n - [使用 Homebrew 安装](#使用-homebrew-安装)\n - [手动下载安装](#手动下载安装)\n - [运行](#运行)\n - [镜像加速](#镜像加速-3)\n - [3.5 Windows 安装 Docker](#35-windows-安装-docker)\n - [系统要求](#系统要求-4)\n - [安装](#安装-1)\n - [运行](#运行-1)\n - [镜像加速](#镜像加速-4)\n - [3.6 Docker 镜像加速器](#36-docker-镜像加速器)\n - [Ubuntu 14.04、Debian 7 Wheezy](#ubuntu-1404debian-7-wheezy)\n - [Ubuntu 16.04+、Debian 8+、CentOS 7](#ubuntu-1604debian-8centos-7)\n - [Windows 10](#windows-10)\n - [macOS](#macos)\n - [检查加速器是否生效](#检查加速器是否生效)\n\n\n# 前言\n\nDocker 容器化引擎，更详细请转向：[Docker_Tutorial: Docker 容器化引擎入门手册](https://github.com/frank-lam/Docker_Tutorial)\n\n> 参考资料：\n>\n> - http://www.funtl.com/\n> - [Docker —— 从入门到实践](https://yeasy.gitbooks.io/docker_practice/content/)\n>\n> 基于以上部分内容做一定的修改\n\n# 1. Docker 简介\n\n## 1.1 什么是 Docker\n\nDocker 最初是 dotCloud 公司创始人 Solomon Hykes 在法国期间发起的一个公司内部项目，它是基于 dotCloud 公司多年云服务技术的一次革新，并于 [2013 年 3 月以 Apache 2.0 授权协议开源](https://en.wikipedia.org/wiki/Docker_(software))，主要项目代码在 [GitHub](https://github.com/moby/moby) 上进行维护。Docker 项目后来还加入了 Linux 基金会，并成立推动 [开放容器联盟（OCI）](https://www.opencontainers.org/)。\n\nDocker 自开源后受到广泛的关注和讨论，至今其 GitHub 项目已经超过 4 万 6 千个星标和一万多个 fork。甚至由于 Docker 项目的火爆，在 2013 年底，[dotCloud 公司决定改名为 Docker](https://blog.docker.com/2013/10/dotcloud-is-becoming-docker-inc/)。Docker 最初是在 Ubuntu 12.04 上开发实现的；Red Hat 则从 RHEL 6.5 开始对 Docker 进行支持；Google 也在其 PaaS 产品中广泛应用 Docker。\n\nDocker 使用 Google 公司推出的 [Go 语言](https://golang.org/) 进行开发实现，基于 Linux 内核的 [cgroup](https://zh.wikipedia.org/wiki/Cgroups)，[namespace](https://en.wikipedia.org/wiki/Linux_namespaces)，以及 [AUFS](https://en.wikipedia.org/wiki/Aufs) 类的 [Union FS](https://en.wikipedia.org/wiki/Union_mount) 等技术，对进程进行封装隔离，属于 [操作系统层面的虚拟化技术](https://en.wikipedia.org/wiki/Operating-system-level_virtualization)。由于隔离的进程独立于宿主和其它的隔离的进程，因此也称其为容器。最初实现是基于 [LXC](https://linuxcontainers.org/lxc/introduction/)，从 0.7 版本以后开始去除 LXC，转而使用自行开发的 [libcontainer](https://github.com/docker/libcontainer)，从 1.11 开始，则进一步演进为使用 [runC](https://github.com/opencontainers/runc) 和 [containerd](https://github.com/containerd/containerd)。\n\nDocker 在容器的基础上，进行了进一步的封装，从文件系统、网络互联到进程隔离等等，极大的简化了容器的创建和维护。使得 Docker 技术比虚拟机技术更为轻便、快捷。\n\n下面的图片比较了 Docker 和传统虚拟化方式的不同之处。传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。\n\n\n\n\n\n\n\n## 1.2 为什么要使用 Docker\n\n作为一种新兴的虚拟化方式，Docker 跟传统的虚拟化方式相比具有众多的优势。\n\n**更高效的利用系统资源**\n\n由于容器不需要进行硬件虚拟以及运行完整操作系统等额外开销，Docker 对系统资源的利用率更高。无论是应用执行速度、内存损耗或者文件存储速度，都要比传统虚拟机技术更高效。因此，相比虚拟机技术，一个相同配置的主机，往往可以运行更多数量的应用。\n\n**更快速的启动时间**\n\n传统的虚拟机技术启动应用服务往往需要数分钟，而 Docker 容器应用，由于直接运行于宿主内核，无需启动完整的操作系统，因此可以做到秒级、甚至毫秒级的启动时间。大大的节约了开发、测试、部署的时间。\n\n**一致的运行环境**\n\n开发过程中一个常见的问题是环境一致性问题。由于开发环境、测试环境、生产环境不一致，导致有些 bug 并未在开发过程中被发现。而 Docker 的镜像提供了除内核外完整的运行时环境，确保了应用运行环境一致性，从而不会再出现 *「这段代码在我机器上没问题啊」* 这类问题。\n\n**持续交付和部署**\n\n对开发和运维（[DevOps](https://zh.wikipedia.org/wiki/DevOps)）人员来说，最希望的就是一次创建或配置，可以在任意地方正常运行。\n\n使用 Docker 可以通过定制应用镜像来实现持续集成、持续交付、部署。开发人员可以通过 `Dockerfile` 来进行镜像构建，并结合 [持续集成(Continuous Integration)](https://en.wikipedia.org/wiki/Continuous_integration) 系统进行集成测试，而运维人员则可以直接在生产环境中快速部署该镜像，甚至结合 [持续部署(Continuous Delivery/Deployment)](https://en.wikipedia.org/wiki/Continuous_delivery) 系统进行自动部署。\n\n而且使用 `Dockerfile` 使镜像构建透明化，不仅仅开发团队可以理解应用运行环境，也方便运维团队理解应用运行所需条件，帮助更好的生产环境中部署该镜像。\n\n**更轻松的迁移**\n\n由于 Docker 确保了执行环境的一致性，使得应用的迁移更加容易。Docker 可以在很多平台上运行，无论是物理机、虚拟机、公有云、私有云，甚至是笔记本，其运行结果是一致的。因此用户可以很轻易的将在一个平台上运行的应用，迁移到另一个平台上，而不用担心运行环境的变化导致应用无法正常运行的情况。\n\n**更轻松的维护和扩展**\n\nDocker 使用的分层存储以及镜像的技术，使得应用重复部分的复用更为容易，也使得应用的维护更新更加简单，基于基础镜像进一步扩展镜像也变得非常简单。此外，Docker 团队同各个开源项目团队一起维护了一大批高质量的 [官方镜像](https://store.docker.com/search?q=&source=verified&type=image)，既可以直接在生产环境使用，又可以作为基础进一步定制，大大的降低了应用服务的镜像制作成本。\n\n**对比传统虚拟机总结**\n\n| 特性 | 容器 | 虚拟机 |\n| ---------- | ------------------ | ----------- |\n| 启动 | 秒级 | 分钟级 |\n| 硬盘使用 | 一般为 `MB` | 一般为 `GB` |\n| 性能 | 接近原生 | 弱于 |\n| 系统支持量 | 单机支持上千个容器 | 一般几十个 |\n\n# 2. Docker 基本概念\n\nDocker 包括三个基本概念\n\n- 镜像（`Image`）\n- 容器（`Container`）\n- 仓库（`Repository`）\n\n理解了这三个概念，就理解了 Docker 的整个生命周期。\n\n## 2.1 Docker 引擎\n\nDocker 引擎是一个包含以下主要组件的客户端服务器应用程序。\n\n- 一种服务器，它是一种称为守护进程并且长时间运行的程序。\n- REST API 用于指定程序可以用来与守护进程通信的接口，并指示它做什么。\n- 一个有命令行界面 (CLI) 工具的客户端。\n\nDocker 引擎组件的流程如下图所示：\n\n\n\n\n\n## 2.2 Docker 架构\n\nDocker 使用客户端-服务器 (C/S) 架构模式，使用远程 API 来管理和创建 Docker 容器。\n\nDocker 容器通过 Docker 镜像来创建。\n\n**容器与镜像**的关系类似于**面向对象**编程中的**对象与类**。\n\n| Docker | 面向对象 |\n| ------ | -------- |\n| 容器 | 对象 |\n| 镜像 | 类 |\n\n\n\n| 标题 | 说明 |\n| ------------------- | ------------------------------------------------------------ |\n| **镜像**(Images) | Docker 镜像是用于创建 Docker 容器的模板。 |\n| **容器**(Container) | 容器是独立运行的一个或一组应用。 |\n| **客户端**(Client) | Docker 客户端通过命令行或者其他工具使用 Docker API () 与 Docker 的守护进程通信。 |\n| **主机**(Host) | 一个物理或者虚拟的机器用于执行 Docker 守护进程和容器。 |\n| **仓库**(Registry) | Docker 仓库用来保存镜像，可以理解为代码控制中的代码仓库。Docker Hub([https://hub.docker.com](https://hub.docker.com/)) 提供了庞大的镜像集合供使用。 |\n| **Docker Machine** | Docker Machine是一个简化Docker安装的命令行工具，通过一个简单的命令行即可在相应的平台上安装Docker，比如VirtualBox、 Digital Ocean、Microsoft Azure。 |\n\n## 2.3 Docker 镜像\n\n我们都知道，操作系统分为内核和用户空间。对于 Linux 而言，内核启动后，会挂载 `root` 文件系统为其提供用户空间支持。而 Docker 镜像（Image），就相当于是一个 `root` 文件系统。比如官方镜像 `ubuntu:16.04` 就包含了完整的一套 Ubuntu 16.04 最小系统的 `root` 文件系统。\n\nDocker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。镜像不包含任何动态数据，其内容在构建之后也不会被改变。\n\n**分层存储**\n\n因为镜像包含操作系统完整的 `root` 文件系统，其体积往往是庞大的，因此在 Docker 设计时，就充分利用 [Union FS](https://en.wikipedia.org/wiki/Union_mount) 的技术，将其设计为分层存储的架构。所以严格来说，镜像并非是像一个 ISO 那样的打包文件，镜像只是一个虚拟的概念，其实际体现并非由一个文件组成，而是由一组文件系统组成，或者说，由多层文件系统联合组成。\n\n镜像构建时，会一层层构建，前一层是后一层的基础。每一层构建完就不会再发生改变，后一层上的任何改变只发生在自己这一层。比如，删除前一层文件的操作，实际不是真的删除前一层的文件，而是仅在当前层标记为该文件已删除。在最终容器运行的时候，虽然不会看到这个文件，但是实际上该文件会一直跟随镜像。因此，在构建镜像的时候，需要额外小心，每一层尽量只包含该层需要添加的东西，任何额外的东西应该在该层构建结束前清理掉。\n\n分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层，然后进一步添加新的层，以定制自己所需的内容，构建新的镜像。\n\n关于镜像构建，将会在后续相关章节中做进一步的讲解。\n\n## 2.4 Docker 容器\n\n镜像（`Image`）和容器（`Container`）的关系，就像是面向对象程序设计中的 `类` 和 `实例` 一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。\n\n容器的实质是进程，但与直接在宿主执行的进程不同，容器进程运行于属于自己的独立的 [命名空间](https://en.wikipedia.org/wiki/Linux_namespaces)。因此容器可以拥有自己的 `root` 文件系统、自己的网络配置、自己的进程空间，甚至自己的用户 ID 空间。容器内的进程是运行在一个隔离的环境里，使用起来，就好像是在一个独立于宿主的系统下操作一样。这种特性使得容器封装的应用比直接在宿主运行更加安全。也因为这种隔离的特性，很多人初学 Docker 时常常会混淆容器和虚拟机。\n\n前面讲过镜像使用的是分层存储，容器也是如此。每一个容器运行时，是以镜像为基础层，在其上创建一个当前容器的存储层，我们可以称这个为容器运行时读写而准备的存储层为**容器存储层**。\n\n容器存储层的生存周期和容器一样，容器消亡时，容器存储层也随之消亡。因此，任何保存于容器存储层的信息都会随容器删除而丢失。\n\n按照 Docker 最佳实践的要求，容器不应该向其存储层内写入任何数据，容器存储层要保持无状态化。所有的文件写入操作，都应该使用 `数据卷（Volume）`、或者绑定宿主目录，在这些位置的读写会跳过容器存储层，直接对宿主（或网络存储）发生读写，其性能和稳定性更高。\n\n数据卷的生存周期独立于容器，容器消亡，数据卷不会消亡。因此，使用数据卷后，容器删除或者重新运行之后，数据却不会丢失。\n\n## 2.5 Docker 仓库\n\n镜像构建完成后，可以很容易的在当前宿主机上运行，但是，如果需要在其它服务器上使用这个镜像，我们就需要一个集中的存储、分发镜像的服务，`Docker Registry` 就是这样的服务。\n\n一个 **Docker Registry** 中可以包含多个**仓库**（`Repository`）；每个仓库可以包含多个**标签**（`Tag`）；每个标签对应一个镜像。\n\n通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本。我们可以通过 `<仓库名>:<标签>` 的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 `latest` 作为默认标签。\n\n以 [Ubuntu 镜像](https://store.docker.com/images/ubuntu) 为例，`ubuntu` 是仓库的名字，其内包含有不同的版本标签，如，`14.04`, `16.04`。我们可以通过 `ubuntu:14.04`，或者 `ubuntu:16.04` 来具体指定所需哪个版本的镜像。如果忽略了标签，比如 `ubuntu`，那将视为 `ubuntu:latest`。\n\n仓库名经常以 *两段式路径* 形式出现，比如 `jwilder/nginx-proxy`，前者往往意味着 Docker Registry 多用户环境下的用户名，后者则往往是对应的软件名。但这并非绝对，取决于所使用的具体 Docker Registry 的软件或服务。\n\n**公有 Docker Registry**\n\nDocker Registry 公开服务是开放给用户使用、允许用户管理镜像的 Registry 服务。一般这类公开服务允许用户免费上传、下载公开的镜像，并可能提供收费服务供用户管理私有镜像。\n\n最常使用的 Registry 公开服务是官方的 [Docker Hub](https://hub.docker.com/)，这也是默认的 Registry，并拥有大量的高质量的官方镜像。除此以外，还有 [CoreOS](https://coreos.com/) 的 [Quay.io](https://quay.io/repository/)，CoreOS 相关的镜像存储在这里；Google 的 [Google Container Registry](https://cloud.google.com/container-registry/)，[Kubernetes](http://kubernetes.io/) 的镜像使用的就是这个服务。\n\n由于某些原因，在国内访问这些服务可能会比较慢。国内的一些云服务商提供了针对 Docker Hub 的镜像服务（`Registry Mirror`），这些镜像服务被称为**加速器**。常见的有 [阿里云加速器](https://cr.console.aliyun.com/#/accelerator)、[DaoCloud 加速器](https://www.daocloud.io/mirror#accelerator-doc) 等。使用加速器会直接从国内的地址下载 Docker Hub 的镜像，比直接从 Docker Hub 下载速度会提高很多。\n\n国内也有一些云服务商提供类似于 Docker Hub 的公开服务。比如 [时速云镜像仓库](https://hub.tenxcloud.com/)、[网易云镜像服务](https://c.163.com/hub#/m/library/)、[DaoCloud 镜像市场](https://hub.daocloud.io/)、[阿里云镜像库](https://cr.console.aliyun.com/) 等。\n\n**私有 Docker Registry**\n\n除了使用公开服务外，用户还可以在本地搭建私有 Docker Registry。Docker 官方提供了 [Docker Registry](https://store.docker.com/images/registry/) 镜像，可以直接使用做为私有 Registry 服务。\n\n开源的 Docker Registry 镜像只提供了 [Docker Registry API](https://docs.docker.com/registry/spec/api/) 的服务端实现，足以支持 `docker` 命令，不影响使用。但不包含图形界面，以及镜像维护、用户管理、访问控制等高级功能。在官方的商业化版本 [Docker Trusted Registry](https://docs.docker.com/datacenter/dtr/2.0/) 中，提供了这些高级功能。\n\n除了官方的 Docker Registry 外，还有第三方软件实现了 Docker Registry API，甚至提供了用户界面以及一些高级功能。比如，[VMWare Harbor](https://github.com/vmware/harbor) 和 [Sonatype Nexus](https://www.sonatype.com/docker)。\n\n# 3. 安装 Docker\n\nDocker 在 1.13 版本之后，从 2017 年的 3 月 1 日开始，版本命名规则变为如下：\n\n| 项目 | 说明 |\n| ----------- | ------------ |\n| 版本格式 | YY.MM |\n| Stable 版本 | 每个季度发行 |\n| Edge 版本 | 每个月发行 |\n\n同时 Docker 划分为 CE 和 EE。CE 即社区版（免费，支持周期三个月），EE 即企业版，强调安全，付费使用。\n\nDocker CE 每月发布一个 Edge 版本 (17.03, 17.04, 17.05…)，每三个月发布一个 Stable 版本 (17.03, 17.06, 17.09…)，Docker EE 和 Stable 版本号保持一致，但每个版本提供一年维护。\n\n官方网站上有各种环境下的 [安装指南](https://docs.docker.com/engine/installation/)，这里主要介绍 Docker CE 在 Linux 、Windows 10 (PC) 和 macOS 上的安装。\n\n## 3.1 Ubuntu 安装 Docker\n\n> 警告：切勿在没有配置 Docker APT 源的情况下直接使用 apt 命令安装 Docker.\n\n### 准备工作\n\n#### 系统要求\n\nDocker CE 支持以下版本的 [Ubuntu](https://www.ubuntu.com/server) 操作系统：\n\n- Artful 17.10 (Docker CE 17.11 Edge +)\n- Xenial 16.04 (LTS)\n- Trusty 14.04 (LTS)\n\nDocker CE 可以安装在 64 位的 x86 平台或 ARM 平台上。Ubuntu 发行版中，LTS（Long-Term-Support）长期支持版本，会获得 5 年的升级维护支持，这样的版本会更稳定，因此在生产环境中推荐使用 LTS 版本,当前最新的 LTS 版本为 Ubuntu 16.04。\n\n#### 卸载旧版本\n\n旧版本的 Docker 称为 `docker` 或者 `docker-engine`，使用以下命令卸载旧版本：\n\n```\n$ sudo apt-get remove docker \\\n docker-engine \\\n docker.io\n```\n\n#### Ubuntu 14.04 可选内核模块\n\n从 Ubuntu 14.04 开始，一部分内核模块移到了可选内核模块包 (`linux-image-extra-*`) ，以减少内核软件包的体积。正常安装的系统应该会包含可选内核模块包，而一些裁剪后的系统可能会将其精简掉。`AUFS` 内核驱动属于可选内核模块的一部分，作为推荐的 Docker 存储层驱动，一般建议安装可选内核模块包以使用 `AUFS`。\n\n如果系统没有安装可选内核模块的话，可以执行下面的命令来安装可选内核模块包：\n\n```\n$ sudo apt-get update\n\n$ sudo apt-get install \\\n linux-image-extra-$(uname -r) \\\n linux-image-extra-virtual\n```\n\n#### Ubuntu 16.04 +\n\nUbuntu 16.04 + 上的 Docker CE 默认使用 `overlay2` 存储层驱动,无需手动配置。\n\n### 使用 APT 安装\n\n#### 安装必要的一些系统工具\n\n```\nsudo apt-get update\nsudo apt-get -y install apt-transport-https ca-certificates curl software-properties-common\n```\n\n#### 安装 GPG 证书\n\n```\ncurl -fsSL http://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -\n```\n\n#### 写入软件源信息\n\n```\nsudo add-apt-repository \"deb [arch=amd64] http://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable\"\n```\n\n#### 更新并安装 Docker CE\n\n```\nsudo apt-get -y update\nsudo apt-get -y install docker-ce\n```\n\n> 以上命令会添加稳定版本的 Docker CE APT 镜像源，如果需要最新或者测试版本的 Docker CE 请将 stable 改为 edge 或者 test。从 Docker 17.06 开始，edge test 版本的 APT 镜像源也会包含稳定版本的 Docker。\n\n### 使用脚本自动安装\n\n在测试或开发环境中 Docker 官方为了简化安装流程，提供了一套便捷的安装脚本，Ubuntu 系统上可以使用这套脚本安装：\n\n```\n$ curl -fsSL get.docker.com -o get-docker.sh\n# 可能会出现 404 错误，请移步下面的特别说明\n$ sudo sh get-docker.sh --mirror Aliyun\n```\n\n执行这个命令后，脚本就会自动的将一切准备工作做好，并且把 Docker CE 的 Edge 版本安装在系统中。\n\n#### 特别说明\n\n2018 年 7 月 21 日，貌似阿里云这边在做调整，故导致 Docker 的 Aliyun 安装脚本不可用，是永久性还是临时性的尚不清除，如果你已经按照之前的操作安装 Docker，请按以下步骤进行修复并重新安装\n\n- 如果已经使用了 Aliyun 脚本安装并成功的\n - 请先卸载 Docker，命令为：`apt-get autoremove docker-ce`\n - 删除 `/etc/apt/sources.list.d` 目录下的 `docker.list` 文件\n- 使用 `AzureChinaCloud` 镜像脚本重新安装，命令为：`sudo sh get-docker.sh --mirror AzureChinaCloud`\n\n### 启动 Docker CE\n\n```\n$ sudo systemctl enable docker\n$ sudo systemctl start docker\n```\n\nUbuntu 14.04 请使用以下命令启动：\n\n```\n$ sudo service docker start\n```\n\n### 建立 docker 用户组\n\n默认情况下，`docker` 命令会使用 [Unix socket](https://en.wikipedia.org/wiki/Unix_domain_socket) 与 Docker 引擎通讯。而只有 `root` 用户和 `docker` 组的用户才可以访问 Docker 引擎的 Unix socket。出于安全考虑，一般 Linux 系统上不会直接使用 `root` 用户。因此，更好地做法是将需要使用 `docker` 的用户加入 `docker` 用户组。\n\n建立 `docker` 组：\n\n```\n$ sudo groupadd docker\n```\n\n将当前用户加入 `docker` 组：\n\n```\n$ sudo usermod -aG docker $USER\n```\n\n退出当前终端并重新登录，进行如下测试。\n\n### 测试 Docker 是否安装正确\n\n```\n$ docker run hello-world\n\nUnable to find image 'hello-world:latest' locally\nlatest: Pulling from library/hello-world\nca4f61b1923c: Pull complete\nDigest: sha256:be0cd392e45be79ffeffa6b05338b98ebb16c87b255f48e297ec7f98e123905c\nStatus: Downloaded newer image for hello-world:latest\n\nHello from Docker!\nThis message shows that your installation appears to be working correctly.\n\nTo generate this message, Docker took the following steps:\n 1. The Docker client contacted the Docker daemon.\n 2. The Docker daemon pulled the \"hello-world\" image from the Docker Hub.\n (amd64)\n 3. The Docker daemon created a new container from that image which runs the\n executable that produces the output you are currently reading.\n 4. The Docker daemon streamed that output to the Docker client, which sent it\n to your terminal.\n\nTo try something more ambitious, you can run an Ubuntu container with:\n $ docker run -it ubuntu bash\n\nShare images, automate workflows, and more with a free Docker ID:\n https://cloud.docker.com/\n\nFor more examples and ideas, visit:\n https://docs.docker.com/engine/userguide/\n```\n\n若能正常输出以上信息，则说明安装成功。\n\n### 镜像加速\n\n鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，强烈建议安装 Docker 之后配置 `国内镜像加速`。\n\n### 参考文档\n\n- [Docker 官方 Ubuntu 安装文档](https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/)\n\n## 3.2 CentOS 安装 Docker\n\n> 警告：切勿在没有配置 Docker YUM 源的情况下直接使用 yum 命令安装 Docker.\n\n### 准备工作\n\n#### 系统要求\n\nDocker CE 支持 64 位版本 CentOS 7，并且要求内核版本不低于 3.10。 CentOS 7 满足最低内核的要求，但由于内核版本比较低，部分功能（如 `overlay2` 存储层驱动）无法使用，并且部分功能可能不太稳定。\n\n#### 卸载旧版本\n\n旧版本的 Docker 称为 `docker` 或者 `docker-engine`，使用以下命令卸载旧版本：\n\n```\n$ sudo yum remove docker \\\n docker-client \\\n docker-client-latest \\\n docker-common \\\n docker-latest \\\n docker-latest-logrotate \\\n docker-logrotate \\\n docker-selinux \\\n docker-engine-selinux \\\n docker-engine\n```\n\n### 使用 yum 安装\n\n执行以下命令安装依赖包：\n\n```\n$ sudo yum install -y yum-utils \\\n device-mapper-persistent-data \\\n lvm2\n```\n\n鉴于国内网络问题，强烈建议使用国内源，官方源请在注释中查看。\n\n执行下面的命令添加 `yum` 软件源：\n\n```\n$ sudo yum-config-manager \\\n --add-repo \\\n https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.repo\n\n\n# 官方源\n# $ sudo yum-config-manager \\\n# --add-repo \\\n# https://download.docker.com/linux/centos/docker-ce.repo \n```\n\n如果需要最新版本的 Docker CE 请使用以下命令：\n\n```\n$ sudo yum-config-manager --enable docker-ce-edge\n```\n\n如果需要测试版本的 Docker CE 请使用以下命令：\n\n```\n$ sudo yum-config-manager --enable docker-ce-test\n```\n\n#### 安装 Docker CE\n\n更新 `yum` 软件源缓存，并安装 `docker-ce`。\n\n```\n$ sudo yum makecache fast\n$ sudo yum install docker-ce\n```\n\n### 使用脚本自动安装\n\n在测试或开发环境中 Docker 官方为了简化安装流程，提供了一套便捷的安装脚本，CentOS 系统上可以使用这套脚本安装：\n\n```\n$ curl -fsSL get.docker.com -o get-docker.sh\n$ sudo sh get-docker.sh --mirror Aliyun\n```\n\n执行这个命令后，脚本就会自动的将一切准备工作做好，并且把 Docker CE 的 Edge 版本安装在系统中。\n\n### 启动 Docker CE\n\n```\n$ sudo systemctl enable docker\n$ sudo systemctl start docker\n```\n\n### 建立 docker 用户组\n\n默认情况下，`docker` 命令会使用 [Unix socket](https://en.wikipedia.org/wiki/Unix_domain_socket) 与 Docker 引擎通讯。而只有 `root` 用户和 `docker` 组的用户才可以访问 Docker 引擎的 Unix socket。出于安全考虑，一般 Linux 系统上不会直接使用 `root` 用户。因此，更好地做法是将需要使用 `docker` 的用户加入 `docker` 用户组。\n\n建立 `docker` 组：\n\n```\n$ sudo groupadd docker\n```\n\n将当前用户加入 `docker` 组：\n\n```\n$ sudo usermod -aG docker $USER\n```\n\n退出当前终端并重新登录，进行如下测试。\n\n### 测试 Docker 是否安装正确\n\n```\n$ docker run hello-world\n\nUnable to find image 'hello-world:latest' locally\nlatest: Pulling from library/hello-world\nca4f61b1923c: Pull complete\nDigest: sha256:be0cd392e45be79ffeffa6b05338b98ebb16c87b255f48e297ec7f98e123905c\nStatus: Downloaded newer image for hello-world:latest\n\nHello from Docker!\nThis message shows that your installation appears to be working correctly.\n\nTo generate this message, Docker took the following steps:\n 1. The Docker client contacted the Docker daemon.\n 2. The Docker daemon pulled the \"hello-world\" image from the Docker Hub.\n (amd64)\n 3. The Docker daemon created a new container from that image which runs the\n executable that produces the output you are currently reading.\n 4. The Docker daemon streamed that output to the Docker client, which sent it\n to your terminal.\n\nTo try something more ambitious, you can run an Ubuntu container with:\n $ docker run -it ubuntu bash\n\nShare images, automate workflows, and more with a free Docker ID:\n https://cloud.docker.com/\n\nFor more examples and ideas, visit:\n https://docs.docker.com/engine/userguide/\n```\n\n若能正常输出以上信息，则说明安装成功。\n\n### 镜像加速\n\n鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，强烈建议安装 Docker 之后配置 `国内镜像加速`。\n\n### 添加内核参数\n\n默认配置下，如果在 CentOS 使用 Docker CE 看到下面的这些警告信息：\n\n```\nWARNING: bridge-nf-call-iptables is disabled\nWARNING: bridge-nf-call-ip6tables is disabled\n```\n\n请添加内核配置参数以启用这些功能。\n\n```\n$ sudo tee -a /etc/sysctl.conf <<-EOF\nnet.bridge.bridge-nf-call-ip6tables = 1\nnet.bridge.bridge-nf-call-iptables = 1\nEOF\n```\n\n然后重新加载 `sysctl.conf` 即可\n\n```\n$ sudo sysctl -p\n```\n\n### 参考文档\n\n- [Docker 官方 CentOS 安装文档](https://docs.docker.com/engine/installation/linux/docker-ce/centos/)。\n\n## 3.3 树莓派卡片电脑安装 Docker\n\n> 警告：切勿在没有配置 Docker APT 源的情况下直接使用 apt 命令安装 Docker.\n\n### 系统要求\n\nDocker CE 不仅支持 `x86_64` 架构的计算机，同时也支持 `ARM` 架构的计算机，本小节内容以树莓派单片电脑为例讲解 `ARM` 架构安装 Docker CE。\n\nDocker CE 支持以下版本的 [Raspbian](https://www.raspberrypi.org/downloads/raspbian/) 操作系统：\n\n- Raspbian Stretch\n- Raspbian Jessie\n\n*注：* `Raspbian` 是树莓派的开发与维护机构 [树莓派基金会](http://www.raspberrypi.org/) 推荐用于树莓派的首选系统，其基于 `Debian`。\n\n### 使用 APT 安装\n\n由于 apt 源使用 HTTPS 以确保软件下载过程中不被篡改。因此，我们首先需要添加使用 HTTPS 传输的软件包以及 CA 证书。\n\n```\n$ sudo apt-get update\n\n$ sudo apt-get install \\\n apt-transport-https \\\n ca-certificates \\\n curl \\\n gnupg2 \\\n lsb-release \\\n software-properties-common\n```\n\n鉴于国内网络问题，强烈建议使用国内源，官方源请在注释中查看。\n\n为了确认所下载软件包的合法性，需要添加软件源的 GPG 密钥。\n\n```\n$ curl -fsSL https://mirrors.ustc.edu.cn/docker-ce/linux/raspbian/gpg | sudo apt-key add -\n\n# 官方源\n# $ curl -fsSL https://download.docker.com/linux/raspbian/gpg | sudo apt-key add -\n```\n\n然后，我们需要向 `source.list` 中添加 Docker CE 软件源：\n\n```\n$ sudo add-apt-repository \\\n \"deb [arch=armhf] https://mirrors.ustc.edu.cn/docker-ce/linux/raspbian \\\n $(lsb_release -cs) \\\n stable\"\n\n\n# 官方源\n# $ sudo add-apt-repository \\\n# \"deb [arch=armhf] https://download.docker.com/linux/raspbian \\\n# $(lsb_release -cs) \\\n# stable\" \n```\n\n> 以上命令会添加稳定版本的 Docker CE APT 源，如果需要最新版本的 Docker CE 请将 stable 改为 edge 或者 test。从 Docker 17.06 开始，edge test 版本的 APT 源也会包含稳定版本的 Docker CE。\n\n#### 安装 Docker CE\n\n更新 apt 软件包缓存，并安装 `docker-ce`。\n\n```\n$ sudo apt-get update\n\n$ sudo apt-get install docker-ce\n```\n\n### 使用脚本自动安装\n\n在测试或开发环境中 Docker 官方为了简化安装流程，提供了一套便捷的安装脚本，Raspbian 系统上可以使用这套脚本安装：\n\n```\n$ curl -fsSL get.docker.com -o get-docker.sh\n$ sudo sh get-docker.sh --mirror Aliyun\n```\n\n执行这个命令后，脚本就会自动的将一切准备工作做好，并且把 Docker CE 的 Edge 版本安装在系统中。\n\n### 启动 Docker CE\n\n```\n$ sudo systemctl enable docker\n$ sudo systemctl start docker\n```\n\n### 建立 docker 用户组\n\n默认情况下，`docker` 命令会使用 [Unix socket](https://en.wikipedia.org/wiki/Unix_domain_socket) 与 Docker 引擎通讯。而只有 `root` 用户和 `docker` 组的用户才可以访问 Docker 引擎的 Unix socket。出于安全考虑，一般 Linux 系统上不会直接使用 `root` 用户。因此，更好地做法是将需要使用 `docker` 的用户加入 `docker` 用户组。\n\n建立 `docker` 组：\n\n```\n$ sudo groupadd docker\n```\n\n将当前用户加入 `docker` 组：\n\n```\n$ sudo usermod -aG docker $USER\n```\n\n退出当前终端并重新登录，进行如下测试。\n\n### 测试 Docker 是否安装正确\n\n```\n$ docker run arm32v7/hello-world\n\nUnable to find image 'hello-world:latest' locally\nlatest: Pulling from library/hello-world\nca4f61b1923c: Pull complete\nDigest: sha256:be0cd392e45be79ffeffa6b05338b98ebb16c87b255f48e297ec7f98e123905c\nStatus: Downloaded newer image for hello-world:latest\n\nHello from Docker!\nThis message shows that your installation appears to be working correctly.\n\nTo generate this message, Docker took the following steps:\n 1. The Docker client contacted the Docker daemon.\n 2. The Docker daemon pulled the \"hello-world\" image from the Docker Hub.\n (amd64)\n 3. The Docker daemon created a new container from that image which runs the\n executable that produces the output you are currently reading.\n 4. The Docker daemon streamed that output to the Docker client, which sent it\n to your terminal.\n\nTo try something more ambitious, you can run an Ubuntu container with:\n $ docker run -it ubuntu bash\n\nShare images, automate workflows, and more with a free Docker ID:\n https://cloud.docker.com/\n\nFor more examples and ideas, visit:\n https://docs.docker.com/engine/userguide/\n```\n\n若能正常输出以上信息，则说明安装成功。\n\n*注意：* ARM 平台不能使用 `x86` 镜像，查看 Raspbian 可使用镜像请访问 [arm32v7](https://hub.docker.com/u/arm32v7/)。\n\n### 镜像加速\n\n鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，强烈建议安装 Docker 之后配置 `国内镜像加速`。\n\n## 3.4 macOS 安装 Docker\n\n### 系统要求\n\n[Docker for Mac](https://docs.docker.com/docker-for-mac/) 要求系统最低为 macOS 10.10.3 Yosemite。如果系统不满足需求，可以安装 [Docker Toolbox](https://docs.docker.com/toolbox/overview/)。\n\n### 安装\n\n#### 使用 Homebrew 安装\n\n[Homebrew](http://brew.sh/) 的 [Cask](https://caskroom.github.io/) 已经支持 Docker for Mac，因此可以很方便的使用 Homebrew Cask 来进行安装：\n\n```\n$ brew cask install docker\n```\n\n#### 手动下载安装\n\n如果需要手动下载，请点击以下链接下载 [Stable](https://download.docker.com/mac/stable/Docker.dmg) 或 [Edge](https://download.docker.com/mac/edge/Docker.dmg) 版本的 Docker for Mac。\n\n如同 macOS 其它软件一样，安装也非常简单，双击下载的 `.dmg` 文件，然后将那只叫 [Moby](https://blog.docker.com/2013/10/call-me-moby-dock/) 的鲸鱼图标拖拽到 `Application` 文件夹即可（其间需要输入用户密码）。\n\n\n\n### 运行\n\n从应用中找到 Docker 图标并点击运行。\n\n\n\n运行之后，会在右上角菜单栏看到多了一个鲸鱼图标，这个图标表明了 Docker 的运行状态。\n\n\n\n第一次点击图标，可能会看到这个安装成功的界面，点击 “Got it!” 可以关闭这个窗口。\n\n\n\n以后每次点击鲸鱼图标会弹出操作菜单。\n\n\n\n启动终端后，通过命令可以检查安装后的 Docker 版本。\n\n```\n$ docker --version\nDocker version 17.10.0-ce, build f4ffd25\n$ docker-compose --version\ndocker-compose version 1.17.0-rc1, build a0f95af\n$ docker-machine --version\ndocker-machine version 0.13.0, build 9ba6da9\n```\n\n如果 `docker version`、`docker info` 都正常的话，可以尝试运行一个 [Nginx 服务器](https://store.docker.com/images/nginx/)：\n\n```\n$ docker run -d -p 80:80 --name webserver nginx\n```\n\n服务运行后，可以访问 [http://localhost](http://localhost/)，如果看到了 “Welcome to nginx!”，就说明 Docker for Mac 安装成功了。\n\n\n\n要停止 Nginx 服务器并删除执行下面的命令：\n\n```\n$ docker stop webserver\n$ docker rm webserver\n```\n\n### 镜像加速\n\n鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，强烈建议安装 Docker 之后配置 `国内镜像加速`。\n\n\n\n## 3.5 Windows 安装 Docker\n\n### 系统要求\n\n[Docker for Windows](https://docs.docker.com/docker-for-windows/install/) 支持 64 位版本的 Windows 10 Pro，且必须开启 Hyper-V。\n\n### 安装\n\n点击以下链接下载 [Stable](https://download.docker.com/win/stable/Docker%20for%20Windows%20Installer.exe) 或 [Edge](https://download.docker.com/win/edge/Docker%20for%20Windows%20Installer.exe) 版本的 Docker for Windows。\n\n下载好之后双击 Docker for Windows Installer.exe 开始安装。\n\n### 运行\n\n在 Windows 搜索栏输入 Docker 点击 Docker for Windows 开始运行。\n\n\n\nDocker CE 启动之后会在 Windows 任务栏出现鲸鱼图标。\n\n\n\n等待片刻，点击 Got it 开始使用 Docker CE。\n\n\n\n### 镜像加速\n\n鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，强烈建议安装 Docker 之后配置 `国内镜像加速`。\n\n## 3.6 Docker 镜像加速器\n\n国内从 Docker Hub 拉取镜像有时会遇到困难，此时可以配置镜像加速器。Docker 官方和国内很多云服务商都提供了国内加速器服务，例如：\n\n- [Docker 官方提供的中国 registry mirror](https://docs.docker.com/registry/recipes/mirror/#use-case-the-china-registry-mirror)\n- [阿里云加速器](https://cr.console.aliyun.com/#/accelerator)\n- [DaoCloud 加速器](https://www.daocloud.io/mirror#accelerator-doc)\n\n我们以 Docker 官方加速器为例进行介绍。\n\n### Ubuntu 14.04、Debian 7 Wheezy\n\n对于使用 [upstart](http://upstart.ubuntu.com/) 的系统而言，编辑 `/etc/default/docker` 文件，在其中的 `DOCKER_OPTS` 中配置加速器地址：\n\n```\nDOCKER_OPTS=\"--registry-mirror=https://registry.docker-cn.com\"\n```\n\n重新启动服务。\n\n```\n$ sudo service docker restart\n```\n\n### Ubuntu 16.04+、Debian 8+、CentOS 7\n\n对于使用 [systemd](https://www.freedesktop.org/wiki/Software/systemd/) 的系统，请在 `/etc/docker/daemon.json` 中写入如下内容（如果文件不存在请新建该文件）\n\n```json\n{\n \"registry-mirrors\": [\n \"https://registry.docker-cn.com\"\n ]\n}\n```\n\n> 注意，一定要保证该文件符合 json 规范，否则 Docker 将不能启动。\n\n之后重新启动服务。\n\n```shell\n$ sudo systemctl daemon-reload\n$ sudo systemctl restart docker\n```\n\n> 注意：如果您之前查看旧教程，修改了 `docker.service` 文件内容，请去掉您添加的内容（`--registry-mirror=https://registry.docker-cn.com`），这里不再赘述。\n\n### Windows 10\n\n对于使用 Windows 10 的系统，在系统右下角托盘 Docker 图标内右键菜单选择 `Settings`，打开配置窗口后左侧导航菜单选择 `Daemon`。在 `Registry mirrors`一栏中填写加速器地址 `https://registry.docker-cn.com`，之后点击 `Apply` 保存后 Docker 就会重启并应用配置的镜像地址了。\n\n### macOS\n\n对于使用 macOS 的用户，在任务栏点击 Docker for mac 应用图标 -> Perferences… -> Daemon -> Registry mirrors。在列表中填写加速器地址 `https://registry.docker-cn.com`。修改完成之后，点击 `Apply & Restart` 按钮，Docker 就会重启并应用配置的镜像地址了。\n\n### 检查加速器是否生效\n\n配置加速器之后，如果拉取镜像仍然十分缓慢，请手动检查加速器配置是否生效，在命令行执行 `docker info`，如果从结果中看到了如下内容，说明配置成功。\n\n```\nRegistry Mirrors:\n https://registry.docker-cn.com/\n```"
},
{
"path": "notes/Docker基础.md",
"content": "\n\n- [一、Docker 快速入门](#一docker-快速入门)\n - [初探 Docker](#初探-docker)\n - [什么是 Docker](#什么是-docker)\n - [为什么要使用 Docker](#为什么要使用-docker)\n - [CentOS 7 安装 Docker](#centos-7-安装-docker)\n - [Docker 镜像加速器](#docker-镜像加速器)\n - [Docker 常用命令](#docker-常用命令)\n - [1. 启动、停止、重启服务](#1-启动停止重启服务)\n - [2. 拉取一个镜像，启动容器](#2-拉取一个镜像启动容器)\n - [3. 启动的容器列表](#3-启动的容器列表)\n - [4. 查看所有的容器](#4-查看所有的容器)\n - [5. 启动、停止、重启某个容器](#5-启动停止重启某个容器)\n - [6. 查看指定容器的日志记录](#6-查看指定容器的日志记录)\n - [7. 删除某个容器，若正在运行，需要先停止](#7-删除某个容器若正在运行需要先停止)\n - [8. 删除容器](#8-删除容器)\n - [9. 删除镜像](#9-删除镜像)\n - [10. 删除虚悬镜像](#10-删除虚悬镜像)\n - [11. 镜像导入与导出](#11-镜像导入与导出)\n- [二、Docker File 镜像构建](#二docker-file-镜像构建)\n- [三、Docker Compose](#三docker-compose)\n - [docker-compose 命令安装](#docker-compose-命令安装)\n - [1. 安装 python-pip](#1-安装-python-pip)\n - [2. 安装 Docker-Compose](#2-安装-docker-compose)\n - [docker-compose.yml 规范](#docker-composeyml-规范)\n- [四、Docker 实战](#四docker-实战)\n - [实战1：快速搭建 MySQL](#实战1快速搭建-mysql)\n - [实战2：快速搭建 phpMyAdmin](#实战2快速搭建-phpmyadmin)\n - [实战3：快速搭建 GitLab](#实战3快速搭建-gitlab)\n- [参考资料](#参考资料)\n\n\n# 一、Docker 快速入门\n\n本文部分内容引用来自：【千锋-李卫民老师博客，推荐大家学习】http://www.funtl.com/\n\nA simple, interactive and fun playground to learn Docker：[Play with Docker](https://labs.play-with-docker.com/)\n\n\n## 初探 Docker\n\n### 什么是 Docker\n\n Docker 最初是 dotCloud 公司创始人 Solomon Hykes 在法国期间发起的一个公司内部项目，它是基于 dotCloud 公司多年云服务技术的一次革新，并于 [2013 年 3 月以 Apache 2.0 授权协议开源](https://en.wikipedia.org/wiki/Docker_(software))，主要项目代码在 [GitHub](https://github.com/moby/moby) 上进行维护。Docker 项目后来还加入了 Linux 基金会，并成立推动 [开放容器联盟（OCI）](https://www.opencontainers.org/)。\n\n Docker 自开源后受到广泛的关注和讨论，至今其 GitHub 项目已经超过 4 万 6 千个星标和一万多个 fork。甚至由于 Docker 项目的火爆，在 2013 年底，[dotCloud 公司决定改名为 Docker](https://blog.docker.com/2013/10/dotcloud-is-becoming-docker-inc/)。Docker 最初是在 Ubuntu 12.04 上开发实现的；Red Hat 则从 RHEL 6.5 开始对 Docker 进行支持；Google 也在其 PaaS 产品中广泛应用 Docker。\n\n Docker 使用 Google 公司推出的 [Go 语言](https://golang.org/) 进行开发实现，基于 Linux 内核的 [cgroup](https://zh.wikipedia.org/wiki/Cgroups)，[namespace](https://en.wikipedia.org/wiki/Linux_namespaces)，以及 [AUFS](https://en.wikipedia.org/wiki/Aufs) 类的 [Union FS](https://en.wikipedia.org/wiki/Union_mount) 等技术，对进程进行封装隔离，属于 [操作系统层面的虚拟化技术](https://en.wikipedia.org/wiki/Operating-system-level_virtualization)。由于隔离的进程独立于宿主和其它的隔离的进程，因此也称其为容器。最初实现是基于 [LXC](https://linuxcontainers.org/lxc/introduction/)，从 0.7 版本以后开始去除 LXC，转而使用自行开发的 [libcontainer](https://github.com/docker/libcontainer)，从 1.11 开始，则进一步演进为使用 [runC](https://github.com/opencontainers/runc) 和 [containerd](https://github.com/containerd/containerd)。\n\n Docker 在容器的基础上，进行了进一步的封装，从文件系统、网络互联到进程隔离等等，极大的简化了容器的创建和维护。使得 Docker 技术比虚拟机技术更为轻便、快捷。\n\n 下面的图片比较了 Docker 和传统虚拟化方式的不同之处。传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。\n\n\n\n\n\n### 为什么要使用 Docker\n\n\n\n 作为一种新兴的虚拟化方式，Docker 跟传统的虚拟化方式相比具有众多的优势。\n\n**更高效的利用系统资源**\n\n 由于容器不需要进行硬件虚拟以及运行完整操作系统等额外开销，Docker 对系统资源的利用率更高。无论是应用执行速度、内存损耗或者文件存储速度，都要比传统虚拟机技术更高效。因此，相比虚拟机技术，一个相同配置的主机，往往可以运行更多数量的应用。\n\n**更快速的启动时间**\n\n 传统的虚拟机技术启动应用服务往往需要数分钟，而 Docker 容器应用，由于直接运行于宿主内核，无需启动完整的操作系统，因此可以做到秒级、甚至毫秒级的启动时间。大大的节约了开发、测试、部署的时间。\n\n**一致的运行环境**\n\n 开发过程中一个常见的问题是环境一致性问题。由于开发环境、测试环境、生产环境不一致，导致有些 bug 并未在开发过程中被发现。而 Docker 的镜像提供了除内核外完整的运行时环境，确保了应用运行环境一致性，从而不会再出现 *「这段代码在我机器上没问题啊」* 这类问题。\n\n**持续交付和部署**\n\n 对开发和运维（[DevOps](https://zh.wikipedia.org/wiki/DevOps)）人员来说，最希望的就是一次创建或配置，可以在任意地方正常运行。\n\n 使用 Docker 可以通过定制应用镜像来实现持续集成、持续交付、部署。开发人员可以通过 `Dockerfile` 来进行镜像构建，并结合 [持续集成(Continuous Integration)](https://en.wikipedia.org/wiki/Continuous_integration) 系统进行集成测试，而运维人员则可以直接在生产环境中快速部署该镜像，甚至结合 [持续部署(Continuous Delivery/Deployment)](https://en.wikipedia.org/wiki/Continuous_delivery) 系统进行自动部署。\n\n 而且使用 `Dockerfile` 使镜像构建透明化，不仅仅开发团队可以理解应用运行环境，也方便运维团队理解应用运行所需条件，帮助更好的生产环境中部署该镜像。\n\n**更轻松的迁移**\n\n 由于 Docker 确保了执行环境的一致性，使得应用的迁移更加容易。Docker 可以在很多平台上运行，无论是物理机、虚拟机、公有云、私有云，甚至是笔记本，其运行结果是一致的。因此用户可以很轻易的将在一个平台上运行的应用，迁移到另一个平台上，而不用担心运行环境的变化导致应用无法正常运行的情况。\n\n**更轻松的维护和扩展**\n\n Docker 使用的分层存储以及镜像的技术，使得应用重复部分的复用更为容易，也使得应用的维护更新更加简单，基于基础镜像进一步扩展镜像也变得非常简单。此外，Docker 团队同各个开源项目团队一起维护了一大批高质量的 [官方镜像](https://store.docker.com/search?q=&source=verified&type=image)，既可以直接在生产环境使用，又可以作为基础进一步定制，大大的降低了应用服务的镜像制作成本。\n\n**对比传统虚拟机总结**\n\n| 特性 | 容器 | 虚拟机 |\n| ---------- | ------------------ | ----------- |\n| 启动 | 秒级 | 分钟级 |\n| 硬盘使用 | 一般为 `MB` | 一般为 `GB` |\n| 性能 | 接近原生 | 弱于 |\n| 系统支持量 | 单机支持上千个容器 | 一般几十个 |\n\n\n\n## CentOS 7 安装 Docker\n\n1. 先更新 yum 软件管理器，然后再安装 Docker\n\n```shell\n[root@localhost /] yum -y update\n[root@localhost /] yum install -y docker\n```\n\n 说明：上述 `-y` 代表选择程序安装中的 yes 选项\n\n 或是，直接安装 \n\n```shell\nyum install docker\n```\n\n2. 验证安装，查看 Docker 版本信息\n\n```shell\n[root@localhost /] docker -v\nDocker version 1.13.1, build 8633870/1.13.1\nYou have new mail in /var/spool/mail/root\n```\n\n3. 启动 / 重启 / 关闭 Docker \n\n```shell\n[root@localhost /] docker start\n[root@localhost /] docker restart\n[root@localhost /] docker stop\n```\n\n\n\n【意外情况】service docker start 无法启动问题\n\n- centos 安装 docker 显示 No package docker available，原因是 yum 没有找到 docker 的包，需要 epel 第三方软件库，运行下面的命令\n\n `sudo yum install epel-release`\n\n- [【亲测有效】Centos安装完成docker后启动docker报错docker](http://www.cnblogs.com/ECJTUACM-873284962/p/9362840.html)\n\n\n\n1. 配置yum源\n\n vim /etc/yum.repos.d/docker.repo\n\n```ini\n[dockerrepo]\nname=Docker Repository\nbaseurl=https://yum.dockerproject.org/repo/main/centos/$releasever/\nenabled=1\ngpgcheck=1\ngpgkey=https://yum.dockerproject.org/gpg\n```\n\n2. 通过yum安装\n\n```\nyum install docker-engine\nservice docker start\nservice docker status\n```\n\n3. 日志\n\n```\nvim /var/log/docker\n```\n\n\n\n在 Ubuntu 16.04 LTS 上 离线安装 Docker / Docker-compose - TonyZhang24 - 博客园\nhttps://www.cnblogs.com/atuotuo/p/9272368.html\n\n\n\n## Docker 镜像加速器\n\n1. 加速器服务\n\n [DaoCloud 加速器，一行命令，镜像万千](https://www.daocloud.io/mirror)\n\n [阿里云 - 开发者平台 - 容器 hub](https://dev.aliyun.com/search.html)\n\n2. 配置 Docker 加速器\n\n 以 Linux 为例\n\n```shell\ncurl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://f1361db2.m.daocloud.io\n```\n\n 该脚本可以将 --registry-mirror 加入到你的 Docker 配置文件 /etc/docker/daemon.json 中。适用于 Ubuntu14.04、Debian、CentOS6 、CentOS7、Fedora、Arch Linux、openSUSE Leap 42.1，其他版本可能有细微不同。更多详情请访问文档。\n\n 删除 /etc/docker/daemon.json 中最后一个逗号，重启 Docker 服务即可\n\n\n\n## Docker 常用命令\n\n\n\n### 1. 启动、停止、重启服务\n\n```shell\n[root@localhost ~]# service docker restart\nRedirecting to /bin/systemctl restart docker.service\n[root@localhost ~]# service docker stop\nRedirecting to /bin/systemctl stop docker.service\n[root@localhost ~]# service docker start\nRedirecting to /bin/systemctl start docker.service\n```\n\n### 2. 拉取一个镜像，启动容器\n\n```shell\n[root@localhost ~]# docker pull centos\n[root@localhost ~]# docker run -it -v /centos_dir:/docker_dir --name biodwhu-1 centos\n```\n\n- -i：允许我们对容器内的 (STDIN) 进行交互\n- -t：在新容器内指定一个伪终端或终端\n- -v：是挂在宿机目录， /centos_dir 是宿机目录，/docker_dir 是当前 Docker 容器的目录，宿机目录必须是绝对的。\n- -p：端口映射\n- --name：是给容器起一个名字，可省略，省略的话 docker 会随机产生一个名字\n\n- --restart：always\n\n### 3. 启动的容器列表\n\n```shell\n[root@localhost ~]# docker ps\n```\n\n### 4. 查看所有的容器\n\n```shell\n[root@localhost ~]# docker ps -a\n```\n\n### 5. 启动、停止、重启某个容器\n\n```shell\n[root@localhost ~]# docker start biodwhu-1\nbiodwhu-1\n[root@localhost ~]# docker stop biodwhu-2\nbiodwhu-2\n[root@localhost ~]# docker restart biodwhu-3\nbiodwhu-3\n```\n\n### 6. 查看指定容器的日志记录\n\n```shell\n[root@localhost ~]# docker logs -f biodwhu-1\n```\n\n### 7. 删除某个容器，若正在运行，需要先停止\n\n```shell\n[root@localhost ~]# docker rm biodwhu-1\nError response from daemon: You cannot remove a running container 2d48fc5b7c17b01e6247cbc012013306faf1e54f24651d5e16d6db4e15f92d33. Stop the container before attempting removal or use -f\n[root@localhost ~]# docker stop biodwhu-1\nbiodwhu-1\n[root@localhost ~]# docker rm biodwhu-1\nbiodwhu-1\n```\n\n### 8. 删除容器\n\n```shell\n# 删除某个容器\n[root@localhost ~]# docker rm f3b346204a39\n\n# 删除所有容器\n[root@localhost ~]# docker stop $(docker ps -a -q)\n[root@localhost ~]# docker rm $(docker ps -a -q)\n```\n\n### 9. 删除镜像\n\n```shell\n# 删除某个镜像\n[root@localhost ~]# docker rmi docker.io/mysql:5.6\n\n# 删除所有镜像\n[root@localhost ~]# docker rmi $(docker images -q)\n\n# 强制删除所有镜像\n[root@localhost ~]# docker rmi -f $(docker images -q)\n```\n\n### 10. 删除虚悬镜像\n\n我们在 build 镜像的过程中，可能会产生一些临时的不具有名称也没有作用的镜像他们的名称一般都是 `` ,我们可以执行下面的命令将其清除掉：\n\n```shell\n[root@localhost ~]# docker rmi $(docker images -f \"dangling=true\" -q)\n# 或者\n[root@localhost ~]# docker image prune -a -f\n```\n\n### 11. 镜像导入与导出\n\n保存镜像\n\n```shell\n[root@localhost ~]# docker save a46c2a2722b9 > /var/docker/images_save/mysql.tar.gz\n```\n\n加载镜像\n\n```shell\n[root@localhost ~]# docker load -i /var/docker/images_save/mysql.tar.gz\n```\n\n\n\n\n\n# 二、Docker File 镜像构建\n\n# 三、Docker Compose\n\n## docker-compose 命令安装\n\nDocker-Compose 是一个部署多个容器的简单但是非常必要的工具.\n\n安装 Docker-Compose 之前，请先安装 python-pip\n\n### 1. 安装 python-pip\n\n1. 首先检查 Linux 有没有安装 python-pip 包，终端执行 pip -v\n\n```shell\n[root@localhost ~]# pip -V\n-bash: pip: command not found\n```\n\n2. 没有 python-pip 包就执行命令\n\n```shell\n[root@localhost ~]# yum -y install epel-release\n```\n\n3. 执行成功之后，再次执行\n\n```shell\n[root@localhost ~]# yum -y install python-pip\n```\n\n4. 对安装好的 pip 进行升级\n\n```shell\n[root@localhost ~]# pip install --upgrade pip\n```\n\n### 2. 安装 Docker-Compose\n\n1. 终端执行\n\n```shell\n[root@localhost ~]# pip install docker-compose\n```\n\n2. 检查 docker-compose 安装\n\n```shell\n[root@localhost ~]# docker-compose -version\n```\n\n参考资料：\n\n- [CentOS7下安装Docker-Compose - YatHo - 博客园](https://www.cnblogs.com/YatHo/p/7815400.html)\n\n## docker-compose.yml 规范\n\n\n\n\n\n\n\n# 四、Docker 实战\n\n## 实战1：快速搭建 MySQL\n\n- 官方镜像仓库\n\n [https://hub.docker.com/_/mysql/](https://hub.docker.com/_/mysql/)\n\n- docker-compose.yml\n\n```yml\nversion: '3.1'\nservices:\n mysql:\n restart: always\n image: mysql:5.6\n container_name: mysql\n ports:\n - 3306:3306\n environment:\n TZ: Asia/Shanghai\n MYSQL_ROOT_PASSWORD: 123456\n command:\n --character-set-server=utf8mb4\n --collation-server=utf8mb4_general_ci\n --explicit_defaults_for_timestamp=true\n --lower_case_table_names=1\n --max_allowed_packet=128M\n --sql-mode=\"STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION,NO_ZERO_DATE,NO_ZERO_IN_DATE,ERROR_FOR_DIVISION_BY_ZERO\"\n volumes:\n - /usr/local/docker/mysql/mysql-data:/var/lib/mysql\n```\n\n\n\n## 实战2：快速搭建 phpMyAdmin\n\n- 官方镜像仓库\n\n [phpmyadmin/phpmyadmin](phpmyadmin/phpmyadmin)\n\n- docker-compose.yml\n\n```yml\nversion: '3.1'\nservices:\n phpmyadmin:\n image: phpmyadmin/phpmyadmin\n container_name: phpmyadmin\n environment:\n - PMA_ARBITRARY=1\n - PMA_HOST=120.92.17.12\n # - PMA_PORT=3306\n # - PMA_USER=xxx\n # - PMA_PASSWORD=xxx\n restart: always\n ports:\n - 6060:80\n volumes:\n - /sessions\n```\n\n\n\n\n\n## 实战3：快速搭建 GitLab\n\nGitLab 使用163邮箱发送邮件 - 刘锐群的笔记 - CSDN博客\nhttps://blog.csdn.net/liuruiqun/article/details/50000213\n\n\n\ngitlab服务器邮箱配置 - weifengCorp - 博客园\nhttps://www.cnblogs.com/weifeng1463/p/8489563.html\n\n\n\ntwang2218/gitlab-ce-zh - Docker Hub\nhttps://hub.docker.com/r/twang2218/gitlab-ce-zh/\n\n```yml\nversion: '3'\nservices:\n web:\n image: 'twang2218/gitlab-ce-zh:10.5'\n restart: always\n hostname: '120.131.11.187'\n environment:\n TZ: 'Asia/Shanghai'\n GITLAB_OMNIBUS_CONFIG: |\n external_url 'http://120.131.11.187:3000'\n gitlab_rails['gitlab_shell_ssh_port'] = 2222\n unicorn['port'] = 8888\n nginx['listen_port'] = 3000\n ports:\n - '3000:3000'\n - '8443:443'\n - '2222:22'\n volumes:\n - /usr/local/docker/gitlab/config:/etc/gitlab\n - /usr/local/docker/gitlab/data:/var/opt/gitlab\n - /usr/local/docker/gitlab/logs:/var/log/gitlab\n```\n\n\n\n\n\n\n\n\n\n\n\n# 参考资料\n\n- [docker前后分离笔记 - 小翼的前端天地](https://my-fe.pub/post/docker-front-and-backend-separation.html#toc-619)\n"
},
{
"path": "notes/Docker实战.md",
"content": "# Docker实战系列\n\n## Docker搭建自己的Gitlab CI Runner\n\n> 这里主要将采用 docker 镜像方式安装\n>\n\n1. 拉取gitlab-runner镜像\n\n```\ndocker pull gitlab/gitlab-runner:latest\n```\n\n2. 添加 gitlab-runner container\n\n```\nsudo docker run -d --name gitlab-runner --restart always \\\n -v /srv/gitlab-runner/config:/etc/gitlab-runner \\\n -v /var/run/docker.sock:/var/run/docker.sock \\\n gitlab/gitlab-runner:latest\n \n sudo docker run -d --restart always \\\n -v /srv/gitlab-runner/config:/etc/gitlab-runner \\\n -v /var/run/docker.sock:/var/run/docker.sock \\\n gitlab/gitlab-runner:latest\n```\n\n3. 注册runner\n\n```\nsudo docker exec -it gitlab-runner gitlab-ci-multi-runner register\n```\n\n4. 注册\n\n```shell\nsudo docker exec -it gitlab-runner gitlab-ci-multi-runner register\n```\n\n\n\n\n\n\n\nsudo docker run -d --name gitlab-runner --restart always \\\n -v /srv/gitlab-runner/config:/etc/gitlab-runner \\\n -v /var/run/docker.sock:/var/run/docker.sock \\\n gitlab/gitlab-runner:latest\n\n\n\n\n\n\n\n\n\n\n\n\n\n[Docker搭建自己的Gitlab CI Runner - 哎_小羊的博客 - CSDN博客](https://blog.csdn.net/aixiaoyang168/article/details/72168834)\n"
},
{
"path": "notes/EalsticSearch/Untitled.md",
"content": "elasticsearch-head的使用 - 仅此而已-远方 - 博客园\nhttps://www.cnblogs.com/xuwenjin/p/8792919.html\n\n\n\n\n\ntyrival/gitbook: Logstash + Elasticsearch 6.7 用户指南中文版\nhttps://github.com/tyrival/gitbook\n\n\n\n\n\nMac下ElasticSearch安装 - 简书\nhttps://www.jianshu.com/p/df4af12a420a\n\n\n\n\n\n## 安装\n\nLogstash在Linux上安装部署 - haw2106 - 博客园\nhttps://www.cnblogs.com/haw2106/p/10410916.html\n\nElasticSearch在linux上安装部署 - socket强 - 博客园\nhttps://www.cnblogs.com/socketqiang/p/11363024.html\n\n详解Docker下使用Elasticsearch可视化Kibana_docker_脚本之家\nhttps://www.jb51.net/article/138582.htm\n\n\n\n\n\ndocker下载镜像报net/http: TLS handshake timeout-西风未眠-51CTO博客\nhttps://blog.51cto.com/10950710/2122702\n\n\n\nDocker安装部署ELK教程 (Elasticsearch+Kibana+Logstash+Filebeat) - 万能付博 - 博客园\nhttps://www.cnblogs.com/fbtop/p/11005469.html\n\n\n\n\n\n1.拉取镜像\n\n```\ndocker pull elasticsearch:6.5.4\ndocker pull kibana:6.5.4\n```\n\n \n\n2.启动容器\n\n```\ndocker run -d --name es1 -p 9200:9200 -p 9300:9300 -e \"discovery.type=single-node\" elasticsearch:6.5.4\ndocker run -d -p 5601:5601 --name kibana --link es1:elasticsearch kibana:6.5.4\n```"
},
{
"path": "notes/FastDFS.md",
"content": "# FastDFS\n\n手把手教你搭建分布式文件存储系统\n\n\n\n用FastDFS一步步搭建文件管理系统 - bojiangzhou - 博客园\nhttps://www.cnblogs.com/chiangchou/p/fastdfs.html\n\n"
},
{
"path": "notes/Frontend/Angular.md",
"content": "# Angular\n\n## 1. 框架背景\n\nAngular 是一个由 Google维护的开源JavaScript框架，用于在HTML和JavaScript中构建Web应用程序，是三大框架之首。\n\n不管是1还是2，Angular最显著的特征就是其**整合性**。涵盖了M、V、C/VM等各个层面，不需要组合、评估其它技术就能完成大部分前端开发任务。这样可以有效降低决策成本，提高决策速度，对需要快速起步的团队是非常有帮助的。\n\n由于它是从一个用来做原型的框架演化而来的，加上诞生时间很早（2009年，作为对比，jQuery诞生于2006年），当时生态不完善，连模块化机制都得自己实现。\n\n但Angular 2就不同了，发布于2016年9月份，它是基于ES6来开发的，它的起点更高，整合了现代前端的各种先进理念，在框架、文档、工具等各个层面提供了全方位的支持\n\n在Angular 中最具特色的就是**依赖注入**系统了，它把后端开发中用来解决复杂问题、实现高弹性设计的技术引入了前端\n\n\n\n## 2. Angular CLI\n\n### \t2.1 安装\n\n\tAngular CLI用于简单，快速构建Angular2项目，只要掌握几行命令就能扣减前端架构。依赖于NodeJs和npm。\n\n```jsx\n//安装脚手架\nnpm install -g angular-cli\n//创建项目\nng new project_name(项目名称)\n//启动项目\ncd project_name\nng serve --open \n```\n\n \n\n### \t2.2 主要特性\n\n1. Angular CLI 可以快速搭建框架，创建module，service，class，directive等；\n2. 具有webpack的功能，代码分割，按需加载；\n3. 代码打包压缩；\n4. 模块测试；\n5. 热部署，有改动立即重新编译，不用刷新浏览器；而且速度很快\n6. 有开发环境，测试环境，生产环境的配置，不用自己操心； \n7. sass，less的预编译Angular CLI都会自动识别后缀来编译；\n8. typescript的配置，Angular CLI在创建应用时都可以自己配置；\n9. 在创建好的工程也可以做一些个性化的配置，webpack的具体配置还不支持，未来可能会增加；\n10. Angular CLI创建的工程结构是最佳实践，生产可用；\n\n\n\n### \t2.3 创建module，component，service，class\n\n\n\n \n\n## 3. 架构\n\n### \t3.1 模块\n\n\t\t模块组件的特征在于可以用于执行单个任务的代码块。 您可以从代码(类)中导出值。 Angular应用程序被称为模块，并使用许多模块构建您的应用程序。 Angular 的基本构建块是可以从模块导出的**组件**类。\n\n```js\nexport class AppComponent {\n title = '朝夕教育';\n}\n\n```\n\n### \t3.2 组件\n\n组件是拥有模板的控制器类，主要处理页面上的应用程序和逻辑的视图。 组件可以拥有独立的样式。\n注册组件，使用 *@Component* 注释，可以将应用程序拆分为更小的部分。\n\n#### 3.2.1 创建组件\n\n使用ng命令`ng generate component `创建的组件会自动生成在`app.module`中的引用，推荐使用ng命令生成组件\n\n```jsx\n//快速创建\nng g c xxx\n```\n\n```jsx\n@Component({\n selector: 'app-root',\n templateUrl: './app.component.html',\n styleUrls: ['./app.component.scss']\n})\n```\n\n@Component最常用的几个选项:\n\n**selector**：这个 CSS 选择器用于在模板中标记出该指令，并触发该指令的实例化。\n\n**template**：组件的内联模板\n\n**templateUrl**：组件模板文件的 URL\n\n**styleUrls**：组件样式文件\n\n**styles**：组件内联样式\n\n\n\n#### 3.2.2 组件生命周期\n\n\tAngular 会按以下顺序执行钩子方法。你可以用它来执行以下类型的操作。\n\n| 钩子方法 | 用途 | 时机 |\n| :------------------------ | :----------------------------------------------------------- | :----------------------------------------------------------- |\n| `ngOnChanges()` | 当 Angular 设置或重新设置数据绑定的输入属性时响应。 该方法接受当前和上一属性值的 `SimpleChanges` 对象注意，这发生的非常频繁，所以你在这里执行的任何操作都会显著影响性能。 | 在 `ngOnInit()` 之前以及所绑定的一个或多个输入属性的值发生变化时都会调用。注意，如果你的组件没有输入，或者你使用它时没有提供任何输入，那么框架就不会调用 `ngOnChanges()`。 |\n| `ngOnInit()` | 在 Angular 第一次显示数据绑定和设置指令/组件的输入属性之后，初始化指令/组件。 | 在第一轮 `ngOnChanges()` 完成之后调用，只调用**一次**。 |\n| `ngDoCheck()` | 检测，并在发生 Angular 无法或不愿意自己检测的变化时作出反应。 | 紧跟在每次执行变更检测时的 `ngOnChanges()` 和 首次执行变更检测时的 `ngOnInit()` 后调用。 |\n| `ngAfterContentInit()` | 当 Angular 把外部内容投影进组件视图或指令所在的视图之后调用。 | 第一次 `ngDoCheck()` 之后调用，只调用一次。 |\n| `ngAfterContentChecked()` | 每当 Angular 检查完被投影到组件或指令中的内容之后调用 | `ngAfterContentInit()` 和每次 `ngDoCheck()` 之后调用 |\n| `ngAfterViewInit()` | 当 Angular 初始化完组件视图及其子视图或包含该指令的视图之后调用 | 第一次 `ngAfterContentChecked()` 之后调用，只调用一次。 |\n| `ngAfterViewChecked()` | 每当 Angular 做完组件视图和子视图或包含该指令的视图的变更检测之后调用。 | `ngAfterViewInit()` 和每次 `ngAfterContentChecked()` 之后调用。 |\n| `ngOnDestroy()` | 每当 Angular 每次销毁指令/组件之前调用并清扫。 在这儿反订阅可观察对象和分离事件处理器，以防内存泄漏 | 在 Angular 销毁指令或组件之前立即调用。 |\n\n#### 3.2.3 组件交互\n\n1. \t**@Input**\n\n 父组件通过`@Input`给子组件绑定属性设置输入类数据\n\n ```jsx\n //父组件\n 获取 \n \n \n @ViewChild('myChild') child: any;\n constructor() { }\n \n ngOnInit(): void {\n }\n getView(e:any){\n console.log(this.child)\n this.child.setInpValue('我是一段数据')\n }\n ```\n\n \n\n### \t3.3 模板\n\n在 Angular 中，**模板**就是一块 HTML。在模板中，你可以通过一种特殊语法来使用 Angular 的许多功能\n\n#### \t3.3.1 插值语法\n\n\t\t所谓 \"插值\" 是指将表达式嵌入到标记文本中。 默认情况下，插值会用双花括号 `{{` 和 `}}` 作为分隔符\t\t\n\n```js\nhello {{ name }} \n```\n\n\t\t花括号之间的文本通常是组件属性的名字。Angular 会把这个名字替换为响应组件属性的字符串值\n\n\t\t括号间的素材是一个**模板表达式**我们可以在`{{}}`内编写js运算\n\n```jsx\nhello {{ 1+1 }} \n```\n\n#### \t3.3.2 属性绑定\n\n1. **Attribute绑定**\n\n ```jsx\n hello {{ 1+1 }} \n ```\n\n2. **类绑定**\n\n ```jsx\n //单一类绑定\n hello {{ 1+1 }} \n \n //多重类绑定\n hello {{ 1+1 }} \n hello {{ 1+1 }} \n hello {{ 1+1 }} \n \n //ngClass\n export class AppComponent {\n isActive = true;\n }\n \n hello {{ 1+1 }} \n \n ```\n\n3. **样式绑定**\n\n ```jsx\n //单一样式绑定\n hello {{ 1+1 }} \n \n //带单位的单一样式绑定\n hello {{ 1+1 }} \n \n //多重样式绑定\n hello {{ 1+1 }} \n hello {{ 1+1 }} \n \n //ngStyle\n export class AppComponent {\n isMax = false;\n }\n hello {{ 1+1 }} \n hello {{ 1+1 }} \n ```\n\n#### \t3.3.3 条件判断\n\n\t\t\t ***ngIf**是直接影响元素是否被渲染，而非控制元素的显示和隐藏\n\n```jsx\nexport class AppComponent {\n isMax = false;\n isMin = false;\n}\nMax title
\nMin title
\n\n//解析完\n\n Max title
\n \n\n\n isMax为true\n \n\n isMax为false\n \n```\n\n#### 3.3.4 循环语句\n\n\t解析器会把 `let color`、`let i` 和 `let odd` 翻译成命名变量 `color`、`i` 和 `odd`\n\n微语法解析器接收of，会将它的首字母大写(Of)，然后加上属性的指令名(ngFor)前缀，它最终生成的名字是 ngFor 的输入属性(colors)\n\n`NgFor` 指令在列表上循环，每个循环中都会设置和重置它自己的上下文对象上的属性。 这些属性包括 `index` 和 `odd` 以及一个特殊的属性名 `$implicit`(隐式变量)\n\nAngular 将 let-color 设置为此上下文中 $implicit 属性的值， 它是由 NgFor 用当前迭代中的 colors 初始化的\n\n```jsx\nexport class AppComponent {\n colors:Array = [ 'red', 'blue', 'yellow', 'green' ];\n}\n\n\n {{odd}}\n {{i}}\n {{color}}\n
\n\n//解析完\n\n {{odd}} {{i}} {{color}}
\n \n```\n\n```jsx\nexport class AppComponent {\n status = 1;\n}\n\n \n 已支付 \n 订单已经确认 \n 已发货 \n 无效 \n \n```\n\n#### \t3.3.5 事件绑定\n\n\t\t Angular 的事件绑定语法由等号左侧括号内的目标事件名和右侧引号内的模板语句组成。目标事件名是 `click` ，模板语句是 `onSave()` \n\n事件对象通过`$event`传递\n\n```jsx\nexport class AppComponent {\n onSave(){\n console.log('点击了按钮')\n }\n}\n\nSave \n```\n\n#### \t3.3.6 双向绑定\n\n双向绑定是应用中的组件共享数据的一种方式。使用双向绑定绑定来侦听事件并在父组件和子组件之间同步更新值\n\nngModel指令**只对表单元素有效**，所以在使用之前需要导入`FormsModule`板块\n\n```jsx\nimport { FormsModule } from '@angular/forms';\n\n@NgModule({\n // 申明组件内用到的视图\n declarations: [\n AppComponent,\n HelloComponent,\n ],\n //引入模块需要的类\n imports: [\n BrowserModule,\n AppRoutingModule,\n FormsModule\n ],\n //全局服务\n providers: [],\n //根组件\n bootstrap: [AppComponent]\n})\n```\n\n```jsx\nexport class AppComponent {\n userName='';\n}\n\n 输入:
你输入了: {{userName}} \n\n```\n\n#### \t3.3.7 模板引用变量\n\n模板变量可以帮助你在模板的另一部分使用这个部分的数据。使用模板变量，你可以执行某些任务，比如响应用户输入或微调应用的表单\n\n在模板中，要使用井号 `#` 来声明一个模板变量。下列模板变量 `#userName` 语法在 `Call \n\n\nexport class AppComponent {\n callUserName(v){\n console.log(v)\n }\n}\n```\n\nAngular 根据你所声明的变量的位置给模板变量赋值：\n\n- 如果在组件上声明变量，该变量就会引用该组件实例。\n- 如果在标准的 HTML 标记上声明变量，该变量就会引用该元素。\n- 如果你在 `` 元素上声明变量，该变量就会引用一个 `TemplateRef` 实例来代表此模板。\n\n#### 3.3.8 表单控件\n\n使用表单控件有三个步骤。\n\n1. 在你的应用中注册响应式表单模块。该模块声明了一些你要用在响应式表单中的指令。\n2. 生成一个新的 `FormControl` 实例，并把它保存在组件中。\n3. 在模板中注册这个 `FormControl`。\n\n**注册响应式表单模块**\n\n要使用响应式表单控件，就要从 `@angular/forms` 包中导入 `ReactiveFormsModule`，并把它添加到你的 NgModule 的 `imports` 数组中。\n\n```js\nimport { ReactiveFormsModule } from '@angular/forms';\n\n@NgModule({\n imports: [\n // other imports ...\n ReactiveFormsModule\n ],\n})\nexport class AppModule { }\n```\n\n要注册一个表单控件，就要导入 `FormControl` 类并创建一个 `FormControl` 的新实例，将其保存为类的属性。\n\n```js\nimport { Component } from '@angular/core';\nimport { FormControl } from '@angular/forms';\n\n@Component({\n selector: 'app-name-editor',\n templateUrl: './name-editor.component.html',\n styleUrls: ['./name-editor.component.css']\n})\nexport class NameEditorComponent {\n name = new FormControl('');\n}\n\n//使用这种模板绑定语法，把该表单控件注册给了模板中名为 name 的输入元素。这样，表单控件和 DOM 元素就可以互相通讯了：视图会反映模型的变化，模型也会反映视图中的变化\n\n\n Name:\n \n\n Value: {{ name.value }}\n
\n```\n\n修改name值可以通过`FormControl` 提供的 `setValue()` 方法\n\n```js\nupdateName() {\n this.name.setValue('Tina');\n}\n```\n\n#### 3.3.9 表单控件分组\n\n表单中通常会包含几个相互关联的控件。响应式表单提供了两种把多个相关控件分组到同一个输入表单中的方法\n\n要将表单组添加到此组件中，请执行以下步骤。\n\n1. 创建一个 `FormGroup` 实例。\n2. 把这个 `FormGroup` 模型关联到视图。\n3. 保存表单数据。\n\n**创建一个 FormGroup 实例**\n\n在组件类中创建一个名叫 `loginForm` 的属性，并设置为 `FormGroup` 的一个新实例。要初始化这个 `FormGroup`，请为构造函数提供一个由控件组成的对象，对象中的每个名字都要和表单控件的名字一一对应\n\n```js\nimport { Component } from '@angular/core';\nimport { FormGroup, FormControl } from '@angular/forms';\n\n@Component({\n selector: 'app-profile-editor',\n templateUrl: './profile-editor.component.html',\n styleUrls: ['./profile-editor.component.css']\n})\nexport class ProfileEditorComponent {\n loginForm = new FormGroup({\n userName: new FormControl(''),\n password: new FormControl(''),\n });\n}\n\n//模板渲染\n\n```\n\n\n\n#### \t3.3.10 表单验证 \n\n\t表单元素添加`required`关键字表示必填，通过绑定`ngModel`的引用可以拿到到当前组件的信息，通过引用获取到验证的信息\n\n```jsx\nexport class AppComponent {\n fromData={\n name:'',\n password:''\n };\n\n subBtnFUn(obj){\n console.log(obj)\n }\n}\n\n\n```\n\n我们还可以通过 **ngModel** 跟踪修改状态与有效性验证，它使用了三个 CSS 类来更新控件，以便反映当前状态。\n\n| 状态 | 为 true 时的类 | 为 false 时的类 |\n| :--------------- | :------------- | :-------------- |\n| 控件已经被访问过 | `ng-touched` | `ng-untouched` |\n| 控件值已经变化 | `ng-dirty` | `ng-pristine` |\n| 控件值是有效的 | `ng-valid` | `ng-invalid` |\n\n#### \t3.3.11 自定义表单验证\n\n\t先引入表单的一些内置依赖\n\n```js\nimport { FormGroup, FormBuilder,Validators } from '@angular/forms';\n\n//构造函数里注入FormBuilder\nconstructor(private fb:FormBuilder) { }\n\n//错误提醒数据\nformErrors = {\n 'title': '',\n 'content': ''\n};\n\n\n//在组件类的初始化函数里对表单中的元素的校验进行定义，并调用表单的valueChanges方法，检测表单的输入的变化\nngOnInit():void {\n this.taskInfo.isComplete = 1;\n this.tasksForm = this.fb.group({\n userName: ['', [Validators.required,\n \t\t\t\t Validators.maxLength(18),\n Validators.minLength(6) ] ],\n password: ['', [this.passWordVal]],\n phone: ['', [Validators.required,this.phoneVal],]\n });\n\n phoneVal(phone: FormControl): object {\n const value = phone.value || '';\n if(!value) return {desc:'请输入手机号'}\n const valid = /[0-9]{11}/.test(value);\n return valid ? {} :{desc:'联系电话必须是11位数字'}\n }\n passWordVal(password:FormControl):object{\n const value = password.value || '';\n const valid = value.match(/^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{6,20}$/);\n return valid ? {} : {passwordValidator: {desc:'密码至少包含 数字和英文，长度6-20'}}\n }\n}\n```\n\n#### 3.3.12 管道\n\n\t管道的作用就是传输。不同的管道具有不同的作用。(其实就是处理数据)\n\n`angular`中自带的`pipe`函数\n\n| 管道 | 功能 |\n| ------------- | ------------------------------------------------------------ |\n| DatePipe | 日期管道，格式化日期 |\n| JsonPipe | 将输入数据对象经过JSON.stringify()方法转换后输出对象的字符串 |\n| UpperCasePipe | 将文本所有小写字母转换成大写字母 |\n| LowerCasePipe | 将文本所有大写字母转换成小写字母 |\n| DecimalPipe | 将数值按照特定的格式显示文本 |\n| CurrentcyPipe | 将数值进行货币格式化处理 |\n| SlicePipe | 将数组或者字符串裁剪成新子集 |\n| PercentPipe | 将数值转百分比格式 |\n\n`pipe`用法\n\n- {{ 输入数据 | 管道 : 管道参数}} (其中‘|’是管道操作符)\n\n- 链式管道 {{ 输入数据 | date | uppercase}}\n\n- 管道流通方向自左向右，逐层执行\n\n 使用脚手架命令：**ng g p test**\n\n ```js\n import { Pipe, PipeTransform } from '@angular/core';\n \n @Pipe({\n name: 'testTitle'\n })\n export class TestPipe implements PipeTransform {\n \n transform(value: unknown, ...args: unknown[]): unknown {\n console.log(value)\n return 'title';\n }\n }\n \n \n {{ 'Angular' | testTitle }}
\n \n ```\n\n \n\n### \t3.4 服务\n\n angular中，把从组件内抽离出来的代码叫服务，服务的本质就是函数\n\n 官方认为组件不应该直接获取或保存数据， 它们应该聚焦于展示数据，而把数据访问的职责委托给某个服务。而服务就充当着数据访问，逻辑处理的功能。把组件和服务区分开，以提高模块性和复用性。通过把组件中和视图有关的功能与其他类型的处理分离开，可以让组件类更加精简、高效。\n\n使用命令ng g s xxx创建一个服务，通过**@Injectable()**装饰器标识服务。\n\n```js\n//导入Injectable装饰器\nimport { Injectable } from '@angular/core';\n//使用Injectable装饰器声明服务\n@Injectable({\n //作用域设定，'root'表示默认注入，注入到AppModule里\n providedIn: 'root',\n})\nexport class TestService {\n}\n\n```\n\n组件中如何使用服务呢，必须将服务依赖注入系统、组件或者模块，才能够使用服务。我们可以用**注册提供商**和**根注入器**实现**。**\n\n 该服务本身是 CLI 创建的一个类，并且加上了 `@Injectable()` 装饰器。默认情况下，该装饰器是用 `providedIn` 属性进行配置的，它会为该服务创建一个提供商。\n\n\n\n### 3.5 依赖注入\n\n\t在这个例子中，`providedIn: 'root'` 指定 Angular 应该在根注入器中提供该服务,从而实现**根注入器**将服务注入，它就在整个应用程序中可用了**。**\n\n**providedIn**：\n\n\t'root' ：注入到AppModule，提供该服务，所有子组件都可以使用（推荐）\n\n\tnull ： 不设定服务作用域（不推荐）\n\n\t组件名：只作用于该组件（懒加载模式）\n\n```js\n\nimport { Injectable } from '@angular/core';\n\n@Injectable({\n providedIn: 'root',\n})\nexport class TestService {\n}\n\n\nimport { Component, OnInit } from '@angular/core';\nimport {HeroService} from '../hero.service'\n\n@Component({\n selector: 'app-test',\n templateUrl: './test.component.html',\n styleUrls: ['./test.component.scss'],\n})\nexport class TestComponent implements OnInit {\n\n constructor(private heroService:HeroService) { }\n\n ngOnInit(): void {\n console.log(this.heroService.getHeroList())\n }\n}\n```\n\n\t也可以使用 `@Component` 或 `@Directive` 内部的 `providers: []`，为特定的组件子树提供服务，这也将导致创建多个服务实例(每个组件使用一个服务实例)\n\n```js\n\nimport { Injectable } from '@angular/core';\n\n@Injectable({\n providedIn: 'root',\n})\nexport class TestService {\n}\n\n\nimport { Component, OnInit } from '@angular/core';\nimport {HeroService} from '../hero.service'\n\n@Component({\n selector: 'app-test',\n templateUrl: './test.component.html',\n styleUrls: ['./test.component.scss'],\n providers: [HeroService]\n})\nexport class TestComponent implements OnInit {\n\n constructor(private heroService:HeroService) { }\n\n ngOnInit(): void {\n console.log(this.heroService.getHeroList())\n }\n}\n```\n\n\n\n### 3.6 路由\n\n\t路由就是连接组件的筋络,它也是树形结构的.有了它,就可以在angular中实现路径的导航模式\n\n可以把路由看成是一组规则,它决定了url的变化对应着哪一种状态,具体表现就是不同视图的切换\n\n在angular中,路由是非常重要的组成部分, 组件的实例化与销毁,模块的加载,组件的某些生命周期钩子的发起,都是与它有关\n\n#### 3.6.1 路由基本使用\n\n**路由器**是一个调度中心,它是一套规则的列表,能够查询当前URL对应的规则,并呈现出相应的视图.\n\n**路由**是列表里面的一个规则,即路由定义,它有很多功能字段:\n\n- **path**字段,表示该路由中的URL路径部分\n- **Component**字段,表示与该路由相关联的组件\n\n每个带路由的Angular应用都有一个路由器服务的单例对象,通过路由定义的列表进行配置后使用。\n\n```js\nimport { NgModule } from '@angular/core';\nimport { RouterModule, Routes } from '@angular/router';\nimport {HomeComponent} from './home/home.component'\n\nconst routes: Routes = [\n {path:'home',component:HomeComponent}\n];\n\n@NgModule({\n imports: [RouterModule.forRoot(routes)],\n exports: [RouterModule]\n})\nexport class AppRoutingModule { }\n\n```\n\n```jsx\n//路由导航 \nhome \n hello \n\n//组件渲染输出\nhome Component \nhello \napp Component \nhello \nhello \n ```\n\n ```js\n import {ActivatedRoute} from '@angular/router';\n constructor(private routerinfo:ActivatedRoute) { }\n \n ngOnInit() {\n //id为参数名字\n this.id=this.routerinfo.snapshot.queryParams[\"id\"]\n }\n ```\n\n \n\n- **params**\n\n 修改路由配置文件`path`,路由导航`a`标签`routerLink`后面数组的第二个参数为传递的值\n\n 并且通过`subscribe`请阅的方式获取`name`参数\n\n ```js\n {\n path: 'hello/:name',\n component:HelloComponent,\n },\n ```\n\n ```jsx\n //我们在后面添加/:name此时name即为传递的参数名字\n //a标签设置如下\n hello \n ```\n\n ```js\n ngOnInit() {\n this.routerinfo.params.subscribe((params:Params)=>{\n this.name=params['name']\n })\n }\n ```\n\n"
},
{
"path": "notes/Frontend/README.md",
"content": "这里将是前端相关的项目目录"
},
{
"path": "notes/Frontend/assets/README.md",
"content": "这里是图片目录"
},
{
"path": "notes/Frontend/前端知识体系.md",
"content": "\n\n- [前端知识体系](#前端知识体系)\n - [前端三要素](#前端三要素)\n - [结构层（HTML）](#结构层html)\n - [表现层（CSS）](#表现层css)\n - [什么是 CSS 预处理器](#什么是-css-预处理器)\n - [常用的 CSS 预处理器有哪些](#常用的-css-预处理器有哪些)\n - [行为层（JavaScript）](#行为层javascript)\n - [Native 原生 JS 开发](#native-原生-js-开发)\n - [TypeScript 微软的标准](#typescript-微软的标准)\n - [JavaScript 框架](#javascript-框架)\n - [UI 框架](#ui-框架)\n - [JavaScript 构建工具](#javascript-构建工具)\n - [三端统一](#三端统一)\n - [混合开发（Hybrid App）](#混合开发hybrid-app)\n - [微信小程序](#微信小程序)\n - [后端技术](#后端技术)\n - [附：当前主流前端框架](#附当前主流前端框架)\n - [Angular](#angular)\n - [Angular Material](#angular-material)\n - [Vue.js](#vuejs)\n - [iView](#iview)\n - [ElementUI](#elementui)\n - [ICE](#ice)\n - [VantUI](#vantui)\n - [AtUI](#atui)\n - [CubeUI](#cubeui)\n - [混合开发](#混合开发)\n - [Flutter](#flutter)\n - [Ionic](#ionic)\n - [微信小程序](#微信小程序-1)\n - [mpvue](#mpvue)\n - [WeUI](#weui)\n\n\n\n# 前端知识体系\n\n## 前端三要素\n\n- HTML（结构）：超文本标记语言（Hyper Text Markup Language），决定网页的结构和内容\n- CSS（表现）：层叠样式表（Cascading Style Sheets），设定网页的表现样式\n- JavaScript（行为）：是一种弱类型脚本语言，其源代码不需经过编译，而是由浏览器解释运行，用于控制网页的行为\n\n### 结构层（HTML）\n\n略\n\n### 表现层（CSS）\n\nCSS 层叠样式表是一门标记语言，并不是编程语言，因此不可以自定义变量，不可以引用等，换句话说就是不具备任何语法支持，它主要缺陷如下：\n\n- 语法不够强大，比如无法嵌套书写，导致模块化开发中需要书写很多重复的选择器；\n- 没有变量和合理的样式复用机制，使得逻辑上相关的属性值必须以字面量的形式重复输出，导致难以维护；\n\n这就导致了我们在工作中无端增加了许多工作量。为了解决这个问题，前端开发人员会使用一种称之为 **【CSS 预处理器】** 的工具，提供 CSS 缺失的样式层复用机制、减少冗余代码，提高样式代码的可维护性。大大提高了前端在样式上的开发效率。\n\n#### 什么是 CSS 预处理器\n\nCSS 预处理器定义了一种新的语言，其基本思想是，用一种专门的编程语言，为 CSS 增加了一些编程的特性，将 CSS 作为目标生成文件，然后开发者就只要使用这种语言进行 CSS 的编码工作。转化成通俗易懂的话来说就是“**用一种专门的编程语言，进行 Web 页面样式设计，再通过编译器转化为正常的 CSS 文件，以供项目使用**”。\n\n#### 常用的 CSS 预处理器有哪些\n\n- SASS：基于 Ruby，通过服务端处理，功能强大。解析效率高。需要学习 Ruby 语言，上手难度高于 LESS。\n- LESS：基于 NodeJS，通过客户端处理，使用简单。功能比 SASS 简单，解析效率也低于 SASS，但在实际开发中足够了，所以我们后台人员如果需要的话，建议使用 LESS。\n\n### 行为层（JavaScript）\n\nJavaScript 一门弱类型脚本语言，其源代码在发往客户端运行之前不需经过编译，而是将文本格式的字符代码发送给浏览器由浏览器解释运行。\n\n#### Native 原生 JS 开发\n\n原生 JS 开发，也就是让我们按照 **【ECMAScript】** 标准的开发方式，简称是 ES，特点是所有浏览器都支持。截止到当前博客发布时间（2018 年 12 月 04 日），ES 标准已发布如下版本：\n\n- ES3\n- ES4（内部，未正式发布）\n- ES5（全浏览器支持）\n- ES6（常用，当前主流版本）\n- ES7\n- ES8\n- ES9（草案阶段）\n\n区别就是逐步增加新特性。\n\n#### TypeScript 微软的标准\n\nTypeScript 是一种由微软开发的自由和开源的编程语言。它是 JavaScript 的一个超集，而且本质上向这个语言添加了可选的静态类型和基于类的面向对象编程。由安德斯·海尔斯伯格（C#、Delphi、TypeScript 之父；.NET 创立者）主导。\n\n该语言的特点就是除了具备 ES 的特性之外还纳入了许多不在标准范围内的新特性，所以会导致很多浏览器不能直接支持 TypeScript 语法，需要编译后（编译成 JS）才能被浏览器正确执行。\n\n#### JavaScript 框架\n\n- jQuery：大家熟知的 JavaScript 框架，优点是简化了 DOM 操作，缺点是 DOM 操作太频繁，影响前端性能；在前端眼里使用它仅仅是为了兼容 IE6、7、8；\n- Angular：Google 收购的前端框架，由一群 Java 程序员开发，其特点是将后台的 MVC 模式搬到了前端并增加了模块化开发的理念，与微软合作，采用 TypeScript 语法开发；对后台程序员友好，对前端程序员不太友好；最大的缺点是版本迭代不合理（如：1 代 -> 2 代，除了名字，基本就是两个东西；截止发表博客时已推出了 Angular8）。Angular 作为 Google 推出的一个“重型”的框架，内置包括路由、HTTP 等常用组件，同时深度集成 TypeScript，WebPack，RxJS，angular-cli 等工具，可以方便地进行大型前端项目的开发以及调试。但是由于 Angular 引入了许多概念，增加了新手上手的复杂性。特别是组件、模块、服务、指令、依赖注入的引入，对于新手而言，厘清其中各个概念的作用域是就不是一件容易的事情。同时 RxJS 的引入，也进一步使得学习曲线变得陡峭。\n- React：Facebook 出品，一款高性能的 JS 前端框架；特点是提出了新概念 **【虚拟 DOM】** 用于减少真实 DOM 操作，在内存中模拟 DOM 操作，有效的提升了前端渲染效率；缺点是使用复杂，因为需要额外学习一门 **【JSX】** 语言；\n- `Vue`：一款渐进式 JavaScript 框架，所谓渐进式就是逐步实现新特性的意思，如实现模块化开发、路由、状态管理等新特性。其特点是综合了 Angular（模块化） 和 React（虚拟 DOM） 的优点；\n- `Axios`：前端通信框架；因为 `Vue` 的边界很明确，就是为了处理 DOM，所以并不具备通信能力，此时就需要额外使用一个通信框架与服务器交互；当然也可以直接选择使用 jQuery 提供的 AJAX 通信功能；\n\n#### UI 框架\n\n- Ant-Design：阿里巴巴出品，基于 React 的 UI 框架\n- ElementUI：饿了么出品，基于 Vue 的 UI 框架\n- Bootstrap：Twitter 推出的一个用于前端开发的开源工具包\n- AmazeUI：又叫“妹子 UI”，一款 HTML5 跨屏前端框架\n\n#### JavaScript 构建工具\n\n- Babel：JS 编译工具，主要用于浏览器不支持的 ES 新特性，比如用于编译 TypeScript\n- WebPack：模块打包器，主要作用是打包、压缩、合并及按序加载\n\n**注：以上知识点已将 WebApp 开发所需技能全部梳理完毕**\n\n## 三端统一\n\n### 混合开发（Hybrid App）\n\n主要目的是实现一套代码三端统一（PC、Android、iOS）并能够调用到设备底层硬件（如：传感器、GPS、摄像头等），打包方式主要有以下两种：\n\n- 云打包：HBuild -> HBuildX，DCloud 出品；API Cloud\n- 本地打包： Cordova（前身是 PhoneGap）\n\n### 微信小程序\n\n详见微信官网，这里就是介绍一个方便微信小程序 UI 开发的框架：WeUI\n\n## 后端技术\n\n前端人员为了方便开发也需要掌握一定的后端技术，但我们 Java 后台人员知道后台知识体系极其庞大复杂，所以为了方便前端人员开发后台应用，就出现了 NodeJS 这样的技术。\n\nNodeJS 的作者已经声称放弃 NodeJS（说是架构做的不好再加上笨重的 node_modules，可能让作者不爽了吧），开始开发全新架构的 Deno\n\n既然是后台技术，那肯定也需要框架和项目管理工具，NodeJS 框架及项目管理工具如下：\n\n- Express：NodeJS 框架\n- Koa：Express 简化版\n- NPM：项目综合管理工具，类似于 Maven\n- YARN：NPM 的替代方案，类似于 Maven 和 Gradle 的关系\n\n## 附：当前主流前端框架\n\n### Angular\n\n#### Angular Material\n\nAngular Material 是 Angular 官方团队维护的一个遵从 Material Design 的 Angular UI 库。它提供了丰富的组件库、CDK、以及内置主题，开箱即用，并且与 Angular 版本同步。\n\n- [官网地址](https://material.angular.io/)\n- [Github](https://github.com/angular/components)\n\n#### ngx-admin\n\nngx-admin 是一款开源的 Angualr UI 库，目前仍处于维护和活跃状态。它也提供了丰富的开箱即用的组件库、内置主题，并且与 Angular 版本同步。代码风格遵循 Angular 最佳实践，也是一个不错的学习资源。\n\n- [Github](https://github.com/akveo/ngx-admin)\n\n### Vue.js\n\n#### iView\n\niview 是一个强大的基于 Vue 的 UI 库，有很多实用的基础组件比 elementui 的组件更丰富，主要服务于 PC 界面的中后台产品。使用单文件的 Vue 组件化开发模式 基于 npm + webpack + babel 开发，支持 ES2015 高质量、功能丰富 友好的 API ，自由灵活地使用空间。\n\n- [官网地址](https://www.iviewui.com/)\n- [Github](https://github.com/TalkingData/iview-weapp)\n- [iview-admin](https://github.com/iview/iview-admin)\n\n**备注：属于前端主流框架，选型时可考虑使用，主要特点是移动端支持较多**\n\n#### ElementUI\n\nElement 是饿了么前端开源维护的 Vue UI 组件库，组件齐全，基本涵盖后台所需的所有组件，文档讲解详细，例子也很丰富。主要用于开发 PC 端的页面，是一个质量比较高的 Vue UI 组件库。\n\n- [官网地址](http://element-cn.eleme.io/#/zh-CN)\n- [Github](https://github.com/ElementUI/element-starter)\n- [vue-element-admin](https://github.com/PanJiaChen/vue-element-admin)\n\n**备注：属于前端主流框架，选型时可考虑使用，主要特点是桌面端支持较多**\n\n#### ICE\n\n飞冰是阿里巴巴团队基于 React/Angular/Vue 的中后台应用解决方案，在阿里巴巴内部，已经有 270 多个来自几乎所有 BU 的项目在使用。飞冰包含了一条从设计端到开发端的完整链路，帮助用户快速搭建属于自己的中后台应用。\n\n- [官网地址](https://alibaba.github.io/ice)\n- [Github](https://github.com/alibaba/ice)\n\n**备注：主要组件还是以 React 为主，截止 2019 年 02 月 17 日更新博客前对 Vue 的支持还不太完善，目前尚处于观望阶段**\n\n#### VantUI\n\nVant UI 是有赞前端团队基于有赞统一的规范实现的 Vue 组件库，提供了一整套 UI 基础组件和业务组件。通过 Vant，可以快速搭建出风格统一的页面，提升开发效率。\n\n- [官网地址](https://youzan.github.io/vant/#/zh-CN/intro)\n- [Github](https://github.com/youzan/vant)\n\n#### AtUI\n\nat-ui 是一款基于 Vue 2.x 的前端 UI 组件库，主要用于快速开发 PC 网站产品。 它提供了一套 npm + webpack + babel 前端开发工作流程，CSS 样式独立，即使采用不同的框架实现都能保持统一的 UI 风格。\n\n- [官网地址](https://at-ui.github.io/at-ui/#/zh)\n- [Github](https://github.com/at-ui/at-ui)\n\n#### CubeUI\n\ncube-ui 是滴滴团队开发的基于 Vue.js 实现的精致移动端组件库。支持按需引入和后编译，轻量灵活；扩展性强，可以方便地基于现有组件实现二次开发。\n\n- [官网地址](https://didi.github.io/cube-ui/#/zh-CN)\n- [Github](https://github.com/didi/cube-ui/)\n\n### 混合开发\n\n#### Flutter\n\nFlutter 是谷歌的移动端 UI 框架，可在极短的时间内构建 Android 和 iOS 上高质量的原生级应用。Flutter 可与现有代码一起工作, 它被世界各地的开发者和组织使用, 并且 Flutter 是免费和开源的。\n\n- [官网地址](http://doc.flutter-dev.cn/)\n- [Github](https://github.com/flutter/flutter)\n\n**备注：Google 出品，主要特点是快速构建原生 APP 应用程序，如做混合应用该框架为必选框架**\n\n#### Ionic\n\nIonic 既是一个 CSS 框架也是一个 Javascript UI 库，Ionic 是目前最有潜力的一款 HTML5 手机应用开发框架。通过 SASS 构建应用程序，它提供了很多 UI 组件来帮助开发者开发强大的应用。它使用 JavaScript MVVM 框架和 AngularJS/Vue 来增强应用。提供数据的双向绑定，使用它成为 Web 和移动开发者的共同选择。\n\n- [官网地址](https://ionicframework.com/)\n- [官网文档](https://ionicframework.com/docs/)\n- [Github](https://github.com/ionic-team/ionic)\n\n### 微信小程序\n\n#### mpvue\n\nmpvue 是美团开发的一个使用 `Vue.js` 开发小程序的前端框架，目前支持 **微信小程序**、**百度智能小程序**，**头条小程序** 和 **支付宝小程序**。 框架基于 `Vue.js`，修改了的运行时框架 `runtime` 和代码编译器 `compiler` 实现，使其可运行在小程序环境中，从而为小程序开发引入了 `Vue.js` 开发体验。\n\n- [官网地址](http://mpvue.com/)\n- [Github](https://github.com/Meituan-Dianping/mpvue)\n\n**备注：完备的 Vue 开发体验，并且支持多平台的小程序开发，推荐使用**\n\n#### WeUI\n\nWeUI 是一套同微信原生视觉体验一致的基础样式库，由微信官方设计团队为微信内网页和微信小程序量身设计，令用户的使用感知更加统一。包含 button、cell、dialog、toast、article、icon 等各式元素。\n\n- [官网地址](https://weui.io/)\n- [Github](https://github.com/weui/weui.git)\n"
},
{
"path": "notes/Git.md",
"content": "\n\n- [前言](#前言)\n- [一、Git 简介](#一git-简介)\n - [什么是版本控制系统](#什么是版本控制系统)\n - [为什么需要版本 控制](#为什么需要版本-控制)\n - [什么是版本控制系统](#什么是版本控制系统-1)\n - [版本控制系统的发展史](#版本控制系统的发展史)\n - [什么是 Git](#什么是-git)\n - [如何安装 Git](#如何安装-git)\n- [二、Git 常用命令速查](#二git-常用命令速查)\n - [配置](#配置)\n - [基础操作](#基础操作)\n - [比对 diff](#比对-diff)\n - [历史 log](#历史-log)\n - [分支 branch](#分支-branch)\n - [远程](#远程)\n- [三、Git 常用场景](#三git-常用场景)\n - [1. 删除本地文件后，想从远程仓库中重新Pull最新版文件](#1-删除本地文件后想从远程仓库中重新pull最新版文件)\n - [2. 储藏与清理](#2-储藏与清理)\n\n\n\n# 前言\n\n这是一篇入门级使用指南，更多详细的请参考 [Git 官网电子书](https://git-scm.com/book/zh/v2)。\n\n在这里将列举一些常用命令和场景解决方案，欢迎大家补充学习。\n\n\n\n# 一、Git 简介\n\n## 什么是版本控制系统\n\n### 为什么需要版本 控制\n\n在软件开发过程，每天都会产生新的代码，代码合并的过程中可能会出现如下问题：\n\n- 代码被覆盖或丢失\n- 代码写的不理想希望还原之前的版本\n- 希望知道与之前版本的差别\n- 是谁修改了代码以及为什么修改\n- 发版时希望分成不同的版本(测试版、发行版等)\n\n因此，我们希望有一种机制，能够帮助我们：\n\n- 可以随时回滚到之前的版本\n- 协同开发时不会覆盖别人的代码\n- 留下修改记录，以便随时查看\n- 发版时可以方便的管理不同的版本\n\n### 什么是版本控制系统\n\n一个标准的版本控制系统 Version Control System (VCS)，通常需要有以下功能：\n\n- 能够创建 Repository (仓库)，用来保存代码\n- 协同开发时方便将代码分发给团队成员\n- 记录每次修改代码的内容、时间、原因等信息\n- 能够创建 Branch (分支)，可以根据不同的场景进行开发\n- 能够创建 Tag (标签)，建立项目里程碑\n\n### 版本控制系统的发展史\n\n版本控制系统发展至今有几种不同的模式：\n\n**Local VCS**\n\n本地使用 `复制/粘贴` 的方式进行管理，缺点是无法协同开发\n\n**Centralized VCS (Lock，悲观锁)**\n\n中央集中式版本控制系统团队共用仓库，当某人需要编辑文件时，进行锁定，以免其他人同时编辑时造成冲突。缺点是虽然避免了冲突，但不是很方便。其他人需要排队才能编辑文件，如果有人编辑了很久或是忘记解锁就会造成其他人长时间等待的情况。\n\n**Centralized VCS (Merge，乐观锁)**\n\n中央集中式版本控制系统团队共用仓库，不采用悲观锁方式来避免冲突，而是事后发现如果别人也修改相同文件(冲突)，再进行手动修改解决。有很多 VCS 属于这种类型，如：CVS，Subversion，Perforce 等\n\n中央集中式版本控制系统的共同问题是，做任何操作都需要和服务器同步，如果服务器宕机则会造成无法继续工作的窘迫。\n\n**Distributed VCS**\n\n分布式版本控制系统，本地也拥有完整的代码仓库，就不会出现上述集中式管理的问题，即使没有网络，依然可以 `commit` 和看 `log`，也无需担心服务器同步问题。如：Git，Mercurial，Bazaar 等就属于分布式版本控制系统。缺点是功能比较复杂，上手需要一定的学习时间。\n\n\n\n## 什么是 Git\n\n- Git 是一个开源的分布式版本控制系统，用于敏捷高效地处理任何或小或大的项目。\n- Git 是 Linus Torvalds 为了帮助管理 Linux 内核开发而开发的一个开放源码的版本控制软件。\n- Git 与常用的版本控制工具 CVS, Subversion 等不同，它采用了分布式版本库的方式，不必服务器端软件支持。\n\n## 如何安装 Git\n\n- Git 官网下载地址：[Git 版本管理工具](https://git-scm.com/downloads)\n\n- 客户端推荐：[SourceTree](https://www.sourcetreeapp.com/)，软件安装跳过注册，[请参考这里](https://www.cnblogs.com/lucio110/p/8192792.html?tdsourcetag=s_pcqq_aiomsg)\n\n\n\n\n\n# 二、Git 常用命令速查\n\n一图胜千言\n\n\n\n\n\n推荐一个不错的可视化工具：[Git Cheat Sheet](http://ndpsoftware.com/git-cheatsheet.html)\n\n## 配置\n\n设置提交者姓名\n\n```shell\n$ git config --global user.name \"John Doe\"\n```\n\n设置提交者邮箱\n\n```shell\n$ git config --global user.email johndoe@example.com\n```\n\n查看配置列表\n\n```shell\n$ git config --list\n```\n\n\n\n## 基础操作\n\n在指定目录创建仓库，如果没有指定目录名将在当前目录创建仓库\n\n```shell\n$ git init [目录名]\n\n# 当前文件夹初始化\n$ git init .\n\n# 指定目录\n$ git init frank\n```\n\n从指定地址克隆仓库，若不指定`目录名`将默认创建与远程同名目录\n\n```shell\n$ git clone <远程仓库地址> [目录名]\n\n# 不想创建目录，目录名为 . ，直接加在内容到当前目录下\n$ git clone https://github.com/frank-lam/2019_campus_apply.git .\n```\n\n将文件或目录中已修改的代码添加追暂存区\n\n```shell\n$ git add <目录名|文件名>\n```\n\n提交暂存区内容\n\n```shell\n$ git commit -m \"<注释>\"\n```\n\n查看仓库状态\n\n```shell\n$ git status\n```\n\n\n\n## 比对 diff\n\n比对当前内容和暂存区内容\n\n```shell\n$ git diff\n```\n\n比对当前内容和最近一次提交\n\n```shell\n$ git diff HEAD\n```\n\n比对当前内容和倒数第二次提交\n\n```shell\n$ git diff HEAD^\n```\n\n比对最近两次提交\n\n```shell\n$ git diff HEAD^ HEAD\n```\n\n\n\n## 历史 log\n\n查看提交历史\n\n```shell\n$ git log --oneline\n```\n\n打印为单行log\n\n```shell\n$ git log --oneline\n```\n\n打印所有记录（忽略HEAD的位置）\n\n```shell\n$ git log --all\n```\n\n打印示意图（忽略HEAD的位置）\n\n```shell\n$ git log --graph\n```\n\n\n\n## 分支 branch\n\n查看所有分支\n\n```shell\n$ git branch\n```\n\n有分支：创建分支，无分支：列出所有分支\n\n```shell\n$ git branch [分支]\n```\n\n切换至分支\n\n```shell\n$ git checkout <分支>\n```\n\n创建并切换至分支分支\n\n```shell\n$ git checkout -b <分支>\n```\n\n将分支与当前分支合并\n\n```shell\n$ git merge <分支>\n```\n\n\n\n## 远程\n\n拉取远程仓库\n\n```shell\n$ git pull\n```\n\n推送至远程仓库\n\n```shell\n$ git push <远程仓库> <分支>\n```\n\n新增远程仓库 origin\n\n```shell\n$ git remote add origin https://xxx.git\n```\n\n修改远程仓库 origin\n\n```shell\n$ git remote set-url origin https://xxx.git\n```\n\n\n\n\n\n# 三、Git 常用场景\n\n## 1. 删除本地文件后，想从远程仓库中重新 Pull 最新版文件\n\nGit提示：up-to-date，但未得到删除的文件\n\n原因：当前本地库处于另一个分支中，需将本分支发 Head 重置至 master\n\n```bash\n$ git checkout master \n$ git reset --hard\n```\n\ngit 强行 pull 并覆盖本地文件\n\n```shell\n$ git fetch --all \n$ git reset --hard origin/master \n$ git pull\n```\n\n## 2. 储藏与清理\n\n应用场景：\n\n1. 当正在 dev 分支上开发某个项目，这时项目中出现一个 bug，需要紧急修复，但是正在开发的内容只是完成一半，还不想提交，这时可以用 git stash 命令将修改的内容保存至堆栈区，然后顺利切换到 hotfix 分支进行 bug 修复，修复完成后，再次切回到 dev 分支，从堆栈中恢复刚刚保存的内容。 \n2. 由于疏忽，本应该在 dev 分支开发的内容，却在 master 上进行了开发，需要重新切回到 dev 分支上进行开发，可以用 git stash 将内容保存至堆栈中，切回到 dev 分支后，再次恢复内容即可。 \n\n总的来说，git stash 命令的作用就是将目前还不想提交的但是已经修改的内容进行保存至堆栈中，后续可以在某个分支上恢复出堆栈中的内容。这也就是说，stash 中的内容不仅仅可以恢复到原先开发的分支，也可以恢复到其他任意指定的分支上。git stash 作用的范围包括工作区和暂存区中的内容，也就是说没有提交的内容都会保存至堆栈中。\n\n\n\n- [Git - 储藏与清理](https://git-scm.com/book/zh/v2/Git-%E5%B7%A5%E5%85%B7-%E5%82%A8%E8%97%8F%E4%B8%8E%E6%B8%85%E7%90%86)\n- [git stash详解 - stone_yw的博客 - CSDN博客](https://blog.csdn.net/stone_yw/article/details/80795669)\n\n\n\n## 3. SSH 连接配置\n\n### 1. 生成密钥对\n\n大多数 Git 服务器都会选择使用 SSH 公钥来进行授权。系统中的每个用户都必须提供一个公钥用于授权，没有的话就要生成一个。生成公钥的过程在所有操作系统上都差不多。首先你要确认一下本机是否已经有一个公钥。\n\nSSH 公钥默认储存在账户的主目录下的 ~/.ssh 目录。进去看看：\n\n```shell\n$ cd ~/.ssh\n$ ls\nauthorized_keys2 id_dsa known_hosts config id_dsa.pub\n```\n\n看一下有没有id_rsa和id_rsa.pub(或者是id_dsa和id_dsa.pub之类成对的文件)，有 .pub 后缀的文件就是公钥，另一个文件则是密钥。\n\n假如没有这些文件，甚至连 .ssh 目录都没有，可以用 ssh-keygen 来创建。该程序在 Linux/Mac 系统上由 SSH 包提供，而在 Windows 上则包含在 MSysGit 包里：\n\n```shell\n$ ssh-keygen -t rsa -C \"your_email@youremail.com\"\n\nCreates a new ssh key using the provided email # Generating public/private rsa key pair.\n\nEnter file in which to save the key (/home/you/.ssh/id_rsa):\n```\n\n直接按Enter就行。然后，会提示你输入密码，如下(建议输一个，安全一点，当然不输也行，应该不会有人闲的无聊冒充你去修改你的代码)：\n\n```shell\nEnter same passphrase again: [Type passphrase again]\n```\n\n完了之后，大概是这样：\n\n```shell\nYour public key has been saved in /home/you/.ssh/id_rsa.pub.\nThe key fingerprint is: # 01:0f:f4:3b:ca:85:d6:17:a1:7d:f0:68:9d:f0:a2:db your_email@youremail.com\n```\n\n到此为止，你本地的密钥对就生成了。\n\n\n(9+条消息)Mac OS 配置多个ssh-key - maoxinwen1的博客 - CSDN博客\nhttps://blog.csdn.net/maoxinwen1/article/details/80269299\n\n\n### 2. 添加公钥到你的远程仓库（github）\n\n1. 查看你生成的公钥：\n\n```\n$ cat ~/.ssh/id_rsa.pub\n\nssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC0X6L1zLL4VHuvGb8aJH3ippTozmReSUzgntvk434aJ/v7kOdJ/MTyBlWXFCR+HAo3FXRitBqxiX1nKhXpHAZsMciLq8vR3c8E7CjZN733f5AL8uEYJA+YZevY5UCvEg+umT7PHghKYaJwaCxV7sjYP7Z6V79OMCEAGDNXC26IBMdMgOluQjp6o6j2KAdtRBdCDS/QIU5THQDxJ9lBXjk1fiq9tITo/aXBvjZeD+gH/Apkh/0GbO8VQLiYYmNfqqAHHeXdltORn8N7C9lOa/UW3KM7QdXo6J0GFlBVQeTE/IGqhMS5PMln3 admin@admin-PC\n```\n\n2. 登陆你的 GitHub 帐户。点击你的头像，然后 `Settings -> 左栏点击 SSH and GPG keys -> 点击 New SSH key`\n\n3. 然后你复制上面的公钥内容，粘贴进“Key”文本域内。 title域，自己随便起个名字。\n\n4. 点击 Add key。\n\n完成以后，验证下这个key是不是正常工作：\n\n```shell\n$ ssh -T git@github.com\n\nAttempts to ssh to github\n```\n\n如果，看到：\n\n```\nHi xxx! You've successfully authenticated, but GitHub does not # provide shell access.\n```\n\n恭喜你，你的设置已经成功了。\n\n### 3. 修改git的remote url\n\n 使用命令 git remote -v 查看你当前的 remote url\n\n```shell\n$ git remote -v\norigin https://github.com/someaccount/someproject.git (fetch)\norigin https://github.com/someaccount/someproject.git (push)\n```\n\n如果是以上的结果那么说明此项目是使用https协议进行访问的（如果地址是git开头则表示是git协议）\n\n你可以登陆你的github，就像本文开头的图例，你在上面可以看到你的ssh协议相应的url，类似：\n\n \n\n复制此ssh链接，然后使用命令 git remote set-url 来调整你的url。\n\n```shell\n$ git remote set-url origin git@github.com:someaccount/someproject.git\n```\n\n然后你可以再用命令 git remote -v 查看一下，url是否已经变成了ssh地址。\n\n然后你就可以愉快的使用 git fetch, git pull , git push，再也不用输入烦人的密码了\n\n\n\n\n\n### 4. 常见问题\n\n- [Git 提交大文件提示 fatal: The remote end hung up unexpectedly - WNFK - 博客园](https://www.cnblogs.com/hanxianlong/p/3464224.html)\n\n\n\n## 4. Git 记住密码\n\n- [Git Pull 避免用户名和密码方法 - 王信平 - 博客园](https://www.cnblogs.com/wangshuo1/p/5531200.html)\n\n\n\n## 5. Git FTP 使用\n\n利用Git版本管理将只修改过的文件上传到FTP服务器 支持SFTP协议 - 吕滔博客\nhttps://lvtao.net/tool/gitftp.html\n\n\n\n## 6. Git 删除文件如何提交\n\n\n\n## 7. Git 中的 origin 是什么意思\n\ngit学习：关于origin和master - mashiqi - 博客园\nhttps://www.cnblogs.com/mashiqi/p/6002671.html\n\n\n\nGit 里面的 origin 到底代表啥意思? - Not Only DBA. - CSDN博客\nhttps://blog.csdn.net/u011478909/article/details/77683754\n\n\n\n## 8. Git 回退到制定版本\n\n**回滚到指定的版本**\n\n```shell\ngit reset --hard e377f60e28c8b84158\n```\n\n**强制提交**\n\n```shell\ngit push -f origin master\n```\n\n"
},
{
"path": "notes/Git命令速查.md",
"content": "# Git 命令速查\n\n> 本文参考极客时间苏玲老师的《玩转Git三剑客》\n\n\n\n## 添加配置\n```bash\ngit config [--local | --global | --system] user.name 'Your name'\ngit config [--local | --global | --system] user.email 'Your email'\n```\n\n\n\n\n\n## 查看配置\n\n```bash\ngit config --list [--local | --global | --system]\n```\n### 区别\n```bash\nlocal：区域为本仓库\nglobal: 当前用户的所有仓库\nsystem: 本系统的所有用户\n```\n\n\n## `git add .` 和 `git add -u`区别\n\n```bash\ngit add . ：将工作空间新增和被修改的文件添加的暂存区\ngit add -u :将工作空间被修改和被删除的文件添加到暂存区(不包含没有纳入Git管理的新增文件)\n```\n\n\n\n## 创建仓库\n\n```bash\ngit init [project folder name] 初始化 git 仓库\ngit add [fileName] 把文件从工作目录添加到暂存区\ngit commit -m'some information' 用于提交暂存区的文件\ngit commit -am'Some information' 用于提交跟踪过的文件\ngit log 查看历史\ngit status 查看状态\n```\n\n**额外** \ngit add -u 可以添加所有已经被 git 控制的文件到暂存区\n以前删除文件夹只会用 「-rf」，今天学到了 「-r」，并得知它们两个区别：「-r」 有时候会提示是否确认删除。 \n\n\n\n## 给文件重命名的简便方法\n\n```bash\ngit mv [old file name] [new file name]\ngit commit -m 'some information'\n```\n\n\n\n## 通过`git log`查看版本演变历史\n\n```bash\ngit log --all 查看所有分支的历史\ngit log --all --graph 查看图形化的 log 地址\ngit log --oneline 查看单行的简洁历史。\ngit log --oneline -n4 查看最近的4条简洁历史。\ngit log --oneline --all -n4 --graph 查看所有分支最近4条单行的图形化历史。\ngit help --web log 跳转到git log 的帮助文档网页\n```\n\n```bash\ngit branch -v 查看本地有多少分支\n```\n\n\n\n## 通过图形界面工具来查看版本历史\n\n```bash\ngitk\n```\n\n\n\n## 探密`.git`目录\n\n查看`.git`文件夹下的内容： \n```bash\nls .git/ -al\n```\n如下: \n```shell\ndrwxr-xr-x 1 Andy 197609 0 12月 17 22:38 ./\ndrwxr-xr-x 1 Andy 197609 0 12月 17 21:50 ../\n-rw-r--r-- 1 Andy 197609 7 12月 17 22:38 COMMIT_EDITMSG\n-rw-r--r-- 1 Andy 197609 301 12月 12 22:55 config\n-rw-r--r-- 1 Andy 197609 73 12月 12 22:55 description\n-rw-r--r-- 1 Andy 197609 96 12月 19 00:00 FETCH_HEAD\n-rw-r--r-- 1 Andy 197609 23 12月 12 22:55 HEAD\ndrwxr-xr-x 1 Andy 197609 0 12月 12 22:55 hooks/\n-rw-r--r-- 1 Andy 197609 249 12月 17 22:38 index\ndrwxr-xr-x 1 Andy 197609 0 12月 12 22:55 info/\ndrwxr-xr-x 1 Andy 197609 0 12月 12 22:55 logs/\ndrwxr-xr-x 1 Andy 197609 0 12月 17 22:38 objects/\n-rw-r--r-- 1 Andy 197609 114 12月 12 22:55 packed-refs\ndrwxr-xr-x 1 Andy 197609 0 12月 12 22:55 refs/\n```\n\n```bash\ncat命令主要用来查看文件内容，创建文件，文件合并，追加文件内容等功能。\ncat HEAD 查看HEAD文件的内容\ngit cat-file 命令 显示版本库对象的内容、类型及大小信息。\ngit cat-file -t b44dd71d62a5a8ed3 显示版本库对象的类型\ngit cat-file -s b44dd71d62a5a8ed3 显示版本库对象的大小\ngit cat-file -p b44dd71d62a5a8ed3 显示版本库对象的内容\n```\n\n`.git`里几个常用的如下： \n```bash\nHEAD：指向当前的工作路径\nconfig：存放本地仓库（local）相关的配置信息。\nrefs/heads: 存放分支\nrefs/heads/master/: 指向master分支最后一次commit\nrefs/tags: 存放tag，又叫里程牌 （当这次commit是具有里程碑意义的 比如项目1.0的时候 就可以打tag）\nobjects：核心文件，存储文件\n```\n.git/objects/ 存放所有的 git 对象，对象哈希值前 2 位作为文件夹名称，后 38 位作为对象文件名, 可通过 git cat-file -p 命令，拼接文件夹名称+文件名查看。 \n\n## `commit`、`tree`和`blob`三个对象之间的关系\n \n\n```bash\ncommit: 提交时的镜像\ntree: 文件夹\nblob: 文件\n```\n\n**【同学问题】** 每次commit，git 都会将当前项目的所有文件夹及文件快照保存到objects目录，如果项目文件比较大，不断迭代，commit无数次后，objects目录中文件大小是不是会变得无限大？ \n**【老师解答】** Git对于内容相同的文件只会存一个blob，不同的commit的区别是commit、tree和有差异的blob，多数未变更的文件对应的blob都是相同的，这么设计对于版本管理系统来说可以省很多存储空间。其次，Git还有增量存储的机制，我估计是对于差异很小的blob设计的吧。 \n\n\n\n## `分离头指针`情况下的注意事项\n\ndetached HEAD \n\n\n\n## 进一步理解`HEAD`和`branch`\n\n```bash\ngit checkout -b new_branch [具体分支 或 commit] 创建新分支并切换到新分支\ngit diff HEAD HEAD~1 比较最近两次提交\ngit diff HEAD HEAD~2 比较最近和倒数第三次提交\ngit diff HEAD HEAD^ 比较最近两次提交\ngit diff HEAD HEAD^^ 比较最近和倒数第三次提交\n```\n\n\n\n## 怎么删除不需要的分支？\n\n查看分支： \n```bash\ngit branch -av\n```\n删除分支命令： \n```bash\ngit branch -d [branch name] 删除\ngit branch -D [branch name] 强制删除\n```\n\n\n\n## 怎么修改最新 commit 的 message？\n\n```bash\ngit commit --amend 对最近一次的commit信息进行修改\n```\n\n\n\n## 怎么修改老旧 commit 的 message？\n\n```bash\ngit rebase -i [要更改的commit的上一级commit]\n```\n接下来就是一个交互过程... \n这期间会产生一个detached HEAD，然后将改好的commit指向该detached HEAD，如下图所示： \n \n\n**git rebase工作的过程中，就是用了分离头指针。rebase意味着基于新base的commit来变更部分commits。它处理的时候，把HEAD指向base的commit，此时如果该commit没有对应branch，就处于分离头指针的状态，然后重新一个一个生成新的commit，当rebase创建完最后一个commit后，结束分离头状态，Git让变完基的分支名指向HEAD。** \n\n\n\n## 怎样把连续的多个commit整理成1个？\n\n```bash\ngit rebase -i [要更改的commit的上一级commit]\n```\n```bash\n$ git log --graph\n* commit 7d3386842a2168ae630b65f687364243139c893c (HEAD -> master, origin/master, origin/HEAD)\n| Author: aimuch \n| Date: Thu Dec 20 23:34:18 2018 +0800\n|\n| update\n|\n* commit 9eb3188bbc63cae1bfed5f9dfc1593019e360a6a\n| Author: aimuch \n| Date: Wed Dec 19 20:30:14 2018 +0800\n|\n| update\n|\n* commit bbe6d53e2b477f2d2aa402af7f315ecdfc63459e\n| Author: aimuch \n| Date: Wed Dec 19 20:12:29 2018 +0800\n|\n| update\n|\n* commit 7735d66ded7f98adeca93d96fb7be12ffb67c76a\n| Author: aimuch \n| Date: Wed Dec 19 00:27:00 2018 +0800\n|\n| update\n|\n* commit d9f9d115fab425b5654f8ccfec6a996aef35b76b\n| Author: aimuch \n| Date: Wed Dec 19 00:23:36 2018 +0800\n|\n| update\n\n```\n```bash\npick 7735d66 update #合并到该commit上\nsquash bbe6d53 update\nsquash 9eb3188 update\nsquash 7d33868 update\n# Rebase d9f9d11..7d33868 onto d9f9d11 (4 commands)\n#\n# Commands:\n# p, pick = use commit\n# r, reword = use commit, but edit the commit message\n# e, edit = use commit, but stop for amending\n# s, squash = use commit, but meld into previous commit\n# f, fixup = like \"squash\", but discard this commit's log message\n# x, exec = run command (the rest of the line) using shell\n# b, break = stop here (continue rebase later with 'git rebase --continue')\n# d, drop = remove commit\n# l, label = label current HEAD with a name\n# t, reset = reset HEAD to a label\n# m, merge [-C | -c ] [# ]\n# . create a merge commit using the original merge commit's\n# . message (or the oneline, if no original merge commit was\n# . specified). Use -c to reword the commit message.\n```\n\n```bash\n# This is a combination of 4 commits.\n# This is the 1st commit message:\n\nupdate\n\n# This is the commit message #2:\n\nupdate\n\n# This is the commit message #3:\n\nupdate\n\n# This is the commit message #4:\n\nupdate\n\n```\n## git 修改.gitignore后生效\n```bash\ngit rm -r --cached . #清除缓存\ngit add . #重新trace file\ngit commit -m \"update .gitignore\" #提交和注释\ngit push origin master #可选，如果需要同步到remote上的话\n```\n\n\n\n## 怎么比较暂存区和HEAD所含文件的差异？\n\n```bash\ngit diff --cached\n```\n或者\n```bash\ngit diff --staged\n```\n\n\n\n## 怎么比较工作区和暂存区所含文件的差异？\n\n```bash\ngit diff\n```\n```bash\ngit diff -- [filename/pathname] #比较具体的文件或者路径\n```\n\n\n\n## 如何让暂存区恢复成和HEAD的一样？\n\n```bash\ngit reset HEAD\n```\n```bash\ngit reset 有三个参数\n--soft 这个只是把 HEAD 指向的 commit 恢复到你指定的 commit，暂存区 工作区不变\n--hard 这个是 把 HEAD， 暂存区， 工作区 都修改为 你指定的 commit 的时候的文件状态\n--mixed 这个是不加时候的默认参数，把 HEAD，暂存区 修改为 你指定的 commit 的时候的文件状态，工作区保持不变\n```\n\n\n\n## 如何让工作区的文件恢复为和暂存区一样？\n\n```bash\ngit checkout -- ...\n```\n**恢复工作区用checkout，恢复暂存区用reset。** \n\n\n\n## 怎样取消暂存区部分文件的更改？\n\n```bash\ngit reset HEAD -- ...\n```\n\n\n\n## 看看不同提交的指定文件的差异\n\n```bash\ngit diff commit-id1 commit-id2 -- ...\n```\n\n\n\n## 正确删除文件的方法\n\n```bash\ngit rm \n```\n\n\n\n## 开发中临时加塞了紧急任务怎么处理？\n\n```bash\ngit stash list #查看stash中存放的信息\ngit stash #将当前工作区内容存放到\"堆栈\"中\n```\n```bash\ngit stash apply #把\"堆栈\"里面的内容弹出到工作区中，同时\"堆栈\"中信息还在\n```\n```bash\ngit stash pop #把\"堆栈\"里面的内容弹出到工作区中，同时丢弃\"堆栈\"中最新的信息\n```\n\n\n\n## 如何指定不需要Git管理的文件？\n\n```bash\n.gitignore\n```\n**【同学提问】** 如果提交commit后，想再忽略一些已经提交的文件，怎么处理。 \n**【老师回答】** The problem is that .gitignore ignores just files that weren't tracked before (by git add). Run git reset name_of_file to unstage the file and keep it. In case you want to also remove given file from the repository (after pushing), use git rm --cached name_of_file. \n把想忽略的文件添加到 .gitignore ；然后通过 git rm -- cached name_of_file 的方式删除掉git仓库里面无需跟踪的文件。 \n\n\n\n## 添加远程仓库\n```bash\ngit remote add [shortname] [url]\n```\n\n\n\n## 配置公私钥\n\n1、 检查是否已存在相应的`ssh key`: \n打开终端, 输入: \n\n```bash\nls -al ~/.ssh\n```\n核对列出来的ssh key是否有已存在的，假如你没有看到列出的公私钥对，或是不想再用之前的公私钥对，你可以选择下面的步骤生成新的公私钥对. \n\n2、生成新的`ssh key`,并添加至`ssh-agent`: \n打开终端, 使用`ssh key`生成命令：\n```bash\nssh-keygen -t rsa -b 4096 -C \"your_email@example.com\"\n```\n**注意** ：后面的邮箱对应相应账号的邮箱，假如是github的账号，且注册账号的邮箱为xxxx@qq.com，则命令行为：`ssh-keygen -t rsa -b 4096 -C \"xxxx@qq.com`。 \n\n3、接下来会提示你保存的`ssh key`的名称以及路径。默认路径是(`/Users/you/.ssh/id_rsa`) (`you`为用户个人目录)。这一步很重要，如果你使用默认的，且下一个账号也是使用默认的路径和文件名，那么之前的`ssh key`就会被后来生成的`ssh key`重写，从而导致之前的账号不可用。因此，正确的做法是给它命名，最后以应用名进行命名，因为更容易区分。以下是我个人配的：\n```bash\n/Users/andy/.ssh/github_rsa \n```\n\n4、接下来会提示设置ssh安全密码。这一步可以使用默认的（即不设置密码），直接按回车即可。倘若想了解更多关于ssh key密码设置的细节，可访问： “Working with SSH key passphrases” 。 \n\n5、 `ssh key`生成后，接下来需要为`ssh key`添加代理，这是为了让请求自动对应相应的账号。网上很多文章写到需要另外配置`config`文件，经本人亲测，其实是不需要的，在生成了`ssh key`后，通过为生成的`ssh key`添加代理即可，为`ssh key`添加代理命令：`ssh-add ~/.ssh/xxx_rsa,xxx_rsa`是你生成的`ssh key`的私钥名。 \n\n6、连接测试 \n接下来我们测试是否配置成功，打开终端，输入: \n```bash\nssh -T git@github.com\n```\n\n\n\n## 怎么快速淘到感兴趣的开源项目？\n\n**UI界面高级搜索**： https://github.com/search/advanced \n\n**命令高级搜索**： \n```bash\ngit 最好 学习 资料 in:readme stars:>1000 language:c\n```\n上述命令的意思是搜索reademe中包含`git、最好、学习、资料`”且`star大于1000`的，用`C语言编写`的仓库。 "
},
{
"path": "notes/Git工作流.md",
"content": "\n\n- [前言](#前言)\n- [一、Git 工作流简介](#一git-工作流简介)\n - [集中式工作流](#集中式工作流)\n - [功能分支工作流](#功能分支工作流)\n - [GitFlow 工作流](#gitflow-工作流)\n - [Forking 工作流](#forking-工作流)\n - [Pull Requests](#pull-requests)\n- [二、工作流](#二工作流)\n - [1. 集中式工作流](#1-集中式工作流)\n - [工作方式](#工作方式)\n - [解决冲突](#解决冲突)\n - [示例](#示例)\n - [有人先初始化好中央仓库](#有人先初始化好中央仓库)\n - [所有人克隆中央仓库](#所有人克隆中央仓库)\n - [小明开发功能](#小明开发功能)\n - [小红开发功能](#小红开发功能)\n - [小明发布功能](#小明发布功能)\n - [小红试着发布功能](#小红试着发布功能)\n - [小红在小明的提交之上 rebase](#小红在小明的提交之上-rebase)\n - [小红解决合并冲突](#小红解决合并冲突)\n - [小红成功发布功能](#小红成功发布功能)\n - [总结](#总结)\n - [2. 功能分支工作流](#2-功能分支工作流)\n - [工作方式](#工作方式-1)\n - [Pull Requests](#pull-requests-1)\n - [示例](#示例-1)\n - [小红开始开发一个新功能](#小红开始开发一个新功能)\n - [小红要去吃个午饭](#小红要去吃个午饭)\n - [小红完成功能开发](#小红完成功能开发)\n - [小黑收到 Pull Request](#小黑收到-pull-request)\n - [小红再做修改](#小红再做修改)\n - [小红发布她的功能](#小红发布她的功能)\n - [与此同时，小明在做和小红一样的事](#与此同时小明在做和小红一样的事)\n - [总结](#总结-1)\n - [3. GitFlow工作流](#3-gitflow工作流)\n - [工作方式](#工作方式-2)\n - [历史分支](#历史分支)\n - [功能分支](#功能分支)\n - [发布分支](#发布分支)\n - [维护分支](#维护分支)\n - [示例](#示例-2)\n - [创建开发分支](#创建开发分支)\n - [小红和小明开始开发新功能](#小红和小明开始开发新功能)\n - [小红完成功能开发](#小红完成功能开发-1)\n - [小红开始准备发布](#小红开始准备发布)\n - [小红完成发布](#小红完成发布)\n - [最终用户发现 Bug](#最终用户发现-bug)\n - [总结](#总结-2)\n - [4. Forking 工作流](#4-forking-工作流)\n - [工作方式](#工作方式-3)\n - [正式仓库](#正式仓库)\n - [Forking 工作流的分支使用方式](#forking-工作流的分支使用方式)\n - [示例](#示例-3)\n - [项目维护者初始化正式仓库](#项目维护者初始化正式仓库)\n - [开发者 fork 正式仓库](#开发者-fork-正式仓库)\n - [开发者克隆自己 fork 出来的仓库](#开发者克隆自己-fork-出来的仓库)\n - [开发者开发自己的功能](#开发者开发自己的功能)\n - [开发者发布自己的功能](#开发者发布自己的功能)\n - [项目维护者集成开发者的功能](#项目维护者集成开发者的功能)\n - [开发者和正式仓库做同步](#开发者和正式仓库做同步)\n - [总结](#总结-3)\n - [5. Pull Requests](#5-pull-requests)\n - [解析 Pull Request](#解析-pull-request)\n - [工作方式](#工作方式-4)\n - [在功能分支工作流中使用 Pull Request](#在功能分支工作流中使用-pull-request)\n - [在 GitFlow 工作流中使用 Pull Request](#在-gitflow-工作流中使用-pull-request)\n - [在 Forking 工作流中使用 Pull Request](#在-forking-工作流中使用-pull-request)\n - [示例](#示例-4)\n - [小红 fork 正式项目](#小红-fork-正式项目)\n - [小红克隆她的 Bitbucket 仓库](#小红克隆她的-bitbucket-仓库)\n - [小红开发新功能](#小红开发新功能)\n - [编辑代码](#编辑代码)\n - [小红 push 功能到她的 Bitbucket 仓库中](#小红-push-功能到她的-bitbucket-仓库中)\n - [小红发起 Pull Request](#小红发起-pull-request)\n - [小明 review Pull Request](#小明-review-pull-request)\n - [小红补加提交](#小红补加提交)\n - [小明接受 Pull Request](#小明接受-pull-request)\n - [总结](#总结-4)\n\n\n\n# 前言\n\n 本文将介绍 Git 工作流相关知识，包含集中式工作流，功能分支工作流， GitFlow 工作流，Forking 工作流，Pull Requests 等等基本概念。\n\n# 一、Git 工作流简介\n\n工作流有各式各样的用法，但也正因此使得在实际工作中如何上手使用增加了难度。这篇指南通过总览公司团队中最常用的几种 Git 工作流让大家可以上手使用。\n\n在阅读的过程中请记住，本文中的几种工作流是作为方案指导而不是条例规定。在展示了各种工作流可能的用法后，你可以从不同的工作流中挑选或揉合出一个满足你自己需求的工作流。\n\n## 集中式工作流\n\n如果你的开发团队成员已经很熟悉 Subversion，集中式工作流让你无需去适应一个全新流程就可以体验 Git 带来的收益。这个工作流也可以作为向更 Git 风格工作流迁移的友好过渡。\n\n \n\n\n\n## 功能分支工作流\n\n功能分支工作流以集中式工作流为基础，不同的是为各个新功能分配一个专门的分支来开发。这样可以在把新功能集成到正式项目前，用 `Pull Requests` 的方式讨论变更。\n\n \n\n\n\n## GitFlow 工作流\n\nGitFlow 工作流通过为功能开发、发布准备和维护分配独立的分支，让发布迭代过程更流畅。严格的分支模型也为大型项目提供了一些非常必要的结构。\n\n \n\n## Forking 工作流\n\nForking 工作流是分布式工作流，充分利用了 Git 在分支和克隆上的优势。可以安全可靠地管理大团队的开发者（developer），并能接受不信任贡献者（contributor）的提交。x\n\n\n\n\n\n \n\n## Pull Requests\n\nPull requests 让开发者更方便地进行协作的功能，提供了友好的 Web 界面可以在提议的修改合并到正式项目之前对修改进行讨论。\n\n \n\n# 二、工作流\n\n## 1. 集中式工作流\n\n转到分布式版本控制系统看起来像个令人生畏的任务，但不改变已用的工作流你也可以用上 Git 带来的收益。团队可以用和 Subversion 完全不变的方式来开发项目。\n\n但使用 Git 加强开发的工作流，Git 比 SVN 有几个优势。首先，每个开发可以有属于自己的整个工程的本地拷贝。隔离的环境让各个开发者的工作和项目的其他部分（修改）独立开来 —— 即自由地提交到自己的本地仓库，先完全忽略上游的开发，直到方便的时候再把修改反馈上去。\n\n其次，Git 提供了强壮的分支和合并模型。不像 SVN，Git 的分支设计成可以做为一种用来在仓库之间集成代码和分享修改的『失败安全』的机制。\n\n### 工作方式\n\n像 Subversion 一样，集中式工作流以中央仓库作为项目所有修改的单点实体。相比 SVN 缺省的开发分支 trunk，Git 叫做 master，所有修改提交到这个分支上。该工作流只用到 master 这一个分支。\n\n开发者开始先克隆中央仓库。在自己的项目拷贝中，像 SVN 一样的编辑文件和提交修改；但修改是存在本地的，和中央仓库是完全隔离的。开发者可以把和上游的同步延后到一个方便时间点。\n\n要发布修改到正式项目中，开发者要把本地 master 分支的修改『推（`push`）』到中央仓库中。这相当于 svn commit 操作，但 `push` 操作会把所有还不在中央仓库的本地提交都推上去。\n\n \n\n### 解决冲突\n\n中央仓库代表了正式项目，所以提交历史应该被尊重且是稳定不变的。如果开发者本地的提交历史和中央仓库有分歧，Git 会拒绝 `push` 提交否则会覆盖已经在中央库的正式提交。\n\n \n\n在开发者提交自己功能修改到中央库前，需要先 `fetch` 在中央库的新增提交，`rebase` 自己提交到中央库提交历史之上。这样做的意思是在说，『我要把自己的修改加到别人已经完成的修改上。』最终的结果是一个完美的线性历史，就像以前的 `SVN` 的工作流中一样。\n\n如果本地修改和上游提交有冲突，Git 会暂停 `rebase` 过程，给你手动解决冲突的机会。Git 解决合并冲突，用和生成提交一样的 `git status` 和 `git add` 命令，很一致方便。还有一点，如果解决冲突时遇到麻烦，Git 可以很简单中止整个 `rebase` 操作，重来一次（或者让别人来帮助解决）。\n\n### 示例\n\n让我们一起逐步分解来看看一个常见的小团队如何用这个工作流来协作的。有两个开发者小明和小红，看他们是如何开发自己的功能并提交到中央仓库上的。\n\n#### 有人先初始化好中央仓库\n\n \n\n第一步，有人在服务器上创建好中央仓库。如果是新项目，你可以初始化一个空仓库；否则你要导入已有的 Git 或 SVN 仓库。\n\n中央仓库应该是个裸仓库（bare repository），即没有工作目录（working directory）的仓库。\n\n#### 所有人克隆中央仓库\n\n \n\n下一步，各个开发者创建整个项目的本地拷贝。通过 `git clone` 命令完成：\n\n```\ngit clone https://github.com/path/to/repo.git\n```\n\n基于你后续会持续和克隆的仓库做交互的假设，克隆仓库时 Git 会自动添加远程别名 origin 指回『父』仓库。\n\n#### 小明开发功能\n\n \n\n在小明的本地仓库中，他使用标准的 Git 过程开发功能：编辑、暂存（Stage）和提交。如果你不熟悉暂存区（Staging Area），这里说明一下：暂存区的用来准备一个提交，但可以不用把工作目录中所有的修改内容都包含进来。这样你可以创建一个高度聚焦的提交，尽管你本地修改很多内容。\n\n```\ngit status # 查看本地仓库的修改状态\ngit add # 暂存文件\ngit commit # 提交文件\n```\n\n请记住，因为这些命令生成的是本地提交，小明可以按自己需求反复操作多次，而不用担心中央仓库上有了什么操作。对需要多个更简单更原子分块的大功能，这个做法是很有用的。\n\n#### 小红开发功能\n\n \n\n与此同时，小红在自己的本地仓库中用相同的编辑、暂存和提交过程开发功能。和小明一样，她也不关心中央仓库有没有新提交；当然更不关心小明在他的本地仓库中的操作，因为所有本地仓库都是私有的。\n\n#### 小明发布功能\n\n \n\n一旦小明完成了他的功能开发，会发布他的本地提交到中央仓库中，这样其它团队成员可以看到他的修改。他可以用下面的 `git push` 命令：\n\n```\ngit push origin master\n```\n\n注意，origin 是在小明克隆仓库时 Git 创建的远程中央仓库别名。master 参数告诉 Git 推送的分支。由于中央仓库自从小明克隆以来还没有被更新过，所以 push 操作不会有冲突，成功完成。\n\n#### 小红试着发布功能\n\n \n\n一起来看看在小明发布修改后，小红 push 修改会怎么样？她使用完全一样的 push 命令：\n\n```\ngit push origin master\n```\n\n但她的本地历史已经和中央仓库有分岐了，Git 拒绝操作并给出下面很长的出错消息：\n\n```\nerror: failed to push some refs to '/path/to/repo.git'\nhint: Updates were rejected because the tip of your current branch is behind\nhint: its remote counterpart. Merge the remote changes (e.g. 'git pull')\nhint: before pushing again.\nhint: See the 'Note about fast-forwards' in 'git push --help' for details.\n```\n\n这避免了小红覆写正式的提交。她要先 pull 小明的更新到她的本地仓库合并上她的本地修改后，再重试。\n\n#### 小红在小明的提交之上 rebase\n\n \n\n小红用 `git pull` 合并上游的修改到自己的仓库中。这条命令类似 `svn update` ——拉取所有上游提交命令到小红的本地仓库，并尝试和她的本地修改合并：\n\n```\ngit pull --rebase origin master\n```\n\n`--rebase` 选项告诉 Git 把小红的提交移到同步了中央仓库修改后的 master 分支的顶部，如下图所示：\n\n \n\n如果你忘加了这个选项，pull 操作仍然可以完成，但每次 pull 操作要同步中央仓库中别人修改时，提交历史会以一个多余的『合并提交』结尾。对于集中式工作流，最好是使用 rebase 而不是生成一个合并提交。\n\n#### 小红解决合并冲突\n\n \n\nrebase 操作过程是把本地提交一次一个地迁移到更新了的中央仓库 master 分支之上。这意味着可能要解决在迁移某个提交时出现的合并冲突，而不是解决包含了所有提交的大型合并时所出现的冲突。这样的方式让你尽可能保持每个提交的聚焦和项目历史的整洁。反过来，简化了哪里引入 Bug 的分析，如果有必要，回滚修改也可以做到对项目影响最小。\n\n如果小红和小明的功能是相关的，不大可能在 rebase 过程中有冲突。如果有，Git 在合并有冲突的提交处暂停 rebase 过程，输出下面的信息并带上相关的指令：\n\n```\nCONFLICT (content): Merge conflict in\n```\n\n \n\nGit 很赞的一点是，任何人可以解决他自己的冲突。在这个例子中，小红可以简单的运行 `git status` 命令来查看哪里有问题。冲突文件列在 Unmerged paths（未合并路径）一节中：\n\n```\n# Unmerged paths:\n# (use \"git reset HEAD ...\" to unstage)\n# (use \"git add/rm ...\" as appropriate to mark resolution)\n#\n# both modified: \n```\n\n接着小红编辑这些文件。修改完成后，用老套路暂存这些文件，并让 `git rebase` 完成剩下的事：\n\n```\ngit add\ngit rebase --continue\n```\n\n要做的就这些了。Git 会继续一个一个地合并后面的提交，如其它的提交有冲突就重复这个过程。\n\n如果你碰到了冲突，但发现搞不定，不要惊慌。只要执行下面这条命令，就可以回到你执行 `git pull --rebase` 命令前的样子：\n\n```\ngit rebase --abort\n```\n\n#### 小红成功发布功能\n\n \n\n小红完成和中央仓库的同步后，就能成功发布她的修改了：\n\n```\ngit push origin master\n```\n\n### 总结\n\n如你所见，仅使用几个 Git 命令我们就可以模拟出传统 Subversion 开发环境。对于要从 SVN 迁移过来的团队来说这太好了，但没有发挥出 Git 分布式本质的优势。\n\n如果你的团队适应了集中式工作流，但想要更流畅的协作效果，绝对值得探索一下功能分支工作流的收益。通过为一个功能分配一个专门的分支，能够做到一个新增功能集成到正式项目之前对新功能进行深入讨论。\n\n\n\n## 2. 功能分支工作流\n\n \n\n一旦你玩转了集中式工作流，在开发过程中可以很简单地加上功能分支，用来鼓励开发者之间协作和简化交流。\n\n功能分支工作流背后的核心思路是所有的功能开发应该在一个专门的分支，而不是在 master 分支上。这个隔离可以方便多个开发者在各自的功能上开发而不会弄乱主干代码。另外，也保证了 master 分支的代码一定不会是有问题的，极大有利于集成环境。\n\n功能开发隔离也让 pull requests 工作流成功可能，pull requests 工作流能为每个分支发起一个讨论，在分支合入正式项目之前，给其它开发者有表示赞同的机会。另外，如果你在功能开发中有问题卡住了，可以开一个 pull requests 来向同学们征求建议。这些做法的重点就是，pull requests 让团队成员之间互相评论工作变成非常方便！\n\n### 工作方式\n\n功能分支工作流仍然用中央仓库，并且 master 分支还是代表了正式项目的历史。但不是直接提交本地历史到各自的本地 master 分支，开发者每次在开始新功能前先创建一个新分支。功能分支应该有个有描述性的名字，比如 animated-menu-items 或 issue-#1061，这样可以让分支有个清楚且高聚焦的用途。\n\n在 master 分支和功能分支之间，Git 是没有技术上的区别，所以开发者可以用和集中式工作流中完全一样的方式编辑、暂存和提交修改到功能分支上。\n\n另外，功能分支也可以（且应该）push 到中央仓库中。这样不修改正式代码就可以和其它开发者分享提交的功能。由于 master 仅有的一个『特殊』分支，在中央仓库上存多个功能分支不会有任何问题。当然，这样做也可以很方便地备份各自的本地提交。\n\n### Pull Requests\n\n功能分支除了可以隔离功能的开发，也使得通过 Pull Requests 讨论变更成为可能。一旦某个开发完成一个功能，不是立即合并到 master，而是 push 到中央仓库的功能分支上并发起一个 Pull Request 请求去合并修改到 master。在修改成为主干代码前，这让其它的开发者有机会先去 Review 变更。\n\nCode Review 是 Pull Requests 的一个重要的收益，但 Pull Requests 目的是讨论代码一个通用方式。你可以把 Pull Requests 作为专门给某个分支的讨论。这意味着可以在更早的开发过程中就可以进行 Code Review。比如，一个开发者开发功能需要帮助时，要做的就是发起一个 Pull Request，相关的人就会自动收到通知，在相关的提交旁边能看到需要帮助解决的问题。\n\n一旦 Pull Request 被接受了，发布功能要做的就和集中式工作流就很像了。首先，确定本地的 master 分支和上游的 master 分支是同步的。然后合并功能分支到本地 master 分支并 push 已经更新的本地 master 分支到中央仓库。\n\n### 示例\n\n下面的示例演示了如何把 Pull Requests 作为 Code Review 的方式，但注意 Pull Requests 可以用于很多其它的目的。\n\n#### 小红开始开发一个新功能\n\n \n\n在开始开发功能前，小红需要一个独立的分支。使用下面的命令新建一个分支：\n\n```\ngit checkout -b marys-feature master\n```\n\n这个命令检出一个基于 master 名为 marys-feature 的分支，Git 的 `-b` 选项表示如果分支还不存在则新建分支。这个新分支上，小红按老套路编辑、暂存和提交修改，按需要提交以实现功能：\n\n```\ngit status\ngit add\ngit commit\n```\n\n#### 小红要去吃个午饭\n\n \n\n早上小红为新功能添加一些提交。去吃午饭前，push 功能分支到中央仓库是很好的做法，这样可以方便地备份，如果和其它开发协作，也让他们可以看到小红的提交。\n\n```\ngit push -u origin marys-feature\n```\n\n这条命令 `push marys-feature` 分支到中央仓库（origin），`-u` 选项设置本地分支去跟踪远程对应的分支。设置好跟踪的分支后，小红就可以使用 `git push` 命令省去指定推送分支的参数。\n\n#### 小红完成功能开发\n\n \n\n小红吃完午饭回来，完成整个功能的开发。在合并到 master 之前，她发起一个 Pull Request 让团队的其它人知道功能已经完成。但首先，她要确认中央仓库中已经有她最近的提交：\n\n```\ngit push\n```\n\n然后，在她的 Git GUI 客户端中发起 Pull Request，请求合并 marys-feature 到 master，团队成员会自动收到通知。Pull Request 很酷的是可以在相关的提交旁边显示评注，所以你可以很对某个变更集提问。\n\n#### 小黑收到 Pull Request\n\n \n\n小黑收到了 Pull Request 后会查看 marys-feature 的修改。决定在合并到正式项目前是否要做些修改，且通过 Pull Request 和小红来回地讨论。\n\n#### 小红再做修改\n\n \n\n要再做修改，小红用和功能第一个迭代完全一样的过程。编辑、暂存、提交并push更新到中央仓库。小红这些活动都会显示在 Pull Request 上，小黑可以断续做评注。\n\n如果小黑有需要，也可以把 marys-feature 分支拉到本地，自己来修改，他加的提交也会一样显示在 Pull Request 上。\n\n#### 小红发布她的功能\n\n \n\n一旦小黑可以的接受 Pull Request，就可以合并功能到稳定项目代码中（可以由小黑或是小红来做这个操作）：\n\n```\ngit checkout master\ngit pull\ngit pull origin marys-feature\ngit push\n```\n\n无论谁来做合并，首先要检出 master 分支并确认是它是最新的。然后执行 `git pull origin marys-feature` 合并 marys-feature 分支到和已经和远程一致的本地 master 分支。你可以使用简单 `git merge marys-feature` 命令，但前面的命令可以保证总是最新的新功能分支。最后更新的 master 分支要重新 push 回到 origin。\n\n这个过程常常会生成一个合并提交。有些开发者喜欢有合并提交，因为它像一个新功能和原来代码基线的连通符。但如果你偏爱线性的提交历史，可以在执行合并时 rebase 新功能到 master 分支的顶部，这样生成一个快进（fast-forward）的合并。\n\n一些 GUI 客户端可以只要点一下『接受』按钮执行好上面的命令来自动化 Pull Request 接受过程。如果你的不能这样，至少在功能合并到 master 分支后能自动关闭 Pull Request。\n\n#### 与此同时，小明在做和小红一样的事\n\n当小红和小黑在 marys-feature 上工作并讨论她的 Pull Request 的时候，小明在自己的功能分支上做完全一样的事。\n\n通过隔离功能到独立的分支上，每个人都可以自主的工作，当然必要的时候在开发者之间分享变更还是比较繁琐的。\n\n### 总结\n\n到了这里，但愿你发现了功能分支可以很直接地在集中式工作流的仅有的 master 分支上完成多功能的开发。另外，功能分支还使用了 Pull Request，使得可以在你的版本控制 GUI 客户端中讨论某个提交。\n\n功能分支工作流是开发项目异常灵活的方式。问题是，有时候太灵活了。对于大型团队，常常需要给不同分支分配一个更具体的角色。GitFlow 工作流是管理功能开发、发布准备和维护的常用模式。\n\n\n\n## 3. GitFlow工作流\n\n \n\nGitFlow 工作流定义了一个围绕项目发布的严格分支模型。虽然比功能分支工作流复杂几分，但提供了用于一个健壮的用于管理大型项目的框架。\n\nGitFlow 工作流没有用超出功能分支工作流的概念和命令，而是为不同的分支分配一个很明确的角色，并定义分支之间如何和什么时候进行交互。除了使用功能分支，在做准备、维护和记录发布也使用各自的分支。当然你可以用上功能分支工作流所有的好处：Pull Requests、隔离实验性开发和更高效的协作。\n\n### 工作方式\n\nGitFlow 工作流仍然用中央仓库作为所有开发者的交互中心。和其它的工作流一样，开发者在本地工作并 push 分支到中央仓库中。\n\n#### 历史分支\n\n相对使用仅有的一个 master 分支，GitFlow 工作流使用2个分支来记录项目的历史。master 分支存储了正式发布的历史，而 develop 分支作为功能的集成分支。这样也方便 master 分支上的所有提交分配一个版本号。\n\n \n\n剩下要说明的问题围绕着这2个分支的区别展开。\n\n#### 功能分支\n\n每个新功能位于一个自己的分支，这样可以 push 到中央仓库以备份和协作。但功能分支不是从 master 分支上拉出新分支，而是使用 develop 分支作为父分支。当新功能完成时，合并回 develop 分支。新功能提交应该从不直接与 master 分支交互。\n\n \n\n注意，从各种含义和目的上来看，功能分支加上 develop 分支就是功能分支工作流的用法。但 GitFlow 工作流没有在这里止步。\n\n#### 发布分支\n\n \n\n一旦 develop 分支上有了做一次发布（或者说快到了既定的发布日）的足够功能，就从 develop 分支上 fork 一个发布分支。新建的分支用于开始发布循环，所以从这个时间点开始之后新的功能不能再加到这个分支上 —— 这个分支只应该做 Bug 修复、文档生成和其它面向发布任务。一旦对外发布的工作都完成了，发布分支合并到 master 分支并分配一个版本号打好 Tag。另外，这些从新建发布分支以来的做的修改要合并回 develop 分支。\n\n使用一个用于发布准备的专门分支，使得一个团队可以在完善当前的发布版本的同时，另一个团队可以继续开发下个版本的功能。这也打造定义良好的开发阶段（比如，可以很轻松地说，『这周我们要做准备发布版本 4.0』，并且在仓库的目录结构中可以实际看到）。\n\n常用的分支约定：\n\n- 用于新建发布分支的分支: develop\n- 用于合并的分支: master\n- 分支命名: release- *或 release/*\n\n#### 维护分支\n\n \n\n维护分支或说是热修复（hotfix）分支用于生成快速给产品发布版本（production releases）打补丁，这是唯一可以直接从 master 分支 fork 出来的分支。修复完成，修改应该马上合并回 master 分支和 develop 分支（当前的发布分支），master 分支应该用新的版本号打好 Tag。\n\n为 Bug 修复使用专门分支，让团队可以处理掉问题而不用打断其它工作或是等待下一个发布循环。你可以把维护分支想成是一个直接在 master 分支上处理的临时发布。\n\n### 示例\n\n下面的示例演示本工作流如何用于管理单个发布循环。假设你已经创建了一个中央仓库。\n\n#### 创建开发分支\n\n \n\n第一步为 master 分支配套一个 develop 分支。简单来做可以本地创建一个空的 develop 分支，push 到服务器上：\n\n```\ngit branch develop\ngit push -u origin develop\n```\n\n以后这个分支将会包含了项目的全部历史，而 master 分支将只包含了部分历史。其它开发者这时应该克隆中央仓库，建好 develop 分支的跟踪分支：\n\n```\ngit clone ssh://user@host/path/to/repo.git\ngit checkout -b develop origin/develop\n```\n\n现在每个开发都有了这些历史分支的本地拷贝。\n\n#### 小红和小明开始开发新功能\n\n \n\n这个示例中，小红和小明开始各自的功能开发。他们需要为各自的功能创建相应的分支。新分支不是基于 master 分支，而是应该基于 develop 分支：\n\n```\ngit checkout -b some-feature develop\n```\n\n他们用老套路添加提交到各自功能分支上：编辑、暂存、提交：\n\n```\ngit status\ngit add\ngit commit\n```\n\n#### 小红完成功能开发\n\n \n\n添加了提交后，小红觉得她的功能 OK 了。如果团队使用 Pull Requests，这时候可以发起一个用于合并到 develop 分支。否则她可以直接合并到她本地的 develop 分支后 push 到中央仓库：\n\n```\ngit pull origin develop\ngit checkout develop\ngit merge some-feature\ngit push\ngit branch -d some-feature\n```\n\n第一条命令在合并功能前确保 develop 分支是最新的。注意，功能决不应该直接合并到 master 分支。冲突解决方法和集中式工作流一样。\n\n#### 小红开始准备发布\n\n \n\n这个时候小明正在实现他的功能，小红开始准备她的第一个项目正式发布。像功能开发一样，她用一个新的分支来做发布准备。这一步也确定了发布的版本号：\n\n```\ngit checkout -b release-0.1 develop\n```\n\n这个分支是清理发布、执行所有测试、更新文档和其它为下个发布做准备操作的地方，像是一个专门用于改善发布的功能分支。\n\n只要小红创建这个分支并 push 到中央仓库，这个发布就是功能冻结的。任何不在 develop 分支中的新功能都推到下个发布循环中。\n\n#### 小红完成发布\n\n \n\n一旦准备好了对外发布，小红合并修改到 master 分支和 develop 分支上，删除发布分支。合并回 develop 分支很重要，因为在发布分支中已经提交的更新需要在后面的新功能中也要是可用的。另外，如果小红的团队要求 Code Review，这是一个发起 Pull Request 的理想时机。\n\n```\ngit checkout master\ngit merge release-0.1\ngit push\ngit checkout develop\ngit merge release-0.1\ngit push\ngit branch -d release-0.1\n```\n\n发布分支是作为功能开发（develop 分支）和对外发布（master 分支）间的缓冲。只要有合并到 master 分支，就应该打好 Tag 以方便跟踪。\n\n```\ngit tag -a 0.1 -m \"Initial public release\" master\ngit push --tags\n```\n\nGit 有提供各种勾子（hook），即仓库有事件发生时触发执行的脚本。可以配置一个勾子，在你 push 中央仓库的 master 分支时，自动构建好对外发布。\n\n#### 最终用户发现 Bug\n\n \n\n对外发布后，小红回去和小明一起做下个发布的新功能开发，直到有最终用户开了一个 Ticket 抱怨当前版本的一个 Bug。为了处理 Bug，小红（或小明）从 master 分支上拉出了一个维护分支，提交修改以解决问题，然后直接合并回 master 分支：\n\n```\ngit checkout -b issue-#001 master\n# Fix the bug\ngit checkout master\ngit merge issue-#001\ngit push\n```\n\n就像发布分支，维护分支中新加这些重要修改需要包含到 develop 分支中，所以小红要执行一个合并操作。然后就可以安全地删除这个分支了：\n\n```\ngit checkout develop\ngit merge issue-#001\ngit push\ngit branch -d issue-#001\n```\n\n### 总结\n\n到了这里，但愿你对集中式工作流、功能分支工作流和 GitFlow 工作流已经感觉很舒适了。你应该也牢固的掌握了本地仓库的潜能，push/pull 模式和 Git 健壮的分支和合并模型。\n\n记住，这里演示的工作流只是可能用法的例子，而不是在实际工作中使用 Git 不可违逆的条例。所以不要畏惧按自己需要对工作流的用法做取舍。不变的目标就是让 Git 为你所用。\n\n\n\n## 4. Forking 工作流\n\nForking 工作流和前面讨论的几种工作流有根本的不同。这种工作流不是使用单个服务端仓库作为『中央』代码基线，而让各个开发者都有一个服务端仓库。这意味着各个代码贡献者有 2 个 Git 仓库而不是 1 个：一个本地私有的，另一个服务端公开的。\n\n \n\nForking 工作流的一个主要优势是，贡献的代码可以被集成，而不需要所有人都能 push 代码到仅有的中央仓库中。开发者 push 到自己的服务端仓库，而只有项目维护者才能 push 到正式仓库。这样项目维护者可以接受任何开发者的提交，但无需给他正式代码库的写权限。\n\n效果就是一个分布式的工作流，能为大型、自发性的团队（包括了不受信的第三方）提供灵活的方式来安全的协作。也让这个工作流成为开源项目的理想工作流。\n\n### 工作方式\n\n和其它的 Git 工作流一样，Forking 工作流要先有一个公开的正式仓库存储在服务器上。但一个新的开发者想要在项目上工作时，不是直接从正式仓库克隆，而是 fork 正式项目在服务器上创建一个拷贝。\n\n这个仓库拷贝作为他个人公开仓库 —— 其它开发者不允许 push 到这个仓库，但可以 pull 到修改（后面我们很快就会看这点很重要）。在创建了自己服务端拷贝之后，和之前的工作流一样，开发者执行 git clone 命令克隆仓库到本地机器上，作为私有的开发环境。\n\n要提交本地修改时，push 提交到自己公开仓库中 —— 而不是正式仓库中。然后，给正式仓库发起一个 pull request，让项目维护者知道有更新已经准备好可以集成了。对于贡献的代码，pull request 也可以很方便地作为一个讨论的地方。\n\n为了集成功能到正式代码库，维护者 pull 贡献者的变更到自己的本地仓库中，检查变更以确保不会让项目出错，合并变更到自己本地的 master 分支，然后 push master 分支到服务器的正式仓库中。到此，贡献的提交成为了项目的一部分，其它的开发者应该执行 pull 操作与正式仓库同步自己本地仓库。\n\n#### 正式仓库\n\n在 Forking 工作流中，『官方』仓库的叫法只是一个约定，理解这点很重要。从技术上来看，各个开发者仓库和正式仓库在Git看来没有任何区别。事实上，让正式仓库之所以正式的唯一原因是它是项目维护者的公开仓库。\n\n#### Forking 工作流的分支使用方式\n\n所有的个人公开仓库实际上只是为了方便和其它的开发者共享分支。各个开发者应该用分支隔离各个功能，就像在功能分支工作流和 GitFlow 工作流一样。唯一的区别是这些分支被共享了。在 Forking 工作流中这些分支会被 pull 到另一个开发者的本地仓库中，而在功能分支工作流和 GitFlow 工作流中是直接被 push 到正式仓库中。\n\n### 示例\n\n#### 项目维护者初始化正式仓库\n\n \n\n和任何使用 Git 项目一样，第一步是创建在服务器上一个正式仓库，让所有团队成员都可以访问到。通常这个仓库也会作为项目维护者的公开仓库。\n\n公开仓库应该是裸仓库，不管是不是正式代码库。所以项目维护者会运行像下面的命令来搭建正式仓库：\n\n```\nssh user@host\ngit init --bare /path/to/repo.git\n```\n\nBitbucket 和 Stash 提供了一个方便的 GUI 客户端以完成上面命令行做的事。这个搭建中央仓库的过程和前面提到的工作流完全一样。如果有现存的代码库，维护者也要 push 到这个仓库中。\n\n#### 开发者 fork 正式仓库\n\n \n\n其它所有的开发需要 fork 正式仓库。可以用 git clone 命令用 SSH 协议连通到服务器，拷贝仓库到服务器另一个位置 —— 是的，fork 操作基本上就只是一个服务端的克隆。Bitbucket 和 Stash 上可以点一下按钮就让开发者完成仓库的 fork 操作。\n\n这一步完成后，每个开发都在服务端有一个自己的仓库。和正式仓库一样，这些仓库应该是裸仓库。\n\n#### 开发者克隆自己 fork 出来的仓库\n\n \n\n下一步，各个开发者要克隆自己的公开仓库，用熟悉的 git clone 命令。\n\n在这个示例中，假定用 Bitbucket 托管了仓库。记住，如果这样的话各个开发者需要有各自的 Bitbucket 账号，使用下面命令克隆服务端自己的仓库：\n\n```\ngit clone https://user@bitbucket.org/user/repo.git\n```\n\n相比前面介绍的工作流只用了一个 origin 远程别名指向中央仓库，Forking 工作流需要 2 个远程别名 —— 一个指向正式仓库，另一个指向开发者自己的服务端仓库。别名的名字可以任意命名，常见的约定是使用 origin 作为远程克隆的仓库的别名（这个别名会在运行 git clone 自动创建），upstream（上游）作为正式仓库的别名。\n\n```\ngit remote add upstream https://bitbucket.org/maintainer/repo\n```\n\n需要自己用上面的命令创建 upstream 别名。这样可以简单地保持本地仓库和正式仓库的同步更新。注意，如果上游仓库需要认证（比如不是开源的），你需要提供用户：\n\n```\ngit remote add upstream https://user@bitbucket.org/maintainer/repo.git\n```\n\n这时在克隆和 pull 正式仓库时，需要提供用户的密码。\n\n#### 开发者开发自己的功能\n\n \n\n在刚克隆的本地仓库中，开发者可以像其它工作流一样的编辑代码、提交修改和新建分支：\n\n```\ngit checkout -b some-feature\n// Edit some code\ngit commit -a -m \"Add first draft of some feature\"\n```\n\n所有的修改都是私有的直到 push 到自己公开仓库中。如果正式项目已经往前走了，可以用 git pull 命令获得新的提交：\n\n```\ngit pull upstream master\n```\n\n由于开发者应该都在专门的功能分支上工作，pull 操作结果会都是快进合并。\n\n#### 开发者发布自己的功能\n\n \n\n一旦开发者准备好了分享新功能，需要做二件事。首先，通过push他的贡献代码到自己的公开仓库中，让其它的开发者都可以访问到。他的 origin 远程别名应该已经有了，所以要做的就是：\n\n```\ngit push origin feature-branch\n```\n\n这里和之前的工作流的差异是，origin 远程别名指向开发者自己的服务端仓库，而不是正式仓库。\n\n第二件事，开发者要通知项目维护者，想要合并他的新功能到正式库中。Bitbucket 和 Stash 提供了 Pull Request 按钮，弹出表单让你指定哪个分支要合并到正式仓库。一般你会想集成你的功能分支到上游远程仓库的 master 分支中。\n\n#### 项目维护者集成开发者的功能\n\n \n\n当项目维护者收到 pull request，他要做的是决定是否集成它到正式代码库中。有二种方式来做：\n\n- 直接在 pull request 中查看代码\n- pull 代码到他自己的本地仓库，再手动合并\n\n第一种做法更简单，维护者可以在 GUI 中查看变更的差异，做评注和执行合并。但如果出现了合并冲突，需要第二种做法来解决。这种情况下，维护者需要从开发者的服务端仓库中 fetch 功能分支，合并到他本地的 master 分支，解决冲突：\n\n```\ngit fetch https://bitbucket.org/user/repo feature-branch\n// 查看变更\ngit checkout master\ngit merge FETCH_HEAD\n```\n\n变更集成到本地的 master 分支后，维护者要 push 变更到服务器上的正式仓库，这样其它的开发者都能访问到：\n\n```\ngit push origin master\n```\n\n注意，维护者的 origin 是指向他自己公开仓库的，即是项目的正式代码库。到此，开发者的贡献完全集成到了项目中\n\n#### 开发者和正式仓库做同步\n\n \n\n由于正式代码库往前走了，其它的开发需要和正式仓库做同步：\n\n```\ngit pull upstream master\n```\n\n### 总结\n\n如果你之前是使用 SVN，Forking 工作流可能看起来像是一个激进的范式切换（paradigm shift）。但不要害怕，这个工作流实际上就是在功能分支工作流之上引入另一个抽象层。不是直接通过单个中央仓库来分享分支，而是把贡献代码发布到开发者自己的服务端仓库中。\n\n示例中解释了，一个贡献如何从一个开发者流到正式的 master 分支中，但同样的方法可以把贡献集成到任一个仓库中。比如，如果团队的几个人协作实现一个功能，可以在开发之间用相同的方法分享变更，完全不涉及正式仓库。\n\n这使得 Forking 工作流对于松散组织的团队来说是个非常强大的工具。任一开发者可以方便地和另一开发者分享变更，任何分支都能有效地合并到正式代码库中。\n\n\n\n\n\n## 5. Pull Requests\n\nPull Requests 是 Bitbucket 上方便开发者之间协作的功能。提供了一个用户友好的 Web 界面，在集成提交的变更到正式项目前可以对变更进行讨论。\n\n \n\n开发者向团队成员通知功能开发已经完成，Pull Requests 是最简单的用法。开发者完成功能开发后，通过 Bitbucket 账号发起一个 Pull Request。这样让涉及这个功能的所有人知道，要去做 Code Review 和合并到 master 分支。\n\n但是，Pull Request 远不止一个简单的通知，而是为讨论提交的功能的一个专门论坛。如果变更有任何问题，团队成员反馈在 Pull Request 中，甚至 push 新的提交微调功能。所有的这些活动都直接跟踪在 Pull Request 中。\n\n \n\n相比其它的协作模型，这种分享提交的形式有助于打造一个更流畅的工作流。SVN 和 Git 都能通过一个简单的脚本收到通知邮件；但是，讨论变更时，开发者通常只能去回复邮件。这样做会变得杂乱，尤其还要涉及后面的几个提交时。Pull Requests 把所有相关功能整合到一个和 Bitbucket 仓库界面集成的用户友好 Web 界面中。\n\n### 解析 Pull Request\n\n当要发起一个 Pull Request，你所要做的就是请求（Request）另一个开发者（比如项目的维护者），来 pull 你仓库中一个分支到他的仓库中。这意味着你要提供 4 个信息（源仓库、源分支、目的仓库、目的分支），以发起 Pull Request。\n\n \n\n### 工作方式\n\nPull Request 可以和功能分支工作流、GitFlow 工作流或 Forking 工作流一起使用。但 Pull Request 要求要么分支不同，要么仓库不同，所以不能用于集中式工作流。在不同的工作流中使用 Pull Request 会有一些不同，但基本的过程是这样的：\n\n- 开发者在本地仓库中新建一个专门的分支开发功能。\n- 开发者 push 分支修改到公开的 Bitbucket 仓库中。\n- 开发者通过 Bitbucket 发起一个 Pull Request。\n- 团队的其它成员 review code，讨论并修改。\n- 项目维护者合并功能到官方仓库中并关闭 Pull Request。\n\n#### 在功能分支工作流中使用 Pull Request\n\n功能分支工作流用一个共享的 Bitbucket 仓库来管理协作，开发者在专门的分支上开发功能。但不是立即合并到 master 分支上，而是在合并到主代码库之前开发者应该开一个 Pull Request 发起功能的讨论。\n\n \n\n功能分支工作流只有一个公开的仓库，所以 Pull Request 的目的仓库和源仓库总是同一个。通常开发者会指定他的功能分支作为源分支，master 分支作为目的分支。\n\n收到 Pull Request 后，项目维护者要决定如何做。如果功能没问题，就简单地合并到 master 分支，关闭 Pull Request。但如果提交的变更有问题，他可以在 Pull Request 中反馈。之后新加的提交也会评论之后接着显示出来\n\n在功能还没有完全开发完的时候，也可能发起一个 Pull Request。比如开发者在实现某个需求时碰到了麻烦，他可以发一个包含正在进行中工作的 Pull Request。其它的开发者可以在 Pull Request 提供建议，或者甚至直接添加提交来解决问题。\n\n#### 在 GitFlow 工作流中使用 Pull Request\n\nGitFlow 工作流和功能分支工作流类似，但围绕项目发布定义一个严格的分支模型。在 GitFlow 工作流中使用 Pull Request 让开发者在发布分支或是维护分支上工作时，可以有个方便的地方对关于发布分支或是维护分支的问题进行交流。\n\n \n\nGitFlow 工作流中 Pull Request 的使用过程和上一节中完全一致：当一个功能、发布或是热修复分支需要 Review 时，开发者简单发起一个 Pull Request，团队的其它成员会通过 Bitbucket 收到通知。\n\n新功能一般合并到 develop 分支，而发布和热修复则要同时合并到 develop 分支和 master 分支上。Pull Request 可能用做所有合并的正式管理。\n\n#### 在 Forking 工作流中使用 Pull Request\n\n在 Forking 工作流中，开发者 push 完成的功能到他自己的仓库中，而不是共享仓库。然后，他发起一个 Pull Request，让项目维护者知道他的功能已经可以 Review 了。\n\n在这个工作流，Pull Request 的通知功能非常有用，因为项目维护者不可能知道其它开发者在他们自己的仓库添加了提交\n\n \n\n由于各个开发有自己的公开仓库，Pull Request 的源仓库和目标仓库不是同一个。源仓库是开发者的公开仓库，源分支是包含了修改的分支。如果开发者要合并修改到正式代码库中，那么目标仓库是正式仓库，目标分支是 master 分支。\n\nPull Request 也可以用于正式项目之外的其它开发者之间的协作。比如，如果一个开发者和一个团队成员一起开发一个功能，他们可以发起一个 Pull Request，用团队成员的 Bitbucket 仓库作为目标，而不是正式项目的仓库。然后使用相同的功能分支作为源和目标分支。\n\n \n\n2 个开发者之间可以在 Pull Request 中讨论和开发功能。完成开发后，他们可以发起另一个 Pull Request，请求合并功能到正式的 master 分支。在 Forking 工作流中，这样的灵活性让 Pull Request 成为一个强有力的协作工具。\n\n### 示例\n\n下面的示例演示了 Pull Request 如何在在 Forking 工作流中使用。也同样适用于小团队的开发协作和第三方开发者向开源项目的贡献。\n\n在示例中，小红是个开发，小明是项目维护者。他们各自有一个公开的 Bitbucket 仓库，而小明的仓库包含了正式工程。\n\n#### 小红 fork 正式项目\n\n \n\n小红先要 fork 小明的 Bitbucket 仓库，开始项目的开发。她登陆 Bitbucket，浏览到小明的仓库页面，点 Fork 按钮。\n\n \n\n然后为 fork 出来的仓库填写名字和描述，这样小红就有了服务端的项目拷贝了。\n\n#### 小红克隆她的 Bitbucket 仓库\n\n \n\n下一步，小红克隆自己刚才 fork 出来的 Bitbucket 仓库，以在本机上准备出工作拷贝。命令如下：\n\n```\ngit clone https://user@bitbucket.org/user/repo.git\n```\n\n请记住，`git clone` 会自动创建 origin 远程别名，是指向小红 fork 出来的仓库。\n\n#### 小红开发新功能\n\n在开始改代码前，小红要为新功能先新建一个新分支。她会用这个分支作为 Pull Request 的源分支。\n\n```\ngit checkout -b some-feature\n```\n\n### 编辑代码\n\n```\ngit commit -a -m \"Add first draft of some feature\"\n```\n\n在新功能分支上，小红按需要添加提交。甚至如果小红觉得功能分支上的提交历史太乱了，她可以用交互式 rebase 来删除或压制提交。对于大型项目，整理功能分支的历史可以让项目维护者更容易看出在 Pull Request 中做了什么内容。\n\n#### 小红 push 功能到她的 Bitbucket 仓库中\n\n \n\n小红完成了功能后，push 功能到她自己的 Bitbucket 仓库中（不是正式仓库），用下面简单的命令：\n\n```\ngit push origin some-branch\n```\n\n这时她的变更可以让项目维护者看到了（或者任何想要看的协作者）。\n\n#### 小红发起 Pull Request\n\n \n\nBitbucket 上有了她的功能分支后，小红可以用她的 Bitbucket 账号浏览到她的 fork 出来的仓库页面，点右上角的【Pull Request】按钮，发起一个 Pull Request。弹出的表单自动设置小红的仓库为源仓库，询问小红以指定源分支、目标仓库和目标分支。\n\n小红想要合并功能到正式仓库，所以源分支是她的功能分支，目标仓库是小明的公开仓库，而目标分支是 master 分支。另外，小红需要提供 Pull Request 的标题和描述信息。如果需要小明以外的人审核批准代码，她可以把这些人填在【Reviewers】文本框中。\n\n \n\n创建好了 Pull Request，通知会通过Bitbucket系统消息或邮件（可选）发给小明。\n\n#### 小明 review Pull Request\n\n \n\n在小明的 Bitbucket 仓库页面的 【Pull Request】Tab 可以看到所有人发起的 Pull Request。点击小红的 Pull Request 会显示出 Pull Request 的描述、功能的提交历史和每个变更的差异（diff）。\n\n如果小明想要合并到项目中，只要点一下【Merge】按钮，就可以同意 Pull Request 并合并到 master 分支。\n\n但如果像这个示例中一样小明发现了在小红的代码中的一个小 Bug，要小红在合并前修复。小明可以在整个 Pull Request 上加上评注，或是选择历史中的某个提交加上评注。\n\n \n\n#### 小红补加提交\n\n如果小红对反馈有任何疑问，可以在 Pull Request 中响应，把 Pull Request 当作是她功能讨论的论坛。\n\n小红在她的功能分支新加提交以解决代码问题，并 push 到她的 Bitbucket 仓库中，就像前一轮中的做法一样。这些提交会进入的 Pull Request，小明在原来的评注旁边可以再次 review 变更。\n\n#### 小明接受 Pull Request\n\n最终，小明接受变更，合并功能分支到 master 分支，并关闭 Pull Request。至此，功能集成到项目中，其它的项目开发者可以用标准的 git pull 命令 pull 这些变更到自己的本地仓库中。\n\n### 总结\n\n到了这里，你应该有了所有需要的工具来集成 Pull Request 到你自己的工作流。请记住，Pull Request 并不是为了替代任何基于 Git 的协作工作流，而是它们的一个便利的补充，让团队成员间的协作更轻松方便。"
},
{
"path": "notes/JavaArchitecture/01-Java基础.md",
"content": "# 前言\n\n本文主要包含 Java 核心基础知识，主要根据以下部分进行节选，选择了个人认为在面试中最为核心的部分。\n\n- 《Java程序员面试笔试宝典》何昊，薛鹏，叶向阳 著\n- [《阿里面经OneNote》](https://blog.csdn.net/sinat_22797429/article/details/76293284)\n\n 主要内容：基本概念、面向对象、关键字、基本数据类型与运算、字符串与数组、异常处理、Object 通用方法\n\n\n\n# 一、基本概念\n\n## 1. Java程序初始化的顺序是怎么样的\n\n 在 Java 语言中，当实例化对象时，对象所在类的所有成员变量首先要进行初始化，只有当所有类成员完成初始化后，才会调用对象所在类的构造函数创建象。\n\n**初始化一般遵循3个原则：**\n\n- 静态对象（变量）优先于非静态对象（变量）初始化，静态对象（变量）只初始化一次，而非静态对象（变量）可能会初始化多次；\n- 父类优先于子类进行初始化；\n- 按照成员变量的定义顺序进行初始化。 即使变量定义散布于方法定义之中，它们依然在任何方法（包括构造函数）被调用之前先初始化；\n\n**加载顺序**\n\n- 父类（静态变量、静态语句块）\n- 子类（静态变量、静态语句块）\n- 父类（实例变量、普通语句块）\n- 父类（构造函数）\n- 子类（实例变量、普通语句块）\n- 子类（构造函数）\n\n\n\n**实例** \n\n```java\nclass Base {\n // 1.父类静态代码块\n static {\n System.out.println(\"Base static block!\");\n }\n // 3.父类非静态代码块\n {\n System.out.println(\"Base block\");\n }\n // 4.父类构造器\n public Base() {\n System.out.println(\"Base constructor!\");\n }\n}\n\npublic class Derived extends Base {\n // 2.子类静态代码块\n static{\n System.out.println(\"Derived static block!\");\n }\n // 5.子类非静态代码块\n {\n System.out.println(\"Derived block!\");\n }\n // 6.子类构造器\n public Derived() {\n System.out.println(\"Derived constructor!\");\n }\n public static void main(String[] args) {\n new Derived();\n }\n}\n```\n\n结果是：\n\n```\nBase static block!\nDerived static block!\nBase block\nBase constructor!\nDerived block!\nDerived constructor!\n```\n\n\n\n## 2. Java和C++的区别\n\n- Java 是**纯粹的面向对象语言**，所有的对象都继承自 java.lang.Object，**C++ 为了兼容 C 即支持面向对象也支持面向过程**。\n- Java 通过虚拟机从而实现**跨平台特性**，但是 C++ 依赖于**特定的平台**。\n- Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。\n- Java 支持**自动垃圾回收**，而 C++ 需要**手动回收**。（C++11 中引入智能指针，使用引用计数法垃圾回收）\n- **Java 不支持多重继承**，只能通过实现多个接口来达到相同目的，而 **C++ 支持多重继承**。\n- Java 不支持操作符重载，虽然可以对两个 String 对象支持加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。\n- Java 内置了线程的支持，而 C++ 需要依靠第三方库。\n- Java 的 **goto 是保留字**，但是不可用，C++ 可以使用 goto。\n- Java **不支持条件编译**，C++ 通过 #ifdef #ifndef 等预处理命令从而实现**条件编译**。\n\n\n\n参考资料：\n- [C++ 工程实践(8)：值语义 - 陈硕 - 博客园](http://www.cnblogs.com/Solstice/archive/2011/08/16/2141515.html)\n- [c++11改进我们的程序之垃圾回收](https://www.cnblogs.com/qicosmos/p/3282779.html)\n\n\n\n## 3. 反射\n\n### 先看一个知乎回答\n\n 首先看一个在知乎上的优秀回答吧：\n\n 反射是什么呢？当我们的程序在运行时，需要动态的加载一些类这些类可能之前用不到所以不用加载到 JVM，而是在运行时根据需要才加载，这样的好处对于服务器来说不言而喻。\n\n 举个例子我们的项目底层有时是用 mysql，有时用 oracle，需要动态地根据实际情况加载驱动类，这个时候反射就有用了，假设 com.java.dbtest.myqlConnection，com.java.dbtest.oracleConnection 这两个类我们要用，这时候我们的程序就写得比较动态化，通过 Class tc = Class.forName(\"com.java.dbtest.TestConnection\"); 通过类的全类名让 JVM 在服务器中找到并加载这个类，而如果是 Oracle 则传入的参数就变成另一个了。这时候就可以看到反射的好处了，这个动态性就体现出 Java 的特性了！\n\n 举多个例子，大家如果接触过 spring，会发现当你配置各种各样的 bean 时，是以配置文件的形式配置的，你需要用到哪些 bean 就配哪些，spring 容器就会根据你的需求去动态加载，你的程序就能健壮地运行。\n\n\n\n### 什么是反射\n\n 反射 (Reflection) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序获取自身的信息，并且可以操作类或对象的内部属性。通过 Class 获取 class 信息称之为反射（Reflection）\n\n 简而言之，通过反射，我们可以在运行时获得程序或程序集中每一个类型的成员和成员的信息。\n\n 程序中一般的对象的类型都是在编译期就确定下来的，而 Java 反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建对象，即使这个对象的类型在编译期是未知的。\n\n 反射的核心是 JVM 在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。\n\n Java 反射框架主要提供以下功能：\n\n 1. 在运行时判断任意一个对象所属的类\n\n 2. 在运行时构造任意一个类的对象\n\n 3. 在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用 private 方法）\n\n 4. 在运行时调用任意一个对象的方法\n\n **重点**：是运行时而不是编译时\n\n\n\n### 主要用途\n\n 很多人都认为反射在实际的 Java 开发应用中并不广泛，其实不然。\n\n当我们在使用 IDE （如Eclipse，IDEA）时，当我们输入一个对象或类并想调用它的属性或方法时，一按点号，编译器就会自动列出它的属性或方法，这里就会用到反射。\n\n **反射最重要的用途就是开发各种通用框架**\n\n 很多框架（比如 Spring ）都是配置化的（比如通过 XML 文件配置 JavaBean,Action 之类的），为了保证框架的通用性，它们可能需要根据配置文件加载不同的对象或类，调用不同的方法，这个时候就必须用到反射——运行时动态加载需要加载的对象。\n\n 对与框架开发人员来说，反射虽小但作用非常大，它是各种容器实现的核心。而对于一般的开发者来说，不深入框架开发则用反射用的就会少一点，不过了解一下框架的底层机制有助于丰富自己的编程思想，也是很有益的。\n\n### 获得Class对象\n\n1. 调用运行时类本身的 `.class` 属性\n\n```java\nClass clazz1 = Person.class;\nSystem.out.println(clazz1.getName());\n```\n\n2. 通过运行时类的对象获取 `getClass();`\n\n```java\nPerson p = new Person();\nClass clazz3 = p.getClass();\nSystem.out.println(clazz3.getName());\n```\n3. 使用 Class 类的 `forName` 静态方法\n\n```java\npublic static Class forName(String className)\n// 在JDBC开发中常用此方法加载数据库驱动:\nClass.forName(driver);\n```\n4. （了解）通过类的加载器 ClassLoader\n\n```java\nClassLoader classLoader = this.getClass().getClassLoader();\nClass clazz5 = classLoader.loadClass(className);\nSystem.out.println(clazz5.getName());\n```\n\n\n\n参考资料：\n\n- [深入解析Java反射（1） - 基础 | 「浮生若梦」 - sczyh30's blog](https://www.sczyh30.com/posts/Java/java-reflection-1/#%E4%B8%80%E3%80%81%E5%9B%9E%E9%A1%BE%EF%BC%9A%E4%BB%80%E4%B9%88%E6%98%AF%E5%8F%8D%E5%B0%84%EF%BC%9F)\n- [学习java应该如何理解反射？ - 知乎](https://www.zhihu.com/question/24304289/answer/147529485)\n\n\n\n## 4. 注解\n\n### 什么是注解\n\n Annontation 是 Java5 开始引入的新特征，中文名称叫注解。它提供了一种安全的类似注释的机制，用来**将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联**。为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且供指定的工具或框架使用。Annontation 像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。\n\n Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。包含在 ` java.lang.annotation` 包中。\n\n 简单来说：注解其实就是**代码中的特殊标记**，这些标记可以**在编译、类加载、运行时被读取，并执行相对应的处理**。 \n\n\n\n### 为什么要用注解\n\n传统的方式，我们是通过配置文件 `.xml` 来告诉类是如何运行的。\n\n有了注解技术以后，我们就可以通过注解告诉类如何运行\n\n例如：我们以前编写 Servlet 的时候，需要在 web.xml 文件配置具体的信息。我们使用了注解以后，可以直接在 Servlet 源代码上，增加注解...Servlet 就被配置到 Tomcat 上了。也就是说，注解可以给类、方法上注入信息。\n\n明显地可以看出，这样是非常直观的，并且 Servlet 规范是推崇这种配置方式的。 \n\n\n\n### 基本Annotation\n\n在 java.lang 包下存在着5个基本的 Annotation，重点掌握前三个。\n\n1. @Override 重写注解\n - 如果我们使用IDE重写父类的方法，我们就可以看见它了。\n - @Override是告诉编译器要检查该方法是实现父类的，可以帮我们避免一些低级的错误。\n - 比如，我们在实现 equals() 方法的时候，把 euqals() 打错了，那么编译器就会发现该方法并不是实现父类的，与注解 @Override 冲突，于是就会给予错误。\n\n2. @Deprecated 过时注解\n - 该注解也非常常见，Java 在设计的时候，可能觉得某些方法设计得不好，为了兼容以前的程序，是不能直接把它抛弃的，于是就设置它为过时。\n - Date对象中的 toLocalString() 就被设置成过时了\n - 当我们在程序中调用它的时候，在 IDE 上会出现一条横杠，说明该方法是过时的。\n\n```java\n@Deprecated\npublic String toLocaleString() {\n DateFormat formatter = DateFormat.getDateTimeInstance();\n return formatter.format(this);\n}\n```\n\n3. @SuppressWarnings 抑制编译器警告注解\n - 该注解在我们写程序的时候并不是很常见，我们可以用它来让编译器不给予我们警告\n - 当我们在使用集合的时候，如果没有指定泛型，那么会提示安全检查的警告\n - 如果我们在类上添加了@SuppressWarnings这个注解，那么编译器就不会给予我们警告了 \n\n4. @SafeVarargs Java 7“堆污染”警告\n - 什么是堆污染呢？？当把一个不是泛型的集合赋值给一个带泛型的集合的时候，这种情况就很容易发生堆污染。\n - 这个注解也是用来抑制编译器警告的注解，用的地方并不多。\n\n5. @FunctionalInterface 用来指定该接口是函数式接口\n - 用该注解显式指定该接口是一个函数式接口。\n\n\n\n### 自定义注解类编写规则\n\n1. Annotation 型定义为 @interface, 所有的 Annotation 会自动继承 java.lang.Annotation 这一接口，并且不能再去继承别的类或是接口.\n2. 参数成员只能用 public 或默认(default)这两个访问权修饰\n3. 参数成员只能用基本类型 byte,short,char,int,long,float,double,boolean 八种基本数据类型和 String、Enum、Class、annotations 等数据类型，以及这一些类型的数组\n4. 要获取类方法和字段的注解信息，必须通过 Java 的反射技术来获取 Annotation 对象，因为你除此之外没有别的获取注解对象的方法\n5. 注解也可以没有定义成员, 不过这样注解就没啥用了\n PS：自定义注解需要使用到元注解\n\n\n\n### 自定义注解实例\n\n```java\nimport java.lang.annotation.Documented;\nimport java.lang.annotation.Retention;\nimport java.lang.annotation.Target;\nimport static java.lang.annotation.ElementType.FIELD;\nimport static java.lang.annotation.RetentionPolicy.RUNTIME;\n\n/**\n * 水果名称注解\n */\n@Target(FIELD)\n@Retention(RUNTIME)\n@Documented\npublic @interface FruitName {\n String value() default \"\";\n}\n```\n\n 参考资料：[注解Annotation实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)\n\n\n\n## 5. 泛型\n\n### 通俗解释\n\n 通俗的讲，泛型就是操作类型的 占位符，即：假设占位符为 T，那么此次声明的数据结构操作的数据类型为T类型。\n\n 假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？答案是可以使用 **Java 泛型**。\n\n 使用 Java 泛型的概念，我们可以写一个泛型方法来对一个对象数组排序。然后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。\n\n### 泛型方法\n\n 你可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。\n\n下面是定义泛型方法的规则：\n\n- 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的 \\）。\n- 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。\n- 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。\n- 泛型方法体的声明和其他方法一样。注意类型参数 **只能代表引用型类型，不能是原始类型** （像 int,double,char 的等）。\n\n```java\npublic class GenericMethodTest\n{\n // 泛型方法 printArray \n public static < E > void printArray( E[] inputArray )\n {\n // 输出数组元素 \n for ( E element : inputArray ){ \n System.out.printf( \"%s \", element );\n }\n System.out.println();\n }\n \n public static void main( String args[] )\n {\n // 创建不同类型数组： Integer, Double 和 Character\n Integer[] intArray = { 1, 2, 3, 4, 5 };\n Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };\n Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };\n \n System.out.println( \"整型数组元素为:\" );\n printArray( intArray ); // 传递一个整型数组\n \n System.out.println( \"\\n双精度型数组元素为:\" );\n printArray( doubleArray ); // 传递一个双精度型数组\n \n System.out.println( \"\\n字符型数组元素为:\" );\n printArray( charArray ); // 传递一个字符型数组\n } \n}\n```\n\n\n\n### 泛型类\n\n 泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。\n\n 和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。\n\n```java\npublic class Box {\n\tprivate T t;\n\tpublic void add(T t) {\n\t this.t = t;\n\t}\n\n\tpublic T get() {\n\t return t;\n\t}\n\n\tpublic static void main(String[] args) {\n\t Box integerBox = new Box();\n\t Box stringBox = new Box();\n\n\t integerBox.add(new Integer(10));\n\t stringBox.add(new String(\"菜鸟教程\"));\n\n\t System.out.printf(\"整型值为 :%d\\n\\n\", integerBox.get());\n\t System.out.printf(\"字符串为 :%s\\n\", stringBox.get());\n\t}\n}\n```\n\n### 类型通配符\n\n1. 类型通配符一般是使用 `?` 代替具体的类型参数。例如 `List` 在逻辑上是 `List`，`List` 等所有 **List<具体类型实参>** 的父类。 \n\n2. 类型通配符上限通过形如 List 来定义，如此定义就是通配符泛型值接受 Number 及其下层子类类型。 \n\n3. 类型通配符下限通过形如 List 来定义，表示类型只能接受 Number 及其三层父类类型，如 Objec 类型的实例。 \n\n\n\n参考资料：\n\n- [Java 泛型，了解这些就够用了。 - 逃离沙漠 - 博客园](https://www.cnblogs.com/demingblog/p/5495610.html)\n- [Java 泛型 | 菜鸟教程](http://www.runoob.com/java/java-generics.html)\n- [【Java心得总结四】Java泛型下——万恶的擦除 - xlturing - 博客园](https://www.cnblogs.com/xltcjylove/p/3671943.html)\n \n\n\n\n## 6. 字节与字符的区别\n\n理解编码的关键，是要把字符的概念和字节的概念理解准确。这两个概念容易混淆，我们在此做一下区分：\n\n| 类型 | **概念描述** | **举例** |\n| -------------- | ------------------------------------------------------------ | ----------------------------- |\n| 字符 | 人们使用的记号，抽象意义上的一个符号。 | '1', '中', 'a', '$', '￥', …… |\n| 字节 | 计算机中存储数据的单元，一个 8 位的二进制数，是一个很具体的存储空间。 | 0x01, 0x45, 0xFA, …… |\n| ANSI 字符串 | 在内存中，如果“字符”是以 **ANSI 编码**形式存在的，一个字符可能使用一个字节或多个字节来表示，那么我们称这种字符串为 **ANSI 字符串**或者**多字节字符串**。 | \"中文123\" （占7字节） |\n| UNICODE 字符串 | 在内存中，如果“字符”是以在 UNICODE 中的序号存在的，那么我们称这种字符串为 **UNICODE 字符串**或者**宽字节字符串**。 | L\"中文123\" （占10字节） |\n\n\n\n**字节与字符区别**\n\n它们完全不是一个位面的概念，所以两者之间没有“区别”这个说法。不同编码里，字符和字节的对应关系不同：\n\n| 类型 | **概念描述** |\n| ------- | ------------------------------------------------------------ |\n| ASCII | 一个英文字母（不分大小写）占一个字节的空间，一个中文汉字占两个字节的空间。一个二进制数字序列，在计算机中作为一个数字单元，一般为 8 位二进制数，换算为十进制。最小值 0，最大值 255。 |\n| UTF-8 | 一个英文字符等于一个字节，一个中文（含繁体）等于三个字节 |\n| Unicode | 一个英文等于两个字节，一个中文（含繁体）等于两个字节。符号：英文标点占一个字节，中文标点占两个字节。举例：英文句号“.”占 1 个字节的大小，中文句号“。”占 2 个字节的大小。 |\n| UTF-16 | 一个英文字母字符或一个汉字字符存储都需要 2 个字节（Unicode扩展区的一些汉字存储需要4个字节） |\n| UTF-32 | 世界上任何字符的存储都需要 4 个字节 |\n\n\n\n参考资料：\n\n- [字符，字节和编码 - Characters, Bytes And Encoding](http://www.regexlab.com/zh/encoding.htm)\n\n\n\n## 7. 有哪些访问修饰符\n\nJava 面向对象的基本思想之一是封装细节并且公开接口。Java 语言采用访问控制修饰符来控制类及类的方法和变量的访问权限，从而向使用者暴露接口，但隐藏实现细节。访问控制分为四种级别：\n\n| 修饰符 | 当前类 | 同 包 | 子 类 | 其他包 |\n| --------- | ------ | ----- | ----- | ------ |\n| public | √ | √ | √ | √ |\n| protected | √ | √ | √ | × |\n| default | √ | √ | × | × |\n| private | √ | × | × | × |\n\n- 类的成员不写访问修饰时默认为 default。默认对于同一个包中的其他类相当于公开（public），对于不是同一个包中的其他类相当于私有（private）。\n- 受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。\n- Java 中，外部类的修饰符只能是 public 或默认，类的成员（包括内部类）的修饰符可以是以上四种。 \n\n\n\n## 8. 深拷贝与浅拷贝\n\n- **浅拷贝**：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅复制所拷贝的对象，而不复制它所引用的对象。\n\n \n\n\n\n- **深拷贝**：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。\n\n \n\n\n\n参考资料：\n\n- [细说 Java 的深拷贝和浅拷贝 - 承香墨影 - SegmentFault 思否](https://segmentfault.com/a/1190000010648514)\n- [（基础系列）object clone 的用法、原理和用途 - 掘金](https://juejin.im/post/59bfc707f265da0646188bca)\n\n## 9. Lamda表达式\n\n\nLambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。\n\nLambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。\n\n使用 Lambda 表达式可以使代码变的更加简洁紧凑。\n\n### 语法\n\nlambda 表达式的语法格式如下：\n\n```java\n(parameters) -> expression\n或\n(parameters) -> { statements; }\n```\n\n以下是 lambda 表达式的重要特征:\n\n- **可选类型声明：**不需要声明参数类型，编译器可以统一识别参数值。\n- **可选的参数圆括号：**一个参数无需定义圆括号，但多个参数需要定义圆括号。\n- **可选的大括号：**如果主体包含了一个语句，就不需要使用大括号。\n- **可选的返回关键字：**如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。\n\n### Lambda 表达式实例\n\nLambda 表达式的简单例子:\n\n```java\n// 1. 不需要参数,返回值为 5 \n() -> 5 \n \n// 2. 接收一个参数(数字类型),返回其2倍的值 \nx -> 2 * x \n \n// 3. 接受2个参数(数字),并返回他们的差值 \n(x, y) -> x – y \n \n// 4. 接收2个int型整数,返回他们的和 \n(int x, int y) -> x + y \n \n// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void) \n(String s) -> System.out.print(s)\n```\n\n在 Java8Tester.java 文件输入以下代码：\n\n```java\npublic class Java8Tester {\n public static void main(String args[]){\n Java8Tester tester = new Java8Tester();\n \n // 类型声明\n MathOperation addition = (int a, int b) -> a + b;\n \n // 不用类型声明\n MathOperation subtraction = (a, b) -> a - b;\n \n // 大括号中的返回语句\n MathOperation multiplication = (int a, int b) -> { return a * b; };\n \n // 没有大括号及返回语句\n MathOperation division = (int a, int b) -> a / b;\n \n System.out.println(\"10 + 5 = \" + tester.operate(10, 5, addition));\n System.out.println(\"10 - 5 = \" + tester.operate(10, 5, subtraction));\n System.out.println(\"10 x 5 = \" + tester.operate(10, 5, multiplication));\n System.out.println(\"10 / 5 = \" + tester.operate(10, 5, division));\n \n // 不用括号\n GreetingService greetService1 = message ->\n System.out.println(\"Hello \" + message);\n \n // 用括号\n GreetingService greetService2 = (message) ->\n System.out.println(\"Hello \" + message);\n \n greetService1.sayMessage(\"Runoob\");\n greetService2.sayMessage(\"Google\");\n }\n \n interface MathOperation {\n int operation(int a, int b);\n }\n \n interface GreetingService {\n void sayMessage(String message);\n }\n \n private int operate(int a, int b, MathOperation mathOperation){\n return mathOperation.operation(a, b);\n }\n}\n```\n\n执行以上脚本，输出结果为：\n\n```shell\n$ javac Java8Tester.java \n$ java Java8Tester\n10 + 5 = 15\n10 - 5 = 5\n10 x 5 = 50\n10 / 5 = 2\nHello Runoob\nHello Google\n```\n使用 Lambda 表达式需要注意以下两点：\n\n- Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们使用各种类型的 Lambda 表达式来定义 MathOperation 接口的方法。然后我们定义了 sayMessage 的执行。\n- Lambda 表达式免去了使用匿名方法的麻烦，并且给予 Java 简单但是强大的函数化的编程能力。\n\n### 变量作用域\n\nlambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。\n\n在 Java8Tester.java 文件输入以下代码：\n\n```java\npublic class Java8Tester {\n \n final static String salutation = \"Hello! \";\n \n public static void main(String args[]){\n GreetingService greetService1 = message -> \n System.out.println(salutation + message);\n greetService1.sayMessage(\"Runoob\");\n }\n \n interface GreetingService {\n void sayMessage(String message);\n }\n}\n```\n\n执行以上脚本，输出结果为：\n\n```shell\n$ javac Java8Tester.java \n$ java Java8Tester\nHello! Runoob\n```\n\n我们也可以直接在 lambda 表达式中访问外层的局部变量：\n\n```java\npublic class Java8Tester {\n public static void main(String args[]) {\n final int num = 1;\n Converter s = (param) -> System.out.println(String.valueOf(param + num));\n s.convert(2); // 输出结果为 3\n }\n \n public interface Converter {\n void convert(int i);\n }\n}\n```\n\nlambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）\n\n```java\nint num = 1; \nConverter s = (param) -> System.out.println(String.valueOf(param + num));\ns.convert(2);\nnum = 5; \n//报错信息：Local variable num defined in an enclosing scope must be final or effectively \n final\n```\n\n在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。\n\n```java\nString first = \"\"; \n\n//编译会出错\nComparator comparator = (first, second) -> Integer.compare(first.length(), second.length()); \n```\n\n\n\n## 10. 字符串常量池\n\n Java 中字符串对象创建有两种形式，一种为字面量形式，如 `String str = \"abc\";`，另一种就是使用 new 这种标准的构造对象的方法，如 `String str = new String(\"abc\");`，这两种方式我们在代码编写时都经常使用，尤其是字面量的方式。然而**这两种实现其实存在着一些性能和内存占用的差别**。这一切都是源于 JVM 为了减少字符串对象的重复创建，其维护了一个特殊的内存，这段内存被成为**字符串常量池**或者**字符串字面量池**。\n\n**工作原理**\n\n 当代码中出现字面量形式创建字符串对象时，JVM首先会对这个字面量进行检查，如果字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回，否则新的字符串对象被创建，然后将这个引用放入字符串常量池，并返回该引用。\n\n```java\npublic class Test {\n public static void main(String[] args) {\n\n String s1 = \"abc\";\n String s2 = \"abc\";\n\n // 以上两个局部变量都存在了常量池中\n System.out.println(s1 == s2); // true\n\n\n // new出来的对象不会放到常量池中,内存地址是不同的\n String s3 = new String();\n String s4 = new String();\n\n /**\n \t* 字符串的比较不可以使用双等号,这样会比较内存地址\n \t* 字符串比较应当用equals,可见String重写了equals\n \t*/\n System.out.println(s3 == s4); // false\n System.out.println(s3.equals(s4)); // true\n }\n}\n```\n\n\n\n## 11. 解释型语言与编译型语言的区别\n\n 我们使用工具编写的字母加符号的代码，是我们能看懂的高级语言，计算机无法直接理解，计算机需要先对我们编写的代码翻译成计算机语言，才能执行我们编写的程序。\n\n 将高级语言翻译成计算机语言有编译，解释两种方式。两种方式只是翻译的时间不同。\n\n**1. 编译型语言**\n\n 编译型语言写得程序在执行之前，需要借助一个程序，将高级语言编写的程序翻译成计算机能懂的机器语言，然后，这个机器语言就能直接执行了，也就是我们常见的（exe文件）。\n\n**2. 解释型语言**\n\n 解释型语言的程序不需要编译，节省了一道工序，不过解释型的语言在运行的时候需要翻译，每个语句都是执行的时候才翻译，对比编译型语言，效率比较低。通俗来讲，就是借助一个程序，且这个程序能试图理解编写的代码，然后按照编写的代码中的要求执行。\n\n**3. 脚本语言**\n\n 脚本语言也是一种解释型语言，又被称为扩建的语言，或者动态语言不需要编译，可以直接使用，由解释器来负责解释。\n\n脚本语言一般都是以文本形式存在，类似于一种命令。\n\n**4. 通俗理解编译型语言和解释型语言**\n\n 同行讨论编译型语言和解释型语言的时候，这么说过，编译型语言相当于做一桌子菜再吃，解释型语言就是吃火锅。解释型的语言执行效率低，类似火锅需要一边煮一边吃。\n\n\n\n\n\n# 二、面向对象\n\n## 1. Java的四个基本特性，对多态的理解，在项目中哪些地方用到多态\n\n- **Java的四个基本特性**\n - **抽象**：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象 和行为抽象 两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。 \n - **封装**：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。 \n - **继承**：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。\n - **多态**：多态性是指允许不同子类型的对象对同一消息作出不同的响应。 \n- **多态的理解(多态的实现方式)** \n - **方法重载**（overload）：实现的是**编译时的多态性**（也称为前绑定）。 \n - **方法重写**（override）：实现的是**运行时的多态性**（也称为后绑定）。运行时的多态是面向对象最精髓的东西。 \n - 要实现多态需要做两件事：\n - 1) **方法重写**（子类继承父类并重写父类中已有的或抽象的方法）；\n - 2) **对象造型**（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。 \n- **项目中对多态的应用** \n - 举一个简单的例子，在物流信息管理系统中，有两种用户：订购客户和卖房客户，两个客户都可以登录系统，他们有相同的方法 Login，但登陆之后他们会进入到不同的页面，也就是在登录的时候会有不同的操作，两种客户都继承父类的 Login 方法，但对于不同的对象，拥有不同的操作。 \n- **面相对象开发方式优点（B65）**\n - 较高的**开发效率**：可以把事物进行抽象，映射为开发的对象。\n - 保证软件的**鲁棒性**：高重用性，可以重用已有的而且在相关领域经过长期测试的代码。\n - 保证软件的**高可维护性**：代码的可读性非常好，设计模式也使得代码结构清晰，拓展性好。\n\n\n\n## 2. 什么是重载和重写\n\n- **重载**：重载发生在同一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载。 \n- **重写**：重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。根据不同的子类对象确定调用的那个方法。 \n\n \n\n\n\n\n## 3. 面向对象和面向过程的区别？用面向过程可以实现面向对象吗？\n\n- 面向对象和面向过程的区别 \n - **面向过程**就像是一个细心的管家，事无具细的都要考虑到。而**面向对象**就像是个家用电器，你只需要知道他的功能，不需要知道它的工作原理。 \n - **面向过程**是一种是“事件”为中心的编程思想。就是分析出解决问题所需的步骤，然后用函数把这些步骤实现，并按顺序调用。**面向对象**是以“对象”为中心的编程思想。 \n - 简单的举个例子：汽车发动、汽车到站 \n - 这对于 **面向过程** 来说，是两个事件，汽车启动是一个事件，汽车到站是另一个事件，**面向过程**编程的过程中我们关心的是事件，而不是汽车本身。针对上述两个事件，形成两个函数，之 后依次调用。（事件驱动，动词为主）\n - 然而这对于**面向对象**来说，我们关心的是汽车这类对象，两个事件只是这类对象所具有的行为。而且对于这两个行为的顺序没有强制要求。（对象驱动，名词为主，将问题抽象出具体的对象，而这个对象有自己的属性和方法，在解决问题的时候是将不同的对象组合在一起使用）\n- 用面向过程可以实现面向对象吗 ？\n - 如果是 C 语言来展现出面向对象的思想，C 语言中是不是有个叫结构体的东西，这个里面有自己定义的变量 可以通过函数指针就可以实现对象\n\n\n\n## 4. 面向对象开发的六个基本原则，在项目中用过哪些原则\n\n- **六个基本原则**（参考《设计模式之禅》）\n\n - **单一职责**（Single Responsibility Principle 简称 SRP）：**一个类应该仅有一个引起它变化的原因**。在面向对象中，如果只让一个类完成它该做的事，而不涉及与它无关的领域就是践行了高内聚的原则，这个类就只有单一职责。 \n\n - **里氏替换**（Liskov Substitution Principle 简称 LSP）：**任何时候子类型能够替换掉它们的父类型**。子类一定是增加父类的能力而不是减少父类的能力，因为子类比父类的能力更多，把能力多的对象当成能力少的对象来用当然没有任何问题。 \n\n - **依赖倒置**（Dependence Inversion Principle 简称 DIP）：**要依赖于抽象，不要依赖于具体类**。要做到依赖倒置，应该做到：①高层模块不应该依赖底层模块，二者都应该依赖于抽象；②抽象不应该依赖于具体实现，具体实现应该依赖于抽象。\n\n - **接口隔离**（Interface Segregation Principle 简称 ISP）：**不应该强迫客户依赖于他们不用的方法** 。接口要小而专，绝不能大而全。臃肿的接口是对接口的污染，既然接口表示能力，那么一个接口只应该描述一种能力，接口也应该是高度内聚的。 \n\n - **最少知识原则**（Least Knowledge Principle 简称 LKP）：**只和你的朋友谈话**。迪米特法则又叫最少知识原则，一个对象应当对其他对象有尽可能少的了解。 \n\n - **开闭原则**（Open Closed Principle 简称 OCP）：**软件实体应当对扩展开放，对修改关闭**。要做到开闭有两个要点：①抽象是关键，一个系统中如果没有抽象类或接口系统就没有扩展点；②封装可变性，将系统中的各种可变因素封装到一个继承结构中，如果多个可变因素混杂在一起，系统将变得复杂而换乱。 \n\n- 其他原则\n\n - 合成聚和复用：优先使用聚合或合成关系复用代码\n - 面向接口编程\n - 优先使用组合，而非继承\n - 一个类需要的数据应该隐藏在类的内部\n - 类之间应该零耦合，或者只有传导耦合，换句话说，类之间要么没关系，要么只使用另一个类的接口提供的操作\n - 在水平方向上尽可能统一地分布系统功能\n\n\n\n- 项目中用到的原则 \n - 单一职责、开放封闭、合成聚合复用(最简单的例子就是String类)、接口隔离\n\n\n\n## 5. 内部类有哪些\n\n可以将一个类的定义放在另一个类的定义内部，这就是内部类。\n\n在 Java 中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类\n\n### （一）成员内部类\n\n成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以**无限制的访问外围类的所有成员属性和方法，尽管是private的**，但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。\n\n```java\npublic class OuterClass {\n private String str;\n \n public void outerDisplay(){\n System.out.println(\"outerClass...\");\n }\n \n public class InnerClass{\n public void innerDisplay(){\n str = \"chenssy...\"; //使用外围内的属性\n System.out.println(str);\n outerDisplay(); //使用外围内的方法\n }\n }\n \n // 推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时\n public InnerClass getInnerClass(){\n return new InnerClass();\n }\n \n public static void main(String[] args) {\n OuterClass outer = new OuterClass();\n OuterClass.InnerClass inner = outer.getInnerClass();\n inner.innerDisplay();\n }\n}\n--------------------\nchenssy...\nouterClass...\n```\n\n在成员内部类中要注意两点：\n\n- 成员内部类中不能存在`static`方法, 但是可以存在`static`域, 前提是需要使用`final`关键字进行修饰.\n\n- 成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。 \n\n\n\n### （二）局部内部类\n\n有这样一种内部类，它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。 \n\n```java\n//定义在方法里：\npublic class Parcel5 {\n public Destionation destionation(String str){\n class PDestionation implements Destionation{\n private String label;\n private PDestionation(String whereTo){\n label = whereTo;\n }\n public String readLabel(){\n return label;\n }\n }\n return new PDestionation(str);\n }\n \n public static void main(String[] args) {\n Parcel5 parcel5 = new Parcel5();\n Destionation d = parcel5.destionation(\"chenssy\");\n }\n}\n\n//定义在作用域内:\npublic class Parcel6 {\n private void internalTracking(boolean b){\n if(b){\n class TrackingSlip{\n private String id;\n TrackingSlip(String s) {\n id = s;\n }\n String getSlip(){\n return id;\n }\n }\n TrackingSlip ts = new TrackingSlip(\"chenssy\");\n String string = ts.getSlip();\n }\n }\n \n public void track(){\n internalTracking(true);\n }\n \n public static void main(String[] args) {\n Parcel6 parcel6 = new Parcel6();\n parcel6.track();\n }\n}\n```\n\n\n\n### （三）匿名内部类\n\n匿名内部类也就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口\n\n\n\n**实例1：不使用匿名内部类来实现抽象方法**\n\n```java\nabstract class Person {\n public abstract void eat();\n}\n \nclass Child extends Person {\n public void eat() {\n System.out.println(\"eat something\");\n }\n}\n \npublic class Demo {\n public static void main(String[] args) {\n Person p = new Child();\n p.eat();\n }\n}\n```\n\n**运行结果**：eat something\n\n\n\n可以看到，我们用 Child 继承了 Person 类，然后实现了 Child 的一个实例，将其向上转型为 Person 类的引用\n\n但是，如果此处的 Child 类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？\n\n这个时候就引入了匿名内部类\n\n \n\n**实例2：匿名内部类的基本实现**\n\n```java\nabstract class Person {\n public abstract void eat();\n}\n \npublic class Demo {\n public static void main(String[] args) {\n Person p = new Person() {\n public void eat() {\n System.out.println(\"eat something\");\n }\n };\n p.eat();\n }\n}\n```\n\n**运行结果**：eat something\n\n\n\n可以看到，我们直接将抽象类 Person 中的方法在大括号中实现了，这样便可以省略一个类的书写，并且，匿名内部类还能用于接口上。\n\n\n\n**实例3：在接口上使用匿名内部类**\n\n```java\ninterface Person {\n public void eat();\n}\n \npublic class Demo {\n public static void main(String[] args) {\n Person p = new Person() {\n public void eat() {\n System.out.println(\"eat something\");\n }\n };\n p.eat();\n }\n}\n```\n\n**运行结果**：eat something\n\n \n\n由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现\n\n最常用的情况就是在多线程的实现上，因为要实现多线程必须继承 Thread 类或是继承 Runnable 接口\n\n \n\n**实例4：Thread类的匿名内部类实现**\n\n```java\n\npublic class Demo {\n public static void main(String[] args) {\n Thread t = new Thread() {\n public void run() {\n for (int i = 1; i <= 5; i++) {\n System.out.print(i + \" \");\n }\n }\n };\n t.start();\n }\n}\n```\n\n**运行结果**：1 2 3 4 5\n\n \n\n**实例5：Runnable接口的匿名内部类实现**\n\n```java\npublic class Demo {\n public static void main(String[] args) {\n Runnable r = new Runnable() {\n public void run() {\n for (int i = 1; i <= 5; i++) {\n System.out.print(i + \" \");\n }\n }\n };\n Thread t = new Thread(r);\n t.start();\n }\n}\n```\n\n**运行结果**：1 2 3 4 5\n\n\n\n### （四）静态内部类\n\n关键字 static 中提到 static 可以修饰成员变量、方法、代码块，其他它还可以修饰内部类，使用 static 修饰的内部类我们称之为静态内部类，不过我们更喜欢称之为嵌套内部类。静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。\n\n1. 它的创建是不需要依赖于外围类的。\n\n2. 它不能使用任何外围类的非 static 成员变量和方法。\n\n```java\npublic class OuterClass {\n private String sex;\n public static String name = \"chenssy\";\n \n // 静态内部类 \n static class InnerClass1{\n // 在静态内部类中可以存在静态成员\n public static String _name1 = \"chenssy_static\";\n \n public void display(){ \n // 静态内部类只能访问外围类的静态成员变量和方法\n\t\t // 不能访问外围类的非静态成员变量和方法\n System.out.println(\"OutClass name :\" + name);\n }\n }\n \n\n // 非静态内部类\n class InnerClass2{\n // 非静态内部类中不能存在静态成员\n public String _name2 = \"chenssy_inner\";\n // 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的\n public void display(){\n System.out.println(\"OuterClass name：\" + name);\n }\n }\n \n // 外围类方法\n public void display(){\n // 外围类访问静态内部类：内部类\n System.out.println(InnerClass1._name1);\n // 静态内部类 可以直接创建实例不需要依赖于外围类\n new InnerClass1().display();\n \n // 非静态内部的创建需要依赖于外围类\n OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();\n // 方位非静态内部类的成员需要使用非静态内部类的实例\n System.out.println(inner2._name2);\n inner2.display();\n }\n \n public static void main(String[] args) {\n OuterClass outer = new OuterClass();\n outer.display();\n }\n}\n----------------\nOutput:\nchenssy_static\nOutClass name :chenssy\nchenssy_inner\nOuterClass name：chenssy\n```\n\n\n\n## 6. 组合、继承和代理的区别\n\n### 定义\n\n- 组合：在新类中 new 另外一个类的对象，以添加该对象的特性。\n- 继承：从基类继承得到子类，获得父类的特性。\n- 代理：在代理类中创建某功能的类，调用类的一些方法以获得该类的部分特性。\n\n### 使用场合\n\n- 组合：各部件之间没什么关系，只需要组合即可。例如组装电脑，需要 new CPU(),new RAM(),new Disk()\n\n ```java\n public class Computer {\n public Computer() {\n CPU cpu=new CPU();\n RAM ram=new RAM();\n Disk disk=new Disk();\n }\n }\n class CPU{ }\n class RAM{ }\n class Disk{ }\n ```\n\n- 继承：子类需要具有父类的功能，各子类之间有所差异。例如 Shape 类作为父类，子类有 Rectangle，CirCle，Triangle……代码不写了，大家都经常用。\n\n- 代理：飞机控制类，我不想暴露太多飞机控制的功能，只需部分前进左右转的控制（而不需要暴露发射导弹功能）。通过在代理类中 new 一个飞机控制对象，然后在方法中添加飞机控制类的各个需要暴露的功能。\n\n ```java\n public class PlaneDelegation{ \n private PlaneControl planeControl; //private外部不可访问\n \t\n // 飞行员权限代理类，普通飞行员不可以开火\n PlaneDelegation(){\n planeControl = new PlaneControl();\n }\n public void speed(){\n planeControl.speed();\n }\n public void left(){\n planeControl.left();\n }\n public void right(){\n planeControl.right();\n }\n }\n \n final class PlaneControl {// final表示不可继承，控制器都能继承那还得了\n protected void speed() {}\n protected void fire() {}\n protected void left() {}\n protected void right() {}\n }\n ```\n\n**说明：**\n\n- 继承：代码复用，引用不灵活；\n- 组合：代码复用，\n- 接口：引用灵活； \n- 推荐组合+接口使用，看 IO 中包装流 FilterInputStream 中的策略模式\n\n\n\n## 7. 什么是构造函数\n\n构造函数是函数的一种特殊形式。特殊在哪里？构造函数中不需要定义返回类型（void 是无需返回值的意思，请注意区分两者），且构造函数的名称与所在的类名完全一致，其余的与函数的特性相同，可以带有参数列表，可以存在函数的重载现象。 \n\n一般用来初始化一些成员变量，当要生成一个类的对象（实例）的时候就会调用类的构造函数。如果不显示声明类的构造方法，会自动生成一个默认的不带参数的空的构造函数。\n\n```java\npublic class Demo{\n private int num=0;\n\n //无参构造函数\n Demo()\n {\n System.out.println(\"constractor_run\");\n }\n\n //有参构造函数\n Demo(int num)\n {\n System.out.println(\"constractor_args_run\");\n }\n\n //普通成员函数\n public void demoFunction()\n {\n System.out.println(\"function_run\");\n }\n}\n```\n\n在这里要说明一点，如果在类中我们不声明构造函数，JVM 会帮我们默认生成一个空参数的构造函数；如果在类中我们声明了带参数列表的构造函数，JVM 就不会帮我们默认生成一个空参数的构造函数，我们想要使用空参数的构造函数就必须自己去显式的声明一个空参的构造函数。 \n\n\n\n**构造函数的作用**\n\n 通过开头的介绍，构造函数的轮廓已经渐渐清晰，那么为什么会有构造函数呢？构造函数有什么作用？构造函数是面向对象编程思想所需求的，它的主要作用有以下两个：\n\n- **创建对象**。任何一个对象创建时，都需要初始化才能使用，所以任何类想要创建实例对象就必须具有构造函数。\n- **对象初始化**。构造函数可以对对象进行初始化，并且是给与之格式（参数列表）相符合的对象初始化，是具有一定针对性的初始化函数。\n\n\n\n\n\n## 8. 向上造型和向下造型\n\n父类引用能指向子类对象，子类引用不能指向父类对象；\n\n**向上造型**\n\n父类引用指向子类对象，例如：\n\n```java\nFather f1 = new Son();\n```\n\n**向下造型**\n\n把指向子类对象的父类引用赋给子类引用，需要强制转换，例如：\n\n```java\nFather f1 = new Son();\nSon s1 = (Son)f1;\n```\n\n但有运行出错的情况：\n\n```java\nFather f2 = new Father();\nSon s2 = (Son)f2; //编译无错但运行会出现错误\n```\n\n在不确定父类引用是否指向子类对象时，可以用 instanceof 来判断：\n\n```java\nif(f3 instanceof Son){\n Son s3 = (Son)f3;\n}\n```\n\n\n\n# 三、关键字\n\n## 1. final与static的区别\n\n### final\n\n- **1. 数据**\n\n - 声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。\n\n - 对于基本类型，final 使数值不变；\n - 对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。\n\n```java\nfinal int x = 1;\n// x = 2; // cannot assign value to final variable 'x'\nfinal A y = new A();\ny.a = 1;\n```\n\n- **2. 方法**\n\n - 声明方法不能被子类覆盖。\n - private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是覆盖基类方法，而是在子类中定义了一个新的方法。\n\n- **3. 类**\n - 声明类不允许被继承。\n\n### static\n\n- **1. 静态变量**\n\n 静态变量在内存中只存在一份，只在类初始化时赋值一次。\n\n - 静态变量：类所有的实例都共享静态变量，可以直接通过类名来访问它；\n - 实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。\n\n```java\npublic class A {\n private int x; // 实例变量\n public static int y; // 静态变量\n}\n```\n\n 注意：不能再成员函数内部定义static变量。\n\n- **2. 静态方法**\n\n 静态方法在类加载的时候就存在了，它不依赖于任何实例，所以静态方法必须有实现，也就是说它不能是抽象方法（abstract）。\n\n- **3. 静态语句块**\n\n 静态语句块在类初始化时运行一次。\n\n- **4. 静态内部类**\n\n 内部类的一种，静态内部类不依赖外部类，且不能访问外部类的非静态的变量和方法。\n\n- **5. 静态导包** \n\n```java\nimport static com.xxx.ClassName.*\n```\n\n 在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。\n\n- **6. 变量赋值顺序** \n\n 静态变量的赋值和静态语句块的运行优先于实例变量的赋值和普通语句块的运行，静态变量的赋值和静态语句块的运行哪个先执行取决于它们在代码中的顺序。\n\n```java\npublic static String staticField = \"静态变量\";\n```\n\n```java\nstatic {\n System.out.println(\"静态语句块\");\n}\n```\n\n```java\npublic String field = \"实例变量\";\n```\n\n```java\n{\n System.out.println(\"普通语句块\");\n}\n```\n\n最后才运行构造函数\n\n```java\npublic InitialOrderTest() {\n System.out.println(\"构造函数\");\n}\n```\n\n存在继承的情况下，初始化顺序为：\n\n- 父类（静态变量、静态语句块）\n- 子类（静态变量、静态语句块）\n- 父类（实例变量、普通语句块）\n- 父类（构造函数）\n- 子类（实例变量、普通语句块）\n- 子类（构造函数）\n\n\n\n## 2. break、continue、return\n\n### break\n\n跳出当前循环；但是如果是嵌套循环，则只能跳出当前的这一层循环，只有逐层 break 才能跳出所有循环。\n\n```java\nfor (int i = 0; i < 10; i++) {\n // 在执行i==6时强制终止循环，i==6不会被执行\n if (i == 6)\n break;\n System.out.println(i); \n} \n\n输出结果为0 1 2 3 4 5 ；6以后的都不会输出\n```\n\n### continue\n\n终止当前循环，但是不跳出循环（在循环中 continue 后面的语句是不会执行了），继续往下根据循环条件执行循环。 \n\n```java\nfor (int i = 0; i < 10; i++) { \n // i==6不会被执行，而是被中断了 \n if (i == 6)\n continue;\n System.out.println(i); \n}\n\n输出结果为0 1 2 3 4 5 7 8 9； 只有6没有输出\n```\n\n### return\n\n- return 从当前的方法中退出，返回到该调用的方法的语句处，继续执行。 \n- return 返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一致。 \n- return 后面也可以不带参数，不带参数就是返回空，其实主要目的就是用于想中断函数执行，返回调用函数处。\n\n特别注意：返回值为 void 的方法，从某个判断中跳出，必须用 return。\n\n\n\n\n\n## 3. final、finally和finalize区别\n\n### final\n\nfinal 用于声明属性、方法和类，分别表示属性不可变、方法不可覆盖和类不可被继承。\n\n- final 属性：被final修饰的变量不可变（引用不可变）\n- final 方法：不允许任何子类重写这个方法，但子类仍然可以使用这个方法\n- final 参数：用来表示这个参数在这个函数内部不允许被修改\n- final 类：此类不能被继承，所有方法都不能被重写\n\n\n\n### finally\n\n 在异常处理的时候，提供 finally 块来执行任何的清除操作。如果抛出一个异常，那么相匹配的 catch 字句就会执行，然后控制就会进入 finally 块，前提是有 finally 块。例如：数据库连接关闭操作上\n\n finally 作为异常处理的一部分，它只能用在 try/catch 语句中，并且附带一个语句块，表示这段语句最终一定会被执行（不管有没有抛出异常），经常被用在需要释放资源的情况下。（×）（**这句话其实存在一定的问题，还没有深入了解，欢迎大家在 issue 中提出自己的见解）** \n\n- 异常情况说明：\n - 在执行 try 语句块之前已经返回或抛出异常，所以 try 对应的 finally 语句并没有执行。 \n - 我们在 try 语句块中执行了 System.exit (0) 语句，终止了 Java 虚拟机的运行。那有人说了，在一般的 Java 应用中基本上是不会调用这个 System.exit(0) 方法的 \n - 当一个线程在执行 try 语句块或者 catch 语句块时被打断（interrupted）或者被终止（killed），与其相对应的 finally 语句块可能不会执行 \n - 还有更极端的情况，就是在线程运行 try 语句块或者 catch 语句块时，突然死机或者断电，finally 语句块肯定不会执行了。可能有人认为死机、断电这些理由有些强词夺理，没有关系，我们只是为了说明这个问题。 \n\n\n\n### finalize\n\n finalize() 是 Object 中的方法，当垃圾回收器将要回收对象所占内存之前被调用，即当一个对象被虚拟机宣告死亡时会先调用它 finalize() 方法，让此对象处理它生前的最后事情（这个对象可以趁这个时机挣脱死亡的命运）。要明白这个问题，先看一下虚拟机是如何判断一个对象该死的。\n\n 可以覆盖此方法来实现对其他资源的回收，例如关闭文件。\n\n\n\n#### 判定死亡\n\n Java 采用可达性分析算法来判定一个对象是否死期已到。Java中以一系列 \"GC Roots\" 对象作为起点，如果一个对象的引用链可以最终追溯到 \"GC Roots\" 对象，那就天下太平。\n\n 否则如果只是A对象引用B，B对象又引用A，A B引用链均未能达到 \"GC Roots\" 的话，那它俩将会被虚拟机宣判符合死亡条件，具有被垃圾回收器回收的资格。\n\n\n\n#### 最后的救赎\n\n上面提到了判断死亡的依据，但被判断死亡后，还有生还的机会。\n\n如何自我救赎：\n\n1. 对象覆写了 finalize() 方法（这样在被判死后才会调用此方法，才有机会做最后的救赎）；\n\n2. 在 finalize() 方法中重新引用到 \"GC Roots\" 链上（如把当前对象的引用 this 赋值给某对象的类变量/成员变量，重新建立可达的引用）.\n\n需要注意：\n\n finalize() 只会在对象内存回收前被调用一次 (The finalize method is never invoked more than once by a Java virtual machine for any given object. )\n\n finalize() 的调用具有不确定性，只保证方法会调用，但不保证方法里的任务会被执行完（比如一个对象手脚不够利索，磨磨叽叽，还在自救的过程中，被杀死回收了）。\n\n\n\n#### finalize()的作用 \n\n 虽然以上以对象救赎举例，但 finalize() 的作用往往被认为是用来做最后的资源回收。\n 基于在自我救赎中的表现来看，此方法有很大的不确定性（不保证方法中的任务执行完）而且运行代价较高。所以用来回收资源也不会有什么好的表现。\n\n 综上：finalize() 方法并没有什么鸟用。\n\n 至于为什么会存在一个鸡肋的方法：书中说 “它不是 C/C++ 中的析构函数，而是 Java 刚诞生时为了使 C/C++ 程序员更容易接受它所做出的一个妥协”。\n\n\n\n参考资料：\n\n- [关于finalize() - CSDN博客](https://blog.csdn.net/L_wwbs/article/details/70770447?locationNum=1&fps=1)\n\n\n\n## 4. assert有什么作用\n\n 断言（assert）作为一种软件调试的方法，提供了一种在代码中进行正确性检查的机制，目前很多开发语言都支持这种机制。\n\n 在实现中，assertion 就是在程序中的一条语句，它对一个 boolean 表达式进行检查，一个正确程序必须保证这个 boolean 表达式的值为 true；如果该值为 false，说明程序已经处于不正确的状态下，系统将给出警告并且退出。一般来说，assertion 用于保证程序最基本、关键的正确性。**assertion 检查通常在开发和测试时开启**。为了提高性能，**在软件发布后，assertion 检查通常是关闭的**。下面简单介绍一下 Java 中 assertion 的实现。\n\n 在语法上，为了支持 assertion，Java 增加了一个关键字 assert。它包括两种表达式，分别如下：\n\n **assert **\n\n 如果 为 true，则程序继续执行。\n\n 如果为 false，则程序抛出 AssertionError，并终止执行。\n\n \n\n **assert : <错误信息表达式>**\n\n 如果 为 true，则程序继续执行。\n\n 如果为 false，则程序抛出 java.lang.AssertionError，并输入<错误信息表达式>。\n\n```java\npublic static void main(String[] args) {\n System.out.println(\"123\");\n\n int a = 0;\n int b = 1;\n assert a == b; //需显示开启，默认为不开启状态 \n assert a == b : \"执行失败！\";\n\n System.out.println(\"1234\");\n}\n```\n\nassert 的应用范围很多，主要包括：\n\n- 检查控制流\n- 检查输入参数是否有效\n- 检查函数结果是否有效\n- 检查程序不变\n\n\n\n### 什么是断言\n\n> 断言是编程术语，表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真，可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言而在部署时禁用断言。同样，程序投入运行后，最终用户在遇到问题时可以重新启用断言。\n\n使用断言可以创建更稳定、品质更好且 不易于出错的代码。当需要在一个值为 `false` 时中断当前操作的话，可以使用断言。单元测试必须使用断言（Junit/JunitX）。\n\n### 常用断言方法\n\n| 断言 | 描述 |\n| ------------------------------------------------------------ | ------------------------------------------------------------ |\n| void assertEquals([String message], expected value, actual value) | 断言两个值相等。值可能是类型有 int, short, long, byte, char or java.lang.Object. 第一个参数是一个可选的字符串消息 |\n| void assertTrue([String message], boolean condition) | 断言一个条件为真 |\n| void assertFalse([String message],boolean condition) | 断言一个条件为假 |\n| void assertNotNull([String message], java.lang.Object object) | 断言一个对象不为空(null) |\n| void assertNull([String message], java.lang.Object object) | 断言一个对象为空(null) |\n| void assertSame([String message], java.lang.Object expected, java.lang.Object actual) | 断言，两个对象引用相同的对象 |\n| void assertNotSame([String message], java.lang.Object unexpected, java.lang.Object actual) | 断言，两个对象不是引用同一个对象 |\n| void assertArrayEquals([String message], expectedArray, resultArray) | 断言预期数组和结果数组相等。数组的类型可能是 int, long, short, char, byte or java.lang.Object. |\n\n\n\n## 5. volatile\n\n> 每次都读错，美式发音：volatile /'vɑlətl/ adj. [化学] 挥发性的；不稳定的；爆炸性的；反复无常的 \n\n volatile 是一个**类型修饰符**（type specifier），它是被设计用来修饰被不同线程访问和修改的变量。在使用 volatile 修饰成员变量后，所有线程在任何时间所看到变量的值都是相同的。此外，使用 volatile 会组织编译器对代码的优化，因此会降低程序的执行效率。所以，除非迫不得已，否则，能不使用 volatile 就尽量不要使用 volatile。\n\n- 每次访问变量时，总是获取主内存的最新值\n- 每次修改变量后，立刻写回到主内存中\n\n \n\n参考资料：\n\n- [理解java Volatile 关键字 - 个人文章 - SegmentFault 思否](https://segmentfault.com/a/1190000015087945)\n \n\n\n\n## 6. instanceof\n\ninstanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。\n\ninstanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。\n\n```java\npublic class Main {\n public static void main(String[] args) {\n Object testObject = new ArrayList();\n displayObjectClass(testObject);\n }\n public static void displayObjectClass(Object o) {\n if (o instanceof Vector)\n System.out.println(\"对象是 java.util.Vector 类的实例\");\n else if (o instanceof ArrayList)\n System.out.println(\"对象是 java.util.ArrayList 类的实例\");\n else\n System.out.println(\"对象是 \" + o.getClass() + \" 类的实例\");\n }\n}\n```\n\n\n\n## 7. strictfp\n\nstrictfp，即 **strict float point** (精确浮点)。 \n\nstrictfp 关键字可应用于类、接口或方法。使用 strictfp 关键字声明一个方法时，该方法中所有的 float 和 double 表达式都严格遵守 FP-strict 的限制,符合 IEEE-754 规范。当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示。\n\n如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，可以用关键字strictfp.\n\n\n\n## 8. transient\n\n> transient 英 /'trænzɪənt/ adj. 短暂的；路过的 n. 瞬变现象；过往旅客；候鸟\n\n我们都知道一个对象只要实现了 Serilizable 接口，这个对象就可以被序列化，Java 的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了 Serilizable 接口，这个类的所有属性和方法都会自动序列化。\n\n然而在实际开发过程中，我们常常会遇到这样的问题，这个类的有些属性需要序列化，而其他属性不需要被序列化，打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上 transient 关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。\n\n**总之，Java 的 transient 关键字为我们提供了便利，你只需要实现 Serilizable 接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。**\n\n\n\n参考资料：\n\n- [Java transient关键字使用小记 - Alexia(minmin) - 博客园](https://www.cnblogs.com/lanxuezaipiao/p/3369962.html)\n\n\n\n## 9. native\n\nnative（即 JNI，Java Native Interface），凡是一种语言，都希望是纯。比如解决某一个方案都喜欢就单单这个语言来写即可。Java 平台有个用户和本地 C 代码进行互操作的 API，称为 Java Native Interface (Java本地接口)。 \n\n7 ，最大 27 -1，15 ,215 -1]，31 -1，31 ,231 -1]，±21亿，[ -2147483648, 2147483647] | 0 | Integer |\n| long | 64 | 最大数据存储容量是 264 -1，63 ,263 -1]， ±922亿亿（±（922+16个零）） | 0L | Long |\n| **浮点型** | | | | |\n| float | 32 | 数据范围在 3.4e-45~1.4e38，直接赋值时必须在数字后加上 f 或 F | 0.0f | Float |\n| double | 64 | 数据范围在 4.9e-324~1.8e308，赋值时可以加 d 或 D 也可以不加 | 0.0d | Double |\n| **布尔型** | | | | |\n| boolean | 1 | true / flase | false | Boolean |\n| **字符型** | | | | |\n| char | 16 | 存储 Unicode 码，用单引号赋值 | '\\u0000' (null) | Character |\n\n- 引用数据类型\n - 类（class）、接口（interface）、数组\n- 自动装箱和拆箱\n - 基本数据类型和它对应的封装类型之间可以相互转换。自动拆装箱是 `jdk5.0` 提供的新特特性，它可以自动实现类型的转换\n - **装箱**：从**基本数据类型**到**封装类型**叫做装箱\n - **拆箱**：从**封装类型**到**基本数据类型**叫拆箱\n\n```java\n// jdk 1.5\npublic class TestDemo {\n public static void main(String[] args) {\n Integer m =10;\n int i = m;\n }\n}\n```\n\n 上面的代码在 jdk1.4 以后的版本都不会报错，它实现了自动拆装箱的功能，如果是 jdk1.4，就得这样写了\n\n```java\n// jdk 1.4\npublic class TestDemo {\n public static void main(String[] args) {\n Integer b = new Integer(210);\n int c = b.intValue();\n }\n}\n```\n\n\n\n## 2. ValueOf缓存池\n\n new Integer(123) 与 Integer.valueOf(123) 的区别在于，new Integer(123) 每次都会新建一个对象，而 Integer.valueOf(123) 可能会使用缓存对象，因此多次使用 Integer.valueOf(123) 会取得同一个对象的引用。\n\n```java\nInteger x = new Integer(123);\nInteger y = new Integer(123);\nSystem.out.println(x == y); // false\nInteger z = Integer.valueOf(123);\nInteger k = Integer.valueOf(123);\nSystem.out.println(z == k); // true\n```\n\n 编译器会在自动装箱过程调用 valueOf() 方法，因此多个 Integer 实例使用自动装箱来创建并且值相同，那么就会引用相同的对象。\n\n```java\nInteger m = 123;\nInteger n = 123;\nSystem.out.println(m == n); // true\n```\n\nvalueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接使用缓存池的内容。\n\n```java\n// valueOf 源码实现\npublic static Integer valueOf(int i) {\n if (i >= IntegerCache.low && i <= IntegerCache.high)\n return IntegerCache.cache[i + (-IntegerCache.low)];\n return new Integer(i);\n}\n```\n\n在 Java 8 中，Integer 缓存池的大小默认为 -128\\~127。\n\n```java\nstatic final int low = -128;\nstatic final int high;\nstatic final Integer cache[];\n\nstatic {\n // high value may be configured by property\n int h = 127;\n String integerCacheHighPropValue =\n sun.misc.VM.getSavedProperty(\"java.lang.Integer.IntegerCache.high\");\n if (integerCacheHighPropValue != null) {\n try {\n int i = parseInt(integerCacheHighPropValue);\n i = Math.max(i, 127);\n // Maximum array size is Integer.MAX_VALUE\n h = Math.min(i, Integer.MAX_VALUE - (-low) -1);\n } catch( NumberFormatException nfe) {\n // If the property cannot be parsed into an int, ignore it.\n }\n }\n high = h;\n\n cache = new Integer[(high - low) + 1];\n int j = low;\n for(int k = 0; k < cache.length; k++)\n cache[k] = new Integer(j++);\n\n // range [-128, 127] must be interned (JLS7 5.1.7)\n assert IntegerCache.high >= 127;\n}\n```\n\nJava 还将一些其它基本类型的值放在缓冲池中，包含以下这些：\n\n- boolean values true and false\n- all byte values\n- short values between -128 and 127\n- int values between -128 and 127\n- char in the range \\u0000 to \\u007F\n\n因此在使用这些基本类型对应的包装类型时，就可以直接使用缓冲池中的对象。\n\n\n\n参考资料：\n\n- [StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123](https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123)\n\n\n\n## 3. i++和++i有什么区别\n\n### i++\n\ni++ 是在程序执行完毕后进行自增，而 ++i 是在程序开始执行前进行自增。\n\n**i++ 的操作分三步**\n\n1. 栈中取出 i\n2. i 自增 1\n3. 将 i 存到栈\n\n三个阶段：内存到寄存器，寄存器自增，写回内存（这三个阶段中间都可以被中断分离开）\n\n所以 i++ 不是原子操作，上面的三个步骤中任何一个步骤同时操作，都可能导致 i 的值不正确自增\n\n\n\n### ++i\n\n在多核的机器上，CPU 在读取内存 i 时也会可能发生同时读取到同一值，这就导致两次自增，实际只增加了一次。\n\ni++ 和 ++i 都不是原子操作\n\n\n\n**原子性**：指的是一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程打断。\n\n\n\nJMM 三大特性：原子性，可见性，有序性。详情请阅读 Github 仓库：[Java 并发编程](03%20Java%20并发编程.md) 一文。\n\n\n\n## 4. 位运算符\n\nJava 定义了位运算符，应用于整数类型 (int)，长整型 (long)，短整型 (short)，字符型 (char)，和字节型 (byte)等类型。\n\n下表列出了位运算符的基本运算，假设整数变量A的值为60和变量B的值为13\n\nA（60）：0011 1100\n\nB（13）：0000 1101\n\n| 操作符 | 名称 | 描述 | 例子 |\n| ------ | ---------- | ------------------------------------------------------------ | ----------------------------- |\n| ＆ | 与 | 如果相对应位都是 1，则结果为 1，否则为 0 | （A＆B）得到 12，即 0000 1100 |\n| \\| | 或 | 如果相对应位都是 0，则结果为 0，否则为 1 | （A\\|B）得到 61，即 0011 1101 |\n| ^ | 异或 | 如果相对应位值相同，则结果为 0，否则为 1 | （A^B）得到49，即 0011 0001 |\n| 〜 | 非 | 按位取反运算符翻转操作数的每一位，即 0 变成 1，1 变成 0 | （〜A）得到-61，即1100 0011 |\n| << | 左移 | （左移一位乘2）按位左移运算符。左操作数按位左移右操作数指定的位数。左移 n 位表示原来的值乘 2n | A << 2得到240，即 1111 0000 |\n| >> | | （右移一位除2）有符号右移，按位右移运算符。左操作数按位右移右操作数指定的位数 | A >> 2得到15即 1111 |\n| >>> | 无符号右移 | 无符号右移，按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充 | A>>>2得到15即0000 1111 |\n\n\n\n## 5. 原码、补码、反码是什么\n\n### 机器数\n\n 一个数在计算机中的二进制表示形式，叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号，正数为 0，负数为 1。\n\n 比如，十进制中的数 +3 ，计算机字长为 8 位，转换成二进制就是 00000011。如果是 -3 ，就是 10000011 。那么，这里的 00000011 和 10000011 就是机器数。\n\n\n\n### 真值\n\n 因为第一位是符号位，所以机器数的形式值就不等于真正的数值。例如上面的有符号数 10000011，其最高位 1 代表负，其真正数值是 -3 而不是形式值 131（10000011 转换成十进制等于 131）。所以，为区别起见，将带符号位的机器数对应的真正数值称为机器数的真值。\n\n例：0000 0001 的真值 = +000 0001 = +1，1000 0001 的真值 = –000 0001 = –1\n\n\n\n### 原码\n\n 原码就是符号位加上真值的绝对值，即用第一位表示符号，其余位表示值。比如如果是 8 位二进制:\n\n [+1]原 = 0000 0001\n\n [-1]原 = 1000 0001\n\n 第一位是符号位。因为第一位是符号位，所以 8 位二进制数的取值范围就是：[1111 1111 , 0111 1111]，即：[-127 , 127]\n\n 原码是人脑最容易理解和计算的表示方式\n\n\n\n### 反码\n\n反码的表示方法是：\n\n- **正数**的反码是其本身；\n- **负数**的反码是在其原码的基础上，**符号位不变，其余各个位取反**。\n\n[+1] = [00000001]原 = [00000001]反 \n\n[-1] = [10000001]原 = [11111110]反 \n\n可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算。\n\n\n\n### 补码\n\n补码的表示方法是：\n\n- **正数**的补码就是其本身；\n- **负数**的补码是在其原码的基础上，符号位不变，其余各位取反, 最后+1。(**反码的基础上 +1**)\n\n[+1] = [0000 0001]原 = [0000 0001]反 = [0000 0001]补 \n\n[-1] = [1000 0001]原 = [1111 1110]反 = [1111 1111]补 \n\n对于负数，补码表示方式也是人脑无法直观看出其数值的。 通常也需要转换成原码在计算其数值。\n\n\n\n参考资料：\n\n- [原码, 反码, 补码 详解 - ziqiu.zhang - 博客园](http://www.cnblogs.com/zhangziqiu/archive/2011/03/30/ComputerCode.html)\n\n\n\n## 6. 不用额外变量交换两个整数的值\n\n如果给定整数 a 和 b，用以下三行代码即可交换 a 和b 的值\n\n```java\na = a ^ b;\nb = a ^ b;\na = a ^ b;\n```\n\n- 假设 a 异或 b 的结果记为 c，**c 就是 a 整数位信息和 b 整数位信息的所有不同信息**。\n - 比如：a = 4 = 100，b = 3 = 011，a^b = c = 111\n- a 异或 c 的结果就是 b，比如：a = 4 = 100，c = 111，a^c = 011 = 3 = b\n- b 异或c 的结果就是 a，比如：b = 3 = 011，c = 111，b^c = 100 = 4 = a\n\n说明：位运算的题目基本上都带有靠经验积累才会做的特征，也就是准备阶段需要做足够多的题，面试时才会有良好的感觉。\n\n\n\n## 7. 不使用运算符进行a+b操作\n\n- a^b; 得到不含进位之和\n- (a & b)<<1; 进位\n- 只要进位不为零，则迭代；否则返回\n\n```java\n#include \n\nint add(int a, int b)\n{\n int c = a & b;\n int r = a ^ b;\n if(c == 0){\n return r;\n }\n else{\n return add(r, c << 1);\n }\n}\n\nint main(int argn, char *argv[])\n{\n printf(\"sum = %d\\n\", add(-10000, 56789));\n return 0;\n}\n```\n\n\n\n## 8. &和&& 、|和||的区别\n\n（1）&& 和 & 都是表示与，区别是 && 只要第一个条件不满足，后面条件就不再判断。而 & 要对所有的条件都进行判断。\n\n```java\n// 例如：\npublic static void main(String[] args) { \n if((23!=23) && (100/0==0)){ \n System.out.println(\"运算没有问题。\"); \n }else{ \n System.out.println(\"没有报错\"); \n } \n} \n// 输出的是“没有报错”。而将 && 改为 & 就会如下错误：\n// Exception in thread \"main\" java.lang.ArithmeticException: / by zero\n```\n\n- 原因：\n - &&时判断第一个条件为 false，后面的 100/0==0 这个条件就没有进行判断。\n\n - & 时要对所有的条件进行判断，所以会对后面的条件进行判断，所以会报错。\n\n\n （2）|| 和 | 都是表示 “或”，区别是 || 只要满足第一个条件，后面的条件就不再判断，而 | 要对所有的条件进行判断。 看下面的程序： \n\n```java\npublic static void main(String[] args) { \n if((23==23)||(100/0==0)){ \n \tSystem.out.println(\"运算没有问题。\"); \n }else{ \n \tSystem.out.println(\"没有报错\"); \n } \n}\n// 此时输出“运算没有问题”。若将||改为|则会报错。\n```\n\n - 原因\n - || 判断第一个条件为 true，后面的条件就没有进行判断就执行了括号中的代码\n - 而 | 要对所有的条件进行判断，所以会报错\n\n\n\n\n\n# 五、字符串与数组\n\n## 1. String,StringBuffer,StringBuilder，以及对String不变性的理解\n\n- String、StringBuffer、StringBuilder \n - 都是 final 类，都不允许被继承\n - String 长度是不可变的，StringBuffer、StringBuilder 长度是可变的\n - StringBuffer 是线程安全的，StringBuilder 不是线程安全的，但它们两个中的所有方法都是相同的，StringBuffer 在 StringBuilder 的方法之上添加了 synchronized 修饰，保证线程安全\n - StringBuilder 比 StringBuffer 拥有更好的性能\n - 如果一个 String 类型的字符串，在编译时就可以确定是一个字符串常量，则编译完成之后，字符串会自动拼接成一个常量。此时 String 的速度比 StringBuffer 和 StringBuilder 的性能好的多\n\n\n\n- String 不变性的理解 \n - String 类是被 final 进行修饰的，不能被继承 \n - 在用 + 号链接字符串的时候会创建新的字符串\n - String s = new String(\"Hello world\"); 可能创建两个对象也可能创建一个对象。如果静态区中有 “Hello world” 字符串常量对象的话，则仅仅在堆中创建一个对象。如果静态区中没有 “Hello world” 对象，则堆上和静态区中都需要创建对象。 \n - 在 Java 中, 通过使用 \"+\" 符号来串联字符串的时候,，实际上底层会转成通过 StringBuilder 实例的 append() 方法来实现。\n\n \n\n## 2. String有重写Object的hashcode和toString吗？如果重写equals不重写hashcode会出现什么问题？\n\n- String 有重写 Object 的 hashcode 和 toString吗？ \n\n - String 重写了 Object 类的 hashcode 和 toString 方法。 \n\n- 当 equals 方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相对等的两个对象必须有相同的 hashCode \n\n - object1.equals(object2) 时为 true， object1.hashCode() == object2.hashCode() 为 true \n - object1.hashCode() == object2.hashCode() 为 false 时，object1.equals(object2) 必定为 false \n - object1.hashCode() == object2.hashCode() 为 true时，但 object1.equals(object2) 不一定定为 true \n\n- 重写 equals 不重写 hashcode 会出现什么问题 \n\n - 在存储散列集合时(如 Set 类)，如果原对象.equals(新对象)，但没有对 hashCode 重写，即两个对象拥有不同的 hashCode，则在集合中将会存储两个值相同的对象，从而导致混淆。因此在重写 equals 方法时，必须重写 hashCode 方法。 \n\n\n\n## 3. 如果你定义一个类，包括学号，姓名，分数，如何把这个对象作为key？要重写equals和hashcode吗\n\n- 需要重写 equals 方法和 hashcode，必须保证对象的属性改变时，其 hashcode 不能改变。 \n\n\n\n## 4. 字面量\n\n在编程语言中，字面量（literal）指的是在源代码中直接表示的一个固定的值。 \n\n八进制是用在整数字面量之前添加 “0” 来表示的。 \n\n十六进制用在整数字面量之前添加 “0x” 或者 “0X” 来表示的\n\n Java 7 中新增了二进制：用在整数字面量之前添加 “0b” 或者 “0B” 来表示的。 \n\n**在数值字面量中使用下划线**\n\n在 Java7 中，数值字面量，不管是整数还是浮点数都允许在数字之间插入任意多个下划线。并且不会对数值产生影响，目的是方便阅读，规则只能在数字之间使用。\n\n```java\npublic class BinaryIntegralLiteral {\n public static void main(String[] args) {\n System.out.println(0b010101);\n System.out.println(0B010101);\n System.out.println(0x15A);\n System.out.println(0X15A);\n System.out.println(077);\n System.out.println(5_000);\n /**\n * 输出结果\n * 21 \n * 21 \n * 346 \n * 346 \n * 63\n * 5000\n */\n }\n}\n```\n\n\n\n# 六、异常处理\n\n## 1. 常见异常分为那两种(Exception，Error)，常见异常的基类以及常见的异常\n\n- Throwable 是 Java 语言中所有错误和异常的超类（万物即可抛）。它有两个子类：Error、Exception。 \n- 异常种类 \n\n - **Error**：Error 为错误，是程序无法处理的，如 OutOfMemoryError、ThreadDeath 等，出现这种情况你唯一能做的就是听之任之，交由 JVM 来处理，不过 JVM 在大多数情况下会选择终止线程。 \n - **Exception**：Exception 是程序可以处理的异常。它又分为两种 CheckedException（受捡异常），一种是 UncheckedException（不受检异常）。 \n - **受检异常**（CheckException）：发生在编译阶段，必须要使用 try…catch（或者throws）否则编译不通过。 \n - **非受检异常** （UncheckedException）：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序奔溃并且无法恢复。 （发生在运行期，具有不确定性，主要是由于程序的逻辑问题所引起的，难以排查，我们一般都需要纵观全局才能够发现这类的异常错误，所以在程序设计中我们需要认真考虑，好好写代码，尽量处理异常，即使产生了异常，也能尽量保证程序朝着有利方向发展。 ）\n- 常见异常的基类（Exception）\n\n - IOException \n - RuntimeException \n- 常见的异常\n\n set = new HashSet<>();\nset.add(e1);\nset.add(e2);\nSystem.out.println(set.size()); // 2\n```\n\n 理想的散列函数应当具有均匀性，即不相等的实例应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来，可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。\n\n 一个数与 31 相乘可以转换成移位和减法：`31\\*x == (x<<5)-x`，编译器会自动进行这个优化。\n\n```java\n@Override\npublic int hashCode() {\n int result = 17;\n result = 31 * result + x;\n result = 31 * result + y;\n result = 31 * result + z;\n return result;\n}\n```\n\n## toString()\n\n默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为**散列码的无符号十六进制**表示。\n\n```java\npublic class ToStringExample {\n private int number;\n\n public ToStringExample(int number) {\n this.number = number;\n }\n}\n```\n\n```java\nToStringExample example = new ToStringExample(123);\nSystem.out.println(example.toString());\n```\n\n```html\nToStringExample@4554617c\n```\n\n## clone()\n\n**1. cloneable** \n\nclone() 是 Object 的 protect 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。\n\n```java\npublic class CloneExample {\n private int a;\n private int b;\n}\n```\n\n```java\nCloneExample e1 = new CloneExample();\n// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'\n```\n\n重写 clone() 得到以下实现：\n\n```java\npublic class CloneExample {\n private int a;\n private int b;\n\n @Override\n protected CloneExample clone() throws CloneNotSupportedException {\n return (CloneExample)super.clone();\n }\n}\n```\n\n```java\nCloneExample e1 = new CloneExample();\ntry {\n CloneExample e2 = e1.clone();\n} catch (CloneNotSupportedException e) {\n e.printStackTrace();\n}\n```\n\n```html\njava.lang.CloneNotSupportedException: CloneTest\n```\n\n以上抛出了 CloneNotSupportedException，这是因为 CloneTest 没有实现 Cloneable 接口。\n\n```java\npublic class CloneExample implements Cloneable {\n private int a;\n private int b;\n\n @Override\n protected Object clone() throws CloneNotSupportedException {\n return super.clone();\n }\n}\n```\n\n应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。\n\n\n\n参考资料：\n\n- [【必读】搞懂 Java equals 和 hashCode 方法 - 掘金](https://juejin.im/post/5ac4d8abf265da23a4050ae3)\n\n\n\n# 更新日志\n\n- 2018/7/11 v1.0 第一版\n- 2018/7/31 v2.0 基础版\n- 2018/8/30-31 v3.0 初版\n"
},
{
"path": "notes/JavaArchitecture/02-Java集合框架.md",
"content": "\n\n- [前言](#前言)\n- [一、概述](#一概述)\n - [集合框架图](#集合框架图)\n - [Collection](#Collection)\n - [Map](#Map)\n - [工具类](#工具类)\n - [通用实现](#通用实现)\n- [二、深入源码分析](#二深入源码分析)\n - [ArrayList](#ArrayList)\n - [1. 概览](#1-概览)\n - [2. 序列化](#2-序列化)\n - [3. 扩容](#3-扩容)\n - [4. 删除元素](#4-删除元素)\n - [5. Fail-Fast](#5-Fail-Fast)\n - [Vector](#Vector)\n - [1. 同步](#1-同步)\n - [2. ArrayList 与 Vector](#2-ArrayList-与-Vector)\n - [3. Vector 替代方案](#3-Vector-替代方案)\n - [synchronizedList](#synchronizedList)\n - [CopyOnWriteArrayList](#CopyOnWriteArrayList)\n - [LinkedList](#LinkedList)\n - [1. 概览](#1-概览-1)\n - [2. add()](#2-add)\n - [3. remove()](#3-remove)\n - [4. get()](#4-get)\n - [5. 总结](#5-总结)\n - [6. ArrayList 与 LinkedList](#6-ArrayList-与-LinkedList)\n - [HashMap](#HashMap)\n - [1. 存储结构](#1-存储结构)\n - [JDK1.7 的存储结构](#jdk17-的存储结构)\n - [JDK1.8 的存储结构](#jdk18-的存储结构)\n - [2. 重要参数](#2-重要参数)\n - [3. 确定哈希桶数组索引位置](#3-确定哈希桶数组索引位置)\n - [4. 分析HashMap的put方法](#4-分析HashMap的put方法)\n - [5. 扩容机制](#5-扩容机制)\n - [6. 线程安全性](#6-线程安全性)\n - [7. JDK1.8与JDK1.7的性能对比](#7-jdk18与jdk17的性能对比)\n - [8. Hash较均匀的情况](#8-hash较均匀的情况)\n - [9. Hash极不均匀的情况](#9-hash极不均匀的情况)\n - [10. HashMap与Hashtable](#10-HashMap与Hashtable)\n - [11. 小结](#11-小结)\n - [ConcurrentHashMap](#ConcurrentHashMap)\n - [1. 概述](#1-概述)\n - [2. 存储结构](#2-存储结构)\n - [2. size 操作](#2-size-操作)\n - [3. 同步方式](#3-同步方式)\n - [4. JDK 1.8 的改动](#4-jdk-18-的改动)\n - [HashSet](#hashset)\n - [1. 成员变量](#1-成员变量)\n - [2. 构造函数](#2-构造函数)\n - [3. add()](#3-add)\n - [4. 总结](#4-总结)\n - [LinkedHashSet and LinkedHashMap](#LinkedHashSet-and-LinkedHashMap)\n - [1. 概览](#1-概览-2)\n - [2. get()](#2-get)\n - [3. put()](#3-put)\n - [4. remove()](#4-remove)\n - [5. LinkedHashSet](#5-LinkedHashSet)\n - [6. LinkedHashMap经典用法](#6-LinkedHashMap经典用法)\n- [三、容器中的设计模式](#三容器中的设计模式)\n - [迭代器模式](#迭代器模式)\n - [适配器模式](#适配器模式)\n- [四、面试指南](#四面试指南)\n - [1. ArrayList和LinkedList区别](#1-ArrayList和LinkedList区别)\n - [2. HashMap和Hashtable区别，HashMap的key类型](#2-HashMap和Hashtable区别HashMap的key类型)\n - [3. HashMap和ConcurrentHashMap](#3-HashMap和ConcurrentHashMap)\n - [4. Hashtable的原理](#4-Hashtable的原理)\n - [5. Hash冲突的解决办法](#5-hash冲突的解决办法)\n - [6. 什么是迭代器](#6-什么是迭代器)\n - [7. 构造相同hash的字符串进行攻击，这种情况应该怎么处理？JDK7如何处理](#7-构造相同hash的字符串进行攻击这种情况应该怎么处理jdk7如何处理)\n - [8. HashMap为什么大小是2的幂次](#8-HashMap为什么大小是2的幂次)\n- [更新日志](#更新日志)\n\n\n# 前言\n\n Java集合框架 (Java Collections Framework, JCF) 也称容器，这里可以类比 C++ 中的 STL，在市面上似乎还没能找到一本详细介绍的书籍。在这里主要对如下部分进行源码分析，及在面试中常见的问题。\n\n 例如，在阿里面试常问到的 HashMap 和 ConcurrentHashMap 原理等等。深入源码分析是面试中必备的技能，通过本文的阅读会对集合框架有更深一步的了解。\n\n\n\n本文参考：\n\n- [CarpenterLee/JCFInternals: 深入理解Java集合框架](https://github.com/CarpenterLee/JCFInternals)\n- [crossoverJie/Java-Interview: 👨🎓 Java related : basic, concurrent, algorithm](https://github.com/crossoverJie/Java-Interview)\n- [Interview-Notebook/Java 容器.md at master · CyC2018/Interview-Notebook](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Java%20%E5%AE%B9%E5%99%A8.md)\n\n\n\n# 一、概述\n\n Java集合框架提供了数据持有对象的方式，提供了对数据集合的操作。Java 集合框架位于 ` java.util` 包下，主要有三个大类：**Collection(接口)**、**Map(接口)**、**集合工具类**。\n\n\n\n## 集合框架图\n\n \n\n\n\n## Collection\n\n- `ArrayList`：**线程不同步**。默认初始容量为 10，当数组大小不足时容量扩大为 1.5 倍。为追求效率，ArrayList 没有实现同步（synchronized），如果需要多个线程并发访问，用户可以手动同步，也可使用 Vector 替代。 \n- `LinkedList`：**线程不同步**。**双向链接实现**。LinkedList 同时实现了 List 接口和 Deque 接口，也就是说它既可以看作一个顺序容器，又可以看作一个队列（Queue），同时又可以看作一个栈（Stack）。这样看来，LinkedList 简直就是个全能冠军。当你需要使用栈或者队列时，可以考虑使用 LinkedList，一方面是因为 Java 官方已经声明不建议使用 Stack 类，更遗憾的是，Java 里根本没有一个叫做 Queue 的类（它是个接口名字）。关于栈或队列，现在的首选是 ArrayDeque，它有着比 LinkedList（当作栈或队列使用时）有着更好的性能。 \n- `Stack and Queue`：Java 里有一个叫做 Stack 的类，却没有叫做 Queue 的类（它是个接口名字）。当需要使用栈时，Java 已不推荐使用 Stack，而是推荐使用更高效的 ArrayDeque；既然 Queue 只是一个接口，当需要使用队列时也就首选 ArrayDeque 了（次选是 LinkedList ）。 \n- `Vector`：**线程同步**。默认初始容量为 10，当数组大小不足时容量扩大为 2 倍。它的同步是通过 `Iterator` 方法加 `synchronized` 实现的。\n- `Stack`：**线程同步**。继承自 Vector，添加了几个方法来完成栈的功能。现在已经不推荐使用 Stack，在栈和队列中有限使用 ArrayDeque，其次是 LinkedList。\n- `TreeSet`：**线程不同步**，内部使用 `NavigableMap` 操作。默认元素 “自然顺序” 排列，可以通过 `Comparator` 改变排序。TreeSet 里面有一个 TreeMap（适配器模式）\n- `HashSet`：**线程不同步**，内部使用 HashMap 进行数据存储，提供的方法基本都是调用 HashMap 的方法，所以两者本质是一样的。集合元素可以为 NULL。\n- `Set`：Set 是一种不包含重复元素的 Collection，Set 最多只有一个 null 元素。Set 集合通常可以通过 Map 集合通过适配器模式得到。\n- `PriorityQueue`：Java 中 PriorityQueue 实现了 Queue 接口，不允许放入 null 元素；其通过堆实现，具体说是通过完全二叉树（complete binary tree）实现的**小顶堆**（任意一个非叶子节点的权值，都不大于其左右子节点的权值），也就意味着可以通过数组来作为 PriorityQueue 的底层实现。 \n - **优先队列的作用是能保证每次取出的元素都是队列中权值最小的**（Java 的优先队列每次取最小元素，C++ 的优先队列每次取最大元素）。这里牵涉到了大小关系，**元素大小的评判可以通过元素本身的自然顺序（natural ordering），也可以通过构造时传入的比较器**（*Comparator*，类似于 C++ 的仿函数）。 \n- `NavigableSet`：添加了搜索功能，可以对给定元素进行搜索：小于、小于等于、大于、大于等于，放回一个符合条件的最接近给定元素的 key。\n- `EnumSet`：线程不同步。内部使用 Enum 数组实现，速度比 `HashSet` 快。**只能存储在构造函数传入的枚举类的枚举值**。\n\n\n\n 注释：更多设计模式，请转向 [Java 设计模式](06%20设计模式.md)\n\n\n\n## Map\n\n- `TreeMap`：线程不同步，基于 **红黑树** （Red-Black tree）的 NavigableMap 实现，能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器，当用 Iterator 遍历 TreeMap 时，得到的记录是排过序的。\n - **TreeMap 底层通过红黑树（Red-Black tree）实现**，也就意味着 `containsKey()`, `get()`, `put()`, `remove()` 都有着 `log(n)` 的时间复杂度。其具体算法实现参照了《算法导论》。\n- `Hashtable`：**线程安全**，HashMap 的迭代器 \\(Iterator\\) 是 `fail-fast` 迭代器。**Hashtable 不能存储 NULL 的 key 和 value。**\n- `HashMap`：线程不同步。根据 `key` 的 `hashcode` 进行存储，内部使用静态内部类 `Node` 的数组进行存储，默认初始大小为 16，每次扩大一倍。当发生 Hash 冲突时，采用拉链法（链表）。JDK 1.8中：**当单个桶中元素个数大于等于8时，链表实现改为红黑树实现；当元素个数小于6时，变回链表实现。由此来防止hashCode攻击。**\n - Java HashMap 采用的是冲突链表方式。 \n - HashMap 是 Hashtable 的轻量级实现，可以接受为 null 的键值 (key\\) 和值 \\(value\\)，而 Hashtable 不允许。\n- `LinkedHashMap`：**保存了记录的插入顺序**，在用 Iterator 遍历 LinkedHashMap 时，先得到的记录肯定是先插入的。也可以在构造时用带参数，按照应用次数排序。在遍历的时候会比 HashMap 慢，不过有种情况例外，当 HashMap 容量很大，实际数据较少时，遍历起来可能会比 LinkedHashMap 慢，因为 LinkedHashMap 的遍历速度只和实际数据有关，和容量无关，而 HashMap 的遍历速度和他的容量有关。\n- `WeakHashMap`：从名字可以看出它是某种 Map。它的特殊之处在于 WeakHashMap 里的 entry 可能会被 GC 自动删除，即使程序员没有调用 `remove()` 或者 `clear()` 方法。 WeakHashMap 的存储结构类似于HashMap\n - 既然有 WeekHashMap，是否有 WeekHashSet 呢？答案是没有！不过 Java Collections 工具类给出了解决方案，`Collections.newSetFromMap(Map map)` 方法可以将任何 Map包装成一个Set。\n\n\n\n\n## 工具类\n\n- `Collections`、`Arrays`：集合类的一个工具类帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。\n\n- `Comparable`、`Comparator`：一般是用于对象的比较来实现排序，两者略有区别。\n\n > - 类设计者没有考虑到比较问题而没有实现 Comparable 接口。这是我们就可以通过使用 Comparator，这种情况下，我们是不需要改变对象的。\n > - 一个集合中，我们可能需要有多重的排序标准，这时候如果使用 Comparable 就有些捉襟见肘了，可以自己继承 Comparator 提供多种标准的比较器进行排序。\n\n\n\n**说明**：线程不同步的时候可以通过，Collections.synchronizedList() 方法来包装一个线程同步方法\n\n\n\n## 通用实现\n\nImplementations Hash Table Resizable Array Balanced Tree Linked List Hash Table + Linked List Interfaces Set HashSet TreeSet LinkedHashSet List ArrayList LinkedList Deque ArrayDeque LinkedList Map HashMap TreeMap LinkedHashMap
\n\n\n\n**参考资料：**\n\n- [CarpenterLee/JCFInternals:深入理解Java集合框架](https://github.com/CarpenterLee/JCFInternals)\n- [Java基础-集合框架 - 掘金](https://juejin.im/post/5af86ac8f265da0ba063410e)\n\n\n\n# 二、深入源码分析\n\n源码分析基于 JDK 1.8 / JDK 1.7，在 IDEA 中 double shift 调出 Search EveryWhere，查找源码文件，找到之后就可以阅读源码。\n\n## ArrayList\n\n### 1. 概览\n\n实现了 RandomAccess 接口，因此支持随机访问，这是理所当然的，因为 ArrayList 是基于数组实现的。\n\n```java\npublic class ArrayList extends AbstractList\n implements List, RandomAccess, Cloneable, java.io.Serializable\n```\n\n数组的默认大小为 10。\n\n```java\nprivate static final int DEFAULT_CAPACITY = 10;\n```\n\n \n\n\n\n### 2. 序列化\n\n基于数组实现，保存元素的数组使用 transient 修饰，该关键字声明数组默认不会被序列化。ArrayList 具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。ArrayList 重写了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。\n\n```java\ntransient Object[] elementData; // non-private to simplify nested class access\n```\n\n\n\n### 3. 扩容\n\n添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 `oldCapacity + (oldCapacity >> 1)`，也就是旧容量的 1.5 倍。\n\n扩容操作需要调用 `Arrays.copyOf()` 把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。\n\n```java\n// JDK 1.8\n \npublic boolean add(E e) {\n ensureCapacityInternal(size + 1); // Increments modCount!!\n elementData[size++] = e;\n return true;\n}\n\n// 判断数组是否越界\nprivate void ensureCapacityInternal(int minCapacity) {\n if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {\n minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);\n }\n ensureExplicitCapacity(minCapacity);\n}\n\nprivate void ensureExplicitCapacity(int minCapacity) {\n modCount++;\n // overflow-conscious code\n if (minCapacity - elementData.length > 0)\n grow(minCapacity);\n}\n\n// 扩容\nprivate void grow(int minCapacity) {\n // overflow-conscious code\n int oldCapacity = elementData.length;\n int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5倍\n if (newCapacity - minCapacity < 0)\n newCapacity = minCapacity;\n if (newCapacity - MAX_ARRAY_SIZE > 0)\n newCapacity = hugeCapacity(minCapacity);\n // minCapacity is usually close to size, so this is a win:\n elementData = Arrays.copyOf(elementData, newCapacity);\n}\n\nprivate static int hugeCapacity(int minCapacity) {\n if (minCapacity < 0) // overflow\n throw new OutOfMemoryError();\n return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;\n}\n```\n\n\n\n### 4. 删除元素\n\n需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上。\n\n```java\npublic E remove(int index) {\n rangeCheck(index);\n modCount++;\n E oldValue = elementData(index);\n int numMoved = size - index - 1;\n if (numMoved > 0)\n System.arraycopy(elementData, index+1, elementData, index, numMoved);\n elementData[--size] = null; // clear to let GC do its work\n return oldValue;\n}\n```\n\n\n\n### 5. Fail-Fast\n\n**开始之前我们想讲讲，什么是 fail-fast 机制?**\n\nfail-fast 机制在遍历一个集合时，当集合结构被修改，会抛出 Concurrent Modification Exception。\n\nfail-fast 会在以下两种情况下抛出 Concurrent Modification Exception\n\n（1）单线程环境\n\n- 集合被创建后，在遍历它的过程中修改了结构。\n\n- 注意 remove() 方法会让 expectModcount 和 modcount 相等，所以是不会抛出这个异常。\n\n（2）多线程环境\n\n- 当一个线程在遍历这个集合，而另一个线程对这个集合的结构进行了修改。\n\n\n\nmodCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指**添加**或者**删除**至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。\n\n在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 Concurrent Modification Exception。\n\n```java\nprivate void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{\n // Write out element count, and any hidden stuff\n int expectedModCount = modCount;\n s.defaultWriteObject();\n\n // Write out size as capacity for behavioural compatibility with clone()\n s.writeInt(size);\n\n // Write out all elements in the proper order.\n for (int i=0; i= elementCount)\n throw new ArrayIndexOutOfBoundsException(index);\n return elementData(index);\n}\n```\n\n\n\n### 2. ArrayList 与 Vector\n\n- Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；\n- Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。\n\n\n\n### 3. Vector 替代方案\n\n#### synchronizedList\n\n为了获得线程安全的 ArrayList，可以使用 `Collections.synchronizedList();` 得到一个线程安全的 ArrayList。\n\n```java\nList list = new ArrayList<>();\nList synList = Collections.synchronizedList(list);\n```\n\n\n\n#### CopyOnWriteArrayList\n\n list = new CopyOnWriteArrayList<>();\n```\n\nCopyOnWrite 容器即写时复制的容器。通俗的理解是**当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行 Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器**。这样做的好处是我们可以对 CopyOnWrite 容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以 CopyOnWrite 容器也是一种**读写分离**的思想，读和写不同的容器。 \n\n```java\npublic boolean add(T e) {\n final ReentrantLock lock = this.lock;\n lock.lock();\n try {\n Object[] elements = getArray();\n int len = elements.length;\n // 复制出新数组\n Object[] newElements = Arrays.copyOf(elements, len + 1);\n // 把新元素添加到新数组里\n newElements[len] = e;\n // 把原数组引用指向新数组\n setArray(newElements);\n return true;\n } finally {\n lock.unlock();\n }\n}\n\nfinal void setArray(Object[] a) {\n array = a;\n}\n```\n\n读的时候不需要加锁，如果读的时候有多个线程正在向 ArrayList 添加数据，读还是会读到旧的数据，因为写的时候不会锁住旧的 ArrayList。 \n\n```java\npublic E get(int index) {\n return get(getArray(), index);\n}\n```\n\n**CopyOnWrite的缺点**\n\n- CopyOnWrite 容器有很多优点，但是同时也存在两个问题，即内存占用问题和数据一致性问题。所以在开发的时候需要注意一下。\n\n**内存占用问题**。\n\n- 因为 CopyOnWrite 的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象（注意：在复制的时候只是复制容器里的引用，只是在写的时候会创建新对象添加到新容器里，而旧容器的对象还在使用，所以有两份对象内存）。如果这些对象占用的内存比较大，比如说 200M 左右，那么再写入 100M 数据进去，内存就会占用 300M，那么这个时候很有可能造成频繁的 Yong GC 和 Full GC。之前我们系统中使用了一个服务由于每晚使用 CopyOnWrite 机制更新大对象，造成了每晚 15 秒的 Full GC，应用响应时间也随之变长。\n\n- 针对内存占用问题，可以通过压缩容器中的元素的方法来减少大对象的内存消耗，比如，如果元素全是 10 进制的数字，可以考虑把它压缩成 36 进制或 64 进制。或者不使用 CopyOnWrite 容器，而使用其他的并发容器，如 ConcurrentHashMap 。\n\n**数据一致性问题**。\n\n- CopyOnWrite 容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用 CopyOnWrite 容器。\n\n- 关于 C++ 的 STL 中，曾经也有过 Copy-On-Write 的玩法，参见陈皓的《[C++ STL String类中的Copy-On-Write](http://blog.csdn.net/haoel/article/details/24058)》，后来，因为有很多线程安全上的事，就被去掉了。\n\n\n\n参考资料：\n\n- [聊聊并发-Java中的Copy-On-Write容器 | 并发编程网 – ifeve.com](http://ifeve.com/java-copy-on-write/)\n\n\n\n## LinkedList\n\n \n\n### 1. 概览\n\n**LinkedList 底层是基于双向链表实现的**，也是实现了 List 接口，所以也拥有 List 的一些特点 (JDK1.7/8 之后取消了循环，修改为双向链表) 。 \n\nLinkedList 同时实现了 List 接口和 Deque 接口，也就是说它既可以看作一个顺序容器，又可以看作一个队列（Queue），同时又可以看作一个栈（Stack）。这样看来， LinkedList 简直就是个全能冠军。当你需要使用栈或者队列时，可以考虑使用 LinkedList ，一方面是因为 Java 官方已经声明不建议使用 Stack 类，更遗憾的是，Java里根本没有一个叫做 Queue 的类（它是个接口名字）。\n\n关于栈或队列，现在的首选是 ArrayDeque，它有着比 LinkedList （当作栈或队列使用时）有着更好的性能。 \n\n基于双向链表实现，内部使用 Node 来存储链表节点信息。\n\n```java\nprivate static class Node {\n E item;\n Node next;\n Node prev;\n}\n```\n\n每个链表存储了 Head 和 Tail 指针：\n\n```java\ntransient Node first;\ntransient Node last;\n```\n\nLinkedList 的实现方式决定了所有跟下标相关的操作都是线性时间，而在首段或者末尾删除元素只需要常数时间。为追求效率*LinkedList*没有实现同步（synchronized），如果需要多个线程并发访问，可以先采用 `Collections.synchronizedList()` 方法对其进行包装。 \n\n\n\n### 2. add()\n\n \n\nadd() 方法有两个版本，一个是 `add(E e)`，该方法在 LinkedList 的末尾插入元素，因为有 last 指向链表末尾，在末尾插入元素的花费是常数时间。只需要简单修改几个相关引用即可；另一个是 `add(int index, E element)`，该方法是在指定下表处插入元素，需要先通过线性查找找到具体位置，然后修改相关引用完成插入操作。\n\n```java\n// JDK 1.8\npublic boolean add(E e) {\n linkLast(e);\n return true;\n}\n\n/**\n* Links e as last element.\n*/\nvoid linkLast(E e) {\n final Node l = last;\n final Node newNode = new Node<>(l, e, null);\n last = newNode;\n if (l == null)\n first = newNode;\n else\n l.next = newNode;\n size++;\n modCount++;\n}\n\n```\n`add(int index, E element)` 的逻辑稍显复杂，可以分成两部分\n\n1. 先根据 index 找到要插入的位置；\n\n2. 修改引用，完成插入操作。\n\n\n```java\npublic void add(int index, E element) {\n checkPositionIndex(index);\n if (index == size)\n linkLast(element);\n else\n linkBefore(element, node(index));\n}\n\nprivate void checkPositionIndex(int index) {\n if (!isPositionIndex(index))\n throw new IndexOutOfBoundsException(outOfBoundsMsg(index));\n}\n```\n\n上面代码中的 `node(int index)` 函数有一点小小的 trick，因为链表双向的，可以从开始往后找，也可以从结尾往前找，具体朝那个方向找取决于条件 `index < (size >> 1)`，也即是 index 是靠近前端还是后端。\n\n\n\n### 3. remove()\n\nremove() 方法也有两个版本，一个是删除跟指定元素相等的第一个元素 `remove(Object o)`，另一个是删除指定下标处的元素 `remove(int index)`。\n\n \n\n两个删除操作都要：\n\n1. 先找到要删除元素的引用；\n2. 修改相关引用，完成删除操作。\n\n在寻找被删元素引用的时候 `remove(Object o)` 调用的是元素的 equals 方法，而 `remove(int index)` 使用的是下标计数，两种方式都是线性时间复杂度。在步骤 2 中，两个 `revome()` 方法都是通过 `unlink(Node x)` 方法完成的。这里需要考虑删除元素是第一个或者最后一个时的边界情况。 \n\n\n\n### 4. get()\n\n```java\npublic E get(int index) {\n\tcheckElementIndex(index);\n\treturn node(index).item;\n}\n \nNode node(int index) {\n\t// assert isElementIndex(index);\n if (index < (size >> 1)) {\n Node x = first;\n for (int i = 0; i < index; i++)\n x = x.next;\n return x;\n\t} else {\n Node x = last;\n for (int i = size - 1; i > index; i--)\n x = x.prev;\n return x;\n\t}\n}\n```\n\n由此可以看出是使用二分查找来看 `index` 离 size 中间距离来判断是从头结点正序查还是从尾节点倒序查。\n\n- node() 会以 `O(n/2)` 的性能去获取一个结点\n - 如果索引值大于链表大小的一半，那么将从尾结点开始遍历\n\n这样的效率是非常低的，特别是当 index 越接近 size 的中间值时。\n\n\n\n### 5. 总结\n\n- LinkedList 插入，删除都是移动指针效率很高。\n- 查找需要进行遍历查询，效率较低。\n\n\n\n### 6. ArrayList 与 LinkedList\n\n- ArrayList 基于动态数组实现，LinkedList 基于双向链表实现；\n- ArrayList 支持随机访问，LinkedList 不支持；\n- LinkedList 在任意位置添加删除元素更快。\n\n\n\n## HashMap\n\n我们这篇文章就来试着分析下 HashMap 的源码，由于 HashMap 底层涉及到太多方面，一篇文章总是不能面面俱到，所以我们可以带着面试官常问的几个问题去看源码：\n\n1. 了解底层如何存储数据的\n2. HashMap 的几个主要方法\n3. HashMap 是如何确定元素存储位置的以及如何处理哈希冲突的\n4. HashMap 扩容机制是怎样的\n5. JDK 1.8 在扩容和解决哈希冲突上对 HashMap 源码做了哪些改动？有什么好处?\n\n\n\nHashMap 的内部功能实现很多，本文主要从根据 key 获取哈希桶数组索引位置、put 方法的详细执行、扩容过程三个具有代表性的点深入展开讲解。\n\n### 1. 存储结构\n\n#### JDK1.7 的存储结构\n\n在 1.7 之前 JDK 采用「拉链法」来存储数据，即数组和链表结合的方式：\n\n \n\n 「拉链法」用专业点的名词来说叫做**链地址法**。简单来说，就是数组加链表的结合。在每个数组元素上存储的都是一个链表。\n\n我们之前说到不同的 key 可能经过 hash 运算可能会得到相同的地址，但是一个数组单位上只能存放一个元素，采用链地址法以后，如果遇到相同的 hash 值的 key 的时候，我们可以将它放到作为数组元素的链表上。待我们去取元素的时候通过 hash 运算的结果找到这个链表，再在链表中找到与 key 相同的节点，就能找到 key 相应的值了。\n\nJDK1.7 中新添加进来的元素总是放在数组相应的角标位置，而原来处于该角标的位置的节点作为 next 节点放到新节点的后边。稍后通过源码分析我们也能看到这一点。\n\n \n\n#### JDK1.8 的存储结构\n\n对于 JDK1.8 之后的 `HashMap` 底层在解决哈希冲突的时候，就不单单是使用数组加上单链表的组合了，因为当处理如果 hash 值冲突较多的情况下，链表的长度就会越来越长，此时通过单链表来寻找对应 Key 对应的 Value 的时候就会使得时间复杂度达到 O(n)，因此在 JDK1.8 之后，在链表新增节点导致链表长度超过 `TREEIFY_THRESHOLD = 8` 的时候，就会在添加元素的同时将原来的单链表转化为红黑树。\n\n对数据结构很在行的读者应该，知道红黑树是一种易于增删改查的二叉树，他对与数据的查询的时间复杂度是 `O(logn)` 级别，所以利用红黑树的特点就可以更高效的对 `HashMap` 中的元素进行操作。\n\n \n\n\n\n**这里需要讲明白两个问题：数据底层具体存储的是什么？这样的存储方式有什么优点呢？** \n\n（1）从源码可知，HashMap 类中有一个非常重要的字段，就是 Node[] table，即哈希桶数组，明显它是一个 Node 的数组。我们来看 Node（ JDK1.8 中） 是何物。\n\n```java\nstatic class Node implements Map.Entry {\n final int hash; //用来定位数组索引位置\n final K key;\n V value;\n Node next; //链表的下一个node\n\n Node(int hash, K key, V value, Node next) { ... }\n public final K getKey(){ ... }\n public final V getValue() { ... }\n public final String toString() { ... }\n public final int hashCode() { ... }\n public final V setValue(V newValue) { ... }\n public final boolean equals(Object o) { ... }\n}\n```\n\nNode 是 HashMap 的一个内部类，实现了 Map.Entry 接口，本质是就是一个映射（键值对）。上图中的每个黑色圆点就是一个Node对象。\n\n（2）HashMap 就是使用哈希表来存储的。哈希表为解决冲突，可以采用**开放地址法**和**链地址法**等来解决问题， Java 中 HashMap 采用了链地址法。链地址法，简单来说，就是数组加链表的结合。在每个数组元素上都一个链表结构，当数据被 Hash 后，得到数组下标，把数据放在对应下标元素的链表上。例如程序执行下面代码：\n\n```java\nmap.put(\"美团\",\"小美\");\n```\n\n系统将调用 \"美团\" 这个 key 的 hashCode() 方法得到其 hashCode 值（该方法适用于每个 Java 对象），然后再通过 Hash 算法的后两步运算（高位运算和取模运算，下文有介绍）来定位该键值对的存储位置，有时两个 key 会定位到相同的位置，表示发生了 Hash 碰撞。当然 Hash 算法计算结果越分散均匀，Hash 碰撞的概率就越小，map 的存取效率就会越高。\n\n如果哈希桶数组很大，即使较差的 Hash 算法也会比较分散，如果哈希桶数组数组很小，即使好的 Hash 算法也会出现较多碰撞，所以就需要在空间成本和时间成本之间权衡，其实就是在根据实际情况确定哈希桶数组的大小，并在此基础上设计好的 hash 算法减少 Hash 碰撞。\n\n**那么通过什么方式来控制 map 使得 Hash 碰撞的概率又小，哈希桶数组（Node[] table）占用空间又少呢？**\n\n答案就是好的 Hash 算法和扩容机制。\n\n在理解 Hash 和扩容流程之前，我们得先了解下 HashMap 的几个字段。从 HashMap 的默认构造函数源码可知，构造函数就是对下面几个字段进行初始化，源码如下：\n\n```java\nint threshold; // 所能容纳的key-value对极限 \nfinal float loadFactor; // 负载因子\nint modCount; \nint size;\n```\n\n首先，**Node[] table的初始化长度 length (默认值是16)**，**Load factor 为负载因子(默认值是0.75)**，threshold 是 HashMap 所能容纳的最大数据量的 Node (键值对)个数。**threshold = length * Load factor**。也就是说，在数组定义好长度之后，负载因子越大，所能容纳的键值对个数越多。\n\n结合负载因子的定义公式可知，threshold 就是在此 Load factor 和 length (数组长度)对应下允许的最大元素数目，超过这个数目就重新 resize(扩容)，扩容后的 HashMap 容量是之前容量的两倍。默认的负载因子 0.75 是对空间和时间效率的一个平衡选择，建议大家不要修改，除非在时间和空间比较特殊的情况下，如果内存空间很多而又对时间效率要求很高，可以降低负载因子 Load factor 的值；相反，如果内存空间紧张而对时间效率要求不高，可以增加负载因子 loadFactor 的值，这个值可以大于1。\n\nsize 这个字段其实很好理解，就是 HashMap 中实际存在的键值对数量。注意和 table 的长度 length、容纳最大键值对数量 threshold 的区别。而 modCount 字段主要用来记录 HashMap 内部结构发生变化的次数，主要用于迭代的快速失败。强调一点，内部结构发生变化指的是结构发生变化，例如 put 新键值对，但是某个 key 对应的 value 值被覆盖不属于结构变化。\n\n在 HashMap 中，哈希桶数组 table 的长度 length 大小必须为 2n （一定是合数），这是一种非常规的设计，常规的设计是把桶的大小设计为素数。相对来说素数导致冲突的概率要小于合数，具体证明可以参考 [为什么一般hashtable的桶数会取一个素数？](https://blog.csdn.net/liuqiyao_01/article/details/14475159) ，**Hashtable 初始化桶大小为 11，就是桶大小设计为素数的应用（Hashtable 扩容后不能保证还是素数）**。HashMap 采用这种非常规设计，**主要是为了在取模和扩容时做优化，同时为了减少冲突，HashMap 定位哈希桶索引位置时，也加入了高位参与运算的过程**。\n\n这里存在一个问题，即使负载因子和 Hash 算法设计的再合理，也免不了会出现拉链过长的情况，一旦出现拉链过长，则会严重影响 HashMap 的性能。于是，在 JDK1.8 版本中，对数据结构做了进一步的优化，引入了红黑树。而当链表长度太长（默认超过8）时，链表就转换为红黑树，利用红黑树快速增删改查的特点提高 HashMap 的性能，其中会用到红黑树的插入、删除、查找等算法。本文不再对红黑树展开讨论，想了解更多红黑树数据结构的工作原理可以参考：[教你初步了解红黑树](https://blog.csdn.net/v_july_v/article/details/6105630)。\n\n\n\n### 2. 重要参数\n\n| 参数 | 说明 |\n| ------------------- | ------------------------------------------------------------ |\n| buckets | 在 HashMap 的注释里使用哈希桶来形象的表示数组中每个地址位置。注意这里并不是数组本身，数组是装哈希桶的，他可以被称为**哈希表**。 |\n| capacity | table 的容量大小，默认为 16。需要注意的是 capacity 必须保证为 2 的 n 次方。 |\n| size | table 的实际使用量。 |\n| threshold | size 的临界值，size 必须小于 threshold，如果大于等于，就必须进行扩容操作。 |\n| loadFactor | 装载因子，table 能够使用的比例，threshold = capacity * loadFactor。 |\n| TREEIFY_THRESHOLD | 树化阀值，哈希桶中的节点个数大于该值（默认为8）的时候将会被转为红黑树行存储结构。 |\n| UNTREEIFY_THRESHOLD | 非树化阀值，小于该值（默认为 6）的时候将再次改为单链表的格式存储 |\n\n\n\n### 3. 确定哈希桶数组索引位置\n\n很多操作都需要先确定一个键值对所在的桶下标。\n\n```java\nint hash = hash(key);\nint i = indexFor(hash, table.length);\n```\n\n（一）计算 hash 值\n\n```java\nfinal int hash(Object k) {\n int h = hashSeed;\n if (0 != h && k instanceof String) {\n return sun.misc.Hashing.stringHash32((String) k);\n }\n\n h ^= k.hashCode();\n\n // This function ensures that hashCodes that differ only by\n // constant multiples at each bit position have a bounded\n // number of collisions (approximately 8 at default load factor).\n h ^= (h >>> 20) ^ (h >>> 12);\n return h ^ (h >>> 7) ^ (h >>> 4);\n}\npublic final int hashCode() {\n return Objects.hashCode(key) ^ Objects.hashCode(value);\n}\n```\n\n（二）取模\n\n令 x = 1<<4，即 x 为 2 的 4 次方，它具有以下性质：\n\n```\nx : 00010000\nx-1 : 00001111\n```\n\n令一个数 y 与 x-1 做与运算，可以去除 y 位级表示的第 4 位以上数：\n\n```\ny : 10110010\nx-1 : 00001111\ny&(x-1) : 00000010\n```\n\n这个性质和 y 对 x 取模效果是一样的：\n\n```\ny : 10110010\nx : 00010000\ny%x : 00000010\n```\n\n我们知道，位运算的代价比求模运算小的多，因此在进行这种计算时用位运算的话能带来更高的性能。\n\n确定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，如果能保证 capacity 为 2 的 n 次方，那么就可以将这个操作转换为位运算。\n\n```java\nstatic int indexFor(int h, int length) {\n return h & (length-1);\n}\n```\n\n\n\n### 4. 分析HashMap的put方法\n\n\n\n HashMap 的 put 方法执行过程可以通过下图来理解，自己有兴趣可以去对比源码更清楚地研究学习。\n\n [] tab; Node p; int n, i;\n // 步骤①：tab为空则创建\n if ((tab = table) == null || (n = tab.length) == 0)\n n = (tab = resize()).length;\n // 步骤②：计算index，并对null做处理 \n if ((p = tab[i = (n - 1) & hash]) == null) \n tab[i] = newNode(hash, key, value, null);\n else {\n Node e; K k;\n // 步骤③：节点key存在，直接覆盖value\n if (p.hash == hash &&\n ((k = p.key) == key || (key != null && key.equals(k))))\n e = p;\n // 步骤④：判断该链为红黑树\n else if (p instanceof TreeNode)\n e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);\n // 步骤⑤：该链为链表\n else {\n for (int binCount = 0; ; ++binCount) {\n if ((e = p.next) == null) {\n p.next = newNode(hash, key,value,null);\n //链表长度大于8转换为红黑树进行处理\n if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st \n treeifyBin(tab, hash);\n break;\n }\n // key已经存在直接覆盖value\n if (e.hash == hash &&\n ((k = e.key) == key || (key != null && key.equals(k)))) \n break;\n p = e;\n }\n }\n \n if (e != null) { // existing mapping for key\n V oldValue = e.value;\n if (!onlyIfAbsent || oldValue == null)\n e.value = value;\n afterNodeAccess(e);\n return oldValue;\n }\n }\n ++modCount;\n // 步骤⑥：超过最大容量 就扩容\n if (++size > threshold)\n resize();\n afterNodeInsertion(evict);\n return null;\n}\n```\n\n### 5. 扩容机制\n\n扩容 (resize) 就是重新计算容量，向 HashMap 对象里不停的添加元素，而 HashMap 对象内部的数组无法装载更多的元素时，对象就需要扩大数组的长度，以便能装入更多的元素。当然 Java 里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。\n\n我们分析下 resize 的源码，鉴于 JDK1.8 融入了红黑树，较复杂，为了便于理解我们仍然使用 JDK1.7 的代码，好理解一些，本质上区别不大，具体区别后文再说。\n\n```JAVA\nvoid resize(int newCapacity) { //传入新的容量\n Entry[] oldTable = table; //引用扩容前的Entry数组\n int oldCapacity = oldTable.length; \n if (oldCapacity == MAXIMUM_CAPACITY) { //扩容前的数组大小如果已经达到最大(2^30)了\n threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了\n return;\n }\n \n Entry[] newTable = new Entry[newCapacity]; //初始化一个新的Entry数组\n transfer(newTable); //！！将数据转移到新的Entry数组里\n table = newTable; //HashMap的table属性引用新的Entry数组\n threshold = (int)(newCapacity * loadFactor);//修改阈值\n}\n```\n\n这里就是使用一个容量更大的数组来代替已有的容量小的数组，transfer() 方法将原有 Entry 数组的元素拷贝到新的 Entry 数组里。\n\n```java\nvoid transfer(Entry[] newTable) {\n Entry[] src = table; //src引用了旧的Entry数组\n int newCapacity = newTable.length;\n for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组\n Entry e = src[j]; //取得旧Entry数组的每个元素\n if (e != null) {\n src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）\n do {\n Entry next = e.next;\n int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置\n e.next = newTable[i]; //标记[1]\n newTable[i] = e; //将元素放在数组上\n e = next; //访问下一个Entry链上的元素\n } while (e != null);\n }\n }\n}\n```\n\nnewTable[i] 的引用赋给了 e.next，也就是使用了单链表的头插入方式，同一位置上新元素总会被放在链表的头部位置；这样先放在一个索引上的元素终会被放到 Entry 链的尾部(如果发生了 hash 冲突的话），这一点和 Jdk1.8 有区别，下文详解。在旧数组中同一条 Entry 链上的元素，通过重新计算索引位置后，有可能被放到了新数组的不同位置上。\n\n下面举个例子说明下扩容过程。假设了我们的 hash 算法就是简单的用 key mod 一下表的大小（也就是数组的长度）。其中的哈希桶数组 table 的 size=2， 所以 key = 3、7、5，put 顺序依次为 5、7、3。在 mod 2 以后都冲突在 table[1] 这里了。这里假设负载因子 loadFactor=1，即当键值对的实际大小 size 大于 table 的实际大小时进行扩容。接下来的三个步骤是哈希桶数组 resize 成 4，然后所有的 Node 重新 rehash 的过程。\n\n \n\n下面我们讲解下 JDK1.8 做了哪些优化。经过观测可以发现，我们使用的是 2 次幂的扩展 (指长度扩为原来 2 倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动 2 次幂的位置。看下图可以明白这句话的意思，n 为 table 的长度，图（a）表示扩容前的 key1 和 key2 两种 key 确定索引位置的示例，图（b）表示扩容后 key1 和 key2 两种 key 确定索引位置的示例，其中 hash1 是 key1 对应的哈希与高位运算结果。\n\n \n\n因此，我们在扩充 HashMap 的时候，不需要像 JDK1.7 的实现那样重新计算 hash，只需要看看原来的 hash 值新增的那个 bit 是 1 还是 0 就好了，是 0 的话索引没变，是 1 的话索引变成“原索引+oldCap”，可以看看下图为 16 扩充为 32 的 resize 示意图：\n\n [] resize() {\n Node[] oldTab = table;\n int oldCap = (oldTab == null) ? 0 : oldTab.length;\n int oldThr = threshold;\n int newCap, newThr = 0;\n if (oldCap > 0) {\n // 超过最大值就不再扩充了，就只好随你碰撞去吧\n if (oldCap >= MAXIMUM_CAPACITY) {\n threshold = Integer.MAX_VALUE;\n return oldTab;\n }\n // 没超过最大值，就扩充为原来的2倍\n else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&\n oldCap >= DEFAULT_INITIAL_CAPACITY)\n newThr = oldThr << 1; // double threshold\n }\n else if (oldThr > 0) // initial capacity was placed in threshold\n newCap = oldThr;\n else { // zero initial threshold signifies using defaults\n newCap = DEFAULT_INITIAL_CAPACITY;\n newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);\n }\n // 计算新的resize上限\n if (newThr == 0) {\n\n float ft = (float)newCap * loadFactor;\n newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?\n (int)ft : Integer.MAX_VALUE);\n }\n threshold = newThr;\n @SuppressWarnings({\"rawtypes\"，\"unchecked\"})\n Node[] newTab = (Node[])new Node[newCap];\n table = newTab;\n if (oldTab != null) {\n // 把每个bucket都移动到新的buckets中\n for (int j = 0; j < oldCap; ++j) {\n Node e;\n if ((e = oldTab[j]) != null) {\n oldTab[j] = null;\n if (e.next == null)\n newTab[e.hash & (newCap - 1)] = e;\n else if (e instanceof TreeNode)\n ((TreeNode)e).split(this, newTab, j, oldCap);\n else { // 链表优化重hash的代码块\n Node loHead = null, loTail = null;\n Node hiHead = null, hiTail = null;\n Node next;\n do {\n next = e.next;\n // 原索引\n if ((e.hash & oldCap) == 0) {\n if (loTail == null)\n loHead = e;\n else\n loTail.next = e;\n loTail = e;\n }\n // 原索引+oldCap\n else {\n if (hiTail == null)\n hiHead = e;\n else\n hiTail.next = e;\n hiTail = e;\n }\n } while ((e = next) != null);\n // 原索引放到bucket里\n if (loTail != null) {\n loTail.next = null;\n newTab[j] = loHead;\n }\n // 原索引+oldCap放到bucket里\n if (hiTail != null) {\n hiTail.next = null;\n newTab[j + oldCap] = hiHead;\n }\n }\n }\n }\n }\n return newTab;\n}\n```\n\n### 6. 线程安全性\n\n在多线程使用场景中，应该尽量避免使用线程不安全的 HashMap，而使用线程安全的 ConcurrentHashMap。那么为什么说 HashMap 是线程不安全的，下面举例子说明在并发的多线程使用场景中使用 HashMap 可能造成死循环。代码例子如下(便于理解，仍然使用 JDK1.7 的环境)：\n\n```java\npublic class HashMapInfiniteLoop { \n\n private static HashMap map = new HashMap(2，0.75f); \n public static void main(String[] args) { \n map.put(5， \"C\"); \n\n new Thread(\"Thread1\") { \n public void run() { \n map.put(7, \"B\"); \n System.out.println(map); \n }; \n }.start(); \n new Thread(\"Thread2\") { \n public void run() { \n map.put(3, \"A); \n System.out.println(map); \n }; \n }.start(); \n } \n}\n```\n\n其中，map初始化为一个长度为2的数组，loadFactor=0.75，threshold=2*0.75=1，也就是说当put第二个key的时候，map就需要进行resize。\n\n通过设置断点让线程1和线程2同时debug到transfer方法(3.3小节代码块)的首行。注意此时两个线程已经成功添加数据。放开thread1的断点至transfer方法的“Entry next = e.next;” 这一行；然后放开线程2的的断点，让线程2进行resize。结果如下图。\n\n \n\n注意，Thread1的 e 指向了key(3)，而next指向了key(7)，其在线程二rehash后，指向了线程二重组后的链表。\n\n线程一被调度回来执行，先是执行 newTalbe[i] = e， 然后是e = next，导致了e指向了key(7)，而下一次循环的next = e.next导致了next指向了key(3)。\n\n \n\n\n\n \n\ne.next = newTable[i] 导致 key(3).next 指向了 key(7)。注意：此时的key(7).next 已经指向了key(3)， 环形链表就这样出现了。\n\n\n\n \n\n于是，当我们用线程一调用map.get(11)时，悲剧就出现了——Infinite Loop。\n\n### 7. JDK1.8与JDK1.7的性能对比\n\nHashMap中，如果key经过hash算法得出的数组索引位置全部不相同，即Hash算法非常好，那样的话，getKey方法的时间复杂度就是O(1)，如果Hash算法技术的结果碰撞非常多，假如Hash算极其差，所有的Hash算法结果得出的索引位置一样，那样所有的键值对都集中到一个桶中，或者在一个链表中，或者在一个红黑树中，时间复杂度分别为O(n)和O(lgn)。 鉴于JDK1.8做了多方面的优化，总体性能优于JDK1.7，下面我们从两个方面用例子证明这一点。\n\n### 8. Hash较均匀的情况\n\n为了便于测试，我们先写一个类Key，如下：\n\n```java\nclass Key implements Comparable {\n\n private final int value;\n\n Key(int value) {\n this.value = value;\n }\n\n @Override\n public int compareTo(Key o) {\n return Integer.compare(this.value, o.value);\n }\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (o == null || getClass() != o.getClass())\n return false;\n Key key = (Key) o;\n return value == key.value;\n }\n\n @Override\n public int hashCode() {\n return value;\n }\n}\n```\n\n这个类复写了equals方法，并且提供了相当好的hashCode函数，任何一个值的hashCode都不会相同，因为直接使用value当做hashcode。为了避免频繁的GC，我将不变的Key实例缓存了起来，而不是一遍一遍的创建它们。代码如下：\n\n```java\npublic class Keys {\n\n public static final int MAX_KEY = 10_000_000;\n private static final Key[] KEYS_CACHE = new Key[MAX_KEY];\n\n static {\n for (int i = 0; i < MAX_KEY; ++i) {\n KEYS_CACHE[i] = new Key(i);\n }\n }\n\n public static Key of(int value) {\n return KEYS_CACHE[value];\n }\n}\n```\n\n现在开始我们的试验，测试需要做的仅仅是，创建不同size的HashMap（1、10、100、......10000000），屏蔽了扩容的情况，代码如下：\n\n```java\nstatic void test(int mapSize) {\n\n HashMap map = new HashMap(mapSize);\n for (int i = 0; i < mapSize; ++i) {\n map.put(Keys.of(i), i);\n }\n\n long beginTime = System.nanoTime(); //获取纳秒\n for (int i = 0; i < mapSize; i++) {\n map.get(Keys.of(i));\n }\n long endTime = System.nanoTime();\n System.out.println(endTime - beginTime);\n}\n\npublic static void main(String[] args) {\n for(int i=10;i<= 1000 0000;i*= 10){\n test(i);\n }\n}\n```\n\n在测试中会查找不同的值，然后度量花费的时间，为了计算getKey的平均时间，我们遍历所有的get方法，计算总的时间，除以key的数量，计算一个平均值，主要用来比较，绝对值可能会受很多环境因素的影响。结果如下：\n\n {\n\n //...\n\n @Override\n public int hashCode() {\n return 1;\n }\n}\n```\n\n仍然执行main方法，得出的结果如下表所示：\n\n \n\n Hashtable 性能差主要是由于所有操作需要竞争同一把锁，而如果容器中有多把锁，每一把锁锁一段数据，这样在多线程访问时不同段的数据时，就不会存在锁竞争了，这样便可以有效地提高并发效率。这就是ConcurrentHashMap 所采用的 \"**分段锁**\" 思想。\n\n [] segments;\n```\n\n Segment 继承了 ReentrantLock，所以它就是一种可重入锁（ReentrantLock)。在 ConcurrentHashMap，一个 Segment 就是一个子哈希表，Segment 里维护了一个 HashEntry 数组，并发环境下，对于不同 Segment 的数据进行操作是不用考虑锁竞争的。（就按默认的 ConcurrentLeve 为16来讲，理论上就允许 16 个线程并发执行，有木有很酷）\n\n **所以，对于同一个 Segment 的操作才需考虑线程同步，不同的 Segment 则无需考虑。**\n\nSegment 类似于 HashMap，一个 Segment 维护着一个 HashEntry 数组\n\n```java\ntransient volatile HashEntry[] table;\n```\n\nHashEntry 是目前我们提到的最小的逻辑处理单元了。一个 ConcurrentHashMap 维护一个 Segment 数组，一个 Segment 维护一个 HashEntry 数组。\n\n```java\nstatic final class HashEntry {\n final int hash;\n final K key;\n volatile V value;\n volatile HashEntry next;\n}\n```\n\n ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。\n\nSegment 继承自 **ReentrantLock**。\n\n```java\nstatic final class Segment extends ReentrantLock implements Serializable {\n\n private static final long serialVersionUID = 2249069246763182397L;\n\n static final int MAX_SCAN_RETRIES =\n Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;\n\n transient volatile HashEntry[] table;\n\n transient int count;\n\n transient int modCount;\n\n transient int threshold;\n\n final float loadFactor;\n}\n```\n\n```java\nfinal Segment[] segments;\n```\n\n默认的并发级别为 16，也就是说默认创建 16 个 Segment。\n\n```java\nstatic final int DEFAULT_CONCURRENCY_LEVEL = 16;\n```\n\n\n\n### 2. size 操作\n\n每个 Segment 维护了一个 count 变量来统计该 Segment 中的键值对个数。\n\n```java\n/**\n * The number of elements. Accessed only either within locks\n * or among other volatile reads that maintain visibility.\n */\ntransient int count;\n```\n\n在执行 size 操作时，需要遍历所有 Segment 然后把 count 累计起来。\n\nConcurrentHashMap 在执行 size 操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。\n\n尝试次数使用 RETRIES_BEFORE_LOCK 定义，该值为 2，retries 初始值为 -1，因此尝试次数为 3。\n\n如果尝试的次数超过 3 次，就需要对每个 Segment 加锁。\n\n```java\n/**\n * Number of unsynchronized retries in size and containsValue\n * methods before resorting to locking. This is used to avoid\n * unbounded retries if tables undergo continuous modification\n * which would make it impossible to obtain an accurate result.\n */\nstatic final int RETRIES_BEFORE_LOCK = 2;\n\npublic int size() {\n // Try a few times to get accurate count. On failure due to\n // continuous async changes in table, resort to locking.\n final Segment[] segments = this.segments;\n int size;\n boolean overflow; // true if size overflows 32 bits\n long sum; // sum of modCounts\n long last = 0L; // previous sum\n int retries = -1; // first iteration isn't retry\n try {\n for (;;) {\n // 超过尝试次数，则对每个 Segment 加锁\n if (retries++ == RETRIES_BEFORE_LOCK) {\n for (int j = 0; j < segments.length; ++j)\n ensureSegment(j).lock(); // force creation\n }\n sum = 0L;\n size = 0;\n overflow = false;\n for (int j = 0; j < segments.length; ++j) {\n Segment seg = segmentAt(segments, j);\n if (seg != null) {\n sum += seg.modCount;\n int c = seg.count;\n if (c < 0 || (size += c) < 0)\n overflow = true;\n }\n }\n // 连续两次得到的结果一致，则认为这个结果是正确的\n if (sum == last)\n break;\n last = sum;\n }\n } finally {\n if (retries > RETRIES_BEFORE_LOCK) {\n for (int j = 0; j < segments.length; ++j)\n segmentAt(segments, j).unlock();\n }\n }\n return overflow ? Integer.MAX_VALUE : size;\n}\n```\n\n### 3. 同步方式\n\nSegment 继承自 ReentrantLock，所以我们可以很方便的对每一个 Segment 上锁。\n\n对于读操作，获取 Key 所在的 Segment 时，需要保证可见性。具体实现上可以使用 volatile 关键字，也可使用锁。但使用锁开销太大，而使用 volatile 时每次写操作都会让所有 CPU 内缓存无效，也有一定开销。ConcurrentHashMap 使用如下方法保证可见性，取得最新的 Segment。\n\n```java\nSegment s = (Segment)UNSAFE.getObjectVolatile(segments, u)\n```\n\n获取 Segment 中的 HashEntry 时也使用了类似方法\n\n```java\nHashEntry e = (HashEntry) UNSAFE.getObjectVolatile\n (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE)\n```\n\n对于写操作，并不要求同时获取所有 Segment 的锁，因为那样相当于锁住了整个 Map。它会先获取该 Key-Value 对所在的 Segment 的锁，获取成功后就可以像操作一个普通的 HashMap 一样操作该 Segment，并保证该Segment 的安全性。\n同时由于其它 Segment 的锁并未被获取，因此理论上可支持 concurrencyLevel（等于 Segment 的个数）个线程安全的并发读写。\n\n获取锁时，并不直接使用 lock 来获取，因为该方法获取锁失败时会挂起。事实上，它使用了自旋锁，如果 tryLock 获取锁失败，说明锁被其它线程占用，此时通过循环再次以 tryLock 的方式申请锁。如果在循环过程中该 Key 所对应的链表头被修改，则重置 retry 次数。如果 retry 次数超过一定值，则使用 lock 方法申请锁。\n\n这里使用自旋锁是因为自旋锁的效率比较高，但是它消耗 CPU 资源比较多，因此在自旋次数超过阈值时切换为互斥锁。\n\n\n\n### 4. JDK 1.8 的改动\n\n- JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发程度与 Segment 数量相等。\n\n- JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。\n\n- 并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。\n\n\n\n参考资料：\n\n- [ConcurrentHashMap演进从Java7到Java8](http://www.jasongj.com/java/concurrenthashmap/)\n\n- [ConcurrentHashMap实现原理及源码分析 - dreamcatcher-cx - 博客园](https://www.cnblogs.com/chengxiao/p/6842045.html)\n\n\n\n\n## HashSet\n\n 前面已经说过 HashSet 是对 HashMap 的简单包装，对 HashSet 的函数调用都会转换成合适的 HashMap 方法，因此 HashSet 的实现非常简单，只有不到 300 行代码（适配器模式）。这里不再赘述。\n\n```java\n//HashSet是对HashMap的简单包装\npublic class HashSet\n{\n\t......\n\tprivate transient HashMap map;//HashSet里面有一个HashMap\n // Dummy value to associate with an Object in the backing Map\n private static final Object PRESENT = new Object();\n public HashSet() {\n map = new HashMap<>();\n }\n ......\n public boolean add(E e) {//简单的方法转换\n return map.put(e, PRESENT)==null;\n }\n ......\n}\n```\n\n\n\n### 1. 成员变量\n\n首先了解下 `HashSet` 的成员变量:\n\n```java\n private transient HashMap map;\n\n // Dummy value to associate with an Object in the backing Map\n private static final Object PRESENT = new Object();\n```\n\n发现主要就两个变量:\n\n- `map` ：用于存放最终数据的。\n- `PRESENT` ：是所有写入 map 的 `value` 值。\n\n\n\n### 2. 构造函数\n\n```java\n public HashSet() {\n map = new HashMap<>();\n }\n \n public HashSet(int initialCapacity, float loadFactor) {\n map = new HashMap<>(initialCapacity, loadFactor);\n } \n```\n\n构造函数很简单，利用了 `HashMap` 初始化了 `map` 。\n\n\n\n### 3. add()\n\n```java\n public boolean add(E e) {\n return map.put(e, PRESENT)==null;\n }\n```\n\n比较关键的就是这个 `add()` 方法。 可以看出它是将存放的对象当做了 `HashMap` 的健，`value` 都是相同的 `PRESENT` 。由于 `HashMap` 的 `key` 是不能重复的，所以每当有重复的值写入到 `HashSet` 时，`value` 会被覆盖，但 `key` 不会收到影响，这样就保证了 `HashSet` 中只能存放不重复的元素。\n\n\n\n### 4. 总结\n\n`HashSet` 的原理比较简单，几乎全部借助于 `HashMap` 来实现的。\n\n所以 `HashMap` 会出现的问题 `HashSet` 依然不能避免。\n\n\n\n## LinkedHashSet and LinkedHashMap\n\n### 1. 概览\n\n 如果你已看过前面关于 HashSet 和 HashMap，的讲解，一定能够想到本文将要讲解的 LinkedHashSet 和 LinkedHashMap 其实也是一回事。 LinkedHashSet 和 LinkedHashMap 在 Java 里也有着相同的实现，前者仅仅是对后者做了一层包装，也就是说 LinkedHashSet 里面有一个 LinkedHashMap（**适配器模式**）。因此本文将重点分析 LinkedHashMap。\n\n LinkedHashMap 实现了 Map 接口，即允许放入 key 为 null 的元素，也允许插入 value 为 null 的元素。从名字上可以看出该容器是 LinkedList 和 HashMap 的混合体，也就是说它同时满足 HashMap 和 LinkedList 的某些特性。**可将 LinkedHashMap 看作采用 LinkedList 增强的 HashMap。**\n\n \n\n`addEntry()`代码如下：\n\n```java\n// LinkedHashMap.addEntry()\nvoid addEntry(int hash, K key, V value, int bucketIndex) {\n if ((size >= threshold) && (null != table[bucketIndex])) {\n resize(2 * table.length);// 自动扩容，并重新哈希\n hash = (null != key) ? hash(key) : 0;\n bucketIndex = hash & (table.length-1);// hash%table.length\n }\n // 1.在冲突链表头部插入新的entry\n HashMap.Entry old = table[bucketIndex];\n Entry e = new Entry<>(hash, key, value, old);\n table[bucketIndex] = e;\n // 2.在双向链表的尾部插入新的entry\n e.addBefore(header);\n size++;\n}\n```\n\n上述代码中用到了 `addBefore()`方 法将新 `entry e` 插入到双向链表头引用 `header` 的前面，这样 `e` 就成为双向链表中的最后一个元素。`addBefore()` 的代码如下：\n\n```java\n// LinkedHashMap.Entry.addBefor()，将this插入到existingEntry的前面\nprivate void addBefore(Entry existingEntry) {\n after = existingEntry;\n before = existingEntry.before;\n before.after = this;\n after.before = this;\n}\n```\n\n上述代码只是简单修改相关 `entry` 的引用而已。\n\n\n\n### 4. remove()\n\n`remove(Object key)`的作用是删除`key`值对应的`entry`，该方法的具体逻辑是在`removeEntryForKey(Object key)`里实现的。`removeEntryForKey()`方法会首先找到`key`值对应的`entry`，然后删除该`entry`（修改链表的相应引用）。查找过程跟`get()`方法类似。\n\n注意，这里的**删除也有两重含义**：\n\n> 1. 从`table`的角度看，需要将该`entry`从对应的`bucket`里删除，如果对应的冲突链表不空，需要修改冲突链表的相应引用。\n> 2. 从`header`的角度来看，需要将该`entry`从双向链表中删除，同时修改链表中前面以及后面元素的相应引用。\n\n\n\n removeEntryForKey(Object key) {\n\t......\n\tint hash = (key == null) ? 0 : hash(key);\n int i = indexFor(hash, table.length);// hash&(table.length-1)\n Entry prev = table[i];// 得到冲突链表\n Entry e = prev;\n while (e != null) {// 遍历冲突链表\n Entry next = e.next;\n Object k;\n if (e.hash == hash &&\n ((k = e.key) == key || (key != null && key.equals(k)))) {// 找到要删除的entry\n modCount++; size--;\n // 1. 将e从对应bucket的冲突链表中删除\n if (prev == e) table[i] = next;\n else prev.next = next;\n // 2. 将e从双向链表中删除\n e.before.after = e.after;\n e.after.before = e.before;\n return e;\n }\n prev = e; e = next;\n }\n return e;\n}\n```\n\n\n\n### 5. LinkedHashSet\n\n前面已经说过*LinkedHashSet*是对*LinkedHashMap*的简单包装，对*LinkedHashSet*的函数调用都会转换成合适的*LinkedHashMap*方法，因此*LinkedHashSet*的实现非常简单，这里不再赘述。\n\n```java\npublic class LinkedHashSet\n extends HashSet\n implements Set, Cloneable, java.io.Serializable {\n ......\n // LinkedHashSet里面有一个LinkedHashMap\n public LinkedHashSet(int initialCapacity, float loadFactor) {\n map = new LinkedHashMap<>(initialCapacity, loadFactor);\n }\n\t......\n public boolean add(E e) {//简单的方法转换\n return map.put(e, PRESENT)==null;\n }\n ......\n}\n```\n\n\n\n### 6. LinkedHashMap经典用法\n\nLinkedHashMap 除了可以保证迭代顺序外，还有一个非常有用的用法：可以轻松实现一个采用了FIFO替换策略的缓存。具体说来，LinkedHashMap 有一个子类方法 `protected boolean removeEldestEntry(Map.Entry eldest)`，该方法的作用是告诉 Map 是否要删除“最老”的 Entry，所谓最老就是当前 Map 中最早插入的 Entry，如果该方法返回 true，最老的那个元素就会被删除。在每次插入新元素的之后 LinkedHashMap 会自动询问 removeEldestEntry() 是否要删除最老的元素。这样只需要在子类中重载该方法，当元素个数超过一定数量时让 removeEldestEntry() 返回 true，就能够实现一个固定大小的 FIFO 策略的缓存。示例代码如下：\n\n```java\n/** 一个固定大小的FIFO替换策略的缓存 */\nclass FIFOCache extends LinkedHashMap{\n private final int cacheSize;\n public FIFOCache(int cacheSize){\n this.cacheSize = cacheSize;\n }\n\n // 当Entry个数超过cacheSize时，删除最老的Entry\n @Override\n protected boolean removeEldestEntry(Map.Entry eldest) {\n return size() > cacheSize;\n }\n}\n```\n\n\n\n\n\n# 三、容器中的设计模式\n\n## 迭代器模式\n\n list = new ArrayList<>();\nlist.add(\"a\");\nlist.add(\"b\");\nfor (String item : list) {\n System.out.println(item);\n}\n```\n\n\n\n## 适配器模式\n\njava.util.Arrays.asList() 可以把数组类型转换为 List 类型。\n\n```java\n@SafeVarargs\npublic static List asList(T... a)\n```\n\n如果要将数组类型转换为 List 类型，应该注意的是 asList() 的参数为泛型的变长参数，因此不能使用基本类型数组作为参数，只能使用相应的包装类型数组。\n\n```java\nInteger[] arr = {1, 2, 3};\nList list = Arrays.asList(arr);\n```\n\n也可以使用以下方式生成 List。\n\n```java\nList list = Arrays.asList(1,2,3);\n```\n\n\n\n# 四、面试指南\n\n## 1. ArrayList和LinkedList区别\n\n- ArrayList 和 LinkedList 可想从名字分析，它们一个是 Array (动态数组) 的数据结构，一个是 Link (链表) 的数据结构，此外，它们两个都是对 List 接口的实现。前者是数组队列，相当于动态数组；后者为双向链表结构，也可当作堆栈、队列、双端队列；\n- **当随机访问 List 时**（get和set操作），ArrayList 比 LinkedList的效率更高，因为 LinkedList 是线性的数据存储方式，所以需要移动指针从前往后依次查找；\n- **当对数据进行增加和删除的操作时**（add 和 remove 操作），LinkedList 比 ArrayList 的效率更高，因为 ArrayList 是数组，所以在其中进行增删操作时，会对操作点之后所有数据的下标索引造成影响，需要进行数据的移动；\n- **从利用效率来看**，ArrayList 自由性较低，因为它需要手动的设置固定大小的容量，但是它的使用比较方便，只需要创建，然后添加数据，通过调用下标进行使用；而 LinkedList 自由性较高，能够动态的随数据量的变化而变化，但是它不便于使用；\n- ArrayList 主要空间开销在于需要在 List 列表预留一定空间；而 LinkList 主要控件开销在于需要存储结点信息以及结点指针信息。\n\n\n\n- **ArrayList、LinkedList 和 Vector如何选择？**\n - 当对数据的主要操作为索引或只在集合的末端增加、删除元素时，使用 ArrayList 或 Vector 效率比较高；\n - 当对数据的操作主要为指定位置的插入或删除操作时，使用 LinkedList 效率比较高；\n - 当在多线程中使用容器时（即多个线程会同时访问该容器），选用 Vector 较为安全；\n\n\n\n## 2. HashMap和Hashtable区别，HashMap的key类型\n\n- **HashMap和Hashtable的区别** \n\n - Hashtable 的方法是同步的，HashMap 非同步，所以在多线程场合要手动同步。\n - Hashtable 不允许 null 值 (key 和 value 都不可以)，HashMap 允许 null 值( key 和 value 都可以)。 \n - 两者的遍历方式大同小异，Hashtable 仅仅比 HashMap 多一个 elements 方法。 \n\n - Hashtable 和 HashMap 都能通过 values() 方法返回一个 Collection ，然后进行遍历处理。 \n\n - 两者也都可以通过 entrySet() 方法返回一个 Set ， 然后进行遍历处理。 \n\n - Hashtable 使用 Enumeration，HashMap 使用 Iterator。 \n - 哈希值的使用不同，Hashtable 直接使用对象的 hashCode。而 HashMap 重新计算hash值，而且用于代替求模。 \n - Hashtable 中 hash 数组默认大小是11，增加的方式是 old*2+1。HashMap 中 hash 数组的默认大小是16，而且一定是 2 的指数。 \n - Hashtable 基于 Dictionary 类，而 HashMap 基于 AbstractMap 类 \n\n- **HashMap中的key可以是任何对象或数据类型吗** \n\n - 可以为null，但不能是可变对象，如果是可变对象的话，对象中的属性改变，则对象 HashCode 也进行相应的改变，导致下次无法查找到已存在Map中的数据。 \n - 如果可变对象在 HashMap 中被用作键，那就要小心在改变对象状态的时候，不要改变它的哈希值了。我们只需要保证成员变量的改变能保证该对象的哈希值不变即可。 \n\n- **Hashtable是线程安全的么** \n\n - Hashtable 是线程安全的，其实现是在对应的方法上添加了 synchronized 关键字进行修饰，由于在执行此方法的时候需要获得对象锁，则执行起来比较慢。所以现在如果为了保证线程安全的话，使用 CurrentHashMap。 \n\n\n\n## 3. HashMap和ConcurrentHashMap\n\n- **HashMap和Concurrent HashMap区别？** \n - HashMap 是非线程安全的，CurrentHashMap 是线程安全的。 \n - ConcurrentHashMap 将整个 Hash 桶进行了分段 segment，也就是将这个大的数组分成了几个小的片段segment，而且每个小的片段 segment 上面都有锁存在，那么在插入元素的时候就需要先找到应该插入到哪一个片段 segment，然后再在这个片段上面进行插入，而且这里还需要获取 segment 锁。 \n - ConcurrentHashMap 让锁的粒度更精细一些，并发性能更好。 \n- **ConcurrentHashMap 线程安全吗， ConcurrentHashMap如何保证 线程安全？** \n - Hashtable 容器在竞争激烈的并发环境下表现出效率低下的原因是所有访问 Hashtable 的线程都必须竞争同一把锁，那假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效的提高并发访问效率，这就是 ConcurrentHashMap 所使用的**分段锁**，首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。 \n - get 操作的高效之处在于整个 get 过程不需要加锁，除非读到的值是空的才会加锁重读。**get 方法里将要使用的共享变量都定义成 volatile**，如用于统计当前 Segement 大小的 count 字段和用于存储值的 HashEntry 的 value。定义成 volatile 的变量，能够在线程之间保持可见性，能够被多线程同时读，并且保证不会读到过期的值，但是只能被单线程写（有一种情况可以被多线程写，就是写入的值不依赖于原值），在 get 操作里只需要读不需要写共享变量 count 和 value，所以可以不用加锁。 \n - put 方法首先定位到 Segment，然后在 Segment 里进行插入操作。\n - 插入操作需要经历两个步骤：（1）判断是否需要对 Segment 里的 HashEntry 数组进行扩容；（2）定位添加元素的位置然后放在HashEntry数组里。 \n\n\n\n## 4. Hashtable的原理\n\n**Hashtable 使用链地址法进行元素存储，通过一个实际的例子来演示一下插入元素的过程：**\n\n假设我们现在 Hashtable 的容量为 5，已经存在了 (8,8)，(10,10)，(13,13)，(16,16)，(17,17)，(21,21) 这 6 个键值对，目前他们在 Hashtable 中的位置如下：\n\n listIt = list.iterator();\n while(listIt.hasNext()){\n System.out.println(listIt.hasNext());\n }\n // 使用迭代器遍历Set集合\n Iterator setIt = set.iterator();\n while(setIt.hasNext()){\n System.out.println(listIt.hasNext());\n }\n // 使用迭代器遍历LinkedList集合\n Iterator linkIt = linkList.iterator();\n while(linkIt.hasNext()){\n System.out.println(listIt.hasNext());\n }\n}\n```\n\n参考资料：\n\n- [深入理解Java中的迭代器 - Mr·Dragon - 博客园](https://www.cnblogs.com/zyuze/p/7726582.html)\n \n\n\n\n## 7. 构造相同hash的字符串进行攻击，这种情况应该怎么处理？JDK7如何处理\n\n**攻击原理：**\n\n 当客户端发送一个请求到服务器，如果该请求中带有参数，服务器端会将 参数名-参数值 作为 key-value 保存在 HashMap 中。如果有人恶意构造请求，在请求中加入大量相同 hash 值的 String 参数名（key），那么在服务器端用于存储这些 key-value 对的 HashMap 会被强行退化成链表，如图：\n\n \n\n如果数据量足够大，那么在查找，插入时会占用大量 CPU，达到拒绝服务攻击的目的。\n\n \n\n**怎么处理**\n\n1. 限制 POST 和 GET 请求的参数个数\n2. 限制 POST 请求的请求体大小\n3. Web Application FireWall（WAF）\n\n\n\n**JDK7如何处理**\n\nHashMap 会动态的使用一个专门 TreeMap 实现来替换掉它。\n\n\n\n\n\n## 8. HashMap为什么大小是2的幂次\n\n首先来看一下 HashMap 的 put 方法的源码\n\n```java\npublic V put(K key, V value) {\n if (key == null) \n return putForNullKey(value); //将空key的Entry加入到table[0]中\n int hash = hash(key.hashCode()); //计算key.hashcode()的hash值，hash函数由HashMap自己实现\n int i = indexFor(hash, table.length); //获取将要存放的数组下标\n /*\n * for中的代码用于：当hash值相同且key相同的情况下，使用新值覆盖旧值（其实就是修改功能）\n */\n //注意：for循环在第一次执行时就会先判断条件\n for (Entry e = table[i]; e != null; e = e.next) {\n Object k;\n //hash值相同且key相同的情况下，使用新值覆盖旧值\n if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {\n V oldValue = e.value;\n e.value = value;\n //e.recordAccess(this);\n return oldValue;//返回旧值\n }\n }\n modCount++;\n addEntry(hash, key, value, i);//增加一个新的Entry到table[i]\n return null;//如果没有与传入的key相等的Entry，就返回null\n}\n```\n\n```java\n/**\n * \"按位与\"来获取数组下标\n */\nstatic int indexFor(int h, int length) {\n return h & (length - 1);\n}\n\n```\n\n**HashMap 始终将自己的桶保持在2n ，这是为什么？indexFor这个方法解释了这个问题**\n\n大家都知道计算机里面位运算是基本运算，位运算的效率是远远高于取余 % 运算的\n\n举个例子：2n 转换成二进制就是 1+n 个 0，减 1 之后就是 0+n个1，如16 -> 10000，15 -> 01111\n\n那么根据 & 位运算的规则，都为 1 (真)时，才为 1，那 0≤运算后的结果≤15，假设 h <= 15，那么运算后的结果就是 h 本身，h >15，运算后的结果就是最后四位二进制做 & 运算后的值，最终，就是 % 运算后的余数。\n\n当容量一定是 2n 时，h & (length - 1) == h % length\n\n\n\n\n\n# 更新日志\n\n- 2018/8/3 v2.5 基础版\n- 2018/9/1 v3.0 初稿版\n"
},
{
"path": "notes/JavaArchitecture/03-Java并发编程.md",
"content": "\n\n- [前言](#前言)\n- [第一部分：并发编程](#第一部分并发编程)\n - [1. 线程状态转换](#1-线程状态转换)\n - [新建（New）](#新建new)\n - [可运行（Runnable）](#可运行runnable)\n - [阻塞（Blocking）](#阻塞blocking)\n - [无限期等待（Waiting）](#无限期等待waiting)\n - [限期等待（Timed Waiting）](#限期等待timed-waiting)\n - [死亡（Terminated）](#死亡terminated)\n - [2. Java实现多线程的方式及三种方式的区别](#2-java实现多线程的方式及三种方式的区别)\n - [实现 Runnable 接口](#实现-runnable-接口)\n - [实现 Callable 接口](#实现-callable-接口)\n - [继承 Thread 类](#继承-thread-类)\n - [实现接口 VS 继承 Thread](#实现接口-vs-继承-thread)\n - [三种方式的区别](#三种方式的区别)\n - [3. 基础线程机制](#3-基础线程机制)\n - [Executor](#executor)\n - [Daemon（守护线程）](#daemon守护线程)\n - [sleep()](#sleep)\n - [yield()](#yield)\n - [线程阻塞](#线程阻塞)\n - [4. 中断](#4-中断)\n - [InterruptedException](#interruptedexception)\n - [interrupted()](#interrupted)\n - [Executor 的中断操作](#executor-的中断操作)\n - [5. 互斥同步](#5-互斥同步)\n - [synchronized](#synchronized)\n - [ReentrantLock](#reentrantlock)\n - [synchronized 和 ReentrantLock 比较](#synchronized-和-reentrantlock-比较)\n - [synchronized与lock的区别，使用场景。看过synchronized的源码没？](#synchronized与lock的区别使用场景看过synchronized的源码没)\n - [什么是CAS](#什么是cas)\n - [入门例子](#入门例子)\n - [Compare And Swap](#compare-and-swap)\n - [什么是乐观锁和悲观锁](#什么是乐观锁和悲观锁)\n - [Synchronized（对象锁）和Static Synchronized（类锁）区别](#synchronized对象锁和static-synchronized类锁区别)\n - [6. 线程之间的协作](#6-线程之间的协作)\n - [join()](#join)\n - [wait() notify() notifyAll()](#wait-notify-notifyall)\n - [await() signal() signalAll()](#await-signal-signalall)\n - [sleep和wait有什么区别](#sleep和wait有什么区别)\n - [7. J.U.C - AQS](#7-juc---aqs)\n - [CountdownLatch](#countdownlatch)\n - [CyclicBarrier](#cyclicbarrier)\n - [Semaphore](#semaphore)\n - [总结](#总结)\n - [8. J.U.C - 其它组件](#8-juc---其它组件)\n - [FutureTask](#futuretask)\n - [BlockingQueue](#blockingqueue)\n - [ForkJoin](#forkjoin)\n - [9. 线程不安全示例](#9-线程不安全示例)\n - [10. Java 内存模型（JMM）](#10-java-内存模型jmm)\n - [主内存与工作内存](#主内存与工作内存)\n - [内存间交互操作](#内存间交互操作)\n - [内存模型三大特性](#内存模型三大特性)\n - [1. 原子性](#1-原子性)\n - [2. 可见性](#2-可见性)\n - [3. 有序性](#3-有序性)\n - [指令重排序](#指令重排序)\n - [数据依赖性](#数据依赖性)\n - [as-if-serial语义](#as-if-serial语义)\n - [程序顺序规则](#程序顺序规则)\n - [重排序对多线程的影响](#重排序对多线程的影响)\n - [先行发生原则（happens-before）](#先行发生原则happens-before)\n - [1. 单一线程原则](#1-单一线程原则)\n - [2. 管程锁定规则](#2-管程锁定规则)\n - [3. volatile 变量规则](#3-volatile-变量规则)\n - [4. 线程启动规则](#4-线程启动规则)\n - [5. 线程加入规则](#5-线程加入规则)\n - [6. 线程中断规则](#6-线程中断规则)\n - [7. 对象终结规则](#7-对象终结规则)\n - [8. 传递性](#8-传递性)\n - [11. 线程安全](#11-线程安全)\n - [线程安全定义](#线程安全定义)\n - [线程安全分类](#线程安全分类)\n - [1. 不可变](#1-不可变)\n - [2. 绝对线程安全](#2-绝对线程安全)\n - [3. 相对线程安全](#3-相对线程安全)\n - [4. 线程兼容](#4-线程兼容)\n - [5. 线程对立](#5-线程对立)\n - [线程安全的实现方法](#线程安全的实现方法)\n - [1. 阻塞同步（互斥同步）](#1-阻塞同步互斥同步)\n - [2. 非阻塞同步](#2-非阻塞同步)\n - [3. 无同步方案](#3-无同步方案)\n - [（一）可重入代码（Reentrant Code）](#一可重入代码reentrant-code)\n - [（二）栈封闭](#二栈封闭)\n - [（三）线程本地存储（Thread Local Storage）](#三线程本地存储thread-local-storage)\n - [12. 锁优化](#12-锁优化)\n - [自旋锁](#自旋锁)\n - [锁消除](#锁消除)\n - [锁粗化](#锁粗化)\n - [轻量级锁](#轻量级锁)\n - [偏向锁](#偏向锁)\n - [13. 多线程开发良好的实践](#13-多线程开发良好的实践)\n - [14. 线程池实现原理](#14-线程池实现原理)\n - [并发队列](#并发队列)\n - [线程池概念](#线程池概念)\n - [Executor类图](#executor类图)\n - [线程池工作原理](#线程池工作原理)\n - [初始化线程池](#初始化线程池)\n - [初始化方法](#初始化方法)\n - [常用方法](#常用方法)\n - [execute与submit的区别](#execute与submit的区别)\n - [shutDown与shutDownNow的区别](#shutdown与shutdownnow的区别)\n - [内部实现](#内部实现)\n - [线程池的状态](#线程池的状态)\n - [线程池其他常用方法](#线程池其他常用方法)\n - [如何合理设置线程池的大小](#如何合理设置线程池的大小)\n- [第二部分：面试指南](#第二部分面试指南)\n - [1. volatile 与 synchronized 的区别](#1-volatile-与-synchronized-的区别)\n - [2. 什么是线程池？如果让你设计一个动态大小的线程池，如何设计，应该有哪些方法？线程池创建的方式？](#2-什么是线程池如果让你设计一个动态大小的线程池如何设计应该有哪些方法线程池创建的方式)\n - [3. 什么是并发和并行](#3-什么是并发和并行)\n - [并发](#并发)\n - [并行](#并行)\n - [4. 什么是线程安全](#4-什么是线程安全)\n - [非线程安全!=不安全？](#非线程安全不安全)\n - [线程安全十万个为什么？](#线程安全十万个为什么)\n - [5. volatile 关键字的如何保证内存可见性](#5-volatile-关键字的如何保证内存可见性)\n - [5. 什么是线程？线程和进程有什么区别？为什么要使用多线程](#5-什么是线程线程和进程有什么区别为什么要使用多线程)\n - [6. 多线程共用一个数据变量需要注意什么？](#6-多线程共用一个数据变量需要注意什么)\n - [7. 内存泄漏与内存溢出](#7-内存泄漏与内存溢出)\n - [Java内存回收机制](#java内存回收机制)\n - [Java内存泄露引起原因](#java内存泄露引起原因)\n - [静态集合类](#静态集合类)\n - [监听器](#监听器)\n - [各种连接](#各种连接)\n - [内部类和外部模块等的引用](#内部类和外部模块等的引用)\n - [单例模式](#单例模式)\n - [8. 如何减少线程上下文切换](#8-如何减少线程上下文切换)\n - [9. 线程间通信和进程间通信](#9-线程间通信和进程间通信)\n - [线程间通信](#线程间通信)\n - [进程间通信](#进程间通信)\n - [10. 什么是同步和异步，阻塞和非阻塞？](#10-什么是同步和异步阻塞和非阻塞)\n - [同步](#同步)\n - [异步](#异步)\n - [阻塞](#阻塞)\n - [非阻塞](#非阻塞)\n - [11. Java中的锁](#11-java中的锁)\n - [一个简单的锁](#一个简单的锁)\n - [锁的可重入性](#锁的可重入性)\n - [锁的公平性](#锁的公平性)\n - [在 finally 语句中调用 unlock()](#在-finally-语句中调用-unlock)\n - [12. 并发包(J.U.C)下面，都用过什么](#12-并发包juc下面都用过什么)\n - [13. 从volatile说到,i++原子操作,线程安全问题](#13-从volatile说到i原子操作线程安全问题)\n- [参考资料](#参考资料)\n- [更新日志](#更新日志)\n\n\n\n# 前言\n\n在本文将总结多线程并发编程中的常见面试题，主要核心线程生命周期、线程通信、并发包部分。主要分成 “并发编程” 和 “面试指南” 两 部分，在面试指南中将讨论并发相关面经。\n\n\n\n# 第一部分：并发编程\n\n## 1. 线程状态转换\n\n \n\n这里笔者也绘制了一张中文版的图，[点击查看](https://raw.githubusercontent.com/frank-lam/2019_campus_apply/master/notes/JavaArchitecture/assets/1536767960941.png)\n\n### 新建（New）\n\n创建后尚未启动。\n\n### 可运行（Runnable）\n\n可能正在运行，也可能正在等待 CPU 时间片。\n\n包含了操作系统线程状态中的 运行（Running ） 和 就绪（Ready）。\n\n### 阻塞（Blocking）\n\n这个状态下，是在多个线程有同步操作的场景，比如正在等待另一个线程的 synchronized 块的执行释放，或者可重入的 synchronized 块里别人调用 wait() 方法，也就是线程在等待进入临界区。 \n\n阻塞可以分为：等待阻塞，同步阻塞，其他阻塞\n\n### 无限期等待（Waiting）\n\n等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。\n\n| 进入方法 | 退出方法 |\n| ------------------------------------------ | ------------------------------------ |\n| 没有设置 Timeout 参数的 Object.wait() 方法 | Object.notify() / Object.notifyAll() |\n| 没有设置 Timeout 参数的 Thread.join() 方法 | 被调用的线程执行完毕 |\n| LockSupport.park() 方法 | - |\n\n### 限期等待（Timed Waiting）\n\n无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。\n\n调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用 “**使一个线程睡眠**” 进行描述。\n\n调用 Object.wait() 方法使线程进入限期等待或者无限期等待时，常常用 “**挂起一个线程**” 进行描述。\n\n**睡眠和挂起**是用来描述**行为**，而**阻塞**和等待用来描述**状态**。\n\n阻塞和等待的区别在于，阻塞是被动的，它是在等待获取一个排它锁。而等待是主动的，通过调用 Thread.sleep() 和 Object.wait() 等方法进入。\n\n| 进入方法 | 退出方法 |\n| ---------------------------------------- | ----------------------------------------------- |\n| Thread.sleep() 方法 | 时间结束 |\n| 设置了 Timeout 参数的 Object.wait() 方法 | 时间结束 / Object.notify() / Object.notifyAll() |\n| 设置了 Timeout 参数的 Thread.join() 方法 | 时间结束 / 被调用的线程执行完毕 |\n| LockSupport.parkNanos() 方法 | - |\n| LockSupport.parkUntil() 方法 | - |\n\n### 死亡（Terminated）\n\n- 线程因为 run 方法正常退出而自然死亡\n- 因为一个没有捕获的异常终止了 run 方法而意外死亡\n\n\n\n\n\n## 2. Java实现多线程的方式及三种方式的区别\n\n有三种使用线程的方法：\n\n- 实现 Runnable 接口；\n- 实现 Callable 接口；\n- 继承 Thread 类。\n\n实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。\n\n\n\n### 实现 Runnable 接口\n\n需要实现 run() 方法。\n\n通过 Thread 调用 start() 方法来启动线程。\n\n```java\npublic class MyRunnable implements Runnable {\n public void run() {\n // ...\n }\n}\n```\n\n```java\npublic static void main(String[] args) {\n MyRunnable instance = new MyRunnable();\n Thread thread = new Thread(instance);\n thread.start();\n}\n```\n\n\n\n### 实现 Callable 接口\n\n与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。\n\n```java\npublic class MyCallable implements Callable {\n public Integer call() {\n return 123;\n }\n}\n```\n\n```java\npublic static void main(String[] args) throws ExecutionException, InterruptedException {\n MyCallable mc = new MyCallable();\n FutureTask ft = new FutureTask<>(mc);\n Thread thread = new Thread(ft);\n thread.start();\n System.out.println(ft.get());\n}\n```\n\n\n\n### 继承 Thread 类\n\n同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。\n\n```java\npublic class MyThread extends Thread {\n public void run() {\n // ...\n }\n}\n```\n\n```java\npublic static void main(String[] args) {\n MyThread mt = new MyThread();\n mt.start();\n}\n```\n\n\n\n### 实现接口 VS 继承 Thread\n\n实现接口会更好一些，因为：\n\n- Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；\n- 类可能只要求可执行就行，继承整个 Thread 类开销过大。\n\n\n\n### 三种方式的区别 \n\n- 实现 Runnable 接口可以避免 Java 单继承特性而带来的局限；增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的；适合多个相同程序代码的线程区处理同一资源的情况。 \n- 继承 Thread 类和实现 Runnable 方法启动线程都是使用 start() 方法，然后 JVM 虚拟机将此线程放到就绪队列中，如果有处理机可用，则执行 run() 方法。 \n- 实现 Callable 接口要实现 call() 方法，并且线程执行完毕后会有返回值。其他的两种都是重写 run() 方法，没有返回值。 \n\n\n\n## 3. 基础线程机制\n\n### Executor\n\nExecutor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。\n\n主要有三种 Executor：\n\n- CachedThreadPool：一个任务创建一个线程；\n- FixedThreadPool：所有任务只能使用固定大小的线程；\n- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。\n\n```java\npublic static void main(String[] args) {\n ExecutorService executorService = Executors.newCachedThreadPool();\n for (int i = 0; i < 5; i++) {\n executorService.execute(new MyRunnable());\n }\n executorService.shutdown();\n}\n```\n\n\n\n**为什么引入Executor线程池框架？**\n\nnew Thread() 的缺点\n\n- 每次 new Thread() 耗费性能 \n- 调用 new Thread() 创建的线程缺乏管理，被称为野线程，而且可以无限制创建，之间相互竞争，会导致过多占用系统资源导致系统瘫痪。 \n- 不利于扩展，比如如定时执行、定期执行、线程中断\n\n采用线程池的优点\n\n- 重用存在的线程，减少对象创建、消亡的开销，性能佳 \n- 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞 \n- 提供定时执行、定期执行、单线程、并发数控制等功能\n\n\n\n### Daemon（守护线程）\n\nJava 中有两类线程：User Thread (用户线程)、Daemon Thread (守护线程)\n\n用户线程即运行在前台的线程，而守护线程是运行在后台的线程。 守护线程作用是为其他前台线程的运行提供便利服务，而且仅在普通、非守护线程仍然运行时才需要，比如垃圾回收线程就是一个守护线程。当 JVM 检测仅剩一个守护线程，而用户线程都已经退出运行时，JVM 就会退出，因为没有如果没有了被守护这，也就没有继续运行程序的必要了。如果有非守护线程仍然存活，JVM 就不会退出。\n\n守护线程并非只有虚拟机内部提供，用户在编写程序时也可以自己设置守护线程。用户可以用 Thread 的 setDaemon(true) 方法设置当前线程为守护线程。\n\n虽然守护线程可能非常有用，但必须小心确保其他所有非守护线程消亡时，不会由于它的终止而产生任何危害。因为你不可能知道在所有的用户线程退出运行前，守护线程是否已经完成了预期的服务任务。一旦所有的用户线程退出了，虚拟机也就退出运行了。 因此，不要在守护线程中执行业务逻辑操作（比如对数据的读写等）。\n\n **另外有几点需要注意：**\n\n- setDaemon(true) 必须在调用线程的 start() 方法之前设置，否则会跑出 IllegalThreadStateException 异常。\n- 在守护线程中产生的新线程也是守护线程。\n- 不要认为所有的应用都可以分配给守护线程来进行服务，比如读写操作或者计算逻辑。\n\n\n\n守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分。\n\n当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。\n\nmain() 属于非守护线程。\n\n使用 setDaemon() 方法将一个线程设置为守护线程。\n\n```java\npublic static void main(String[] args) {\n Thread thread = new Thread(new MyRunnable());\n thread.setDaemon(true);\n}\n```\n\n\n\n### sleep()\n\nThread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。\n\nsleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。\n\n```java\npublic void run() {\n try {\n Thread.sleep(3000);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n}\n```\n\n\n\n### yield()\n\n对静态方法 Thread.yield() 的调用声明了**当前线程已经完成了生命周期中最重要的部分**，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。\n\n```java\npublic void run() {\n Thread.yield();\n}\n```\n\n\n\n\n\n### 线程阻塞\n\n线程可以阻塞于四种状态：\n\n- 当线程执行 Thread.sleep() 时，它一直阻塞到指定的毫秒时间之后，或者阻塞被另一个线程打断；\n- 当线程碰到一条 wait() 语句时，它会一直阻塞到接到通知 notify()、被中断或经过了指定毫秒时间为止（若制定了超时值的话）\n- 线程阻塞与不同 I/O 的方式有多种。常见的一种方式是 InputStream 的 read() 方法，该方法一直阻塞到从流中读取一个字节的数据为止，它可以无限阻塞，因此不能指定超时时间；\n- 线程也可以阻塞等待获取某个对象锁的排他性访问权限（即等待获得 synchronized 语句必须的锁时阻塞）。\n\n> 注意，并非所有的阻塞状态都是可中断的，以上阻塞状态的前两种可以被中断，后两种不会对中断做出反应\n\n\n\n\n\n## 4. 中断\n\n一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。\n\n### InterruptedException\n\n通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于**阻塞、限期等待或者无限期等待**状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。\n\n对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。\n\n```java\npublic class InterruptExample {\n\n private static class MyThread1 extends Thread {\n @Override\n public void run() {\n try {\n Thread.sleep(2000);\n System.out.println(\"Thread run\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n }\n}\n```\n\n```java\npublic static void main(String[] args) throws InterruptedException {\n Thread thread1 = new MyThread1();\n thread1.start();\n thread1.interrupt();\n System.out.println(\"Main run\");\n}\n```\n\n```java\nMain run\njava.lang.InterruptedException: sleep interrupted\n at java.lang.Thread.sleep(Native Method)\n at InterruptExample.lambda$main$0(InterruptExample.java:5)\n at InterruptExample$$Lambda$1/713338599.run(Unknown Source)\n at java.lang.Thread.run(Thread.java:745)\n```\n\n\n\n### interrupted()\n\n如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。\n\n但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。\n\n```java\npublic class InterruptExample {\n\n private static class MyThread2 extends Thread {\n @Override\n public void run() {\n while (!interrupted()) {\n // ..\n }\n System.out.println(\"Thread end\");\n }\n }\n}\n```\n\n```javascript\npublic static void main(String[] args) throws InterruptedException {\n Thread thread2 = new MyThread2();\n thread2.start();\n thread2.interrupt();\n}\n```\n\n```\nThread end\n```\n\n\n\n### Executor 的中断操作\n\n调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。\n\n以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。\n\n```java\npublic static void main(String[] args) {\n ExecutorService executorService = Executors.newCachedThreadPool();\n executorService.execute(() -> {\n try {\n Thread.sleep(2000);\n System.out.println(\"Thread run\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n });\n executorService.shutdownNow();\n System.out.println(\"Main run\");\n}\n```\n\n```java\nMain run\njava.lang.InterruptedException: sleep interrupted\n at java.lang.Thread.sleep(Native Method)\n at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)\n at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)\n at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)\n at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)\n at java.lang.Thread.run(Thread.java:745)\n```\n\n如果只想中断 Executor 中的一个线程，可以通过使用 submit() 方法来提交一个线程，它会返回一个 Future 对象，通过调用该对象的 cancel(true) 方法就可以中断线程。\n\n```java\nFuture future = executorService.submit(() -> {\n // ..\n});\nfuture.cancel(true);\n```\n\n\n\n## 5. 互斥同步\n\nJava 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。\n\n### synchronized\n\n**1. 同步一个代码块**\n\n```java\npublic void func() {\n synchronized (this) {\n // ...\n }\n}\n```\n\n它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。\n\n对于以下代码，使用 ExecutorService 执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。\n\n```java\npublic class SynchronizedExample {\n public void func1() {\n synchronized (this) {\n for (int i = 0; i < 10; i++) {\n System.out.print(i + \" \");\n }\n }\n }\n}\n```\n\n```java\npublic static void main(String[] args) {\n SynchronizedExample e1 = new SynchronizedExample();\n ExecutorService executorService = Executors.newCachedThreadPool();\n executorService.execute(() -> e1.func1());\n executorService.execute(() -> e1.func1());\n}\n```\n\n```java\n0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9\n```\n\n对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。\n\n```java\npublic static void main(String[] args) {\n SynchronizedExample e1 = new SynchronizedExample();\n SynchronizedExample e2 = new SynchronizedExample();\n ExecutorService executorService = Executors.newCachedThreadPool();\n executorService.execute(() -> e1.func1());\n executorService.execute(() -> e2.func1());\n}\n```\n\n```\n0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9\n```\n\n\n\n**2. 同步一个方法**\n\n```java\npublic synchronized void func () {\n // ...\n}\n```\n\n它和同步代码块一样，作用于同一个对象。\n\n\n\n**3. 同步一个类**\n\n```java\npublic void func() {\n synchronized (SynchronizedExample.class) {\n // ...\n }\n}\n```\n\n作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。\n\n```java\npublic class SynchronizedExample {\n public void func2() {\n synchronized (SynchronizedExample.class) {\n for (int i = 0; i < 10; i++) {\n System.out.print(i + \" \");\n }\n }\n }\n}\n```\n\n```java\npublic static void main(String[] args) {\n SynchronizedExample e1 = new SynchronizedExample();\n SynchronizedExample e2 = new SynchronizedExample();\n ExecutorService executorService = Executors.newCachedThreadPool();\n executorService.execute(() -> e1.func2());\n executorService.execute(() -> e2.func2());\n}\n```\n\n```\n0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9\n```\n\n\n\n**4. 同步一个静态方法**\n\n- 非静态同步函数的锁是：this\n- 静态的同步函数的锁是：字节码对象\n\n```java\npublic synchronized static void fun() {\n // ...\n}\n```\n\n作用于整个类。\n\n\n\n### ReentrantLock\n\n重入锁（ReentrantLock）是一种递归无阻塞的同步机制。\n\n```java\npublic class LockExample {\n private Lock lock = new ReentrantLock();\n\n public void func() {\n lock.lock();\n try {\n for (int i = 0; i < 10; i++) {\n System.out.print(i + \" \");\n }\n } finally {\n lock.unlock(); // 确保释放锁，从而避免发生死锁。\n }\n }\n}\n```\n\n```java\npublic static void main(String[] args) {\n LockExample lockExample = new LockExample();\n ExecutorService executorService = Executors.newCachedThreadPool();\n executorService.execute(() -> lockExample.func());\n executorService.execute(() -> lockExample.func());\n}\n```\n\n```\n0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9\n```\n\nReentrantLock 是 java.util.concurrent（J.U.C）包中的锁，相比于 synchronized，它多了以下高级功能：\n\n**1. 等待可中断**\n\n当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。\n\n**2. 可实现公平锁**\n\n公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。\n\nsynchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。\n\n**3. 锁绑定多个条件**\n\n一个 ReentrantLock 对象可以同时绑定多个 Condition 对象。\n\n\n\n### synchronized 和 ReentrantLock 比较\n\n**1. 锁的实现**\n\nsynchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。\n\n**2. 性能**\n\n新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等。目前来看它和 ReentrantLock 的性能基本持平了，因此性能因素不再是选择 ReentrantLock 的理由。synchronized 有更大的性能优化空间，应该优先考虑 synchronized。\n\n**3. 功能**\n\nReentrantLock 多了一些高级功能。\n\n**4. 使用选择**\n\n除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。\n\n\n\n### synchronized与lock的区别，使用场景。看过synchronized的源码没？\n\n- （用法）synchronized（隐式锁）：在需要同步的对象中加入此控制，synchronized 可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。 \n- （用法）lock（显示锁）：需要显示指定起始位置和终止位置。一般使用 ReentrantLock 类做为锁，多个线程中必须要使用一个 ReentrantLock 类做为对象才能保证锁的生效。且在加锁和解锁处需要通过 lock() 和 unlock() 显示指出。所以一般会在 finally 块中写 unlock() 以防死锁。 \n- （性能）synchronized 是托管给 JVM 执行的，而 lock 是 Java 写的控制锁的代码。在 Java1.5 中，synchronize 是性能低效的。因为这是一个重量级操作，需要调用操作接口，导致有可能加锁消耗的系统时间比加锁以外的操作还多。相比之下使用 Java 提供的 Lock 对象，性能更高一些。但是到了 Java1.6 ，发生了变化。synchronize 在语义上很清晰，可以进行很多优化，有适应自旋，锁消除，锁粗化，轻量级锁，偏向锁 等等。导致 在 Java1.6 上 synchronize 的性能并不比 Lock 差。 \n- （机制）**synchronized 原始采用的是 CPU 悲观锁机制，即线程获得的是独占锁。Lock 也属于悲观锁**。独占锁意味着其他线程只能依靠阻塞来等待线程释放锁。相对而言乐观锁每次不加锁，而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁实现的机制就是 CAS 操作（Compare and Swap）。 \n\n \n\n### 什么是CAS\n\n> 蘑菇街面试，这里简单论述一下\n\n#### 入门例子\n\n在 Java 并发包中有这样一个包，java.util.concurrent.atomic，该包是对 Java 部分数据类型的原子封装，在原有数据类型的基础上，提供了原子性的操作方法，保证了线程安全。下面以 AtomicInteger 为例，来看一下是如何实现的。\n\n```java\npublic final int incrementAndGet() {\n for (;;) {\n int current = get();\n int next = current + 1;\n if (compareAndSet(current, next))\n return next;\n }\n}\n\npublic final int decrementAndGet() {\n for (;;) {\n int current = get();\n int next = current - 1;\n if (compareAndSet(current, next))\n return next;\n }\n}\n```\n\n以这两个方法为例，incrementAndGet 方法相当于原子性的 ++i，decrementAndGet 方法相当于原子性的 --i，这两个方法中都没有使用阻塞式的方式来保证原子性（如 Synchronized ），那它们是如何保证原子性的呢，下面引出 CAS。\n\n#### Compare And Swap\n\nCAS 指的是现代 CPU 广泛支持的一种对内存中的共享数据进行操作的一种特殊指令。这个指令会对内存中的共享数据做原子的读写操作。\n\n简单介绍一下这个指令的操作过程：\n\n- 首先，CPU 会将内存中将要被更改的数据与期望的值做比较。\n- 然后，当这两个值相等时，CPU 才会将内存中的数值替换为新的值。否则便不做操作。\n- 最后，CPU 会将旧的数值返回。\n\n这一系列的操作是原子的。它们虽然看似复杂，但却是 Java 5 并发机制优于原有锁机制的根本。简单来说，CAS 的含义是：我认为原有的值应该是什么，如果是，则将原有的值更新为新值，否则不做修改，并告诉我原来的值是多少。\n 简单的来说，CAS 有 3 个操作数，内存值 V，旧的预期值 A，要修改的新值 B。当且仅当预期值 A 和内存值 V 相同时，将内存值 V 修改为 B，否则返回 V。这是一种乐观锁的思路，它相信在它修改之前，没有其它线程去修改它；而 Synchronized 是一种悲观锁，它认为在它修改之前，一定会有其它线程去修改它，悲观锁效率很低。\n\n\n\n### 什么是乐观锁和悲观锁\n\n- 为什么需要锁（并发控制）\n - 在多用户环境中，在同一时间可能会有多个用户更新相同的记录，这会产生冲突。这就是著名的并发性问题。\n - 典型的冲突有：\n - 丢失更新：一个事务的更新覆盖了其它事务的更新结果，就是所谓的更新丢失。例如：用户 A 把值从 6 改为 2，用户 B 把值从 2 改为 6，则用户 A 丢失了他的更新。\n - 脏读：当一个事务读取其它完成一半事务的记录时，就会发生脏读取。例如：用户 A,B 看到的值都是6，用户 B 把值改为 2，用户 A 读到的值仍为 6。\n - 为了解决这些并发带来的问题。 我们需要引入并发控制机制。\n- 并发控制机制\n - **悲观锁：假定会发生并发冲突**，独占锁，屏蔽一切可能违反数据完整性的操作。\n - **乐观锁：假设不会发生并发冲突**，只在提交操作时检查是否违反数据完整性。乐观锁不能解决脏读的问题。\n\n参考资料：\n\n- [乐观锁与悲观锁——解决并发问题 - WhyWin - 博客园](https://www.cnblogs.com/0201zcr/p/4782283.html)\n\n\n\n### Synchronized（对象锁）和Static Synchronized（类锁）区别\n\n- 一个是实例锁（锁在某一个实例对象上，如果该类是单例，那么该锁也具有全局锁的概念），一个是全局锁（该锁针对的是类，无论实例多少个对象，那么线程都共享该锁）。\n\n 实例锁对应的就是 synchronized关 键字，而类锁（全局锁）对应的就是 static synchronized（或者是锁在该类的 class 或者 classloader 对象上）。\n\n```java\n/**\n * static synchronized 和synchronized的区别！\n * 关键是区别第四种情况！\n */\npublic class StaticSynchronized {\n\n /**\n * synchronized方法\n */\n public synchronized void isSynA(){\n System.out.println(\"isSynA\");\n }\n public synchronized void isSynB(){\n System.out.println(\"isSynB\");\n }\n\n /**\n * static synchronized方法\n */\n public static synchronized void cSynA(){\n System.out.println(\"cSynA\");\n }\n public static synchronized void cSynB(){\n System.out.println(\"cSynB\");\n }\n\n public static void main(String[] args) {\n StaticSynchronized x = new StaticSynchronized();\n StaticSynchronized y = new StaticSynchronized();\n /**\n * x.isSynA()与x.isSynB(); 不能同时访问(同一个对象访问synchronized方法)\n * x.isSynA()与y.isSynB(); 能同时访问(不同对象访问synchronized方法)\n * x.cSynA()与y.cSynB(); 不能同时访问(不同对象也不能访问static synchronized方法)\n * x.isSynA()与y.cSynA(); 能同时访问(static synchronized方法占用的是类锁，\n * 而访问synchronized方法占用的是对象锁，不存在互斥现象)\n */\n }\n}\n```\n\n\n\n## 6. 线程之间的协作\n\n当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。\n\n### join()\n\n在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。\n\n对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。\n\n```java\npublic class JoinExample {\n private class A extends Thread {\n @Override\n public void run() {\n System.out.println(\"A\");\n }\n }\n\n private class B extends Thread {\n private A a;\n B(A a) {\n this.a = a;\n }\n\n @Override\n public void run() {\n try {\n a.join();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n System.out.println(\"B\");\n }\n }\n\n public void test() {\n A a = new A();\n B b = new B(a);\n b.start();\n a.start();\n }\n}\n```\n\n```java\npublic static void main(String[] args) {\n JoinExample example = new JoinExample();\n example.test();\n}\n```\n\n```\nA\nB\n```\n\n\n\n### wait() notify() notifyAll()\n\n调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify()（随机叫醒一个） 或者 notifyAll() （叫醒所有 wait 线程，争夺时间片的线程只有一个）来唤醒挂起的线程。\n\n它们都属于 Object 的一部分，而不属于 Thread。\n\n只能用在**同步方法**或者**同步控制块**中使用！否则会在运行时抛出 IllegalMonitorStateExeception。\n\n使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。\n\n```java\npublic class WaitNotifyExample {\n public synchronized void before() {\n System.out.println(\"before\");\n notifyAll();\n }\n\n public synchronized void after() {\n try {\n wait();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n System.out.println(\"after\");\n }\n}\n```\n\n```java\npublic static void main(String[] args) {\n ExecutorService executorService = Executors.newCachedThreadPool();\n WaitNotifyExample example = new WaitNotifyExample();\n executorService.execute(() -> example.after());\n executorService.execute(() -> example.before());\n}\n```\n\n```\nbefore\nafter\n```\n\n\n\n### await() signal() signalAll()\n\njava.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。\n\n使用 Lock 来获取一个 Condition 对象。\n\n```java\npublic class AwaitSignalExample {\n private Lock lock = new ReentrantLock();\n private Condition condition = lock.newCondition();\n\n public void before() {\n lock.lock();\n try {\n System.out.println(\"before\");\n condition.signalAll();\n } finally {\n lock.unlock();\n }\n }\n\n public void after() {\n lock.lock();\n try {\n condition.await();\n System.out.println(\"after\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n lock.unlock();\n }\n }\n}\n```\n\n```java\npublic static void main(String[] args) {\n ExecutorService executorService = Executors.newCachedThreadPool();\n AwaitSignalExample example = new AwaitSignalExample();\n executorService.execute(() -> example.after());\n executorService.execute(() -> example.before());\n}\n```\n\n```\nbefore\nafter\n```\n\n\n\n### sleep和wait有什么区别\n\n- sleep 和 wait\n - wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；\n - wait() 会释放锁，sleep() 不会。\n- 有什么区别\n - sleep() 方法（休眠）是线程类（Thread）的静态方法，调用此方法会让当前线程暂停执行指定的时间，将执行机会（CPU）让给其他线程，但是对象的锁依然保持，因此休眠时间结束后会自动恢复（线程回到就绪状态）。 \n - wait() 是 Object 类的方法，调用对象的 wait() 方法导致当前线程放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的 notify() 方法（或 notifyAll() 方法）时才能唤醒等待池中的线程进入等锁池（lock pool），如果线程重新获得对象的锁就可以进入就绪状态。 \n\n\n\n## 7. J.U.C - AQS\n\nAQS 是 AbstractQueuedSynchronizer 的简称，java.util.concurrent（J.U.C）大大提高了并发性能，AQS (AbstractQueuedSynchronizer) 被认为是 J.U.C 的核心。它提供了一个基于 FIFO 队列，这个队列可以用来构建锁或者其他相关的同步装置的基础框架。下图是 AQS 底层的数据结构：\n\n\n\n \n\n\n\nCountDownLatch 类只提供了一个构造器：\n\n```java\npublic CountDownLatch(int count) { }; // 参数count为计数值\n```\n\n然后下面这 3 个方法是 CountDownLatch 类中最重要的方法：\n\n```java\n//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行\npublic void await() throws InterruptedException { };\n//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行\npublic boolean await(long timeout, TimeUnit unit) throws InterruptedException { };\n//将count值减1\npublic void countDown() { };\n```\n\n下面看一个例子大家就清楚 CountDownLatch 的用法了：\n\n```java\npublic class Test {\n public static void main(String[] args) {\n final CountDownLatch latch = new CountDownLatch(2);\n new Thread() {\n public void run() {\n try {\n System.out.println(\"子线程\" + Thread.currentThread().getName() + \"正在执行\");\n Thread.sleep(3000);\n System.out.println(\"子线程\" + Thread.currentThread().getName() + \"执行完毕\");\n latch.countDown();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n ;\n }.start();\n new Thread() {\n public void run() {\n try {\n System.out.println(\"子线程\" + Thread.currentThread().getName() + \"正在执行\");\n Thread.sleep(3000);\n System.out.println(\"子线程\" + Thread.currentThread().getName() + \"执行完毕\");\n latch.countDown();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n ;\n }.start();\n try {\n System.out.println(\"等待2个子线程执行完毕...\");\n latch.await();\n System.out.println(\"2个子线程已经执行完毕\");\n System.out.println(\"继续执行主线程\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n}\n```\n\n执行结果：\n\n```\n线程Thread-0正在执行\n线程Thread-1正在执行\n等待2个子线程执行完毕...\n线程Thread-0执行完毕\n线程Thread-1执行完毕\n2个子线程已经执行完毕\n继续执行主线程\n```\n\n\n\n### CyclicBarrier\n\n用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。\n\n和 CountdownLatch 相似，都是通过维护计数器来实现的。但是它的计数器是递增的，每次执行 await() 方法之后，计数器会加 1，直到计数器的值和设置的值相等，等待的所有线程才会继续执行。和 CountdownLatch 的另一个区别是，CyclicBarrier 的计数器可以循环使用，所以它才叫做循环屏障。\n\n下图应该从下往上看才正确。\n\n implements RunnableFuture\n```\n\n```java\npublic interface RunnableFuture extends Runnable, Future\n```\n\nFutureTask 可用于异步获取执行结果或取消执行任务的场景。当一个计算任务需要执行很长时间，那么就可以用 FutureTask 来封装这个任务，主线程在完成自己的任务之后再去获取结果。\n\n```java\npublic class FutureTaskExample {\n public static void main(String[] args) throws ExecutionException, InterruptedException {\n FutureTask futureTask = new FutureTask(new Callable() {\n @Override\n public Integer call() throws Exception {\n int result = 0;\n for (int i = 0; i < 100; i++) {\n Thread.sleep(10);\n result += i;\n }\n return result;\n }\n });\n\n Thread computeThread = new Thread(futureTask);\n computeThread.start();\n\n Thread otherThread = new Thread(() -> {\n System.out.println(\"other task is running...\");\n try {\n Thread.sleep(1000);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n });\n otherThread.start();\n System.out.println(futureTask.get());\n }\n}\n```\n\n```java\nother task is running...\n4950\n```\n\n\n\n### BlockingQueue\n\njava.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：\n\n- **FIFO 队列** ：LinkedBlockingQueue、ArrayBlockingQueue（固定长度）\n- **优先级队列** ：PriorityBlockingQueue\n\n提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，直到队列有空闲位置。\n\n**使用 BlockingQueue 实现生产者消费者问题**\n\n```java\npublic class ProducerConsumer {\n\n private static BlockingQueue queue = new ArrayBlockingQueue<>(5);\n\n private static class Producer extends Thread {\n @Override\n public void run() {\n try {\n queue.put(\"product\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n System.out.print(\"produce..\");\n }\n }\n\n private static class Consumer extends Thread {\n\n @Override\n public void run() {\n try {\n String product = queue.take();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n System.out.print(\"consume..\");\n }\n }\n}\n```\n\n```java\npublic static void main(String[] args) {\n for (int i = 0; i < 2; i++) {\n Producer producer = new Producer();\n producer.start();\n }\n for (int i = 0; i < 5; i++) {\n Consumer consumer = new Consumer();\n consumer.start();\n }\n for (int i = 0; i < 3; i++) {\n Producer producer = new Producer();\n producer.start();\n }\n}\n```\n\n```\nproduce..produce..consume..consume..produce..consume..produce..consume..produce..consume..\n```\n\n\n\n### ForkJoin\n\n主要用于并行计算中，和 MapReduce 原理类似，都是把大的计算任务拆分成多个小任务并行计算。\n\n```java\npublic class ForkJoinExample extends RecursiveTask {\n private final int threshold = 5;\n private int first;\n private int last;\n\n public ForkJoinExample(int first, int last) {\n this.first = first;\n this.last = last;\n }\n\n @Override\n protected Integer compute() {\n int result = 0;\n if (last - first <= threshold) {\n // 任务足够小则直接计算\n for (int i = first; i <= last; i++) {\n result += i;\n }\n } else {\n // 拆分成小任务\n int middle = first + (last - first) / 2;\n ForkJoinExample leftTask = new ForkJoinExample(first, middle);\n ForkJoinExample rightTask = new ForkJoinExample(middle + 1, last);\n leftTask.fork();\n rightTask.fork();\n result = leftTask.join() + rightTask.join();\n }\n return result;\n }\n}\n```\n\n```javascript\npublic static void main(String[] args) throws ExecutionException, InterruptedException {\n ForkJoinExample example = new ForkJoinExample(1, 10000);\n ForkJoinPool forkJoinPool = new ForkJoinPool();\n Future result = forkJoinPool.submit(example);\n System.out.println(result.get());\n}\n```\n\nForkJoin 使用 ForkJoinPool 来启动，它是一个特殊的线程池，线程数量取决于 CPU 核数。\n\n```java\npublic class ForkJoinPool extends AbstractExecutorService\n```\n\nForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，Thread2 从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。\n\n \n\n所有的变量都存储在**主内存**中，每个线程还有自己的**工作内存**，工作内存存储在高速缓存或者寄存器中，保存了该线程使用的变量的主内存副本拷贝。\n\n线程只能直接操作工作内存中的变量，不同线程之间的变量值传递需要通过主内存来完成。\n\n\n\n**Java内存模型和硬件关系图**\n\n \n\n**Java内存模型抽象结构图**\n\n \n\n- read：把一个变量的值从主内存传输到工作内存中\n- load：在 read 之后执行，把 read 得到的值放入工作内存的变量副本中\n- use：把工作内存中一个变量的值传递给执行引擎\n- assign：把一个从执行引擎接收到的值赋给工作内存的变量\n- store：把工作内存的一个变量的值传送到主内存中\n- write：在 store 之后执行，把 store 得到的值放入主内存的变量中\n- lock：作用于主内存的变量，把一个变量标识为一条线程独占状态\n- unlock：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定\n\n\n\n如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行 read 和 load 操作，如果把变量从工作内存中同步回主内存中，就要按顺序地执行 store 和 write 操作。Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。也就是 read 和 load 之间，store 和 write 之间是可以插入其他指令的，如对主内存中的变量a、b进行访问时，可能的顺序是read a，read b，load b， load a。\n\n\n\n**Java内存模型还规定了在执行上述8种基本操作时，必须满足如下规则：**\n\n- 不允许 read 和 load、store 和 write 操作之一单独出现\n- 不允许一个线程丢弃它的最近 assign 的操作，即变量在工作内存中改变了之后必须同步到主内存中\n- 不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中\n- 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load 或 assign）的变量。即就是对一个变量实施 use 和 store 操作之前，必须先执行过了 assign 和 load 操作。\n- 一个变量在同一时刻只允许一条线程对其进行lock操作，lock 和 unlock必须成对出现\n- 如果对一个变量执行 lock 操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行 load 或 assign 操作初始化变量的值\n- 如果一个变量事先没有被 lock 操作锁定，则不允许对它执行 unlock 操作；也不允许去 unlock 一个被其他线程锁定的变量。\n- 对一个变量执行 unlock 操作之前，必须先把此变量同步到主内存中（执行 store 和 write 操作）。\n\n\n\n参考资料：\n\n[volatile关键字与Java内存模型(JMM) - yzwall - 博客园](https://www.cnblogs.com/yzwall/p/6661528.html)\n\n\n\n\n### 内存模型三大特性\n\n#### 1. 原子性\n\n- 概念\n - 事物有原子性，这个概念大概都清楚，即一个操作或多个操作要么执行的过程中不被任何因素打断，要么不执行。\n- 如何实现原子性？\n - 通过同步代码块 synchronized 或者 local 锁来确保原子性\n\n\n\nJava 内存模型保证了 read、load、use、assign、store、write、lock 和 unlock 操作具有原子性，例如对一个 int 类型的变量执行 assign 赋值操作，这个操作就是原子性的。但是 Java 内存模型允许虚拟机将没有被 volatile 修饰的 64 位数据（long，double）的读写操作划分为两次 32 位的操作来进行，即 load、store、read 和 write 操作可以不具备原子性。\n\n有一个错误认识就是，int 等原子性的变量在多线程环境中不会出现线程安全问题。前面的线程不安全示例代码中，cnt 变量属于 int 类型变量，1000 个线程对它进行自增操作之后，得到的值为 997 而不是 1000。\n\n为了方便讨论，将内存间的交互操作简化为 3 个：load、assign、store。\n\n下图演示了两个线程同时对 cnt 变量进行操作，load、assign、store 这一系列操作整体上看不具备原子性，那么在 T1 修改 cnt 并且还没有将修改后的值写入主内存，T2 依然可以读入该变量的值。可以看出，这两个线程虽然执行了两次自增运算，但是主内存中 cnt 的值最后为 1 而不是 2。因此对 int 类型读写操作满足原子性只是说明 load、assign、store 这些单个操作具备原子性。\n\n map = new HashMap<>();\n Map unmodifiableMap = Collections.unmodifiableMap(map);\n unmodifiableMap.put(\"a\", 1);\n }\n}\n```\n\n```java\nException in thread \"main\" java.lang.UnsupportedOperationException\n at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)\n at ImmutableExample.main(ImmutableExample.java:9)\n```\n\nCollections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都直接抛出异常。\n\n```java\npublic V put(K key, V value) {\n throw new UnsupportedOperationException();\n}\n```\n\n多线程环境下，应当尽量使对象成为不可变，来满足线程安全。\n\n\n\n#### 2. 绝对线程安全\n\n不管运行时环境如何，调用者都不需要任何额外的同步措施。\n\n\n\n#### 3. 相对线程安全\n\n相对的线程安全需要保证对这个对象单独的操作是线程安全的，在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。\n\n在 Java 语言中，大部分的线程安全类都属于这种类型，例如 Vector、HashTable、Collections 的 synchronizedCollection() 方法包装的集合等。\n\n对于下面的代码，如果删除元素的线程删除了一个元素，而获取元素的线程试图访问一个已经被删除的元素，那么就会抛出 ArrayIndexOutOfBoundsException。\n\n```java\npublic class VectorUnsafeExample {\n private static Vector vector = new Vector<>();\n\n public static void main(String[] args) {\n while (true) {\n for (int i = 0; i < 100; i++) {\n vector.add(i);\n }\n ExecutorService executorService = Executors.newCachedThreadPool();\n executorService.execute(() -> {\n for (int i = 0; i < vector.size(); i++) {\n vector.remove(i);\n }\n });\n executorService.execute(() -> {\n for (int i = 0; i < vector.size(); i++) {\n vector.get(i);\n }\n });\n executorService.shutdown();\n }\n }\n}\n```\n\n```java\nException in thread \"Thread-159738\" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 3\n at java.util.Vector.remove(Vector.java:831)\n at VectorUnsafeExample.lambda$main$0(VectorUnsafeExample.java:14)\n at VectorUnsafeExample$$Lambda$1/713338599.run(Unknown Source)\n at java.lang.Thread.run(Thread.java:745)\n```\n\n如果要保证上面的代码能正确执行下去，就需要对删除元素和获取元素的代码进行同步。\n\n```java\nexecutorService.execute(() -> {\n synchronized (vector) {\n for (int i = 0; i < vector.size(); i++) {\n vector.remove(i);\n }\n }\n});\nexecutorService.execute(() -> {\n synchronized (vector) {\n for (int i = 0; i < vector.size(); i++) {\n vector.get(i);\n }\n }\n});\n```\n\n\n\n#### 4. 线程兼容\n\n线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API 中大部分的类都是属于线程兼容的，如与前面的 Vector 和 HashTable 相对应的集合类 ArrayList 和 HashMap 等。\n\n\n\n#### 5. 线程对立\n\n线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。由于 Java 语言天生就具备多线程特性，线程对立这种排斥多线程的代码是很少出现的，而且通常都是有害的，应当尽量避免。\n\n\n\n### 线程安全的实现方法\n\n#### 1. 阻塞同步（互斥同步）\n\nsynchronized 和 ReentrantLock。\n\n互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。\n\n互斥同步属于一种**悲观的并发策略**，总是认为只要不去做正确的同步措施，那就肯定会出现问题。无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。\n\n\n\n#### 2. 非阻塞同步\n\n随着硬件指令集的发展，我们可以使用基于冲突检测的**乐观并发策略**：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步。\n\n乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。\n\n硬件支持的原子性操作最典型的是：**比较并交换**（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是**内存地址 V、旧的预期值 A 和新值 B**。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。\n\nJ.U.C 包里面的整数原子类 AtomicInteger，其中的 compareAndSet() 和 getAndIncrement() 等方法都使用了 Unsafe 类的 CAS 操作。\n\n以下代码使用了 AtomicInteger 执行了自增的操作。\n\n```java\nprivate AtomicInteger cnt = new AtomicInteger();\n\npublic void add() {\n cnt.incrementAndGet();\n}\n```\n\n以下代码是 incrementAndGet() 的源码，它调用了 unsafe 的 getAndAddInt() 。\n\n```java\npublic final int incrementAndGet() {\n return unsafe.getAndAddInt(this, valueOffset, 1) + 1;\n}\n```\n\n以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值 ==var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。\n\n可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。\n\n```java\npublic final int getAndAddInt(Object var1, long var2, int var4) {\n int var5;\n do {\n var5 = this.getIntVolatile(var1, var2);\n } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));\n\n return var5;\n}\n```\n\nABA ：如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。\n\nJ.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。\n\n\n\n#### 3. 无同步方案\n\n要保证线程安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。\n\n##### （一）可重入代码（Reentrant Code）\n\n这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。\n\n可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。\n\n##### （二）栈封闭\n\n多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在栈中，属于线程私有的。\n\n```java\nimport java.util.concurrent.ExecutorService;\nimport java.util.concurrent.Executors;\n\npublic class StackClosedExample {\n public void add100() {\n int cnt = 0;\n for (int i = 0; i < 100; i++) {\n cnt++;\n }\n System.out.println(cnt);\n }\n}\n```\n\n```java\npublic static void main(String[] args) {\n StackClosedExample example = new StackClosedExample();\n ExecutorService executorService = Executors.newCachedThreadPool();\n executorService.execute(() -> example.add100());\n executorService.execute(() -> example.add100());\n executorService.shutdown();\n}\n```\n\n```java\n100\n100\n```\n\n\n\n##### （三）线程本地存储（Thread Local Storage）\n\n如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。\n\n符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完，其中最重要的一个应用实例就是经典 Web 交互模型中的 “**一个请求对应一个服务器线程**”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。\n\n可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。\n\n\n\n这是一个非常好的例题，请参考整理：\n\n[关于ThreadLocal类以下说法正确的是?_迅雷笔试题_牛客网](https://www.nowcoder.com/questionTerminal/b82e4a85a66e4dc488a5ab49094976e9?orderByHotValue=0&pos=73&mutiTagIds=171)\n\n\n\n\n\n\n**示例用法**\n\n先通过下面这个实例来理解 ThreadLocal 的用法。先声明一个 ThreadLocal 对象，存储布尔类型的数值。然后分别在main线程、Thread1、Thread2中为 ThreadLocal 对象设置不同的数值：\n\n```java\npublic class ThreadLocalDemo {\n public static void main(String[] args) {\n\n \t// 声明 ThreadLocal对象\n ThreadLocal mThreadLocal = new ThreadLocal();\n\n // 在主线程、子线程1、子线程2中去设置访问它的值\n mThreadLocal.set(true);\n\n System.out.println(\"Main \" + mThreadLocal.get());\n\n new Thread(\"Thread#1\"){\n @Override\n public void run() {\n mThreadLocal.set(false);\n System.out.println(\"Thread#1 \" + mThreadLocal.get());\n }\n }.start();\n\n new Thread(\"Thread#2\"){\n @Override\n public void run() {\n System.out.println(\"Thread#2 \" + mThreadLocal.get());\n }\n }.start();\n }\n}\n```\n\n打印的结果输出如下所示：\n\n```\nMainThread true\nThread#1 false\nThread#2 null\n```\n\n可以看见，在不同线程对同一个 ThreadLocal对象设置数值，在不同的线程中取出来的值不一样。接下来就分析一下源码，看看其内部结构。\n\n\n\n**结构概览**\n\n>\n // 即每个Entry对象都有一个ThreadLocal的弱引用（作为key），这是为了防止内存泄露。\n // 一旦线程结束，key变为一个不可达的对象，这个Entry就可以被GC了。\n static class Entry extends WeakReference> {\n /** The value associated with this ThreadLocal. */\n Object value;\n Entry(ThreadLocal k, Object v) {\n super(k);\n value = v;\n }\n }\n // ThreadLocalMap 的初始容量，必须为2的倍数\n private static final int INITIAL_CAPACITY = 16;\n\n // resized时候需要的table\n private Entry[] table;\n\n // table中的entry个数\n private int size = 0;\n\n // 扩容数值\n private int threshold; // Default to 0\n }\n```\n\n一起看一下其常用的构造函数：\n\n```java\nThreadLocalMap(ThreadLocal firstKey, Object firstValue) {\n table = new Entry[INITIAL_CAPACITY];\n int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);\n table[i] = new Entry(firstKey, firstValue);\n size = 1;\n setThreshold(INITIAL_CAPACITY);\n}\n```\n\n构造函数的第一个参数就是本 ThreadLocal 实例 (this)，第二个参数就是要保存的线程本地变量。构造函数首先创建一个长度为16的 Entry 数组，然后计算出 firstKey 对应的哈希值，然后存储到 table 中，并设置 size 和 threshold。\n\n注意一个细节，计算 hash 的时候里面采用了 hashCode & (size - 1) 的算法，这相当于取模运算 hashCode % size 的一个更高效的实现（和HashMap中的思路相同）。正是因为这种算法，我们要求 size必须是 2 的指数，因为这可以使得 hash 发生冲突的次数减小。\n\n\n\n**3. ThreadLocalMap#set**\n\nThreadLocal 中 put 函数最终调用了 ThreadLocalMap 中的 set 函数，跟进去看一看：\n\n```java\nprivate void set(ThreadLocal key, Object value) {\n Entry[] tab = table;\n int len = tab.length;\n int i = key.threadLocalHashCode & (len-1);\n\n for (Entry e = tab[i];\n e != null;\n // 冲突了\n e = tab[i = nextIndex(i, len)]) {\n ThreadLocal k = e.get();\n\n if (k == key) {\n e.value = value;\n return;\n }\n\n if (k == null) {\n replaceStaleEntry(key, value, i);\n return;\n }\n }\n\n tab[i] = new Entry(key, value);\n int sz = ++size;\n if (!cleanSomeSlots(i, sz) && sz >= threshold)\n rehash();\n}\n```\n\n在上述代码中如果 Entry 在存放过程中冲突了，调用 nextIndex 来处理，如下所示。是否还记得 hashmap 中对待冲突的处理？这里好像是另一种套路：只要 i 的数值小于 len，就加1取值，官方术语称为：线性探测法。\n\n```java\n private static int nextIndex(int i, int len) {\n return ((i + 1 < len) ? i + 1 : 0);\n }\n```\n\n以上步骤ok了之后，再次关注一下源码中的 cleanSomeSlots，该函数主要的作用就是清理无用的 entry，避免出现内存泄露：\n\n```java\nprivate boolean cleanSomeSlots(int i, int n) {\n boolean removed = false;\n Entry[] tab = table;\n int len = tab.length;\n do {\n i = nextIndex(i, len);\n Entry e = tab[i];\n if (e != null && e.get() == null) {\n n = len;\n removed = true;\n i = expungeStaleEntry(i);\n }\n } while ( (n >>>= 1) != 0);\n return removed;\n}\n```\n\n\n\n**4. ThreadLocal#get**\n\n看完了 set 函数，肯定是要关注 get 的，源码如下所示：\n\n```java\npublic T get() {\n // 获取Thread对象t\n Thread t = Thread.currentThread();\n // 获取t中的map\n ThreadLocalMap map = getMap(t);\n if (map != null) {\n ThreadLocalMap.Entry e = map.getEntry(this);\n if (e != null) {\n @SuppressWarnings(\"unchecked\")\n T result = (T)e.value;\n return result;\n }\n }\n // 如果t中的map为空\n return setInitialValue();\n}\n```\n\n如果 map 为 null，就返回 setInitialValue() 这个方法，跟进这个方法看一下：\n\n```java\n private T setInitialValue() {\n T value = initialValue();\n Thread t = Thread.currentThread();\n ThreadLocalMap map = getMap(t);\n if (map != null)\n map.set(this, value);\n else\n createMap(t, value);\n return value;\n }\n```\n\n最后返回的是 value，而 value 来自 `initialValue() `，进入这个源码中查看：\n\n```java\nprotected T initialValue() {\n return null;\n}\n```\n\n原来如此，如果不设置 ThreadLocal 的数值，默认就是 null，来自于此。\n\nThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，尽可能在每次使用 ThreadLocal 后手动调用 remove()，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。\n\n\n\n参考资料：\n\n- [深入理解 Java 之 ThreadLocal 工作原理](https://allenwu.itscoder.com/threadlocal-source)\n \n\n\n\n## 12. 锁优化\n\n这里的锁优化主要是指虚拟机对 synchronized 的优化。\n\n### 自旋锁\n\n互斥同步的进入阻塞状态的开销都很大，应该尽量避免。在许多应用中，共享数据的锁定状态只会持续很短的一段时间。自旋锁的思想是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。\n\n自旋锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。\n\n在 JDK 1.6 中引入了自适应的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。\n\n### 锁消除\n\n锁消除是指对于被检测出不可能存在竞争的共享数据的锁进行消除。\n\n锁消除主要是通过**逃逸分析**来支持，如果堆上的共享数据不可能逃逸出去被其它线程访问到，那么就可以把它们当成私有数据对待，也就可以将它们的锁进行消除。\n\n对于一些看起来没有加锁的代码，其实隐式的加了很多锁。例如下面的字符串拼接代码就隐式加了锁：\n\n```java\npublic static String concatString(String s1, String s2, String s3) {\n return s1 + s2 + s3;\n}\n```\n\nString 是一个不可变的类，编译器会对 String 的拼接自动优化。在 JDK 1.5 之前，会转化为 StringBuffer 对象的连续 append() 操作：\n\n```java\npublic static String concatString(String s1, String s2, String s3) {\n StringBuffer sb = new StringBuffer();\n sb.append(s1);\n sb.append(s2);\n sb.append(s3);\n return sb.toString();\n}\n```\n\n每个 append() 方法中都有一个同步块。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 concatString() 方法内部。也就是说，sb 的所有引用永远不会“逃逸”到 concatString() 方法之外，其他线程无法访问到它，因此可以进行消除。\n\n\n\n### 锁粗化\n\n如果一系列的连续操作都对同一个对象反复加锁和解锁，频繁的加锁操作就会导致性能损耗。\n\n上一节的示例代码中连续的 append() 方法就属于这类情况。如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁的范围扩展（粗化）到整个操作序列的外部。对于上一节的示例代码就是扩展到第一个 append() 操作之前直至最后一个 append() 操作之后，这样只需要加锁一次就可以了。\n\n\n\n### 轻量级锁\n\nJDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：无锁状态（unlocked）、偏向锁状态（biasble）、轻量级锁状态（lightweight locked）和重量级锁状态（inflated）。\n\n以下是 HotSpot 虚拟机对象头的内存布局，这些数据被称为 mark word。其中 tag bits 对应了五个状态，这些状态在右侧的 state 表格中给出，应该注意的是 state 表格不是存储在对象头中的。除了 marked for gc 状态，其它四个状态已经在前面介绍过了。\n\n workQueue // 阻塞队列（用来保存等待被执行的任务）\n\tThreadFactory threadFactory, // 线程工厂，主要用来创建线程；\n\tRejectedExecutionHandler handler // 当拒绝处理任务时的策略\n){\n \nthis(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,\n Executors.defaultThreadFactory(), defaultHandler);\n}\n```\n\n关于 workQueue 参数，有四种队列可供选择：\n\n- ArrayBlockingQueue：基于数组结构的有界阻塞队列，按 FIFO 排序任务；\n- LinkedBlockingQuene：基于链表结构的阻塞队列，按 FIFO 排序任务；\n- SynchronousQuene：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于 ArrayBlockingQuene；\n- PriorityBlockingQuene：具有优先级的无界阻塞队列；\n\n关于 handler 参数，线程池的饱和策略，当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种策略处理该任务，线程池提供了 4 种策略：\n\n- ThreadPoolExecutor.AbortPolicy：丢弃任务并抛出RejectedExecutionException异常。\n- ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。\n- ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）\n- ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务\n\n当然也可以根据应用场景实现 RejectedExecutionHandler 接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务。\n\n### 线程池的状态\n\n```java\nprivate final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));\n```\n\n其中 AtomicInteger 变量 ctl 的功能非常强大：利用低 29 位表示线程池中线程数，通过高 3 位表示线程池的运行状态：\n\n- **RUNNING**：-1 << COUNT_BITS，即高 3 位为 111，该状态的线程池会接收新任务，并处理阻塞队列中的任务；\n- **SHUTDOWN**： 0 << COUNT_BITS，即高 3 位为 000，该状态的线程池不会接收新任务，但会处理阻塞队列中的任务；\n- **STOP** ： 1 << COUNT_BITS，即高 3 位为 001，该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；\n- **TIDYING** ： 2 << COUNT_BITS，即高 3 位为 010，该状态表示线程池对线程进行整理优化；\n- **TERMINATED**： 3 << COUNT_BITS，即高 3 位为 011，该状态表示线程池停止工作；\n\n### 线程池其他常用方法\n\n如果执行了线程池的 prestartAllCoreThreads() 方法，线程池会提前创建并启动所有核心线程。\nThreadPoolExecutor 提供了动态调整线程池容量大小的方法：setCorePoolSize() 和 setMaximumPoolSize()。\n\n### 如何合理设置线程池的大小\n\n一般需要根据任务的类型来配置线程池大小：\n如果是 CPU 密集型任务，就需要尽量压榨 CPU，参考值可以设为 NCPU+1\n如果是 IO 密集型任务，参考值可以设置为 2*NCPU\n\n\n\n- 参考资料\n - [Java线程池的使用及原理](http://tangxiaolin.com/learn/show?id=402881d2651d1bdf01651de142df0000)\n - [深入分析java线程池的实现原理 - 简书](https://www.jianshu.com/p/87bff5cc8d8c)\n - [尚学堂线程池并发队列ThreadPoolExecutor_Callable原理解析哔哩哔哩 (゜-゜)つロ 干杯~-bilibili](https://www.bilibili.com/video/av26354412?p=2)\n\n\n\n# 第二部分：面试指南\n\n在这里将总结面试中和并发编程相关的常见知识点，如在第一部分中出现的这里将不进行详细阐述。面试指南中，我将用最简洁的语言描述，更多是以一种大纲的形式列出问答点，根据自己掌握的情况回答。\n\n\n\n参考资料：\n\n- [Java线程面试题 Top 50 - ImportNew](http://www.importnew.com/12773.html)\n\n\n\n## 1. volatile 与 synchronized 的区别\n\n**（1）仅靠volatile不能保证线程的安全性。（原子性）**\n\n- ① volatile 轻量级，只能修饰变量。synchronized重量级，还可修饰方法\n- ② volatile 只能保证数据的可见性，不能用来同步，因为多个线程并发访问 volatile 修饰的变量不会阻塞。\n\nsynchronized 不仅保证可见性，而且还保证原子性，因为，只有获得了锁的线程才能进入临界区，从而保证临界区中的所有语句都全部执行。多个线程争抢 synchronized 锁对象时，会出现阻塞。\n\n\n\n**（2）线程安全性**\n\n线程安全性包括两个方面，①可见性。②原子性。\n\n从上面自增的例子中可以看出：仅仅使用 volatile 并不能保证线程安全性。而 synchronized 则可实现线程的安全性。\n\n\n\n## 2. 什么是线程池？如果让你设计一个动态大小的线程池，如何设计，应该有哪些方法？线程池创建的方式？\n\n- 什么是线程池 \n\n - 线程池顾名思义就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。 \n\n- 设计一个动态大小的线程池，如何设计，应该有哪些方法 \n\n - 一个线程池包括以下四个基本组成部分： \n - 线程管理器 (ThreadPool)：用于创建并管理线程池，包括创建线程，销毁线程池，添加新任务； \n - 工作线程 (PoolWorker)：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务； \n - 任务接口 (Task)：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等； \n - 任务队列 (TaskQueue)：用于存放没有处理的任务。提供一种缓冲机制； \n - 所包含的方法 \n - private ThreadPool() 创建线程池 \n - public static ThreadPool getThreadPool() 获得一个默认线程个数的线程池 \n - public void execute(Runnable task) 执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器决定 \n - public void execute(Runnable[] task) 批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器决定 \n - public void destroy() 销毁线程池,该方法保证在所有任务都完成的情况下才销毁所有线程，否则等待任务完成才销毁 \n - public int getWorkThreadNumber() 返回工作线程的个数 \n - public int getFinishedTasknumber() 返回已完成任务的个数,这里的已完成是只出了任务队列的任务个数，可能该任务并没有实际执行完成 \n - public void addThread() 在保证线程池中所有线程正在执行，并且要执行线程的个数大于某一值时。增加线程池中线程的个数 \n - public void reduceThread() 在保证线程池中有很大一部分线程处于空闲状态，并且空闲状态的线程在小于某一值时，减少线程池中线程的个数 \n\n- 线程池四种创建方式\n\n Java 通过 Executors 提供四种线程池，分别为：\n\n - new CachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。\n - new FixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。\n - new ScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。\n - new SingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。\n\n\n\n## 3. 什么是并发和并行\n\n sf = new SoftReference(obj);\nobj = null; // 使对象只被软引用关联\n```\n\n#### 3. 弱引用（Weak Reference）\n\n被弱引用关联的对象一定会被回收，也就是说它只能存活到下一次垃圾回收发生之前。\n\n使用 WeakReference 类来实现弱引用。\n\n```java\nObject obj = new Object();\nWeakReference wf = new WeakReference(obj);\nobj = null;\n```\n\n#### 4. 虚引用（Phantom Reference）\n\n又称为幽灵引用或者幻影引用。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用取得一个对象。\n\n为一个对象设置虚引用关联的唯一目的就是能在这个对象被回收时收到一个系统通知。\n\n使用 PhantomReference 来实现虚引用。\n\n```java\nObject obj = new Object();\nPhantomReference pf = new PhantomReference(obj);\nobj = null;\n```\n\n\n\n### 4. 方法区的回收\n\nJava虚拟机规范中确实说过可以**不要求虚拟机在方法区实现垃圾收集**，而且在方法区中进行垃圾收集的 “性价比” 一般比较低：在堆中，尤其在新生代中，常规的应用一次垃圾收集一般可以回收 70% ~ 95%的空间，而永久代的垃圾收集效率远低于此。\n\n永久代的垃圾收集主要回收两部分：**废弃常量** 和 **无用的类**。\n\n- 回收废弃常量与回收 Java 堆中的对象非常类似。\n- 要判定一个类是否是 “无用的类” 的条件相对苛刻许多。类需要同时满足下面3个条件才能算 “无用的类”\n - 该类的所有实例都已经被回收。\n - 加载该类的 `ClassLoader` 已经被回收。\n - 该类对应的 `java.lang.Class` 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。\n\n在大量使用反射、动态代理、GGLib 等 ByteCode 框架、动态生成 Jsp 以及 OSGI 这类频繁自定义 ClassLoader 的场景都需要虚拟机具备类卸载的功能，以保证永久代不会溢出。 \n\n\n\n### 5. finalize()\n\nfinalize() 类似 C++ 的析构函数，用来做关闭外部资源等工作。但是 try-finally 等方式可以做的更好，并且该方法运行代价高昂，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。\n\n当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能通过在该方法中让对象重新被引用，从而实现自救。自救只能进行一次，如果回收的对象之前调用了 finalize() 方法自救，后面回收时不会调用 finalize() 方法。\n\n\n\n## 3. 垃圾收集算法（垃圾处理方法）\n\n### 1. 标记 - 清除\n\n 中才会被设置为1。\n\n- 默认值：int 0, boolean false, float 0.0, char '0', 抽象数据类型 null\n\n```java\npublic static int value = 123;\n```\n\n- 对于 static final 类型，在准备阶段就会被赋上正确的值\n\n```java\npublic static final int value = 123;\n```\n\n\n\n\n\n#### 4. 解析\n\n解析阶段是虚拟机将常量池的**符号引用替换为直接引用**的过程\n\n- 类或接口的解析\n- 字段解析\n- 类方法解析\n- 接口方法解析\n\n\n\n**什么是符号引用和直接引用？**\n\n- **符号引用**：符号引用是一组符号来描述所引用的目标对象，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。符号引用与虚拟机实现的内存布局无关，引用的目标对象并不一定已经加载到内存中。\n- **直接引用**：直接引用可以是直接指向目标对象的指针、相对偏移量或是一个能间接定位到目标的句柄。直接引用是与虚拟机内存布局实现相关的，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同，如果有了直接引用，那引用的目标必定已经在内存中存在。\n\n\n\n符号引用就是字符串，这个字符串包含足够的信息，以供实际使用时可以找到相应的位置。你比如说某个方法的符号引用，如：“java/io/PrintStream.println:(Ljava/lang/String;)V”。里面有类的信息，方法名，方法参数等信息。\n\n当第一次运行时，要根据字符串的内容，到该类的方法表中搜索这个方法。运行一次之后，符号引用会被替换为直接引用，下次就不用搜索了。直接引用就是偏移量，通过偏移量虚拟机可以直接在该类的内存区域中找到方法字节码的起始位置。\n\n\n\n\n\n参考资料：\n\n- [【必读】JVM 类加载机制 - 掘金](https://juejin.im/post/5a1d644551882534af25b381)\n\n\n\n#### 5. 初始化\n\n初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段即虚拟机执行类构造器 \\() 方法的过程。\n\n\n\n\n\n在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。\n\n\\() 方法具有以下特点：\n\n- 是由编译器自动收集类中所有类变量的赋值动作和静态语句块中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定。特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码：\n\n```java\npublic class Test {\n static {\n i = 0; // 给变量赋值可以正常编译通过\n System.out.print(i); // 这句编译器会提示“非法向前引用”\n }\n static int i = 1;\n}\n```\n\n- 与类的构造函数（或者说实例构造器 \\()）不同，不需要显式的调用父类的构造器。虚拟机会自动保证在子类的 \\() 方法运行之前，父类的 \\() 方法已经执行结束。因此虚拟机中第一个执行 \\() 方法的类肯定为 java.lang.Object。\n- 由于父类的 \\() 方法先执行，也就意味着父类中定义的静态语句块要优先于子类的变量赋值操作。例如以下代码：\n\n```java\nstatic class Parent {\n public static int A = 1;\n static {\n A = 2;\n }\n}\n\nstatic class Sub extends Parent {\n public static int B = A;\n}\n\npublic static void main(String[] args) {\n System.out.println(Sub.B); // 2\n}\n```\n\n- \\() 方法对于类或接口不是必须的，如果一个类中不包含静态语句块，也没有对类变量的赋值操作，编译器可以不为该类生成 \\() 方法。\n- 接口中不可以使用静态语句块，但仍然有类变量初始化的赋值操作，因此接口与类一样都会生成 \\() 方法。但接口与类不同的是，执行接口的 \\() 方法不需要先执行父接口的 \\() 方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的 \\() 方法。\n- 虚拟机会保证一个类的 \\() 方法在多线程环境下被正确的加锁和同步，如果多个线程同时初始化一个类，只会有一个线程执行这个类的 \\() 方法，其它线程都会阻塞等待，直到活动线程执行 \\() 方法完毕。如果在一个类的 \\() 方法中有耗时的操作，就可能造成多个线程阻塞，在实际过程中此种阻塞很隐蔽。\n\n\n\n\n\n### 类加载器\n\n虚拟机设计团队把类加载阶段中的 “通过一个类的全限定名来获取描述此类的二进制字节流（即字节码）” 这个动作放到 Java 虚拟机外部去实现，以便让应用程序自己决定如何去获取所需要的类（通过一个类的全限之名获取描述此类的二进制字节流）。实现这个动作的代码模块称为 **“类加载器”**。\n\n \n\n#### 1. 类与类加载器\n\n两个类相等：只有被同一个类加载器加载的类才可能会相等。相同的字节码被不同的类加载器加载的类不相等。\n\n这里的相等，包括类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回结果为 true，也包括使用 instanceof 关键字做对象所属关系判定结果为 true。\n\n\n\n#### 2. 类加载器分类\n\n从 Java 虚拟机的角度来讲，只存在以下两种不同的类加载器：\n\n- **启动类加载器**（Bootstrap ClassLoader），这个类加载器用 C++ 实现，是虚拟机自身的一部分；\n- **所有其他类的加载器**，这些类由 Java 实现，独立于虚拟机外部，并且全都继承自抽象类 java.lang.ClassLoader。\n\n\n\n从 Java 开发人员的角度看，类加载器可以划分得更细致一些：\n\n- **启动类加载器**（Bootstrap ClassLoader）\n - 此类加载器负责将存放在 \\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给启动类加载器，直接使用 null 代替即可。\n- **扩展类加载器**（Extension ClassLoader）\n - 这个类加载器是由 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将 /lib/ext 或者被 java.ext.dir 系统变量所指定路径中的所有类库加载到内存中，开发者可以直接使用扩展类加载器。\n- **应用程序类加载器**（Application ClassLoader）\n - 这个类加载器是由 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。由于这个类加载器是 ClassLoader 中的 getSystemClassLoader() 方法的返回值，因此一般称为系统类加载器。它负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。\n- **自定义类加载器**\n - 载器步骤： \n - 定义一个类，继承 ClassLoader\n - 重写 loadClass 方法\n - 实例化 Class 对象\n - 自定义类加载器的优势\n - 类加载器是 Java 语言的一项创新，也是 Java 语言流行的重要原因之一，它最初的设计是为了满足 java applet 的需求而开发出来的\n - 高度的灵活性\n - 通过自定义类加载器可以实现热部署\n - 代码加密\n\n\n\n参考资料：\n\n- [深入理解Java虚拟机 - JY的博客 | JY Blog](https://jybeyonding.github.io/2018/03/16/%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3Java%E8%99%9A%E6%8B%9F%E6%9C%BA-%E7%AC%AC7%E7%AB%A0-%E8%99%9A%E6%8B%9F%E6%9C%BA%E7%B1%BB%E5%8A%A0%E8%BD%BD%E6%9C%BA%E5%88%B6/)\n\n\n\n#### 3. 双亲委派模型\n\n- 为什么要使用双亲委派模型？\n - 主要是为了避免重复加载的问题\n\nJVM 如何加载一个类的过程，双亲委派模型中有哪些方法有没有可能父类加载器和子类加载器，加载同一个类？如果加载同一个类，该使用哪一个类？\n\n- **双亲委派机制图**\n\n /lib下面的类库加载到内存中（比如rt.jar）。由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不允许直接通过引用进行操作。 \n - 标准扩展（Extension）类加载器：是由 Sun 的 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将< Java_Runtime_Home >/lib/ext或者由系统变量 java.ext.dir指定位置中的类库加载到内存中。开发者可以直接使用标准扩展类加载器。\n - 系统（System）类加载器：由 Sun 的 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。它负责将系统类路径（CLASSPATH）中指定的类库加载到内存中。开发者可以直接使用系统类加载器。除了以上列举的三种类加载器，还有一种比较特殊的类型 — 线程上下文类加载器。 \n- 如果加载同一个类，该使用哪一个类？ \n\n - 父类的\n\n\n\n## 7. Student s = new Student(); 在内存中做了哪些事情\n\n1. 加载 Student.class 文件进内存 \n2. 在栈内存为 s 开辟空间 \n3. 在堆内存为 Student 对象开辟空间 \n4. 对 Student 对象的成员变量进行默认初始化 \n5. 对 Student 对象的成员变量进行显示初始化 \n6. 通过构造方法对 Student 对象的成员变量赋值 \n7. Student 对象初始化完毕，把对象地址赋值给 s 变量 \n\n\n\n## 8. Java虚拟机工具\n\nJDK 本身提供了很多方便的 JVM 性能调优监控工具，除了 jps、jstat、jinfo、jmap、jhat、jstack 等小巧的工具，还有集成式的 jvisualvm 和 jconsole。\n\n\n\n### （1）jps\n\n**jps（JVM Process Status Tool，虚拟机进程监控工具）**，这个命令可以列出正在运行的虚拟机进程，并显示虚拟机执行主类名称，以及这些进程的本地虚拟机唯一 ID。这个 ID 被称为本地虚拟机唯一 ID（local virtual Machine Identifier，简写为LVMID）。如果你在 linux 的一台服务器上使用 jps 得到的 LVMID 其实就是和 ps 命令得到的 PID 是一样的。\n\n**语法格式如下：**\n\n```shell\njps [options] [hostid]\n```\n\n如果不指定hostid就默认为当前主机或服务器。\n\n**options参数选项说明如下：**\n\n```shell\n-q 不输出类名、Jar名和传入main方法的参数\n-m 输出传入main方法的参数\n-l 输出main类或Jar的全限名\n-v 输出传入JVM的参数\n```\n\n**使用（查看所有java进程）**\n\n```shell\njps -lv\n```\n\n\n\n示例：\n\n```shell\n[root@chengchi ~]# jps\n24804 Jps\n1862 mango.jar\n\n[root@chengchi ~]# jps -lv\n24787 sun.tools.jps.Jps -Dapplication.home=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.171-8.b10.el7_5.x86_64 -Xms8m\n1862 /home/www/api.chengchijinfu.com/mango_server/target/mango.jar -Dserver.port=8080 -Dspring.profiles.active=prod\n```\n\n\n\n### （2）jstat\n\n**jstat（JVM Statistics Monitoring Tool，虚拟机统计信息监视工具）**，这个命令用于监视虚拟机各种运行状态信息。它可以显示本地或者远程虚拟机进程中的**类装载、内存、垃圾收集、JIT编译等运行数据**，虽然没有GUI图形界面，只是提供了纯文本控制台环境的服务器上，但它是运行期间定位虚拟机性能问题的首选工具。\n\n 语法格式如下：\n\n```shell\njstat [option vmid [interval [s | ms] [count ] ] ]\n```\n\n\n\n例如：需要每 1000 毫秒查询一次进程 16418 垃圾收集状况，一共查询 10 次，那命令如下：\n\n\n\n参考：[jstat命令详解 - CSDN博客](https://blog.csdn.net/zhaozheng7758/article/details/8623549)\n\n\n\n\n### （3）jinfo\n\n**jinfo （Configuration Info for Java，配置信息工具）** 这个命令可以实时地查看和调整虚拟机各项参数。 \n\n查看2788的MaxPerm大小可以用 \n\n```shell\n[root@Bill-8 bin]# jinfo -flag MaxPermSize 2788\n-XX:MaxPermSize=134217728\n```\n\n\n\n### （4）jmap\n\n**jmap（Memory Map for Java，内存映像工具）**，用于生成堆转存的快照，一般是 heapdump 或者 dump 文件。如果不适用 jmap 命令，可以使用 -XX:+HeapDumpOnOutOfMemoryError 参数，当虚拟机发生内存溢出的时候可以产生快照。或者使用kill -3 pid也可以产生。jmap 的作用并不仅仅是为了获取 dump 文件，它可以查询 finalize 执行队列，java 堆和永久代的详细信息，如空间使用率，当前用的哪种收集器。\n\n**jmap的命令格式：**\n\n```shell\njmap [option] vmid\n```\n\n\n\n```shell\njmap -J-d64 -heap 16418\n```\n\n\n\n### （5）jhat\n\n**jhat（虚拟机堆转储快照分析工具）**，这个工具是用来分析 jmap dump 出来的文件。\n 由于这个工具功能比较简陋，运行起来也比较耗时，所以这个工具不推荐使用，推荐使用MAT。\n\n例如分析dump 出来的 test.bin，命令如下：\n\n```shell\njhat test.bin \n```\n\n它会在本地启动一个web服务，端口是7000，这样直接访问 127.0.0.1:7000就能看到分析结果了。\n\n\n\n### （6）jstack\n\n> 阿里实习面试\n\n**jstack（Java Stack Trace，Java堆栈跟踪工具）**，这个命令用于查看虚拟机当前时刻的线程快照（一般是threaddump 或者 javacore文件）。线程快照就是当前虚拟机内每一条线程正在执行的方法堆栈的集合。**生成线程快照的主要目的是：**定位线程出现长时间停顿的原因，入线程间死锁、死循环、请求外部资源导致的长时间等待都是导致线程长时间停顿的常见原因。线程出现停顿的时候通过jstack来查看各个线程的调用堆栈，就可以知道没有响应的线程到底在后台做些什么事情。\n\n命令格式：\n\n```shell\njstack [option] vmid\n```\n\n使用：查看进程2849 的堆栈信息\n\n```shell\n[root@Bill-8 yrd_soft]# jstack 2849\n```\n\n \n\n\n\n### （7）jconsole\n\n> 阿里面经\n\nJConsole 中，您将能够监视 JVM 内存的使用情况、线程堆栈跟踪、已装入的类和 VM 信息以及 CE MBean。\n\njconsole：一个 java GUI 监视工具，可以以图表化的形式显示各种数据。并可通过远程连接监视远程的服务器VM。用 Java 写的 GUI 程序，用来监控 VM，并可监控远程的 VM，非常易用，而且功能非常强。命令行里打 jconsole，选则进程就可以了。\n\n \n\n### （8）jvisualvm\n\njvisualvm 同 jconsole 都是一个基于图形化界面的、可以查看本地及远程的 JAVA GUI 监控工具，Jvisualvm 同 jconsole 的使用方式一样，直接在命令行打入 jvisualvm 即可启动，jvisualvm 界面更美观一些，数据更实时：\n\n\n\n参考资料：\n\n- [JVM性能监控工具](https://www.jianshu.com/p/25e94a1399a0)\n\n\n\n\n\n## 9. 了解过JVM调优没，基本思路是什么\n\n详情转向：[美团技术：从实际案例聊聊Java应用的GC优化](https://tech.meituan.com/jvm_optimize.html)\n\n\n\n\n## 10. JVM线程死锁，你该如何判断是因为什么？如果用VisualVM，dump线程信息出来，会有哪些信息\n\n- 常常需要在隔两分钟后再次收集一次thread dump，如果得到的输出相同，仍然是大量thread都在等待给同一个地址上锁，那么肯定是死锁了。 \n\n\n\n\n\n## 11. 什么是内存泄露？用什么工具可以查出内存泄漏\n\n在 Java 中，内存泄漏就是存在一些被分配的对象，这些对象有下面两个特点\n\n- 这些对象是可达的，即在有向图中，存在通路可以与其相连；\n- 这些对象是无用的，即程序以后不会再使用这些对象。\n\n如果对象满足这两个条件，这些对象就可以判定为 Java 中的内存泄漏，这些对象不会被 GC 所回收，然而它却占用内存。\n\n\n\n在 C++ 中，内存泄漏的范围更大一些。有些对象被分配了内存空间，然后却不可达，由于 C++ 中没有 GC，这些内存将永远收不回来。在 Java 中，这些不可达的对象都由 GC 负责回收，因此程序员不需要考虑这部分的内存泄露。\n\n通过分析，我们得知，对于C++，程序员需要自己管理边和顶点，而对于 Java 程序员只需要管理边就可以了(不需要管理顶点的释放)。通过这种方式，Java 提高了编程的效率。\n\n1 \n```\n\n 其中，数字越小表示优先级越高。\n\n 例如：我们在 web.xml 中设置 TestServlet2 的优先级为 1，而 TestServlet1 的优先级为 2，启动和关闭Tomcat：优先级高的先启动也先关闭。 \n\n2. 客户端首次向某个Servlet发送请求\n\n3. Servlet 类被修改后，Tomcat 容器会重新装载 Servlet。\n\n\n\n## 6. forward和redirect\n\n*本节参考：《Java程序员面试笔试宝典》P172*\n\n 在设计 Web 应用程序时，经常需要把一个系统进行结构化设计，即按照模块进行划分，让不同的 Servlet 来实现不同的功能，例如可以让其中一个 Servlet 接收用户的请求，另外一个 Servlet 来处理用户的请求。为了实现这种程序的模块化，就需要保证在不同的 Servlet 之间可以相互跳转，而 Servlet 中主要有两种实现跳转的方式：forward 与 redirect 方式。\n\n forward 是服务器内部的重定向，服务器直接访问目标地址的 URL，把那个 URL 的响应内容读取过来，而客户端并不知道，因此在客户端浏览器的地址栏中不会显示转向后的地址，还是原来的地址。由于在整个定向的过程中用的是同一个 Request，因此 forward 会将 Request 的信息带到被定向的 JSP 或 Servlet 中使用。\n\n redirect 则是客户端的重定向，是完全的跳转，即客户端浏览器会获取到跳转后的地址，然后重新发送请求，因此浏览器中会显示跳转后的地址。同事，由于这种方式比 forward 方式多了一次网络请求，因此其效率要低于 forward 方式。需要注意的是，客户端的重定向可以通过设置特定的 HTTP 头或改写 JavaScript 脚本实现。\n\n 下图可以更好的说明二者的区别：\n\n\\\n\n **POST**（`create`）：在服务器新建一个资源。 \n eg. 用户收藏某本图书 `POST` \n\n **PUT**（`update`）：在服务器更新资源（客户端提供改变后的完整资源）。 \n eg. 用户修改对某本图书的收藏 `PUT` \n\n **DELETE**（`delete`）：从服务器删除资源。 \n eg. 用户删除某篇笔记 `DELETE` \n\n5. 如果记录数量很多，服务器不可能都将它们返回给用户。API应该提供参数，过滤返回结果\n\n ?limit=10：指定返回记录的数量\n eg. 获取图书信息 `GET` `?limit=10`\n\n6. 服务器向用户返回的状态码和提示信息 \n 每个状态码代表不同意思, 就像代号一样\n\n 2系 代表正常返回\n\n 4系 代表数据异常 \n\n 5系 代表服务器异常\n\n\n\n# 二、Spring\n\n## 1. Spring IOC、AOP的理解、实现的原理，以及优点 \n\nSpring的IoC容器是Spring的核心，Spring AOP是spring框架的重要组成部分\n\n### IOC\n\n- **我的理解**\n - 正常的情况下，比如有一个类，在类里面有方法（不是静态的方法），调用类里面的方法，创建类的对象，使用对象调用方法，创建类对象的过程，需要new出来对象\n - 通过控制反转，把对象的创建不是通过new方式实现，而是交给Spring配置创建类对象\n - IOC的意思是控件反转也就是由容器控制程序之间的关系，这也是spring的优点所在，把控件权交给了外部容器，之前的写法，由程序代码直接操控，而现在控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。换句话说之前用new的方式获取对象，现在由spring给你至于怎么给你就是di了。\n\n\n\n- **Spring IOC实现原理** \n - 创建xml配置文件，配置要创建的对象类\n - 通过反射创建实例； \n - 获取需要注入的接口实现类并将其赋值给该接口。 \n\n- **优点**\n\n - 解耦合，开发更方便组织分工\n - 高层不依赖于底层（依赖倒置）\n - 是应用更容易测试\n - 因为把对象生成放在了XML里定义，所以当我们需要换一个实现子类将会变成很简单（一般这样的对象都是现实于某种接口的），只要修改XML就可以了，这样我们甚至可以实现对象的热插拨\n\n\n\n### AOP\n\n- **我的理解**\n\n - AOP（Aspect Oriented Programming ）称为面向切面编程，扩展功能不是修改源代码实现，在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限等待，Struts2的拦截器设计就是基于AOP的思想，是个比较经典的例子。\n - 面向切面编程（aop）是对面向对象编程（oop）的补充 \n - 面向切面编程提供声明式事务管理\n - AOP就是典型的代理模式的体现\n\n- **Spring AOP实现原理** \n\n - 动态代理（利用**反射和动态编译**将代理模式变成动态的） \n\n - JDK的动态代理\n\n - JDK内置的Proxy动态代理可以在运行时动态生成字节码，而没必要针对每个类编写代理类\n - JDKProxy返回动态代理类，是目标类所实现接口的另一个实现版本，它实现了对目标类的代理（如同UserDAOProxy与UserDAOImp的关系） \n\n - cglib动态代理 \n\n - CGLibProxy返回的动态代理类，则是目标代理类的一个子类（代理类扩展了UserDaoImpl类） \n - cglib继承被代理的类，重写方法，织入通知，动态生成字节码并运行\n\n- **优点**\n\n - 各个步骤之间的良好隔离性 \n - 源代码无关性\n - 松耦合\n - 易扩展\n - 代码复用\n\n\n\n## 2. 什么是依赖注入，注入的方式有哪些\n\n- DI（依赖注入）\n\n - 所谓依赖注入，就是把底层类作为参数传入上层类，实现上层类对下层类的控制。DI依赖注入，向类里面属性注入值 ，依赖注入不能单独存在，需要在IOC基础上完成操作。\n\n- - 使用set方法注入 \n - 使用有参构造注入 \n - 使用接口注入\n - 注解注入(@Autowire) \n\n\n## 3. Spring IOC初始化过程\n\n \n\n\n\n\n\n\n\n## 8. Spring中bean加载机制，生命周期\n\n### 加载机制\n\n【Spring】详解Spring中Bean的加载 - weknow619 - 博客园\nhttps://www.cnblogs.com/weknow619/p/6673667.html\n\n### 生命周期\n\n在传统的Java应用中，bean的生命周期很简单。使用Java关键字new进行bean实例化，然后该bean就可以使用了。一旦该bean不再被使用，则由Java自动进行垃圾回收。\n\n相比之下，Spring容器中的bean的生命周期就显得相对复杂多了。正确理解Spring bean的生命周期非常重要，因为你或许要利用Spring提供的扩展点来自定义bean的创建过程。下图展示了bean装载到Spring应用上下文中的一个典型的生命周期过程。 \n\n \n```\n\n\n\n### 二：装配bean时常用的注解\n\n@Autowired：属于Spring 的org.springframework.beans.factory.annotation包下,可用于为类的属性、构造器、方法进行注值 \n@Resource：不属于spring的注解，而是来自于JSR-250位于java.annotation包下，使用该annotation为目标bean指定协作者Bean。 \n\n...\n\n\n\n更详细请转向：[Spring常用注解介绍【经典总结】 - CSDN博客](https://blog.csdn.net/u010648555/article/details/76299467)\n\n\n\n\n\n\n\n## 15. Spring 中用到了那些设计模式？\n\nSpring框架中使用到了大量的设计模式，下面列举了比较有代表性的：\n\n- 代理模式—在AOP和remoting中被用的比较多。\n- 单例模式—在spring配置文件中定义的bean默认为单例模式。\n- 模板方法—用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。\n- 工厂模式—BeanFactory用来创建对象的实例。\n- 适配器–spring aop\n- 装饰器–spring data hashmapper\n- 观察者– spring 时间驱动模型\n- 回调–Spring ResourceLoaderAware回调接口\n\n### 工厂模式（Factory Method）\n\nSpring容器就是实例化和管理Bean的工厂\n\n工厂模式隐藏了创建类的细节，返回值必定是接口或者抽象类,而不是具体的某个对象，工厂类根据条件生成不同的子类实例。当得到子类的实例后，就可以调用基类中的方法，不必考虑返回的是哪一个子类的实例。\n\n这个很明显，在各种BeanFactory以及ApplicationContext创建中都用到了；\n\n**Spring通过配置文件，就可以管理所有的bean，而这些bean就是Spring工厂能产生的实例，因此，首先我们在Spring配置文件中对两个实例进行配置**。\n\n### 单态模式【单例模式】（Singleton）\n\n**Spring默认将所有的Bean设置成 单例模式，即对所有的相同id的Bean的请求，都将返回同一个共享的Bean实例。这样就可以大大降低Java创建对象和销毁时的系统开销**。\n\n使用Spring将Bean设置称为单例行为，则无需自己完成单例模式。\n\n| 可以通过singleton=“true | false” 或者 scope=“？”来指定 |\n\n\n### 适配器（Adapter）\n\n**在Spring的Aop中，使用的Advice（通知）来增强被代理类的功能。Spring实现这一AOP功能的原理就使用代理模式（1、JDK动态代理。2、CGLib字节码生成技术代理。）对类进行方法级别的切面增强，即，生成被代理类的代理类， 并在代理类的方法前，设置拦截器，通过执行拦截器重的内容增强了代理方法的功能，实现的面向切面编程**。\n\n### 代理（Proxy）\n\nSpring实现了一种能够通过额外的方法调用完成任务的设计模式 - 代理设计模式,比如JdkDynamicAopProxy和Cglib2AopProxy。\n\n代理设计模式的一个很好的例子是**org.springframework.aop.framework.ProxyFactoryBean**。**该工厂根据Spring bean构建AOP代理。该类实现了定义getObject()方法的FactoryBean接口。此方法用于将需求Bean的实例返回给bean factory**。在这种情况下，它不是返回的实例，而是AOP代理。在执行代理对象的方法之前，可以通过调用补充方法来进一步“修饰”代理对象(其实所谓的静态代理不过是在装饰模式上加了个要不要你来干动作行为而已，而不是装饰模式什么也不做就加了件衣服，其他还得由你来全权完成)。\n\n### 观察者（Observer）\n\n定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。**spring中Observer模式常用的地方是listener的实现。如ApplicationListener**。\n\n\n\n补充面试题：Spring里面的工厂模式和代理模式，IO中的装饰者模式，挑几个最熟的能讲讲思路和伪代码实现？\n\n\n\n\n\n## 16. Spring 的优点有哪些\n\n1. 降低了组件之间的耦合性 ，实现了软件各层之间的解耦 \n2. 可以使用容易提供的众多服务，如事务管理，消息服务等 \n3. 容器提供单例模式支持 \n4. 容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能 \n5. 容器提供了众多的辅助类，能加快应用的开发 \n6. spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等 \n7. spring属于低侵入式设计，代码的污染极低 \n8. 独立于各种应用服务器 \n9. spring的DI机制降低了业务对象替换的复杂性 \n10. Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring的部分或全部 \n\n\n\n## 17. IOC和AOP用到的设计模式\n\n用过spring的朋友都知道spring的强大和高深，都觉得深不可测，其实当你真正花些时间读一读源码就知道它的一些技术实现其实是建立在一些最基本的技术之上而已；例如AOP(面向方面编程)的实现是建立在CGLib提供的类代理和jdk提供的接口代理，IOC(控制反转)的实现建立在工厂模式、Java反射机制和jdk的操作XML的DOM解析方式.\n\n\n\n\n\n# 二、SpringMVC\n\n## 1. Spring MVC的工作原理\n\nSpring MVC 的工作原理如下图： \n\n\n\n \n\n- ① 客户端的所有请求都交给前端控制器DispatcherServlet来处理，它会负责调用系统的其他模块来真正处理用户的请求。 \n- ② DispatcherServlet收到请求后，将根据请求的信息（包括URL、HTTP协议方法、请求头、请求参数、Cookie等）以及HandlerMapping的配置找到处理该请求的Handler（任何一个对象都可以作为请求的Handler）。 \n- ③ 在这个地方Spring会通过HandlerAdapter对该处理进行封装。 \n- ④ HandlerAdapter是一个适配器，它用统一的接口对各种Handler中的方法进行调用。 \n- ⑤ Handler完成对用户请求的处理后，会返回一个ModelAndView对象给DispatcherServlet，ModelAndView顾名思义，包含了数据模型以及相应的视图的信息。 \n- ⑥ ModelAndView的视图是逻辑视图，DispatcherServlet还要借助ViewResolver完成从逻辑视图到真实视图对象的解析工作。 \n- ⑦ 当得到真正的视图对象后，DispatcherServlet会利用视图对象对模型数据进行渲染。 \n- ⑧ 客户端得到响应，可能是一个普通的HTML页面，也可以是XML或JSON字符串，还可以是一张图片或者一个PDF文件。 \n\n\n\n**组件及其作用**\n\n1. 前端控制器 (DispatcherServlet)\n\n 接收请求，响应结果，相当于转发器，中央处理器。负责调用系统的其他模块来真正处理用户的请求。 \n\n 有了DispatcherServlet减少了其他组件之间的耦合度\n\n2. 处理器映射器 (HandlerMapping)\n\n 作用：根据请求的 url 查找 Handler\n\n3. **处理器 (Handler)**\n\n 注意：编写 Handler 时按照 HandlerAdapter 的要求去做，这样适配器才可以去正确执行 Handler\n\n4. 处理器适配器 (HandlerAdapter)\n\n 作用：按照特定规则（HandlerAdapter要求的规则）执行Handler。\n\n5. 视图解析器 (ViewResolver)\n\n 作用：进行视图解析，根据逻辑视图解析成真正的视图 (View)\n\n6. **视图 (View)**\n\n View 是一个接口实现类支持不同的 View 类型（jsp,pdf等等）\n\n注意：只需要程序员开发，处理器和视图。\n\n\n\n## 2. Spring MVC注解的优点\n\n\n\n\n\n# 三、Hibernate\n\n## 1. 简述Hibernate常见优化策略。\n\n- 制定合理的缓存策略（二级缓存、查询缓存）。 \n- 采用合理的Session管理机制。 \n- 尽量使用延迟加载特性。 \n- 设定合理的批处理参数。 \n- 如果可以，选用UUID作为主键生成器。 \n- 如果可以，选用基于版本号的乐观锁替代悲观锁。 \n- 在开发过程中, 开启hibernate.show_sql选项查看生成的SQL，从而了解底层的状况；开发完成后关闭此选项。 \n- 考虑数据库本身的优化，合理的索引、恰当的数据分区策略等都会对持久层的性能带来可观的提升，但这些需要专业的DBA（数据库管理员）提供支持。 \n\n\n\n## 2. Hibernate一级缓存与二级缓存之间的区别\n\n- Hibernate的Session提供了一级缓存的功能，默认总是有效的，当应用程序保存持久化实体、修改持久化实体时，Session并不会立即把这种改变提交到数据库，而是缓存在当前的Session中，除非显示调用了Session的flush()方法或通过close()方法关闭Session。通过一级缓存，可以减少程序与数据库的交互，从而提高数据库访问性能。 \n- SessionFactory级别的二级缓存是全局性的，所有的Session可以共享这个二级缓存。不过二级缓存默认是关闭的，需要显示开启并指定需要使用哪种二级缓存实现类（可以使用第三方提供的实现）。一旦开启了二级缓存并设置了需要使用二级缓存的实体类，SessionFactory就会缓存访问过的该实体类的每个对象，除非缓存的数据超出了指定的缓存空间。 \n- 一级缓存和二级缓存都是对整个实体进行缓存，不会缓存普通属性，如果希望对普通属性进行缓存，可以使用查询缓存。查询缓存是将HQL或SQL语句以及它们的查询结果作为键值对进行缓存，对于同样的查询可以直接从缓存中获取数据。查询缓存默认也是关闭的，需要显示开启。 \n\n\n\n## 3. Hibernate的理解\n\n\n\n# 四、MyBatis\n\n## 1. Mybatis原理\n\n## 2. Hibernate了解吗，Mybatis和Hibernate的区别\n\n\n\n# 五、Tomcat\n\n## 1. tomcat加载基本流程，涉及到的参数\n\n\n\n\n\n\n\n# 附录：参考资料\n\n\n\n参考资料：\n\n- [Java-Guide/Spring学习与面试.md at master · Snailclimb/Java-Guide](https://github.com/Snailclimb/Java-Guide/blob/master/%E4%B8%BB%E6%B5%81%E6%A1%86%E6%9E%B6/Spring%E5%AD%A6%E4%B9%A0%E4%B8%8E%E9%9D%A2%E8%AF%95.md)\n- [biezhi/java-bible: 我的技术摘要](https://github.com/biezhi/java-bible)\n- [Spring 常见的一些面试题整理 搜云库](https://www.souyunku.com/2018/03/21/spring/)\n\n参考面经：\n\n- [阿里Java研发工程师实习面经_笔经面经_牛客网](https://www.nowcoder.com/discuss/72899?type=2&order=3&pos=509&page=1)\n\n- [网易面经（Java开发岗） - Andya - 博客园](https://www.cnblogs.com/Andya/p/7456511.html )\n\n\n\n"
},
{
"path": "notes/JavaArchitecture/08-系统架构.md",
"content": "## tomcat集群怎么保证同步 \n\n\n\n\n\n## 布隆过滤器\n\n\n\n\n\n（其他）\n\n\n\n1. 常用的hash算法有哪些？ \n\n - 加法Hash；把输入元素一个一个的加起来构成最后的结果 \n - 位运算Hash；这类型Hash函数通过利用各种位运算（常见的是移位和异或）来充分的混合输入元素 \n - 乘法Hash；这种类型的Hash函数利用了乘法的不相关性（乘法的这种性质，最有名的莫过于平方取头尾的随机数生成算法，虽然这种算法效果并不好）；jdk5.0里面的String类的hashCode()方法也使用乘法Hash；32位FNV算法 \n - 除法Hash；除法和乘法一样，同样具有表面上看起来的不相关性。不过，因为除法太慢，这种方式几乎找不到真正的应用 \n - 查表Hash；查表Hash最有名的例子莫过于CRC系列算法。虽然CRC系列算法本身并不是查表，但是，查表是它的一种最快的实现方式。查表Hash中有名的例子有：Universal Hashing和Zobrist Hashing。他们的表格都是随机生成的。 \n - 混合Hash；混合Hash算法利用了以上各种方式。各种常见的Hash算法，比如MD5、Tiger都属于这个范围。它们一般很少在面向查找的Hash函数里面使用 \n\n \n\n2. 如何设计存储海量数据的存储系统 \n\n3. 缓存的实现原理，设计缓存要注意什么 \n\n4. 什么是一致性哈希？用来解决什么问题？ \n\n在设计分布式cache系统的时候，我们需要让key的分布均衡，并且在增加cache server后，cache的迁移做到最少。 \n\n \n\n1. 现在有一个进程挂起了，如何用工具查出原因？ \n\n - 通过 Javacore 了解线程运行状况 \n\n javacore，也可以称为“threaddump”或是“javadump”，它是 Java 提供的一种诊断特性，能够提供一份可读的当前运行的 JVM 中线程使用情况的快照。即在某个特定时刻，JVM 中有哪些线程在运行，每个线程执行到哪一个类，哪一个方法。 \n\n 应用程序如果出现不可恢复的错误或是内存泄露，就会自动触发 Javacore 的生成。而为了性能问题诊断的需要，我们也会主动触发生成 Javacore。在 AIX、Linux、Solaris 环境中，我们通常使用 kill -3 产生该进程的 Javacore。IBM Java6 中产生 Javacore 的详细方法可以参考文章 [1]。 \n\n \n\n2. 你知道的开源协议有哪些？ \n\n - Mozilla Public License： MPL License，允许免费重发布、免费修改，但要求修改后的代码版权归软件的发起者。这种授权维护了商业软件的利益，它要求基于这种软件得修改无偿贡献版权给该软件。这样，围绕该软件得所有代码得版权都集中在发起开发人得手中。但MPL是允许修改，无偿使用得。MPL软件对链接没有要求。 \n - BSD开源协议：给于使用者很大自由的协议。可以自由的使用，修改源代码，也可以将修改后的代码作为开源或者专有软件再发布。 \n - Apache Licence 2.0 ：Apache Licence是著名的非盈利开源组织Apache采用的协议。该协议和BSD类似，同样鼓励代码共享和尊重原作者的著作权，同样允许代码修改，再发布(作为开源或商业软件)。 \n - GPL：GPL许可证是自由软件的应用最广泛的软件许可证，人们可以修改程式的一个或几个副本或程式的任何部分，以此形成基於这些程式的衍生作品。必须在修改过的档案中附有明显的说明：您修改了此一档案及任何修改的日期。 您必须让您发布或出版的作品，包括本程式的全部或一部分，或内含本程式的全部或部分所衍生的作品，允许第三方在此许可证条款下使用，并且不得因为此项授权行为而收费。 \n - LGPL：LGPL是GPL的一个为主要为类库使用设计的开源协议。和GPL要求任何使用/修改/衍生之GPL类库的的软件必须采用GPL协议不同。LGPL允许商业软件通过类库引用(link)方式使用LGPL类库而不需要开源商业软件的代码。这使得采用LGPL协议的开源代码可以被商业软件作为类库引用并发布和销售。 \n - Public Domain：公共域授权。将软件授权为公共域，这些软件包没有授权协议，任何人都可以随意使用它 \n\n3. 你知道的开源软件有哪些？ \n\n - JDK \n - Eclipse \n - Tomcat \n - Spring \n - Hibernate \n - MySQL "
},
{
"path": "notes/JavaArchitecture/Overview.md",
"content": "\n\n## 概述\n\n为了更加系统的学习，参考各类书籍和课程，以下将通过下列8方面展开，对Java技术栈进行总结。\n\n\n\n##### 目录结构\n\n1. ##### Java 基础\n\n - 基本概念\n - 基本类型与运算\n - 字符串与数组\n - 异常处理\n\n2. ##### Java 集合框架\n\n3. ##### Java 并发与线程\n\n - 多线程\n - 并发包\n\n4. ##### Java IO流\n\n - NIO\n - AIO\n - BIO\n\n5. ##### Java 虚拟机\n\n6. ##### 设计模式（常见8种）\n\n - 单例模式\n - 工厂模式\n - 观察者模式\n - 适配器模式\n - 模仿方法模式\n - 策略模式\n - 责任链模式\n - 装饰者模式\n\n7. ##### Web框架\n\n8. ##### 系统架构\n\n - Nginx\n - Docker\n - 负载均衡\n\n\n\n\n\n\n\n蒋蒋蒋蒋大仙的个人空间 - 哔哩哔哩 ( ゜- ゜)つロ 乾杯~ Bilibili\nhttps://space.bilibili.com/231379623/#/"
},
{
"path": "notes/JavaWeb/Hibernate.md",
"content": "> hibernate 美 /'haɪbɚnet/ vi. 过冬；（动物）冬眠；（人等）避寒\n\n\n\n\n\n"
},
{
"path": "notes/JavaWeb/Mybatis.md",
"content": "# 前言\n\n\n\n\n\n参考仓库：\n\n- [springmvc-mybatis-learning](https://github.com/brianway/springmvc-mybatis-learning)\n\n1. Spring、SpringMVC原理、流程\n\n1. Mybatis原理\n2. Hibernate了解吗，Mybatis和Hibernate的区别"
},
{
"path": "notes/JavaWeb/Spring.md",
"content": "\n\n[TOC]\n\n\n\n- [前言](#前言)\n- [一、基础概念](#一基础概念)\n - [1. JavaBean](#1-javabean)\n - [2. Bean](#2-bean)\n - [3. 传统Javabean与Spring中的bean的区别](#3-传统javabean与spring中的bean的区别)\n - [4. POJO](#4-pojo)\n- [二、Spring核心技术](#二spring核心技术)\n - [1. IOC（控制反转）](#1-ioc控制反转)\n - [1.1 什么是IOC](#11-什么是ioc)\n - [1.2 IoC能做什么](#12-ioc能做什么)\n - [1.3 IoC和DI](#13-ioc和di)\n - [1.4 IOC底层原理 (降低类之间的耦合度)](#14-ioc底层原理-降低类之间的耦合度)\n - [1.5 Spring中怎么用](#15-spring中怎么用)\n - [（1）配置文件方式](#1配置文件方式)\n - [（2）注解方式](#2注解方式)\n - [2. DI（依赖注入）](#2-di依赖注入)\n - [2.1 什么是依赖注入](#21-什么是依赖注入)\n - [2.2 为什么使用依赖注入](#22-为什么使用依赖注入)\n - [2.3 为什么要实现松耦合](#23-为什么要实现松耦合)\n - [2.4 IOC和DI区别](#24-ioc和di区别)\n - [2.5 依赖注入方式](#25-依赖注入方式)\n - [（1）使用set方法注入](#1使用set方法注入)\n - [（2）使用有参构造注入](#2使用有参构造注入)\n - [（3）注入对象类型属性](#3注入对象类型属性)\n - [（4）p名称空间注入](#4p名称空间注入)\n - [（5）注入复杂类型属性](#5注入复杂类型属性)\n - [3. AOP（面向切面编程）](#3-aop面向切面编程)\n - [3.1 什么是AOP](#31-什么是aop)\n - [3.2 底层原理](#32-底层原理)\n - [第一种 JDK 自带的动态代理技术](#第一种-jdk-自带的动态代理技术)\n - [第二种 CGLIB(CodeGenerationLibrary)是一个开源项目](#第二种-cglibcodegenerationlibrary是一个开源项目)\n - [3.3 AOP操作术语](#33-aop操作术语)\n - [3.4 Spring的AOP操作](#34-spring的aop操作)\n - [（1）AOP准备操作](#1aop准备操作)\n - [（2）使用表达式配置切入点](#2使用表达式配置切入点)\n - [3.5 使用xml实现AOP](#35-使用xml实现aop)\n - [3.6 使用注解实现AOP](#36-使用注解实现aop)\n - [3.7 为什么需要代理模式？](#37-为什么需要代理模式)\n - [3.8 静态代理](#38-静态代理)\n - [3.9 动态代理，使用JDK内置的Proxy实现](#39-动态代理使用jdk内置的proxy实现)\n - [3.10 动态代理，使用cglib实现](#310-动态代理使用cglib实现)\n - [4. Spring Ioc容器](#4-spring-ioc容器)\n - [4.1 Bean作用域](#41-bean作用域)\n - [4.2 Bean 的生命周期](#42-bean-的生命周期)\n - [4.3 BeanFactory 和ApplicationContext（Bean工厂和应用上下文）](#43-beanfactory-和applicationcontextbean工厂和应用上下文)\n\n\n\n# 前言\n\n为了更好的深入学习Spring核心技术，在这里整理了Spring相关的常见核心知识，和面试知识点，本文将通过浅显易懂的语言和代码实现，相信可以在最短的时间内进行巩固学习。\n\n\n\n本文参考：\n\n- [理解并实现一个IOC容器](https://github.com/biezhi/java-bible/blob/master/ioc/index.md)\n- [【源码实现】Java-Guide/Spring学习与面试.md at master · Snailclimb/Java-Guide](https://github.com/Snailclimb/Java-Guide/blob/master/%E4%B8%BB%E6%B5%81%E6%A1%86%E6%9E%B6/Spring%E5%AD%A6%E4%B9%A0%E4%B8%8E%E9%9D%A2%E8%AF%95.md)\n- [一起来谈谈 Spring AOP！ - 掘金](https://juejin.im/post/5aa7818af265da23844040c6)\n- [黑马程序员Spring2016学习笔记](https://github.com/Only-lezi/spring-learning/tree/master/spring-learning-article)\n- [Spring学习总结（二）——静态代理、JDK与CGLIB动态代理、AOP+IoC - 张果 - 博客园](http://www.cnblogs.com/best/p/5679656.html)\n- [Spring IoC有什么好处呢？ - 知乎](https://www.zhihu.com/question/23277575/answer/169698662)\n- [极客学院Spring Wiki](http://wiki.jikexueyuan.com/project/spring/transaction-management.html) \n- [【必读】Spring W3Cschool教程](https://www.w3cschool.cn/wkspring/f6pk1ic8.html) \n- [【必读】Java新手如何学习Spring、Struts、Hibernate三大框架？ - 知乎，深度好文](https://www.zhihu.com/question/21142149)\n \n\n\n\n个人的使用体会\n\n- **spring**：核心提供依赖注入\n- **spring mvc**： mvc框架\n- **spring boot**：说不太出什么感觉，跟mvc比就感觉配置少了好多\n- **spring cloud**：围绕微服务的一套东西 \n\n\n\nfrom 2018/7/27\n\n\n\n\n\n# 一、基础概念\n\n## 1. JavaBean\n\n**JavaBean是一种组件技术**，就好像你做了一个扳子，而这个扳子会在很多地方被拿去用，这个扳子也提供多种功能(你可以拿这个扳子扳、锤、撬等等)，而这个扳子就是一个组件。\n\n **JavaBean是一个遵循特定写法的Java类**，它通常具有如下特点：\n\n- 这个Java类必须具有一个无参的构造函数\n- 属性必须私有化。\n- 私有化的属性必须通过public类型的方法暴露给其它程序，并且方法的命名也必须遵守一定的命名规范。\n- 这个类应是可序列化的。（比如可以实现Serializable 接口，用于实现bean的持久性）\n\n许多开发者把JavaBean看作遵从特定命名约定的POJO。 简而言之，当一个POJO可序列化，有一个无参的构造函数，使用getter和setter方法来访问属性时，他就是一个JavaBean。 \n\n```java\npackage gacl.javabean.study;\n\n/**\n * @author gacl\n * Person类就是一个最简单的JavaBean\n */\npublic class Person {\n\n //Person类封装的私有属性\n // 姓名 String类型\n private String name;\n // 性别 String类型\n private String sex;\n // 年龄 int类型\n private int age;\n \n \n /**\n * 无参数构造方法\n */\n public Person() {\n \n }\n \n //Person类对外提供的用于访问私有属性的public方法\n public String getName() {\n return name;\n }\n public void setName(String name) {\n this.name = name;\n }\n public String getSex() {\n return sex;\n }\n public void setSex(String sex) {\n this.sex = sex;\n }\n public int getAge() {\n return age;\n }\n public void setAge(int age) {\n this.age = age;\n }\n}\n```\n\nJavaBean在J2EE开发中，通常用于封装数据，对于遵循以上写法的JavaBean组件，其它程序可以通过反射技术实例化JavaBean对象，并且通过反射那些遵守命名规范的方法，从而获知JavaBean的属性，进而调用其属性保存数据。 \n\n\n\n## 2. Bean\n\n- **Bean的中文含义是“豆子”，Bean的含义是可重复使用的Java组件**。所谓组件就是一个由可以自行进行内部管理的一个或几个类所组成、外界不了解其内部信息和运行方式的群体。使用它的对象只能通过接口来操作。\n- Bean并不需要继承特别的基类(BaseClass)或实现特定的接口(Interface)。Bean的编写规范使Bean的容器(Container)能够分析一个Java类文件，并将其方法(Methods)翻译成属性(Properties)，即把Java类作为一个Bean类使用。Bean的编写规范包括Bean类的构造方法、定义属性和访问方法编写规则。\n- Java Bean是基于Java的组件模型，由**属性、方法和事件**3部分组成。在该模型中，JavaBean可以被修改或与其他组件结合以生成新组件或完整的程序。它是一种Java类，通过封装成为具有某种功能或者处理某个业务的对象。因此，也可以通过嵌在JSP页面内的Java代码访问Bean及其属性。\n\n\n\n## 3. 传统Javabean与Spring中的bean的区别\n\nJavabean已经没人用了\n\nspringbean可以说是javabean的发展, 但已经完全不是一回事儿了\n\n \n\n**用处不同：**传统javabean更多地作为值传递参数，而spring中的bean用处几乎无处不在，任何组件都可以被称为bean。\n\n**写法不同：**传统javabean作为值对象，要求每个属性都提供getter和setter方法；但spring中的bean只需为接受设值注入的属性提供setter方法。\n\n**生命周期不同：**传统javabean作为值对象传递，不接受任何容器管理其生命周期；spring中的bean有spring管理其生命周期行为。\n\n所有可以被spring容器实例化并管理的java类都可以称为bean。\n\n原来服务器处理页面返回的值都是直接使用request对象，后来增加了javabean来管理对象，所有页面值只要是和javabean对应，就可以用类.GET属性方法来获取值。javabean不只可以传参数，也可以处理数据，相当与把一个服务器执行的类放到了页面上，使对象管理相对不那么乱（对比asp的时候所有内容都在页面上完成）。\n\nspring中的bean，是通过配置文件、javaconfig等的设置，有spring自动实例化，用完后自动销毁的对象。让我们只需要在用的时候使用对象就可以，不用考虑如果创建类对象（这就是spring的注入）。一般是用在服务器端代码的执行上。\n\n\n\n## 4. POJO\n\nPOJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，**具有一部分getter/setter方法的那种类就可以称作POJO**，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规范，理论上讲，任何一个 Java 类都可以是一个 Bean 。但通常情况下，由于 Java Bean 是被容器所创建（如 Tomcat) 的，所以 Java Bean 应具有一个无参的构造器，另外，通常 Java Bean 还要实现 Serializable 接口用于实现 Bean 的持久性。 Java Bean 是不能被跨进程访问的 \n\n\n\n一般在web应用程序中建立一个数据库的映射对象时，我们只能称它为POJO。\nPOJO(Plain Old Java Object)这个名字用来强调它是一个普通java对象，而不是一个特殊的对象。\n2005年11月时，“POJO”主要用来指代那些没用遵从特定的Java对象模型，约定或框架如EJB的Java对象.\n理想地讲，一个POJO是一个不受任何限制的Java对象（除了Java语言规范）。例如一个POJO不应该是\n\n 1. 扩展预定的类，如 public class Foo extends javax.servlet.http.HttpServlet { ...\n \n 2. 实现预定的接口，如 public class Bar implements javax.ejb.EntityBean { ...\n \n 3. 包含预定的标注，如 @javax.ejb.Entity public class Baz{ ...\n 然后，因为技术上的困难及其他原因，许多兼容POJO风格的软件产品或框架事实上仍然要求使用预定的标注，譬如用于更方便的持久化。\n\n\n\n\n\n# 二、Spring核心技术\n\n## 1. IOC（控制反转）\n\n### 1.1 什么是IOC\n\nIoC(Inversion of Control)，意为控制反转，不是什么技术，而是一种设计思想。Ioc意味着**将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制**。\n\n如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：\n\n- **谁控制谁，控制什么**：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。\n- **为何是反转，哪些方面反转了**：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。\n\n**简单来说**\n\n> 正转：比如有一个类，在类里面有方法（不是静态的方法），调用类里面的方法，创建类的对象，使用对象调用方法，创建类对象的过程，需要new出来对象\n>\n> 反转：把对象的创建不是通过new方式实现，而是交给Spring配置创建类对象\n\n\n\n【必读】IOC深度理解，请转向：[深入浅出IOC](../JavaWeb/深入浅出IOC.md)\n\n\n\n\n### 1.2 IoC能做什么\n\nIoC 不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。\n\n其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。\n\nIoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。\n\n### 1.3 IoC和DI\n\n**DI—Dependency Injection，即“依赖注入”**：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。\n\n理解DI的关键是：“**谁依赖谁，为什么需要依赖，谁注入谁，注入了什么**”，那我们来深入分析一下：\n\n- **谁依赖于谁：** 当然是应用程序依赖于IoC容器；\n- **为什么需要依赖：** 应用程序需要IoC容器来提供对象需要的外部资源；\n- **谁注入谁：** 很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；\n- **注入了什么：** 就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。\n\nIoC和DI由什么关系呢？其实它们是同一个概念的不同角度描述，由于控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系），所以2004年大师级人物Martin Fowler又给出了一个新的名字：“依赖注入”，相对IoC 而言，**“依赖注入”**明确描述了**“被注入对象依赖IoC容器配置依赖对象”**。\n\n对于Spring Ioc这个核心概念，我相信每一个学习Spring的人都会有自己的理解。这种概念上的理解没有绝对的标准答案，仁者见仁智者见智。 理解了IoC和DI的概念后，一切都将变得简单明了，剩下的工作只是在框架中堆积木而已，下一节来看看Spring是怎么用的\n\n\n\n### 1.4 IOC底层原理 (降低类之间的耦合度)\n\n- 底层原理使用技术\n - xml配置文件\n - dom4j解决xml\n - 工厂设计模式\n - 反射\n- 原理\n\n```java\n//伪代码\n//需要实例化的类\npublic class UserService{\n}\n\npublic class UserServlet{\n //得到UserService的对象\n //原始的做法：new 对象(); 来创建\n \n //经过spring后\n UserFactory.getService(); //(下面两步的代码调用的)\n}\n```\n\n**第一步：创建xml配置文件，配置要创建的对象类**\n\n```xml\n\n```\n\n**第二步：创建工厂类，使用dom4j解析配置文件+反射**\n\n```java\npublic class Factory {\n //返回UserService对象的方法\n public static UserService getService() {\n //1.使用dom4j来解析xml文件 \n //根据id值userService，得到id值对应的class属性值\n String classValue = \"class属性值\";\n //2.使用反射来创建类对象\n Class clazz = Class.forName(classValue)；\n //创建类的对象\n UserService service = clazz.newInstance();\n return service;\n }\n}\n```\n\n \n\n超详细原理讲解：[java-bible/4.principle.md at master · biezhi/java-bible](https://github.com/biezhi/java-bible/blob/master/ioc/4.principle.md)\n\n\n\n\t \n```\n\n`Lol` 类是这样的：\n\n```java\npublic class Lol {\n\n\tprivate String name;\n\t\n\tpublic Lol() {\n\t}\n\t\n\tpublic void gank(){\n\t\tSystem.out.println(this.name + \"在gank!!\");\n\t}\n\t\n\tpublic String getName() {\n\t\treturn name;\n\t}\n\n\tpublic void setName(String name) {\n\t\tthis.name = name;\n\t}\n}\n```\n\n上面的代码运行结果自然是 `剑圣在gank!!`。\n\n#### （2）注解方式\n\nSpring更高级的用法，在3.0版本之后有了基于Annotation的注入实现，为毛每次都要配置 `Xml` 看到都蛋疼。。\n\n首先还是要在 `xml` 中配置启用注解方式\n\n```xml\n\n\n 1234567\n```\n\n#### （2）使用有参构造注入\n\n```java\npublic class Person {\n private String pname;\n\n public void setPname(String pname) {\n this.pname = pname;\n }\n}\n```\n\n```xml\n\n \n \n```\n\n#### （3）注入对象类型属性 \n\n- 创建service和dao类，在service中得到dao \n\n具体实现过程 \n\n- 在service中把dao作为属性，生成dao的set方法\n\n```java\npublic class UserService {\n // 1.定义UserDao类型属性\n private UserDao userDao;\n\n // 2.生成set方法\n public void setUserDao(UserDao userDao) {\n this.userDao = userDao;\n }\n}\n```\n\n1. 配置文件注入关系\n\n```java\n\n \n \n \n \n 12345678\n```\n\n#### （4）p名称空间注入 \n\n\n\n\n\n#### （5）注入复杂类型属性\n\n```java\n\n \n \n \n \n aaa \n bbb \n ccc \n
\n \n \n \n qqq \n www \n eee \n
\n \n \n \n \n \n \n \n admin \n admin \n \n \n \n```\n\n\n\n## 3. AOP（面向切面编程）\n\n\n\n\n\n 12345678\n```\n\n#### （2）使用表达式配置切入点\n\n1. 切入点：实际增强的方法\n2. 常用的表达式\n execution(<访问修饰符>? <返回类型> <方法名>(<参数>)<异常>)\n （1）对包内的add方法进行增强\n `execution(* cn.blinkit.aop.Book.add(..))`\n （2）* 是对类里面的所有方法进行增强\n `execution(* cn.blinkit.aop.Book.*(..))`\n （3）*.* 是所有的类中的方法进行增强\n `execution(* *.*(..))`\n （4）匹配所有save开头的方法\n `execution(* save*(..))`\n\n\n\n### 3.5 使用xml实现AOP\n\n**aop配置代码：** Book\n\n```java\npublic class Book {\n public void add() {\n System.out.println(\"add......\");\n }\n}\n```\n\nMyBook\n\n```java\npublic class MyBook {\n public void before1() {\n System.out.println(\"前置增强......\");\n }\n\n public void after1() {\n System.out.println(\"后置增强......\");\n }\n\n //环绕通知\n public void around1(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {\n //方法之前\n System.out.println(\"方法之前.....\");\n\n //执行被增强的方法\n proceedingJoinPoint.proceed();\n\n //方法之后\n System.out.println(\"方法之后......\");\n\n }\n}\n```\n\nxml配置\n\n```xml\n \n \n \n \n \n \n \n```\n\n测试代码\n\n```java\npublic class AOPTest {\n @Test\n public void testBook() {\n ApplicationContext context = new ClassPathXmlApplicationContext(\"cn/blinkit/aop/spring-aop.xml\");\n Book book = (Book) context.getBean(\"book\");\n book.add();\n\n }\n}\n```\n\n\n\n### 3.6 使用注解实现AOP\n\n1. 创建对象\n (1)创建Book和MyBook **（增强类）** 对象\n\n2. 在spring核心配置文件中，开启aop操作\n 具体操作见xml配置文件代码：\n\n ```xml\n \n \n \n \n \n ```\n\n3. 在增强类上面使用注解完成aop操作\n （1）类上面加上`@Aspect`\n （2）方法上面加上\n `@Before(value = \"execution(* cn.blinkit.aop.anno.Book.*(..))\")`\n `@After(value = \"表达式\")`\n `@Around(value = \"表达式\")`等...\n\n4. \n\n**Book**\n\n```java\npublic class Book {\n public void add() {\n System.out.println(\"add...注解版本...\");\n }\n}\n```\n\n**MyBook增强类**\n\n```java\n@Aspect\npublic class MyBook {\n //在方法上面使用注解完成增强配置\n @Before(value = \"execution(* cn.blinkit.aop.anno.Book.*(..))\")\n public void before1() {\n System.out.println(\"前置增强...注解版本...\");\n }\n\n @After(value = \"execution(* cn.blinkit.aop.anno.Book.*(..))\")\n public void after1() {\n System.out.println(\"后置增强...注解版本...\");\n }\n\n //环绕通知\n @Around(value = \"execution(* cn.blinkit.aop.anno.Book.*(..))\")\n public void around1(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {\n //方法之前\n System.out.println(\"方法之前...注解版本...\");\n\n //执行被增强的方法\n proceedingJoinPoint.proceed();\n\n //方法之后\n System.out.println(\"方法之后...注解版本...\");\n\n }\n}\n```\n\n**xml配置**\n\n```xml\n\n () {\n @Override\n public int compare(Interval o1, Interval o2) {\n return o1.end - o2.end;\n }\n });\n ```\n\n **投飞镖刺破气球** \n\n [452. Minimum Number of Arrows to Burst Balloons (Medium)](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)\n\n ```\n Input:\n [[10,16], [2,8], [1,6], [7,12]]\n \n Output:\n 2\n ```\n\n 题目描述：气球在一个水平数轴上摆放，可以重叠，飞镖垂直投向坐标轴，使得路径上的气球都会刺破。求解最小的投飞镖次数使所有气球都被刺破。\n\n 也是计算不重叠的区间个数，不过和 Non-overlapping Intervals 的区别在于，[1, 2] 和 [2, 3] 在本题中算是重叠区间。\n\n ```java\n public int findMinArrowShots(int[][] points) {\n if (points.length == 0) {\n return 0;\n }\n Arrays.sort(points, Comparator.comparingInt(o -> o[1]));\n int cnt = 1, end = points[0][1];\n for (int i = 1; i < points.length; i++) {\n if (points[i][0] <= end) {\n continue;\n }\n cnt++;\n end = points[i][1];\n }\n return cnt;\n }\n ```\n\n **根据身高和序号重组队列** \n\n [406. Queue Reconstruction by Height(Medium)](https://leetcode.com/problems/queue-reconstruction-by-height/description/)\n\n ```html\n Input:\n [[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]\n \n Output:\n [[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]\n ```\n\n 题目描述：一个学生用两个分量 (h, k) 描述，h 表示身高，k 表示排在前面的有 k 个学生的身高比他高或者和他一样高。\n\n 为了在每次插入操作时不影响后续的操作，身高较高的学生应该先做插入操作，否则身高较小的学生原先正确插入第 k 个位置可能会变成第 k+1 个位置。\n\n 身高降序、k 值升序，然后按排好序的顺序插入队列的第 k 个位置中。\n\n ```java\n public int[][] reconstructQueue(int[][] people) {\n if (people == null || people.length == 0 || people[0].length == 0) {\n return new int[0][0];\n }\n Arrays.sort(people, (a, b) -> (a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]));\n List queue = new ArrayList<>();\n for (int[] p : people) {\n queue.add(p[1], p);\n }\n return queue.toArray(new int[queue.size()][]);\n }\n ```\n\n **分隔字符串使同种字符出现在一起** \n\n [763. Partition Labels (Medium)](https://leetcode.com/problems/partition-labels/description/)\n\n ```html\n Input: S = \"ababcbacadefegdehijhklij\"\n Output: [9,7,8]\n Explanation:\n The partition is \"ababcbaca\", \"defegde\", \"hijhklij\".\n This is a partition so that each letter appears in at most one part.\n A partition like \"ababcbacadefegde\", \"hijhklij\" is incorrect, because it splits S into less parts.\n ```\n\n ```java\n public List partitionLabels(String S) {\n int[] lastIndexsOfChar = new int[26];\n for (int i = 0; i < S.length(); i++) {\n lastIndexsOfChar[char2Index(S.charAt(i))] = i;\n }\n List partitions = new ArrayList<>();\n int firstIndex = 0;\n while (firstIndex < S.length()) {\n int lastIndex = firstIndex;\n for (int i = firstIndex; i < S.length() && i <= lastIndex; i++) {\n int index = lastIndexsOfChar[char2Index(S.charAt(i))];\n if (index > lastIndex) {\n lastIndex = index;\n }\n }\n partitions.add(lastIndex - firstIndex + 1);\n firstIndex = lastIndex + 1;\n }\n return partitions;\n }\n \n private int char2Index(char c) {\n return c - 'a';\n }\n ```\n\n\n **种植花朵** \n\n [605. Can Place Flowers (Easy)](https://leetcode.com/problems/can-place-flowers/description/)\n\n ```html\n Input: flowerbed = [1,0,0,0,1], n = 1\n Output: True\n ```\n\n 题目描述：花朵之间至少需要一个单位的间隔，求解是否能种下 n 朵花。\n\n ```java\n public boolean canPlaceFlowers(int[] flowerbed, int n) {\n int len = flowerbed.length;\n int cnt = 0;\n for (int i = 0; i < len && cnt < n; i++) {\n if (flowerbed[i] == 1) {\n continue;\n }\n int pre = i == 0 ? 0 : flowerbed[i - 1];\n int next = i == len - 1 ? 0 : flowerbed[i + 1];\n if (pre == 0 && next == 0) {\n cnt++;\n flowerbed[i] = 1;\n }\n }\n return cnt >= n;\n }\n ```\n\n **判断是否为子序列** \n\n [392. Is Subsequence (Medium)](https://leetcode.com/problems/is-subsequence/description/)\n\n ```html\n s = \"abc\", t = \"ahbgdc\"\n Return true.\n ```\n\n ```java\n public boolean isSubsequence(String s, String t) {\n int index = -1;\n for (char c : s.toCharArray()) {\n index = t.indexOf(c, index + 1);\n if (index == -1) {\n return false;\n }\n }\n return true;\n }\n ```\n\n **修改一个数成为非递减数组** \n\n [665. Non-decreasing Array (Easy)](https://leetcode.com/problems/non-decreasing-array/description/)\n\n ```html\n Input: [4,2,3]\n Output: True\n Explanation: You could modify the first 4 to 1 to get a non-decreasing array.\n ```\n\n 题目描述：判断一个数组能不能只修改一个数就成为非递减数组。\n\n 在出现 nums[i] < nums[i - 1] 时，需要考虑的是应该修改数组的哪个数，使得本次修改能使 i 之前的数组成为非递减数组，并且 **不影响后续的操作** 。优先考虑令 nums[i - 1] = nums[i]，因为如果修改 nums[i] = nums[i - 1] 的话，那么 nums[i] 这个数会变大，就有可能比 nums[i + 1] 大，从而影响了后续操作。还有一个比较特别的情况就是 nums[i] < nums[i - 2]，只修改 nums[i - 1] = nums[i] 不能使数组成为非递减数组，只能修改 nums[i] = nums[i - 1]。\n\n ```java\n public boolean checkPossibility(int[] nums) {\n int cnt = 0;\n for (int i = 1; i < nums.length && cnt < 2; i++) {\n if (nums[i] >= nums[i - 1]) {\n continue;\n }\n cnt++;\n if (i - 2 >= 0 && nums[i - 2] > nums[i]) {\n nums[i] = nums[i - 1];\n } else {\n nums[i - 1] = nums[i];\n }\n }\n return cnt <= 1;\n }\n ```\n\n **股票的最大收益** \n\n [122. Best Time to Buy and Sell Stock II (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)\n\n 题目描述：一次股票交易包含买入和卖出，多个交易之间不能交叉进行。\n\n 对于 [a, b, c, d]，如果有 a <= b <= c <= d ，那么最大收益为 d - a。而 d - a = (d - c) + (c - b) + (b - a) ，因此当访问到一个 prices[i] 且 prices[i] - prices[i-1] > 0，那么就把 prices[i] - prices[i-1] 添加到收益中，从而在局部最优的情况下也保证全局最优。\n\n ```java\n public int maxProfit(int[] prices) {\n int profit = 0;\n for (int i = 1; i < prices.length; i++) {\n if (prices[i] > prices[i - 1]) {\n profit += (prices[i] - prices[i - 1]);\n }\n }\n return profit;\n }\n ```\n\n ## 双指针\n\n 双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。\n\n **有序数组的 Two Sum** \n\n [Leetcode ：167. Two Sum II - Input array is sorted (Easy)](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/description/)\n\n ```html\n Input: numbers={2, 7, 11, 15}, target=9\n Output: index1=1, index2=2\n ```\n\n 题目描述：在有序数组中找出两个数，使它们的和为 target。\n\n 使用双指针，一个指针指向值较小的元素，一个指针指向值较大的元素。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。\n\n 如果两个指针指向元素的和 sum == target，那么得到要求的结果；如果 sum > target，移动较大的元素，使 sum 变小一些；如果 sum < target，移动较小的元素，使 sum 变大一些。\n\n ```java\n public int[] twoSum(int[] numbers, int target) {\n int i = 0, j = numbers.length - 1;\n while (i < j) {\n int sum = numbers[i] + numbers[j];\n if (sum == target) {\n return new int[]{i + 1, j + 1};\n } else if (sum < target) {\n i++;\n } else {\n j--;\n }\n }\n return null;\n }\n ```\n\n **两数平方和** \n\n [633. Sum of Square Numbers (Easy)](https://leetcode.com/problems/sum-of-square-numbers/description/)\n\n ```html\n Input: 5\n Output: True\n Explanation: 1 * 1 + 2 * 2 = 5\n ```\n\n 题目描述：判断一个数是否为两个数的平方和，例如 5 = 12 + 22 。\n\n ```java\n public boolean judgeSquareSum(int c) {\n int i = 0, j = (int) Math.sqrt(c);\n while (i <= j) {\n int powSum = i * i + j * j;\n if (powSum == c) {\n return true;\n } else if (powSum > c) {\n j--;\n } else {\n i++;\n }\n }\n return false;\n }\n ```\n\n **反转字符串中的元音字符** \n\n [345. Reverse Vowels of a String (Easy)](https://leetcode.com/problems/reverse-vowels-of-a-string/description/)\n\n ```html\n Given s = \"leetcode\", return \"leotcede\".\n ```\n\n 使用双指针，指向待反转的两个元音字符，一个指针从头向尾遍历，一个指针从尾到头遍历。\n\n ```java\n private final static HashSet vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));\n \n public String reverseVowels(String s) {\n int i = 0, j = s.length() - 1;\n char[] result = new char[s.length()];\n while (i <= j) {\n char ci = s.charAt(i);\n char cj = s.charAt(j);\n if (!vowels.contains(ci)) {\n result[i++] = ci;\n } else if (!vowels.contains(cj)) {\n result[j--] = cj;\n } else {\n result[i++] = cj;\n result[j--] = ci;\n }\n }\n return new String(result);\n }\n ```\n\n **回文字符串** \n\n [680. Valid Palindrome II (Easy)](https://leetcode.com/problems/valid-palindrome-ii/description/)\n\n ```html\n Input: \"abca\"\n Output: True\n Explanation: You could delete the character 'c'.\n ```\n\n 题目描述：可以删除一个字符，判断是否能构成回文字符串。\n\n ```java\n public boolean validPalindrome(String s) {\n int i = -1, j = s.length();\n while (++i < --j) {\n if (s.charAt(i) != s.charAt(j)) {\n return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);\n }\n }\n return true;\n }\n \n private boolean isPalindrome(String s, int i, int j) {\n while (i < j) {\n if (s.charAt(i++) != s.charAt(j--)) {\n return false;\n }\n }\n return true;\n }\n ```\n\n **归并两个有序数组** \n\n [88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)\n\n ```html\n Input:\n nums1 = [1,2,3,0,0,0], m = 3\n nums2 = [2,5,6], n = 3\n \n Output: [1,2,2,3,5,6]\n ```\n\n 题目描述：把归并结果存到第一个数组上。\n\n 需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值\n\n ```java\n public void merge(int[] nums1, int m, int[] nums2, int n) {\n int index1 = m - 1, index2 = n - 1;\n int indexMerge = m + n - 1;\n while (index1 >= 0 || index2 >= 0) {\n if (index1 < 0) {\n nums1[indexMerge--] = nums2[index2--];\n } else if (index2 < 0) {\n nums1[indexMerge--] = nums1[index1--];\n } else if (nums1[index1] > nums2[index2]) {\n nums1[indexMerge--] = nums1[index1--];\n } else {\n nums1[indexMerge--] = nums2[index2--];\n }\n }\n }\n ```\n\n **判断链表是否存在环** \n\n [141. Linked List Cycle (Easy)](https://leetcode.com/problems/linked-list-cycle/description/)\n\n 使用双指针，一个指针每次移动一个节点，一个指针每次移动两个节点，如果存在环，那么这两个指针一定会相遇。\n\n ```java\n public boolean hasCycle(ListNode head) {\n if (head == null) {\n return false;\n }\n ListNode l1 = head, l2 = head.next;\n while (l1 != null && l2 != null && l2.next != null) {\n if (l1 == l2) {\n return true;\n }\n l1 = l1.next;\n l2 = l2.next.next;\n }\n return false;\n }\n ```\n\n **最长子序列** \n\n [524. Longest Word in Dictionary through Deleting (Medium)](https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/description/)\n\n ```\n Input:\n s = \"abpcplea\", d = [\"ale\",\"apple\",\"monkey\",\"plea\"]\n \n Output:\n \"apple\"\n ```\n\n 题目描述：删除 s 中的一些字符，使得它构成字符串列表 d 中的一个字符串，找出能构成的最长字符串。如果有多个相同长度的结果，返回按字典序排序的最大字符串。\n\n ```java\n public String findLongestWord(String s, List d) {\n String longestWord = \"\";\n for (String target : d) {\n int l1 = longestWord.length(), l2 = target.length();\n if (l1 > l2 || (l1 == l2 && longestWord.compareTo(target) < 0)) {\n continue;\n }\n if (isValid(s, target)) {\n longestWord = target;\n }\n }\n return longestWord;\n }\n \n private boolean isValid(String s, String target) {\n int i = 0, j = 0;\n while (i < s.length() && j < target.length()) {\n if (s.charAt(i) == target.charAt(j)) {\n j++;\n }\n i++;\n }\n return j == target.length();\n }\n ```\n\n ## 排序\n\n ### 快速选择\n\n 一般用于求解 **Kth Element** 问题，可以在 O(N) 时间复杂度，O(1) 空间复杂度完成求解工作。\n\n 与快速排序一样，快速选择一般需要先打乱数组，否则最坏情况下时间复杂度为 O(N2 )。\n\n ### 堆排序\n\n 堆排序用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。当然它也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。\n\n **Kth Element** \n\n [215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)\n\n **排序** ：时间复杂度 O(NlogN)，空间复杂度 O(1)\n\n ```java\n public int findKthLargest(int[] nums, int k) {\n Arrays.sort(nums);\n return nums[nums.length - k];\n }\n ```\n\n **堆排序** ：时间复杂度 O(NlogK)，空间复杂度 O(K)。\n\n ```java\n public int findKthLargest(int[] nums, int k) {\n PriorityQueue pq = new PriorityQueue<>(); // 小顶堆\n for (int val : nums) {\n pq.add(val);\n if (pq.size() > k) // 维护堆的大小为 K\n pq.poll();\n }\n return pq.peek();\n }\n ```\n\n **快速选择** ：时间复杂度 O(N)，空间复杂度 O(1)\n\n ```java\n public int findKthLargest(int[] nums, int k) {\n k = nums.length - k;\n int l = 0, h = nums.length - 1;\n while (l < h) {\n int j = partition(nums, l, h);\n if (j == k) {\n break;\n } else if (j < k) {\n l = j + 1;\n } else {\n h = j - 1;\n }\n }\n return nums[k];\n }\n \n private int partition(int[] a, int l, int h) {\n int i = l, j = h + 1;\n while (true) {\n while (a[++i] < a[l] && i < h) ;\n while (a[--j] > a[l] && j > l) ;\n if (i >= j) {\n break;\n }\n swap(a, i, j);\n }\n swap(a, l, j);\n return j;\n }\n \n private void swap(int[] a, int i, int j) {\n int t = a[i];\n a[i] = a[j];\n a[j] = t;\n }\n ```\n\n ### 桶排序\n\n **出现频率最多的 k 个数** \n\n [347. Top K Frequent Elements (Medium)](https://leetcode.com/problems/top-k-frequent-elements/description/)\n\n ```html\n Given [1,1,1,2,2,3] and k = 2, return [1,2].\n ```\n\n 设置若干个桶，每个桶存储出现频率相同的数，并且桶的下标代表桶中数出现的频率，即第 i 个桶中存储的数出现的频率为 i。把数都放到桶之后，从后向前遍历桶，最先得到的 k 个数就是出现频率最多的的 k 个数。\n\n ```java\n public List topKFrequent(int[] nums, int k) {\n Map frequencyForNum = new HashMap<>();\n for (int num : nums) {\n frequencyForNum.put(num, frequencyForNum.getOrDefault(num, 0) + 1);\n }\n List[] buckets = new ArrayList[nums.length + 1];\n for (int key : frequencyForNum.keySet()) {\n int frequency = frequencyForNum.get(key);\n if (buckets[frequency] == null) {\n buckets[frequency] = new ArrayList<>();\n }\n buckets[frequency].add(key);\n }\n List topK = new ArrayList<>();\n for (int i = buckets.length - 1; i >= 0 && topK.size() < k; i--) {\n if (buckets[i] != null) {\n topK.addAll(buckets[i]);\n }\n }\n return topK;\n }\n ```\n\n **按照字符出现次数对字符串排序** \n\n [451. Sort Characters By Frequency (Medium)](https://leetcode.com/problems/sort-characters-by-frequency/description/)\n\n ```html\n Input:\n \"tree\"\n \n Output:\n \"eert\"\n \n Explanation:\n 'e' appears twice while 'r' and 't' both appear once.\n So 'e' must appear before both 'r' and 't'. Therefore \"eetr\" is also a valid answer.\n ```\n\n ```java\n public String frequencySort(String s) {\n Map frequencyForNum = new HashMap<>();\n for (char c : s.toCharArray())\n frequencyForNum.put(c, frequencyForNum.getOrDefault(c, 0) + 1);\n \n List[] frequencyBucket = new ArrayList[s.length() + 1];\n for (char c : frequencyForNum.keySet()) {\n int f = frequencyForNum.get(c);\n if (frequencyBucket[f] == null) {\n frequencyBucket[f] = new ArrayList<>();\n }\n frequencyBucket[f].add(c);\n }\n StringBuilder str = new StringBuilder();\n for (int i = frequencyBucket.length - 1; i >= 0; i--) {\n if (frequencyBucket[i] == null) {\n continue;\n }\n for (char c : frequencyBucket[i]) {\n for (int j = 0; j < i; j++) {\n str.append(c);\n }\n }\n }\n return str.toString();\n }\n ```\n\n ### 荷兰国旗问题\n\n 荷兰国旗包含三种颜色：红、白、蓝。有这三种颜色的球，算法的目标是将这三种球按颜色顺序正确地排列。\n\n 它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。\n\n i 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di <=dj 。利用这个结论，可以求解最短路径等 **最优解** 问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径。\n\n 在程序实现 BFS 时需要考虑以下问题：\n\n - 队列：用来存储每一轮遍历得到的节点；\n - 标记：对于遍历过的节点，应该将它标记，防止重复遍历。\n\n **计算在网格中从原点到特定点的最短路径长度** \n\n ```html\n [[1,1,0,1],\n [1,0,1,0],\n [1,1,1,1],\n [1,0,1,1]]\n ```\n\n 1 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。\n\n ```java\n public int minPathLength(int[][] grids, int tr, int tc) {\n final int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};\n final int m = grids.length, n = grids[0].length;\n Queue> queue = new LinkedList<>();\n queue.add(new Pair<>(0, 0));\n int pathLength = 0;\n while (!queue.isEmpty()) {\n int size = queue.size();\n pathLength++;\n while (size-- > 0) {\n Pair cur = queue.poll();\n for (int[] d : direction) {\n int nr = cur.getKey() + d[0], nc = cur.getValue() + d[1];\n Pair next = new Pair<>(nr, nc);\n if (next.getKey() < 0 || next.getValue() >= m\n || next.getKey() < 0 || next.getValue() >= n) {\n \n continue;\n }\n grids[next.getKey()][next.getValue()] = 0; // 标记\n if (next.getKey() == tr && next.getValue() == tc) {\n return pathLength;\n }\n queue.add(next);\n }\n }\n }\n return -1;\n }\n ```\n\n **组成整数的最小平方数数量** \n\n [279. Perfect Squares (Medium)](https://leetcode.com/problems/perfect-squares/description/)\n\n ```html\n For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.\n ```\n\n 可以将每个整数看成图中的一个节点，如果两个整数之差为一个平方数，那么这两个整数所在的节点就有一条边。\n\n 要求解最小的平方数数量，就是求解从节点 n 到节点 0 的最短路径。\n\n 本题也可以用动态规划求解，在之后动态规划部分中会再次出现。\n\n ```java\n public int numSquares(int n) {\n List squares = generateSquares(n);\n Queue queue = new LinkedList<>();\n boolean[] marked = new boolean[n + 1];\n queue.add(n);\n marked[n] = true;\n int level = 0;\n while (!queue.isEmpty()) {\n int size = queue.size();\n level++;\n while (size-- > 0) {\n int cur = queue.poll();\n for (int s : squares) {\n int next = cur - s;\n if (next < 0) {\n break;\n }\n if (next == 0) {\n return level;\n }\n if (marked[next]) {\n continue;\n }\n marked[next] = true;\n queue.add(cur - s);\n }\n }\n }\n return n;\n }\n \n /**\n * 生成小于 n 的平方数序列\n * @return 1,4,9,...\n */\n private List generateSquares(int n) {\n List squares = new ArrayList<>();\n int square = 1;\n int diff = 3;\n while (square <= n) {\n squares.add(square);\n square += diff;\n diff += 2;\n }\n return squares;\n }\n ```\n\n **最短单词路径** \n\n [127. Word Ladder (Medium)](https://leetcode.com/problems/word-ladder/description/)\n\n ```html\n Input:\n beginWord = \"hit\",\n endWord = \"cog\",\n wordList = [\"hot\",\"dot\",\"dog\",\"lot\",\"log\",\"cog\"]\n \n Output: 5\n \n Explanation: As one shortest transformation is \"hit\" -> \"hot\" -> \"dot\" -> \"dog\" -> \"cog\",\n return its length 5.\n ```\n\n ```html\n Input:\n beginWord = \"hit\"\n endWord = \"cog\"\n wordList = [\"hot\",\"dot\",\"dog\",\"lot\",\"log\"]\n \n Output: 0\n \n Explanation: The endWord \"cog\" is not in wordList, therefore no possible transformation.\n ```\n\n 找出一条从 beginWord 到 endWord 的最短路径，每次移动规定为改变一个字符，并且改变之后的字符串必须在 wordList 中。\n\n ```java\n public int ladderLength(String beginWord, String endWord, List wordList) {\n wordList.add(beginWord);\n int N = wordList.size();\n int start = N - 1;\n int end = 0;\n while (end < N && !wordList.get(end).equals(endWord)) {\n end++;\n }\n if (end == N) {\n return 0;\n }\n List[] graphic = buildGraphic(wordList);\n return getShortestPath(graphic, start, end);\n }\n \n private List[] buildGraphic(List wordList) {\n int N = wordList.size();\n List[] graphic = new List[N];\n for (int i = 0; i < N; i++) {\n graphic[i] = new ArrayList<>();\n for (int j = 0; j < N; j++) {\n if (isConnect(wordList.get(i), wordList.get(j))) {\n graphic[i].add(j);\n }\n }\n }\n return graphic;\n }\n \n private boolean isConnect(String s1, String s2) {\n int diffCnt = 0;\n for (int i = 0; i < s1.length() && diffCnt <= 1; i++) {\n if (s1.charAt(i) != s2.charAt(i)) {\n diffCnt++;\n }\n }\n return diffCnt == 1;\n }\n \n private int getShortestPath(List[] graphic, int start, int end) {\n Queue queue = new LinkedList<>();\n boolean[] marked = new boolean[graphic.length];\n queue.add(start);\n marked[start] = true;\n int path = 1;\n while (!queue.isEmpty()) {\n int size = queue.size();\n path++;\n while (size-- > 0) {\n int cur = queue.poll();\n for (int next : graphic[cur]) {\n if (next == end) {\n return path;\n }\n if (marked[next]) {\n continue;\n }\n marked[next] = true;\n queue.add(next);\n }\n }\n }\n return 0;\n }\n ```\n\n ### DFS\n\n pacificAtlantic(int[][] matrix) {\n List ret = new ArrayList<>();\n if (matrix == null || matrix.length == 0) {\n return ret;\n }\n \n m = matrix.length;\n n = matrix[0].length;\n this.matrix = matrix;\n boolean[][] canReachP = new boolean[m][n];\n boolean[][] canReachA = new boolean[m][n];\n \n for (int i = 0; i < m; i++) {\n dfs(i, 0, canReachP);\n dfs(i, n - 1, canReachA);\n }\n for (int i = 0; i < n; i++) {\n dfs(0, i, canReachP);\n dfs(m - 1, i, canReachA);\n }\n \n for (int i = 0; i < m; i++) {\n for (int j = 0; j < n; j++) {\n if (canReachP[i][j] && canReachA[i][j]) {\n ret.add(new int[]{i, j});\n }\n }\n }\n \n return ret;\n }\n \n private void dfs(int r, int c, boolean[][] canReach) {\n if (canReach[r][c]) {\n return;\n }\n canReach[r][c] = true;\n for (int[] d : direction) {\n int nextR = d[0] + r;\n int nextC = d[1] + c;\n if (nextR < 0 || nextR >= m || nextC < 0 || nextC >= n\n || matrix[r][c] > matrix[nextR][nextC]) {\n \n continue;\n }\n dfs(nextR, nextC, canReach);\n }\n }\n ```\n\n ### Backtracking\n\n Backtracking（回溯）属于 DFS。\n\n - 普通 DFS 主要用在 **可达性问题** ，这种问题只需要执行到特点的位置然后返回即可。\n - 而 Backtracking 主要用于求解 **排列组合** 问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串，这种问题在执行到特定的位置返回之后还会继续执行求解过程。\n\n 因为 Backtracking 不是立即就返回，而要继续求解，因此在程序实现时，需要注意对元素的标记问题：\n\n - 在访问一个新元素进入新的递归调用时，需要将新元素标记为已经访问，这样才能在继续递归调用时不用重复访问该元素；\n - 但是在递归返回时，需要将元素标记为未访问，因为只需要保证在一个递归链中不同时访问一个元素，可以访问已经访问过但是不在当前递归链中的元素。\n\n **数字键盘组合** \n\n [17. Letter Combinations of a Phone Number (Medium)](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/)\n\n letterCombinations(String digits) {\n List combinations = new ArrayList<>();\n if (digits == null || digits.length() == 0) {\n return combinations;\n }\n doCombination(new StringBuilder(), combinations, digits);\n return combinations;\n }\n \n private void doCombination(StringBuilder prefix, List combinations, final String digits) {\n if (prefix.length() == digits.length()) {\n combinations.add(prefix.toString());\n return;\n }\n int curDigits = digits.charAt(prefix.length()) - '0';\n String letters = KEYS[curDigits];\n for (char c : letters.toCharArray()) {\n prefix.append(c); // 添加\n doCombination(prefix, combinations, digits);\n prefix.deleteCharAt(prefix.length() - 1); // 删除\n }\n }\n ```\n\n **IP 地址划分** \n\n [93. Restore IP Addresses(Medium)](https://leetcode.com/problems/restore-ip-addresses/description/)\n\n ```html\n Given \"25525511135\",\n return [\"255.255.11.135\", \"255.255.111.35\"].\n ```\n\n ```java\n public List restoreIpAddresses(String s) {\n List addresses = new ArrayList<>();\n StringBuilder tempAddress = new StringBuilder();\n doRestore(0, tempAddress, addresses, s);\n return addresses;\n }\n \n private void doRestore(int k, StringBuilder tempAddress, List addresses, String s) {\n if (k == 4 || s.length() == 0) {\n if (k == 4 && s.length() == 0) {\n addresses.add(tempAddress.toString());\n }\n return;\n }\n for (int i = 0; i < s.length() && i <= 2; i++) {\n if (i != 0 && s.charAt(0) == '0') {\n break;\n }\n String part = s.substring(0, i + 1);\n if (Integer.valueOf(part) <= 255) {\n if (tempAddress.length() != 0) {\n part = \".\" + part;\n }\n tempAddress.append(part);\n doRestore(k + 1, tempAddress, addresses, s.substring(i + 1));\n tempAddress.delete(tempAddress.length() - part.length(), tempAddress.length());\n }\n }\n }\n ```\n\n **在矩阵中寻找字符串** \n\n [79. Word Search (Medium)](https://leetcode.com/problems/word-search/description/)\n\n ```html\n For example,\n Given board =\n [\n ['A','B','C','E'],\n ['S','F','C','S'],\n ['A','D','E','E']\n ]\n word = \"ABCCED\", -> returns true,\n word = \"SEE\", -> returns true,\n word = \"ABCB\", -> returns false.\n ```\n\n ```java\n private final static int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};\n private int m;\n private int n;\n \n public boolean exist(char[][] board, String word) {\n if (word == null || word.length() == 0) {\n return true;\n }\n if (board == null || board.length == 0 || board[0].length == 0) {\n return false;\n }\n \n m = board.length;\n n = board[0].length;\n boolean[][] hasVisited = new boolean[m][n];\n \n for (int r = 0; r < m; r++) {\n for (int c = 0; c < n; c++) {\n if (backtracking(0, r, c, hasVisited, board, word)) {\n return true;\n }\n }\n }\n \n return false;\n }\n \n private boolean backtracking(int curLen, int r, int c, boolean[][] visited, final char[][] board, final String word) {\n if (curLen == word.length()) {\n return true;\n }\n if (r < 0 || r >= m || c < 0 || c >= n\n || board[r][c] != word.charAt(curLen) || visited[r][c]) {\n \n return false;\n }\n \n visited[r][c] = true;\n \n for (int[] d : direction) {\n if (backtracking(curLen + 1, r + d[0], c + d[1], visited, board, word)) {\n return true;\n }\n }\n \n visited[r][c] = false;\n \n return false;\n }\n ```\n\n **输出二叉树中所有从根到叶子的路径** \n\n [257. Binary Tree Paths (Easy)](https://leetcode.com/problems/binary-tree-paths/description/)\n\n ```html\n 1\n / \\\n 2 3\n \\\n 5\n ```\n\n ```html\n [\"1->2->5\", \"1->3\"]\n ```\n\n ```java\n \n public List binaryTreePaths(TreeNode root) {\n List paths = new ArrayList<>();\n if (root == null) {\n return paths;\n }\n List values = new ArrayList<>();\n backtracking(root, values, paths);\n return paths;\n }\n \n private void backtracking(TreeNode node, List values, List paths) {\n if (node == null) {\n return;\n }\n values.add(node.val);\n if (isLeaf(node)) {\n paths.add(buildPath(values));\n } else {\n backtracking(node.left, values, paths);\n backtracking(node.right, values, paths);\n }\n values.remove(values.size() - 1);\n }\n \n private boolean isLeaf(TreeNode node) {\n return node.left == null && node.right == null;\n }\n \n private String buildPath(List values) {\n StringBuilder str = new StringBuilder();\n for (int i = 0; i < values.size(); i++) {\n str.append(values.get(i));\n if (i != values.size() - 1) {\n str.append(\"->\");\n }\n }\n return str.toString();\n }\n ```\n\n **排列** \n\n [46. Permutations (Medium)](https://leetcode.com/problems/permutations/description/)\n\n ```html\n [1,2,3] have the following permutations:\n [\n [1,2,3],\n [1,3,2],\n [2,1,3],\n [2,3,1],\n [3,1,2],\n [3,2,1]\n ]\n ```\n\n ```java\n public List> permute(int[] nums) {\n List> permutes = new ArrayList<>();\n List permuteList = new ArrayList<>();\n boolean[] hasVisited = new boolean[nums.length];\n backtracking(permuteList, permutes, hasVisited, nums);\n return permutes;\n }\n \n private void backtracking(List permuteList, List> permutes, boolean[] visited, final int[] nums) {\n if (permuteList.size() == nums.length) {\n permutes.add(new ArrayList<>(permuteList)); // 重新构造一个 List\n return;\n }\n for (int i = 0; i < visited.length; i++) {\n if (visited[i]) {\n continue;\n }\n visited[i] = true;\n permuteList.add(nums[i]);\n backtracking(permuteList, permutes, visited, nums);\n permuteList.remove(permuteList.size() - 1);\n visited[i] = false;\n }\n }\n ```\n\n **含有相同元素求排列** \n\n [47. Permutations II (Medium)](https://leetcode.com/problems/permutations-ii/description/)\n\n ```html\n [1,1,2] have the following unique permutations:\n [[1,1,2], [1,2,1], [2,1,1]]\n ```\n\n 数组元素可能含有相同的元素，进行排列时就有可能出现重复的排列，要求重复的排列只返回一个。\n\n 在实现上，和 Permutations 不同的是要先排序，然后在添加一个元素时，判断这个元素是否等于前一个元素，如果等于，并且前一个元素还未访问，那么就跳过这个元素。\n\n ```java\n public List> permuteUnique(int[] nums) {\n List> permutes = new ArrayList<>();\n List permuteList = new ArrayList<>();\n Arrays.sort(nums); // 排序\n boolean[] hasVisited = new boolean[nums.length];\n backtracking(permuteList, permutes, hasVisited, nums);\n return permutes;\n }\n \n private void backtracking(List permuteList, List> permutes, boolean[] visited, final int[] nums) {\n if (permuteList.size() == nums.length) {\n permutes.add(new ArrayList<>(permuteList));\n return;\n }\n \n for (int i = 0; i < visited.length; i++) {\n if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {\n continue; // 防止重复\n }\n if (visited[i]){\n continue;\n }\n visited[i] = true;\n permuteList.add(nums[i]);\n backtracking(permuteList, permutes, visited, nums);\n permuteList.remove(permuteList.size() - 1);\n visited[i] = false;\n }\n }\n ```\n\n **组合** \n\n [77. Combinations (Medium)](https://leetcode.com/problems/combinations/description/)\n\n ```html\n If n = 4 and k = 2, a solution is:\n [\n [2,4],\n [3,4],\n [2,3],\n [1,2],\n [1,3],\n [1,4],\n ]\n ```\n\n ```java\n public List> combine(int n, int k) {\n List> combinations = new ArrayList<>();\n List combineList = new ArrayList<>();\n backtracking(combineList, combinations, 1, k, n);\n return combinations;\n }\n \n private void backtracking(List combineList, List> combinations, int start, int k, final int n) {\n if (k == 0) {\n combinations.add(new ArrayList<>(combineList));\n return;\n }\n for (int i = start; i <= n - k + 1; i++) { // 剪枝\n combineList.add(i);\n backtracking(combineList, combinations, i + 1, k - 1, n);\n combineList.remove(combineList.size() - 1);\n }\n }\n ```\n\n **组合求和** \n\n [39. Combination Sum (Medium)](https://leetcode.com/problems/combination-sum/description/)\n\n ```html\n given candidate set [2, 3, 6, 7] and target 7,\n A solution set is:\n [[7],[2, 2, 3]]\n ```\n\n ```java\n public List> combinationSum(int[] candidates, int target) {\n List> combinations = new ArrayList<>();\n backtracking(new ArrayList<>(), combinations, 0, target, candidates);\n return combinations;\n }\n \n private void backtracking(List tempCombination, List> combinations,\n int start, int target, final int[] candidates) {\n \n if (target == 0) {\n combinations.add(new ArrayList<>(tempCombination));\n return;\n }\n for (int i = start; i < candidates.length; i++) {\n if (candidates[i] <= target) {\n tempCombination.add(candidates[i]);\n backtracking(tempCombination, combinations, i, target - candidates[i], candidates);\n tempCombination.remove(tempCombination.size() - 1);\n }\n }\n }\n ```\n\n **含有相同元素的求组合求和** \n\n [40. Combination Sum II (Medium)](https://leetcode.com/problems/combination-sum-ii/description/)\n\n ```html\n For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,\n A solution set is:\n [\n [1, 7],\n [1, 2, 5],\n [2, 6],\n [1, 1, 6]\n ]\n ```\n\n ```java\n public List> combinationSum2(int[] candidates, int target) {\n List> combinations = new ArrayList<>();\n Arrays.sort(candidates);\n backtracking(new ArrayList<>(), combinations, new boolean[candidates.length], 0, target, candidates);\n return combinations;\n }\n \n private void backtracking(List tempCombination, List> combinations,\n boolean[] hasVisited, int start, int target, final int[] candidates) {\n \n if (target == 0) {\n combinations.add(new ArrayList<>(tempCombination));\n return;\n }\n for (int i = start; i < candidates.length; i++) {\n if (i != 0 && candidates[i] == candidates[i - 1] && !hasVisited[i - 1]) {\n continue;\n }\n if (candidates[i] <= target) {\n tempCombination.add(candidates[i]);\n hasVisited[i] = true;\n backtracking(tempCombination, combinations, hasVisited, i + 1, target - candidates[i], candidates);\n hasVisited[i] = false;\n tempCombination.remove(tempCombination.size() - 1);\n }\n }\n }\n ```\n\n **1-9 数字的组合求和** \n\n [216. Combination Sum III (Medium)](https://leetcode.com/problems/combination-sum-iii/description/)\n\n ```html\n Input: k = 3, n = 9\n \n Output:\n \n [[1,2,6], [1,3,5], [2,3,4]]\n ```\n\n 从 1-9 数字中选出 k 个数不重复的数，使得它们的和为 n。\n\n ```java\n public List ![](\"assets/logo-2021.svg\"){kind=logo}
![](\"assets/zhishixingqiu.JPG\")
![](\"https://opencollective.com/fullstack-tutorial/contributors.svg?width=890&button=false\")
\n\n\n\n## Stargazers over time\n\n\n\n\n\n## License\n\n![\"知识共享许可协议\"](\"https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png\")
\n\nCopyright (c) 2021-present, Frank Lam\n\n\n\n## 关于作者 :boy:\n\n![\"BLOG\"](\"https://img.shields.io/badge/BLOG-frankfeekr.cn-blue.svg\"){kind=icon}
\n![\"邮箱\"](\"https://img.shields.io/badge/Email-frank__lin@whu.edu.cn-lightgrey.svg\"){kind=icon}
\n![\"QQ群\"](\"https://img.shields.io/badge/QQ群-862619503-green.svg\"){kind=icon}
\n ![](\"assets/wechat/wx-green.png\")