-
Notifications
You must be signed in to change notification settings - Fork 1
Expand file tree
/
Copy pathsearch.xml
More file actions
227 lines (109 loc) · 145 KB
/
search.xml
File metadata and controls
227 lines (109 loc) · 145 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
<?xml version="1.0" encoding="utf-8"?>
<search>
<entry>
<title>玩转 IDEA 系列教程——强烈推荐官方中文(汉化)插件！</title>
<link href="/2020/06/04/idea/idea01/"/>
<url>/2020/06/04/idea/idea01/</url>
<content type="html"><![CDATA[<p><img src="https://upload-images.jianshu.io/upload_images/7326374-6ced95eb61b5c7f3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="玩转 IDEA 系列教程"></p><blockquote><p>每天进步一点，不做curd工程师与Api调用工程师<br>欢迎访问个人博客网站：<a href="https://www.coder-programming.cn/" target="_blank" rel="noopener">https://www.coder-programming.cn/</a></p></blockquote><p>IDEA2020.1版本的到来，官方也悄悄更新了IDEA的中文插件。至今为止也有一段时间了，本人也下载使用过，对于英语底子薄弱的同学来说，中文插件还是非常友好的！</p><p>有兴趣的童鞋也可以下载尝尝鲜~</p><p>接下来，我们来介绍如何安装这款插件！</p><h3 id="一、在线安装"><a href="#一、在线安装" class="headerlink" title="一、在线安装"></a>一、在线安装</h3><p>打开设置——>插件 </p><p>输入框<strong>搜索</strong>：<code>Chinese (Simplified) Language Pack</code></p><p><img src="https://upload-images.jianshu.io/upload_images/7326374-83502d2553bef53b.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="settings"></p><p><img src="https://upload-images.jianshu.io/upload_images/7326374-865b2992d6e8bf3e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="搜索安装"></p><p>之后重启即可使用！</p><h3 id="二、离线安装"><a href="#二、离线安装" class="headerlink" title="二、离线安装"></a>二、离线安装</h3><p>离线下载地址：<a href="https://plugins.jetbrains.com/plugin/13710-chinese-simplified-language-pack-eap" target="_blank" rel="noopener">https://plugins.jetbrains.com/plugin/13710-chinese-simplified-language-pack-eap</a></p><blockquote><p>注意事项：需要根据自身的IDEA版本号进行相应的选择下载！</p></blockquote><h4 id="下载离线包"><a href="#下载离线包" class="headerlink" title="下载离线包"></a>下载离线包</h4><p><img src="https://upload-images.jianshu.io/upload_images/7326374-2e619f00d788d070.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="下载地址"></p><p><img src="https://upload-images.jianshu.io/upload_images/7326374-d931e1f8b8cb89a8.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="查看对应的版本号"></p><p><img src="https://upload-images.jianshu.io/upload_images/7326374-5f306ae6f01494f3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="build.png"></p><h4 id="安装"><a href="#安装" class="headerlink" title="安装"></a>安装</h4><blockquote><p>安装离线包有两张方法</p></blockquote><p>方式一：</p><p>File -> Settings -> Plugins -> 安装本地插件包</p><p><img src="https://upload-images.jianshu.io/upload_images/7326374-5e6b0d36aaae4838.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="本地安装"></p><p>方式二：</p><p>直接将插件包托入到IDEA框内即可！</p><p><img src="https://upload-images.jianshu.io/upload_images/7326374-964e7ab9ae57523c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="离线安装方式2"></p><p>之后重启即可使用！</p><h3 id="效果"><a href="#效果" class="headerlink" title="效果"></a>效果</h3><p><img src="https://upload-images.jianshu.io/upload_images/7326374-77788a7f9f4174f8.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="安装完成"></p><h2 id="文末"><a href="#文末" class="headerlink" title="文末"></a>文末</h2><p>文章收录至<br>Github: <a href="https://links.jianshu.com/go?to=https%3A%2F%2Fgithub.com%2FCoderMerlin%2Fcoder-programming" target="_blank" rel="noopener">https://github.com/CoderMerlin/coder-programming</a><br>Gitee: <a href="https://links.jianshu.com/go?to=https%3A%2F%2Fgitee.com%2F573059382%2Fcoder-programming" target="_blank" rel="noopener">https://gitee.com/573059382/coder-programming</a><br>欢迎<strong>关注</strong>并star~</p><p><img src="https://upload-images.jianshu.io/upload_images/7326374-0c9d0fbd2c954edb.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="微信公众号"></p>]]></content>
<categories>
<category> 工具 </category>
</categories>
<tags>
<tag> 工具 </tag>
</tags>
</entry>
<entry>
<title>博客搭建-博客搭建完整教程</title>
<link href="/2020/05/14/BLOG03-HEXO-JC/"/>
<url>/2020/05/14/BLOG03-HEXO-JC/</url>
<content type="html"><![CDATA[<blockquote><p>每天进步一点，不做curd工程师与Api调用工程师！</p></blockquote><blockquote><p>欢迎大家访问我的博客：<a href="https://codermerlin.github.io/" target="_blank" rel="noopener">Coder编程——个人博客</a></p></blockquote><h2 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h2><p>其实早在三年前，刚毕业那会就在网上学着搭建自己的个人博客。后面由于其他原因（主要是<strong>懒</strong>）就没再继续管理。如今又为何重新拾起呢？</p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/emoticon/htwyakszb.jpg" alt="后退我要开始装逼啦"></p><p>第一：自己本身从毕业到工作也已经有了三年时间，或多或少有了一些工作经验和感悟。<br>第二：平时有时间的时候，自己也会看看博客，写写文章（划划水）。<br>第三：工作这么久，也要记录一下自己的学习记录，分享给大家。<br>….</p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/emoticon/hlbbzdl.jpg" alt="我知道了"></p><p>下面的开始写教程了，这篇教程主要参考：</p><ul><li><a href="https://www.itrhx.com/" target="_blank" rel="noopener">https://www.itrhx.com/</a></li></ul><p>他的教程写的非常详细！本文也主要参考他写的内容，并修改~</p><p>推荐文章： <a href="http://www.cnblogs.com/jhzhu/p/3893297.html" target="_blank" rel="noopener">《我为什么写博客》</a> （By 知明所以）<br> <a href="http://mindhacks.cn/2009/02/15/why-you-should-start-blogging-now/" target="_blank" rel="noopener">《为什么你应该（从现在开始就）写博客》</a> (By 刘未鹏 | Mind Hacks)</p><h2 id="1-概念"><a href="#1-概念" class="headerlink" title="1. 概念"></a>1. 概念</h2><h3 id="1-1-Github-Pages"><a href="#1-1-Github-Pages" class="headerlink" title="1.1 Github Pages"></a>1.1 Github Pages</h3><p><strong>Github Pages</strong>可以被认为是用户编写的、托管在github上的静态网页。使用Github Pages可以为你提供一个免费的服务器，免去了自己搭建服务器和写数据库的麻烦。此外还可以绑定自己的域名。</p><p>类似Github Pages的</p><ul><li>Gitee Pages</li><li>Gitlab Pages</li><li>Coding</li></ul><p>等等</p><p>后续我也会写文章专门介绍，这几个Pages的搭建过程，欢迎大家关注~</p><h3 id="1-2-Hexo"><a href="#1-2-Hexo" class="headerlink" title="1.2 Hexo"></a>1.2 Hexo</h3><p><strong>Hexo</strong> 是一个快速、简洁且高效的博客框架。<strong>Hexo</strong> 使用 <strong>Markdown</strong>（或其他渲染引擎）解析文章，在几秒内，即可利用靓丽的主题生成静态网页。</p><h2 id="2-环境安装"><a href="#2-环境安装" class="headerlink" title="2. 环境安装"></a>2. 环境安装</h2><h3 id="2-1-安装Node-js"><a href="#2-1-安装Node-js" class="headerlink" title="2.1 安装Node.js"></a>2.1 安装Node.js</h3><p>访问<a href="https://nodejs.org/en/download/" target="_blank" rel="noopener">官网</a>，按需下载相应版本，默认安装可以了。</p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BLOG01/A02.png" alt="Node"></p><p>更多详细教程：</p><ul><li><a href="https://www.runoob.com/nodejs/nodejs-install-setup.html" target="_blank" rel="noopener">https://www.runoob.com/nodejs/nodejs-install-setup.html</a></li><li><a href="https://blog.csdn.net/antma/article/details/86104068" target="_blank" rel="noopener">https://blog.csdn.net/antma/article/details/86104068</a></li></ul><h3 id="2-2-安装Git"><a href="#2-2-安装Git" class="headerlink" title="2.2 安装Git"></a>2.2 安装Git</h3><p>访问<a href="https://git-scm.com/download/win" target="_blank" rel="noopener">官网</a>，按需下载相应版本，默认安装即可。</p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BLOG01/A02-1.png" alt="Git官网"></p><p>更多详细教程：</p><ul><li>Win10安装：<a href="https://blog.csdn.net/qq_32786873/article/details/80570783" target="_blank" rel="noopener">https://blog.csdn.net/qq_32786873/article/details/80570783</a></li><li>Mac安装：<a href="https://www.jianshu.com/p/b91f848655af" target="_blank" rel="noopener">https://www.jianshu.com/p/b91f848655af</a></li></ul><h3 id="2-3-检查软件是否安装成功"><a href="#2-3-检查软件是否安装成功" class="headerlink" title="2.3 检查软件是否安装成功"></a>2.3 检查软件是否安装成功</h3><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BLOG01/A04.png" alt="Git"><br>同时按下 Win 键和 R 键打开运行窗口,输入 cmd ，然后输入以下命令，有相应版本信息显示则安装成功，若不正确可以卸载软件重新安装，此外若安装成功，在桌面右键鼠标，可以看到菜单里多了 Git GUI Here 和 Git Bash Here两个选项，第一个是图形界面的Git操作，另一个是命令行</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">$ git --version</span><br><span class="line">$ node -v</span><br><span class="line">$ npm -v</span><br></pre></td></tr></table></figure><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BLOG01/A03.png" alt="检查版本"></p><p>正确输出版本号，说明安装成功了~</p><h2 id="3-Hexo安装"><a href="#3-Hexo安装" class="headerlink" title="3. Hexo安装"></a>3. Hexo安装</h2><p>正在编写。。。</p>]]></content>
<categories>
<category> HEXO </category>
</categories>
<tags>
<tag> HEXO </tag>
</tags>
</entry>
<entry>
<title>博客搭建-设置标签/分类/归档相关页面</title>
<link href="/2020/05/12/BLOG02-HEXO-BQFLGD/"/>
<url>/2020/05/12/BLOG02-HEXO-BQFLGD/</url>
<content type="html"><![CDATA[<blockquote><p>每天进步一点，不做curd工程师与Api调用工程师</p></blockquote><h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>最近晚上有时间就忙着倒腾自己的博客网站：<a href="https://www.coder-programming.cn/" target="_blank" rel="noopener">https://www.coder-programming.cn/</a></p><p>网站还在建设当中，我会慢慢分享自己的搭建博客的过程和遇到的问题，在这里与大家一起分享！</p><h3 id="设置标签页面"><a href="#设置标签页面" class="headerlink" title="设置标签页面"></a>设置标签页面</h3><p>主题的 _config.yml 文件中，找到如下配置<code>menu_desktop</code> 或者 <code>menu_mobile</code>。(注意：填写的路径要对应上)</p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BOLG03/04.png" alt="配置项"></p><p>在<code>\source\tags</code> 中新建index.md。写入以下内容即可。</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">---</span><br><span class="line">layout: tag</span><br><span class="line">index: true</span><br><span class="line">title: 所有标签</span><br><span class="line">---</span><br></pre></td></tr></table></figure><p>在需要发布的文章同样注意加入tags。举个栗子：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line">---</span><br><span class="line">title: Java学习路线整理</span><br><span class="line">updated: 2020-03-19 00:34:14</span><br><span class="line">date: 2020-03-19 00:34:14</span><br><span class="line">categories: </span><br><span class="line"> - [Java]</span><br><span class="line"> - [面试]</span><br><span class="line">tags:</span><br><span class="line"> - [Java]</span><br><span class="line"> - [面试]</span><br><span class="line"> </span><br><span class="line">top: true</span><br><span class="line">---</span><br></pre></td></tr></table></figure><p>效果如图：<br><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BOLG03/02.png" alt="标签图"></p><h3 id="设置分类页面"><a href="#设置分类页面" class="headerlink" title="设置分类页面"></a>设置分类页面</h3><p>主题的 _config.yml 文件中，找到如下配置<code>menu_desktop</code> 或者 <code>menu_mobile</code>。(注意：填写的路径要对应上)</p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BOLG03/04.png" alt="配置项"></p><p>在<code>\source\categories</code> 中新建index.md。写入以下内容即可。</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">---</span><br><span class="line">layout: category</span><br><span class="line">title: 所有分类</span><br><span class="line">---</span><br></pre></td></tr></table></figure><p>在需要发布的文章同样注意加入tags。举个栗子：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line">---</span><br><span class="line">title: Java学习路线整理</span><br><span class="line">updated: 2020-03-19 00:34:14</span><br><span class="line">date: 2020-03-19 00:34:14</span><br><span class="line">categories: </span><br><span class="line"> - [Java]</span><br><span class="line"> - [面试]</span><br><span class="line">tags:</span><br><span class="line"> - [Java]</span><br><span class="line"> - [面试]</span><br><span class="line"> </span><br><span class="line">top: true</span><br><span class="line">---</span><br></pre></td></tr></table></figure><p>效果如图：<br><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BOLG03/01.png" alt="分类图"></p><h3 id="设置归档页面"><a href="#设置归档页面" class="headerlink" title="设置归档页面"></a>设置归档页面</h3><p><strong>归档页面不要添加任何文件！</strong><br><strong>归档页面不要添加任何文件！</strong><br><strong>归档页面不要添加任何文件！</strong><br>重要的事说三遍！</p><p>只需要在主题的 _config.yml 文件中，找到如下配置<code>menu_desktop</code> 或者 <code>menu_mobile</code>。(注意：填写的路径要对应上), 填写<code>archives/</code>即可。</p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BOLG03/04.png" alt="配置项"></p><p>效果如图：</p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BOLG03/03.png" alt="归档图"></p><h2 id="推荐"><a href="#推荐" class="headerlink" title="推荐"></a>推荐</h2><p><a href="https://mp.weixin.qq.com/s?__biz=MzIwMTg3NzYyOA==&mid=2247484326&idx=1&sn=0f11d4a0d23ac377a83f9fba1d4a67d4&chksm=96e672b5a191fba32b18844de26ba6dc2060a8e16b184d73c6f9dd45ca0498062eaa9273d86c&token=475512204&lang=zh_CN#rd?_blank" target="_blank" rel="noopener">[博客搭建] 增加百度统计功能</a></p><p><a href="https://www.processon.com/i/5cd53c2fe4b01941c8cf1c21" target="_blank" rel="noopener">ProcessOn是一个在线作图工具的聚合平台~</a></p><h2 id="文末"><a href="#文末" class="headerlink" title="文末"></a>文末</h2><blockquote><p>欢迎关注个人微信公众号：<strong>Coder编程</strong><br>欢迎关注<strong>Coder编程</strong>公众号，主要分享数据结构与算法、Java相关知识体系、框架知识及原理、Spring全家桶、微服务项目实战、DevOps实践之路、每日一篇互联网大厂面试或笔试题以及PMP项目管理知识等。更多精彩内容正在路上~<br>新建了一个qq群：315211365，欢迎大家进群交流一起学习。谢谢了！也可以介绍给身边有需要的朋友。</p></blockquote><blockquote><p>文章收录至<br>Github: <a href="https://github.com/CoderMerlin/coder-programming" target="_blank" rel="noopener">https://github.com/CoderMerlin/coder-programming</a><br>Gitee: <a href="https://gitee.com/573059382/coder-programming" target="_blank" rel="noopener">https://gitee.com/573059382/coder-programming</a><br>欢迎<strong>关注</strong>并star~<br><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/coder-programming-wechat.webp.jpg" alt="微信公众号"></p></blockquote>]]></content>
<categories>
<category> HEXO </category>
</categories>
<tags>
<tag> HEXO </tag>
</tags>
</entry>
<entry>
<title>博客搭建-增加百度统计功能</title>
<link href="/2020/05/12/BLOG01-HEXO-BDTJ/"/>
<url>/2020/05/12/BLOG01-HEXO-BDTJ/</url>
<content type="html"><![CDATA[<blockquote><p>每天进步一点，不做curd工程师与Api调用工程师</p></blockquote><h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>最近晚上有时间就忙着倒腾自己的博客网站：<a href="https://www.coder-programming.cn/" target="_blank" rel="noopener">https://www.coder-programming.cn/</a></p><p>网站还在建设当中，我会慢慢分享自己的搭建博客的过程和遇到的问题，在这里与大家一起分享！</p><p>百度统计是百度推出的一款免费的专业网站流量分析工具，能够告诉用户访客是如何找到并浏览用户的网站，在网站上做了些什么，非常有趣，接下来我们把百度统计添加到自己博客当中</p><p>访问<a href="https://tongji.baidu.com/" target="_blank" rel="noopener">百度统计首页</a>，注册一个账号后登陆，添加你的博客网站</p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BLOG02BDTJ/01.png" alt="01"></p><p>点击<strong>增加网站</strong>,填写个人网站的信息。</p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BLOG02BDTJ/02.png" alt="02"></p><p>接着点击代码获取，复制该代码<br><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BLOG02BDTJ/03.png" alt="03"></p><p>然后到目录<code>\themes\hexo-theme-material-x\layout\_partial\head.ejs</code>，里面粘贴你刚刚复制的代码。<br>代码如下：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><% if (config.baidu_analytics_key) { %></span><br><span class="line"> <!-- ba --></span><br><span class="line"> <script></span><br><span class="line"> var _hmt = _hmt || [];</span><br><span class="line"> (function() {</span><br><span class="line"> var hm = document.createElement("script");</span><br><span class="line"> hm.src = "https://hm.baidu.com/hm.js?<%= config.baidu_analytics_key %>";</span><br><span class="line"> var s = document.getElementsByTagName("script")[0];</span><br><span class="line"> s.parentNode.insertBefore(hm, s);</span><br><span class="line"> })();</span><br><span class="line"> </script></span><br><span class="line"> <% } %></span><br></pre></td></tr></table></figure><p>修改博客根目录下的 _config.yml 文件(注意：不是主题下的_config.yml)，将你的key填写进去：</p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BLOG02BDTJ/05.png" alt="05"></p><p>所有操作完成后可以在百度统计管理页面检查代码是否安装成功，如果代码安装正确，一般20分钟后，可以查看网站分析数据</p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BLOG02BDTJ/06.png" alt="06"></p><p><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/BLOG02BDTJ/07.png" alt="07"></p><p>另外推荐：<a href="https://web.umeng.com/main.php?c=user&a=index" target="_blank" rel="noopener">友盟</a>，2010年4月在北京成立，安全、可靠、公正、第三方的网站流量统计分析系统</p><p>参考：<br><a href="https://www.itrhx.com/2018/08/27/A04-Hexo-blog-topic-personalization/" target="_blank" rel="noopener">https://www.itrhx.com/2018/08/27/A04-Hexo-blog-topic-personalization/</a></p><h2 id="推荐"><a href="#推荐" class="headerlink" title="推荐"></a>推荐</h2><p><a href="https://www.processon.com/i/5cd53c2fe4b01941c8cf1c21" target="_blank" rel="noopener">ProcessOn是一个在线作图工具的聚合平台~</a></p><h2 id="文末"><a href="#文末" class="headerlink" title="文末"></a>文末</h2><blockquote><p>欢迎关注个人微信公众号：<strong>Coder编程</strong><br>欢迎关注<strong>Coder编程</strong>公众号，主要分享数据结构与算法、Java相关知识体系、框架知识及原理、Spring全家桶、微服务项目实战、DevOps实践之路、每日一篇互联网大厂面试或笔试题以及PMP项目管理知识等。更多精彩内容正在路上~<br>新建了一个qq群：315211365，欢迎大家进群交流一起学习。谢谢了！也可以介绍给身边有需要的朋友。</p></blockquote><blockquote><p>文章收录至<br>Github: <a href="https://github.com/CoderMerlin/coder-programming" target="_blank" rel="noopener">https://github.com/CoderMerlin/coder-programming</a><br>Gitee: <a href="https://gitee.com/573059382/coder-programming" target="_blank" rel="noopener">https://gitee.com/573059382/coder-programming</a><br>欢迎<strong>关注</strong>并star~<br><img src="https://cdn.jsdelivr.net/gh/CoderMerlin/blog-image/images/coder-programming-wechat.webp.jpg" alt="微信公众号"></p></blockquote>]]></content>
<categories>
<category> HEXO </category>
</categories>
<tags>
<tag> HEXO </tag>
<tag> 百度统计 </tag>
</tags>
</entry>
<entry>
<title>Java学习路线整理</title>
<link href="/2020/03/19/java/"/>
<url>/2020/03/19/java/</url>
<content type="html"><![CDATA[</li></ol><!-- TOC --><ul><li><a href="#java">Java</a><ul><li><a href="#基础">基础</a></li><li><a href="#并发">并发</a></li><li><a href="#jvm">JVM</a></li><li><a href="#java8-新特性">Java8 新特性</a></li><li><a href="#代码优化">代码优化</a></li></ul></li><li><a href="#网络">网络</a></li><li><a href="#操作系统">操作系统</a></li><li><a href="#数据结构">数据结构</a></li><li><a href="#算法">算法</a><ul><li><a href="#入门">入门</a></li><li><a href="#经典">经典</a></li><li><a href="#面试">面试</a></li></ul></li><li><a href="#数据库">数据库</a></li><li><a href="#系统设计">系统设计</a><ul><li><a href="#设计模式">设计模式</a></li><li><a href="#常用框架">常用框架</a><ul><li><a href="#springspringboot">Spring/SpringBoot</a></li><li><a href="#netty">Netty</a></li></ul></li><li><a href="#分布式">分布式</a></li><li><a href="#网站架构">网站架构</a></li><li><a href="#软件底层">软件底层</a></li><li><a href="#其他">其他</a></li></ul></li><li><a href="#其他-1">其他</a></li></ul><!-- /TOC --><h2 id="Java"><a href="#Java" class="headerlink" title="Java"></a>Java</h2><h3 id="基础"><a href="#基础" class="headerlink" title="基础"></a>基础</h3><ul><li><strong><a href="https://book.douban.com/subject/2000732/" target="_blank" rel="noopener">《Head First Java》</a></strong> ： 可以说是我的 Java 启蒙书籍了，特别适合新手读当然也适合我们用来温故 Java 知识点。</li><li><strong><a href="https://book.douban.com/subject/25762168/" target="_blank" rel="noopener">《Java 核心技术卷 1+卷 2》</a></strong>: 很棒的两本书，建议有点 Java 基础之后再读，介绍的还是比较深入的，非常推荐。这两本书我一般也会用来巩固知识点或者当做工具书参考，是两本适合放在自己身边的好书。</li><li><strong><a href="https://book.douban.com/subject/2130190/" target="_blank" rel="noopener">《Java 编程思想 (第 4 版)》</a></strong>（推荐，豆瓣评分 9.1，3.2K+人评价）：大部分人称之为Java领域的圣经，但我不推荐初学者阅读，有点劝退的味道。稍微有点基础后阅读更好。</li><li><strong><a href="https://book.douban.com/subject/26259017/" target="_blank" rel="noopener">《JAVA 网络编程 第 4 版》</a></strong>： 可以系统的学习一下网络的一些概念以及网络编程在 Java 中的使用。</li><li><strong><a href="https://book.douban.com/subject/26740520/" target="_blank" rel="noopener">《Java性能权威指南》</a></strong>：O’Reilly 家族书，性能调优的入门书，我个人觉得性能调优是每个 Java 从业者必备知识，这本书的缺点就是太老了，但是这本书可以作为一个实战书，尤其是 JVM 调优！不适合初学者。前置书籍：《深入理解 Java 虚拟机》</li></ul><h3 id="并发"><a href="#并发" class="headerlink" title="并发"></a>并发</h3><ul><li><strong><a href="https://book.douban.com/subject/30351286/" target="_blank" rel="noopener">《Java 并发编程之美》</a></strong> ：<strong>我觉得这本书还是非常适合我们用来学习 Java 多线程的。这本书的讲解非常通俗易懂，作者从并发编程基础到实战都是信手拈来。</strong> 另外，这本书的作者加多自身也会经常在网上发布各种技术文章。我觉得这本书也是加多大佬这么多年在多线程领域的沉淀所得的结果吧！他书中的内容基本都是结合代码讲解，非常有说服力！</li><li><strong><a href="https://book.douban.com/subject/26663605/" target="_blank" rel="noopener">《实战 Java 高并发程序设计》</a></strong>： 这个是我第二本要推荐的书籍，比较适合作为多线程入门/进阶书籍来看。这本书内容同样是理论结合实战，对于每个知识点的讲解也比较通俗易懂，整体结构也比较清。</li><li><strong><a href="https://github.com/RedSpider1/concurrent" target="_blank" rel="noopener">《深入浅出 Java 多线程》</a></strong>：这本书是几位大厂（如阿里）的大佬开源的，Github 地址：<a href="https://github.com/RedSpider1/concurrent" target="_blank" rel="noopener">https://github.com/RedSpider1/concurrent</a>几位作者为了写好《深入浅出 Java 多线程》这本书阅读了大量的 Java 多线程方面的书籍和博客，然后再加上他们的经验总结、Demo 实例、源码解析，最终才形成了这本书。这本书的质量也是非常过硬！给作者们点个赞！这本书有统一的排版规则和语言风格、清晰的表达方式和逻辑。并且每篇文章初稿写完后，作者们就会互相审校，合并到主分支时所有成员会再次审校，最后再通篇修订了三遍。</li><li><strong>《Java 并发编程的艺术》</strong> ：这本书不是很适合作为 Java 多线程入门书籍，需要具备一定的 JVM 基础，有些东西讲的还是挺深入的。另外，就我自己阅读这本书的感觉来说，我觉得这本书的章节规划有点杂乱，但是，具体到某个知识点又很棒！这可能也和这本书由三名作者共同编写完成有关系吧！</li><li>……</li></ul><h3 id="JVM"><a href="#JVM" class="headerlink" title="JVM"></a>JVM</h3><ul><li><strong><a href="https://book.douban.com/subject/24722612/" target="_blank" rel="noopener">《深入理解 Java 虚拟机（第 3 版）》</a>）</strong>：必读！必读！必读！神书，建议多刷几篇。里面不光有丰富地JVM理论知识，还有JVM实战案例！必读！</li><li><strong><a href="https://book.douban.com/subject/26354292/" target="_blank" rel="noopener">《实战 JAVA 虚拟机》</a></strong>：作为入门的了解 Java 虚拟机的知识还是不错的。</li></ul><h3 id="Java8-新特性"><a href="#Java8-新特性" class="headerlink" title="Java8 新特性"></a>Java8 新特性</h3><ul><li><strong><a href="https://book.douban.com/subject/26772632/" target="_blank" rel="noopener">《Java 8 实战》</a></strong>：面向 Java 8 的技能升级，包括 Lambdas、流和函数式编程特性。实战系列的一贯风格让自己快速上手应用起来。Java 8 支持的 Lambda 是精简表达在语法上提供的支持。Java 8 提供了 Stream，学习和使用可以建立流式编程的认知。</li><li><strong><a href="https://book.douban.com/subject/26556574/" target="_blank" rel="noopener">《Java 8 编程参考官方教程》</a></strong>：建议当做工具书来用！哪里不会翻哪里！</li></ul><h3 id="代码优化"><a href="#代码优化" class="headerlink" title="代码优化"></a>代码优化</h3><ul><li><strong><a href="https://book.douban.com/subject/4262627/" target="_blank" rel="noopener">《重构_改善既有代码的设计》</a></strong>：豆瓣 9.1 分，重构书籍的开山鼻祖。</li><li><strong><a href="https://book.douban.com/subject/3360807/" target="_blank" rel="noopener">《Effective java 》</a></strong>：本书介绍了在 Java 编程中很多极具实用价值的经验规则，这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。这篇文章能够非常实际地帮助你写出更加清晰、健壮和高效的代码。本书中的每条规则都以简短、独立的小文章形式出现，并通过例子代码加以进一步说明。</li><li><strong><a href="https://book.douban.com/subject/5442024/" target="_blank" rel="noopener">《代码整洁之道》</a></strong>：虽然是用 Java 语言作为例子，全篇都是在阐述 Java 面向对象的思想，但是其中大部分内容其它语言也能应用到。</li><li><strong>阿里巴巴 Java 开发手册</strong> ：<a href="https://github.com/alibaba/p3c" target="_blank" rel="noopener">https://github.com/alibaba/p3c</a></li><li><strong>Google Java 编程风格指南：</strong> <a href="http://www.hawstein.com/posts/google-java-style.html" target="_blank" rel="noopener">http://www.hawstein.com/posts/google-java-style.html</a></li></ul><h2 id="网络"><a href="#网络" class="headerlink" title="网络"></a>网络</h2><ul><li><strong><a href="https://book.douban.com/subject/25863515/" target="_blank" rel="noopener">《图解 HTTP》</a></strong>： 讲漫画一样的讲 HTTP，很有意思，不会觉得枯燥，大概也涵盖也 HTTP 常见的知识点。因为篇幅问题，内容可能不太全面。不过，如果不是专门做网络方向研究的小伙伴想研究 HTTP 相关知识的话，读这本书的话应该来说就差不多了。</li><li><strong><a href="https://book.douban.com/subject/10746113/" target="_blank" rel="noopener">《HTTP 权威指南》</a></strong>:如果要全面了解 HTTP 非此书不可！</li></ul><h2 id="操作系统"><a href="#操作系统" class="headerlink" title="操作系统"></a>操作系统</h2><ul><li><strong><a href="https://book.douban.com/subject/4889838/" target="_blank" rel="noopener">《鸟哥的 Linux 私房菜》</a></strong>：本书是最具知名度的 Linux 入门书《鸟哥的 Linux 私房菜基础学习篇》的最新版，全面而详细地介绍了 Linux 操作系统。</li></ul><h2 id="数据结构"><a href="#数据结构" class="headerlink" title="数据结构"></a>数据结构</h2><ul><li><strong><a href="https://book.douban.com/subject/6424904/" target="_blank" rel="noopener">《大话数据结构》</a></strong>：入门类型的书籍，读起来比较浅显易懂，适合没有数据结构基础或者说数据结构没学好的小伙伴用来入门数据结构。</li></ul><h2 id="算法"><a href="#算法" class="headerlink" title="算法"></a>算法</h2><h3 id="入门"><a href="#入门" class="headerlink" title="入门"></a>入门</h3><ul><li><strong><a href="https://book.douban.com/subject/30357170/" target="_blank" rel="noopener">《我的第一本算法书》</a> （豆瓣评分 7.1，0.2K+人评价）</strong> 一本不那么“专业”的算法书籍。和下面两本推荐的算法书籍都是比较通俗易懂，“不那么深入”的算法书籍。我个人非常推荐，配图和讲解都非常不错！</li><li><strong><a href="https://book.douban.com/subject/26979890/" target="_blank" rel="noopener">《算法图解》</a>（豆瓣评分 8.4，1.5K+人评价）</strong> ：入门类型的书籍，读起来比较浅显易懂，非常适合没有算法基础或者说算法没学好的小伙伴用来入门。示例丰富，图文并茂，以让人容易理解的方式阐释了算法.读起来比较快，内容不枯燥！</li><li><strong><a href="https://book.douban.com/subject/25894685/" target="_blank" rel="noopener">《啊哈!算法》</a> （豆瓣评分 7.7，0.5K+人评价）</strong> ：和《算法图解》类似的算法趣味入门书籍。</li></ul><h3 id="经典"><a href="#经典" class="headerlink" title="经典"></a>经典</h3><blockquote><p>下面这些书籍都是经典中的经典，但是阅读起来难度也比较大，不做太多阐述，神书就完事了！推荐先看 《算法》，然后再选下面的书籍进行进一步阅读。不需要都看，找一本好好看或者找某本书的某一个章节知识点好好看。</p></blockquote><ul><li><strong><a href="https://book.douban.com/subject/10432347/" target="_blank" rel="noopener">《算法 第四版》</a>（豆瓣评分 9.3，0.4K+人评价）：</strong> 我在大二的时候被我们的一个老师强烈安利过！自己也在当时购买了一本放在宿舍，到离开大学的时候自己大概看了一半多一点。因为内容实在太多了！另外，这本书还提供了详细的Java代码，非常适合学习 Java 的朋友来看，可以说是 Java 程序员的必备书籍之一了。再来介绍一下这本书籍吧！这本书籍算的上是算法领域经典的参考书，全面介绍了关于算法和数据结构的必备知识，并特别针对排序、搜索、图处理和字符串处理进行了论述。</li><li><strong><a href="https://book.douban.com/subject/3227098/" target="_blank" rel="noopener">编程珠玑</a>（豆瓣评分 9.1，2K+人评价）</strong> ：经典名著，被无数读者强烈推荐的书籍，几乎是顶级程序员必看的书籍之一了。这本书的作者也非常厉害，Java之父 James Gosling 就是他的学生。很多人都说这本书不是教你具体的算法，而是教你一种编程的思考方式。这种思考方式不仅仅在编程领域适用，在其他同样适用。</li><li><strong><a href="https://book.douban.com/subject/4048566/" target="_blank" rel="noopener">《算法设计手册》</a>（豆瓣评分9.1 ， 45人评价）</strong> :被 <a href="https://teachyourselfcs.com/" target="_blank" rel="noopener">Teach Yourself Computer Science</a> 强烈推荐的一本算法书籍。</li><li><strong><a href="https://book.douban.com/subject/20432061/" target="_blank" rel="noopener">《算法导论》</a> （豆瓣评分 9.2，0.4K+人评价）</strong></li><li><strong><a href="https://book.douban.com/subject/1130500/" target="_blank" rel="noopener">《计算机程序设计艺术（第1卷）》</a>（豆瓣评分 9.4，0.4K+人评价）</strong> </li></ul><h3 id="面试-1"><a href="#面试-1" class="headerlink" title="面试"></a>面试</h3><ol><li><strong><a href="https://book.douban.com/subject/6966465/" target="_blank" rel="noopener">《剑指Offer》</a>（豆瓣评分 8.3，0.7K+人评价）</strong>这本面试宝典上面涵盖了很多经典的算法面试题，如果你要准备大厂面试的话一定不要错过这本书。《剑指Offer》 对应的算法编程题部分的开源项目解析：<a href="https://github.com/gatieme/CodingInterviews" target="_blank" rel="noopener">CodingInterviews</a></li><li><strong><a href="https://book.douban.com/subject/30422021/" target="_blank" rel="noopener">程序员代码面试指南：IT名企算法与数据结构题目最优解（第2版）</a> （豆瓣评分 8.7，0.2K+人评价）</strong> ：题目相比于《剑指 offer》 来说要难很多，题目涵盖面相比于《剑指 offer》也更加全面。全书一共有将近300道真实出现过的经典代码面试题。</li><li><strong><a href="https://book.douban.com/subject/3004255/" target="_blank" rel="noopener">编程之美</a>（豆瓣评分 8.4，3K+人评价）</strong>：这本书收集了约60道算法和程序设计题目，这些题目大部分在近年的笔试、面试中出现过，或者是被微软员工热烈讨论过。作者试图从书中各种有趣的问题出发，引导读者发现问题，分析问题，解决问题，寻找更优的解法。</li></ol><h2 id="数据库"><a href="#数据库" class="headerlink" title="数据库"></a>数据库</h2><p><strong>MySQL:</strong></p><ul><li><strong><a href="https://book.douban.com/subject/23008813/" target="_blank" rel="noopener">《高性能 MySQL》</a></strong>：这本书不用多说了把！MySQL 领域的经典之作，拥有广泛的影响力。不但适合数据库管理员（dba）阅读，也适合开发人员参考学习。不管是数据库新手还是专家，相信都能从本书有所收获。如果你的时间不够的话，第5章关于索引的内容和第6章关于查询的内容是必读的！</li><li><a href="https://book.douban.com/subject/24708143/" target="_blank" rel="noopener">《MySQL 技术内幕-InnoDB 存储引擎》</a>（推荐，豆瓣评分 8.7）：了解 InnoDB 存储引擎底层原理必备的一本书，比较深入。</li></ul><p><strong>Redis:</strong></p><ul><li><strong><a href="https://book.douban.com/subject/26612779/" target="_blank" rel="noopener">《Redis 实战》</a></strong>：如果你想了解 Redis 的一些概念性知识的话，这本书真的非常不错。</li><li><strong><a href="https://book.douban.com/subject/25900156/" target="_blank" rel="noopener">《Redis 设计与实现》</a></strong>：也还行吧！</li></ul><h2 id="系统设计"><a href="#系统设计" class="headerlink" title="系统设计"></a>系统设计</h2><h3 id="设计模式"><a href="#设计模式" class="headerlink" title="设计模式"></a>设计模式</h3><ul><li><strong><a href="https://book.douban.com/subject/1052241/" target="_blank" rel="noopener">《设计模式 : 可复用面向对象软件的基础》</a></strong> ：设计模式的经典！</li><li><strong><a href="https://book.douban.com/subject/2243615/" target="_blank" rel="noopener">《Head First 设计模式（中文版）》</a></strong> ：相当赞的一本设计模式入门书籍。用实际的编程案例讲解算法设计中会遇到的各种问题和需求变更（对的，连需求变更都考虑到了！），并以此逐步推导出良好的设计模式解决办法。</li><li><strong><a href="https://book.douban.com/subject/2334288/" target="_blank" rel="noopener">《大话设计模式》</a></strong> ：本书通篇都是以情景对话的形式，用多个小故事或编程示例来组织讲解GOF(即《设计模式 : 可复用面向对象软件的基础》这本书))，但是不像《设计模式 : 可复用面向对象软件的基础》难懂。但是设计模式只看书是不够的，还是需要在实际项目中运用，在实战中体会。</li></ul><h3 id="常用框架"><a href="#常用框架" class="headerlink" title="常用框架"></a>常用框架</h3><h4 id="Spring-SpringBoot"><a href="#Spring-SpringBoot" class="headerlink" title="Spring/SpringBoot"></a>Spring/SpringBoot</h4><ul><li><strong><a href="https://book.douban.com/subject/26767354/" target="_blank" rel="noopener">《Spring 实战（第 4 版）》</a></strong> ：不建议当做入门书籍读，入门的话可以找点国人的书或者视频看。这本定位就相当于是关于 Spring 的新华字典，只有一些基本概念的介绍和示例，涵盖了 Spring 的各个方面，但都不够深入。就像作者在最后一页写的那样：“学习 Spring，这才刚刚开始”。</li><li><strong>《<a href="https://book.douban.com/subject/30452948/" target="_blank" rel="noopener">Spring源码深度解析 第2版</a>》</strong> ：读Spring源码必备的一本书籍。市面上关于Spring源码分析的书籍太少了。</li><li><strong><a href="https://book.douban.com/subject/30452637/" target="_blank" rel="noopener">《Spring 5高级编程（第5版）》</a></strong> ：推荐阅读，对于Spring5的新特性介绍的很好！不过内容比较多，可以作为工具书参考。</li><li><strong><a href="https://read.douban.com/ebook/58113975/?dcs=subject-rec&dcm=douban&dct=26767354" target="_blank" rel="noopener">《精通Spring4.x企业应用开发实战》</a></strong> :通过实战讲解，比较适合作为Spring入门书籍来看。</li><li><strong><a href="https://book.douban.com/subject/26652876/" target="_blank" rel="noopener">《Spring入门经典》</a></strong> ：适合入门，也有很多示例！</li><li><strong><a href="https://book.douban.com/subject/34894533/" target="_blank" rel="noopener">《Spring Boot实战派》</a></strong> ：这本书使用的Spring Boot 2.0+的版本，还算比较新。整本书采用“知识点+实例”的形式编写。本书通过“58个基于知识的实例+2个综合性的项目”，深入地讲解Spring Boot的技术原理、知识点和具体应用；把晦涩难懂的理论用实例展现出来，使得读者对知识的理解变得非常容易，同时也立即学会如何使用它。说实话，我还是比较推荐这本书的。</li><li><strong><a href="https://book.douban.com/subject/33390560/" target="_blank" rel="noopener">《Spring Boot编程思想（核心篇）》</a></strong> ：SpringBoot深入书，不适合初学者。书尤其的厚，这本书的缺点是书的很多知识点的讲解过于啰嗦和拖沓，优点是书中对SpringBoot内部原理讲解很清楚。</li></ul><h4 id="Netty"><a href="#Netty" class="headerlink" title="Netty"></a>Netty</h4><ul><li><strong><a href="https://book.douban.com/subject/30381214/" target="_blank" rel="noopener">《Netty进阶之路：跟着案例学Netty》</a></strong> : 这本书的优点是有不少实际的案例的讲解，通过案例来学习是很不错的！</li><li><strong><a href="https://waylau.gitbooks.io/netty-4-user-guide/content/" target="_blank" rel="noopener">《Netty 4.x 用户指南》</a></strong> ：《Netty 4.x 用户指南》中文翻译（包含了官方文档以及其他文章）。</li><li><strong><a href="https://juejin.im/book/5b4bc28bf265da0f60130116?referrer=59fbb2daf265da4319559f3a" target="_blank" rel="noopener">《Netty 入门与实战：仿写微信 IM 即时通讯系统》</a></strong> ：基于 Netty 框架实现 IM 核心系统，带你深入学习 Netty 网络编程核心知识</li><li><strong><a href="https://book.douban.com/subject/27038538/" target="_blank" rel="noopener">《Netty 实战》</a></strong> ：可以作为工具书参考！</li></ul><h3 id="分布式"><a href="#分布式" class="headerlink" title="分布式"></a>分布式</h3><ul><li><strong><a href="https://book.douban.com/subject/26292004/" target="_blank" rel="noopener">《从 Paxos 到 Zookeeper》</a></strong>：简要介绍几种典型的分布式一致性协议，以及解决分布式一致性问题的思路，其中重点讲解了 Paxos 和 ZAB 协议。同时，本书深入介绍了分布式一致性问题的工业解决方案——ZooKeeper，并着重向读者展示这一分布式协调框架的使用方法、内部实现及运维技巧，旨在帮助读者全面了解 ZooKeeper，并更好地使用和运维 ZooKeeper。</li><li><strong><a href="https://book.douban.com/subject/27591386/" target="_blank" rel="noopener">《RabbitMQ 实战指南》</a></strong>：《RabbitMQ 实战指南》从消息中间件的概念和 RabbitMQ 的历史切入，主要阐述 RabbitMQ 的安装、使用、配置、管理、运维、原理、扩展等方面的细节。如果你想浅尝 RabbitMQ 的使用，这本书是你最好的选择；如果你想深入 RabbitMQ 的原理，这本书也是你最好的选择；总之，如果你想玩转 RabbitMQ，这本书一定是最值得看的书之一</li><li><strong><a href="https://book.douban.com/subject/27025912/" target="_blank" rel="noopener">《Spring Cloud 微服务实战》</a></strong>：从时下流行的微服务架构概念出发，详细介绍了 Spring Cloud 针对微服务架构中几大核心要素的解决方案和基础组件。对于各个组件的介绍，《Spring Cloud 微服务实战》主要以示例与源码结合的方式来帮助读者更好地理解这些组件的使用方法以及运行原理。同时，在介绍的过程中，还包含了作者在实践中所遇到的一些问题和解决思路，可供读者在实践中作为参考。</li></ul><h3 id="网站架构"><a href="#网站架构" class="headerlink" title="网站架构"></a>网站架构</h3><ul><li><strong><a href="https://book.douban.com/subject/25723064/" target="_blank" rel="noopener">《大型网站技术架构：核心原理与案例分析+李智慧》</a></strong>:这本书我读过，基本不需要你有什么基础啊~读起来特别轻松，但是却可以学到很多东西，非常推荐了。另外我写过这本书的思维导图，关注我的微信公众号：“Java 面试通关手册”回复“大型网站技术架构”即可领取思维导图。</li><li><strong><a href="https://book.douban.com/subject/26999243/" target="_blank" rel="noopener">《亿级流量网站架构核心技术》</a></strong>：一书总结并梳理了亿级流量网站高可用和高并发原则，通过实例详细介绍了如何落地这些原则。本书分为四部分：概述、高可用原则、高并发原则、案例实战。从负载均衡、限流、降级、隔离、超时与重试、回滚机制、压测与预案、缓存、池化、异步化、扩容、队列等多方面详细介绍了亿级流量网站的架构核心技术，让读者看后能快速运用到实践项目中。</li></ul><h3 id="软件底层"><a href="#软件底层" class="headerlink" title="软件底层"></a>软件底层</h3><ul><li><strong><a href="https://book.douban.com/subject/10426640/" target="_blank" rel="noopener">《深入剖析 Tomcat》</a></strong>：本书深入剖析 Tomcat 4 和 Tomcat 5 中的每个组件，并揭示其内部工作原理。通过学习本书，你将可以自行开发 Tomcat 组件，或者扩展已有的组件。 读完这本书，基本可以摆脱背诵面试题的尴尬。</li><li><strong><a href="https://book.douban.com/subject/26745255/" target="_blank" rel="noopener">《深入理解 Nginx（第 2 版）》</a></strong>：作者讲的非常细致，注释都写的都很工整，对于 Nginx 的开发人员非常有帮助。优点是细致，缺点是过于细致，到处都是代码片段，缺少一些抽象。</li></ul><h3 id="其他"><a href="#其他" class="headerlink" title="其他"></a>其他</h3><ul><li><strong><a href="https://book.douban.com/subject/25953851/" target="_blank" rel="noopener">《深入分析 Java Web 技术内幕》</a></strong>： 感觉还行，涉及的东西也蛮多。</li></ul><h2 id="其他-1"><a href="#其他-1" class="headerlink" title="其他"></a>其他</h2><ul><li><p><strong><a href="https://read.douban.com/ebook/387525/?dcs=subject-rec&dcm=douban&dct=2243615" target="_blank" rel="noopener">《黑客与画家》</a></strong>：这本书是硅谷创业之父，Y Combinator 创始人 Paul Graham 的文集。之所以叫这个名字，是因为作者认为黑客（并非负面的那个意思）与画家有着极大的相似性，他们都是在创造，而不是完成某个任务。</p></li><li><p><strong><a href="https://book.douban.com/subject/26265544/" target="_blank" rel="noopener">《图解密码技术》</a></strong>：本书以<strong>图配文</strong>的形式，第一部分讲述了密码技术的历史沿革、对称密码、分组密码模式（包括ECB、CBC、CFB、OFB、CTR）、公钥、混合密码系统。第二部分重点介绍了认证方面的内容，涉及单向散列函数、消息认证码、数字签名、证书等。第三部分讲述了密钥、随机数、PGP、SSL/TLS 以及密码技术在现实生活中的应用。关键字：JWT 前置知识、区块链密码技术前置知识。属于密码知识入门书籍。</p></li><li><p>《人月神话》 、《程序开发心理学》 、《程序员修炼之道，从小工道专家》、 《高效程序员的45个习惯，敏捷开发修炼之道》 、《高效能程序员的修炼》 、《软技能，代码之外的生存之道》 、《程序员的职业素养》 、《程序员的思维修炼》</p></li></ul>]]></content>
<categories>
<category> Java </category>
<category> 面试 </category>
</categories>
<tags>
<tag> Java </tag>
<tag> 面试 </tag>
</tags>
</entry>
<entry>
<title>分享一些摘抄的优美句子~</title>
<link href="/2020/01/14/good/"/>
<url>/2020/01/14/good/</url>
<content type="html"><![CDATA[<h5 id="1-有一个夜晚我烧毁了所有的记忆，从此我的梦就透明了。有一个早晨我扔掉了所有的昨天，从此我的脚步就轻盈了。"><a href="#1-有一个夜晚我烧毁了所有的记忆，从此我的梦就透明了。有一个早晨我扔掉了所有的昨天，从此我的脚步就轻盈了。" class="headerlink" title="1.有一个夜晚我烧毁了所有的记忆，从此我的梦就透明了。有一个早晨我扔掉了所有的昨天，从此我的脚步就轻盈了。"></a>1.有一个夜晚我烧毁了所有的记忆，从此我的梦就透明了。有一个早晨我扔掉了所有的昨天，从此我的脚步就轻盈了。</h5><p>——泰戈尔</p><h5 id="2-我是你路上最后一个过客，最后一个春天，最后一场雪，最后一次求生的战争"><a href="#2-我是你路上最后一个过客，最后一个春天，最后一场雪，最后一次求生的战争" class="headerlink" title="2.我是你路上最后一个过客，最后一个春天，最后一场雪，最后一次求生的战争"></a>2.我是你路上最后一个过客，最后一个春天，最后一场雪，最后一次求生的战争</h5><p>——保尔 艾吕雅</p><h5 id="3-虽然我已经十年没见过他，但我知道我会永远想念他。后来我再也没有交过像十二岁时那帮人一样的好朋友。也许，每个人都是这样"><a href="#3-虽然我已经十年没见过他，但我知道我会永远想念他。后来我再也没有交过像十二岁时那帮人一样的好朋友。也许，每个人都是这样" class="headerlink" title="3.虽然我已经十年没见过他，但我知道我会永远想念他。后来我再也没有交过像十二岁时那帮人一样的好朋友。也许，每个人都是这样"></a>3.虽然我已经十年没见过他，但我知道我会永远想念他。后来我再也没有交过像十二岁时那帮人一样的好朋友。也许，每个人都是这样</h5><p>——罗伯莱纳</p><h5 id="4-在喧闹、混杂的生活中你应该与你的内心和平相处。尽管这世上有很多假冒和欺骗，有很多单调乏味的工作和众多破灭的梦幻，他仍然是一个美好的世界。记住：你应该努力的追求幸福。"><a href="#4-在喧闹、混杂的生活中你应该与你的内心和平相处。尽管这世上有很多假冒和欺骗，有很多单调乏味的工作和众多破灭的梦幻，他仍然是一个美好的世界。记住：你应该努力的追求幸福。" class="headerlink" title="4.在喧闹、混杂的生活中你应该与你的内心和平相处。尽管这世上有很多假冒和欺骗，有很多单调乏味的工作和众多破灭的梦幻，他仍然是一个美好的世界。记住：你应该努力的追求幸福。"></a>4.在喧闹、混杂的生活中你应该与你的内心和平相处。尽管这世上有很多假冒和欺骗，有很多单调乏味的工作和众多破灭的梦幻，他仍然是一个美好的世界。记住：你应该努力的追求幸福。</h5><p>（此文于1692年镌于巴尔的摩圣保罗教堂）</p><h5 id="5-我开始真正爱自己，我不再继续沉溺于过去，也不再为明天而忧虑，现在的我只活在一切在发生的当下，今天我活在此时此地，如此日复一日，这就叫”完美”。"><a href="#5-我开始真正爱自己，我不再继续沉溺于过去，也不再为明天而忧虑，现在的我只活在一切在发生的当下，今天我活在此时此地，如此日复一日，这就叫”完美”。" class="headerlink" title="5.我开始真正爱自己，我不再继续沉溺于过去，也不再为明天而忧虑，现在的我只活在一切在发生的当下，今天我活在此时此地，如此日复一日，这就叫”完美”。"></a>5.我开始真正爱自己，我不再继续沉溺于过去，也不再为明天而忧虑，现在的我只活在一切在发生的当下，今天我活在此时此地，如此日复一日，这就叫”完美”。</h5><p>——《当我开始爱自己》</p><h5 id="6-如果有一天你不再寻找爱情，只是去爱；你不再渴望成功，只是去做；你不再追逐成长，只是去修；一切才真正开始"><a href="#6-如果有一天你不再寻找爱情，只是去爱；你不再渴望成功，只是去做；你不再追逐成长，只是去修；一切才真正开始" class="headerlink" title="6.如果有一天你不再寻找爱情，只是去爱；你不再渴望成功，只是去做；你不再追逐成长，只是去修；一切才真正开始"></a>6.如果有一天你不再寻找爱情，只是去爱；你不再渴望成功，只是去做；你不再追逐成长，只是去修；一切才真正开始</h5><p>——纪伯伦</p><h5 id="7-我原谅了从前的自己，就像谅解了一个野心勃勃的傻逼，体恤了一个笨手笨脚的勇士，释怀了一个难以启齿的秘密。"><a href="#7-我原谅了从前的自己，就像谅解了一个野心勃勃的傻逼，体恤了一个笨手笨脚的勇士，释怀了一个难以启齿的秘密。" class="headerlink" title="7.我原谅了从前的自己，就像谅解了一个野心勃勃的傻逼，体恤了一个笨手笨脚的勇士，释怀了一个难以启齿的秘密。"></a>7.我原谅了从前的自己，就像谅解了一个野心勃勃的傻逼，体恤了一个笨手笨脚的勇士，释怀了一个难以启齿的秘密。</h5><h5 id="8-原来可以这样爱你，什么也可以说，什么也可以不说。让我采一束月光吧！插在今夜我寂寥的窗前。过了今夜，我不会再有力气为你写诗和流泪。"><a href="#8-原来可以这样爱你，什么也可以说，什么也可以不说。让我采一束月光吧！插在今夜我寂寥的窗前。过了今夜，我不会再有力气为你写诗和流泪。" class="headerlink" title="8.原来可以这样爱你，什么也可以说，什么也可以不说。让我采一束月光吧！插在今夜我寂寥的窗前。过了今夜，我不会再有力气为你写诗和流泪。"></a>8.原来可以这样爱你，什么也可以说，什么也可以不说。让我采一束月光吧！插在今夜我寂寥的窗前。过了今夜，我不会再有力气为你写诗和流泪。</h5><p>——海烟</p><h5 id="9-我不知该如何珍藏明里这份温暖，也不知该将她的灵魂带往何处。我清楚地明白，我们无法保证将来能够永远在一起。横亘在我们面前的是那沉重的人生于漫长时间，让人不由得产生一种无力感"><a href="#9-我不知该如何珍藏明里这份温暖，也不知该将她的灵魂带往何处。我清楚地明白，我们无法保证将来能够永远在一起。横亘在我们面前的是那沉重的人生于漫长时间，让人不由得产生一种无力感" class="headerlink" title="9.我不知该如何珍藏明里这份温暖，也不知该将她的灵魂带往何处。我清楚地明白，我们无法保证将来能够永远在一起。横亘在我们面前的是那沉重的人生于漫长时间，让人不由得产生一种无力感"></a>9.我不知该如何珍藏明里这份温暖，也不知该将她的灵魂带往何处。我清楚地明白，我们无法保证将来能够永远在一起。横亘在我们面前的是那沉重的人生于漫长时间，让人不由得产生一种无力感</h5><p>——新海诚</p><h5 id="10-此刻有谁在世上某处哭，无缘无故在世上哭，在哭我。此刻有谁在夜间某处笑，无缘无故的在夜间笑，在笑我。此刻有谁在世上某处走，无缘无故的在世上走，走向我。此刻有谁在世上某处死，无缘无故在世上死，望着我。"><a href="#10-此刻有谁在世上某处哭，无缘无故在世上哭，在哭我。此刻有谁在夜间某处笑，无缘无故的在夜间笑，在笑我。此刻有谁在世上某处走，无缘无故的在世上走，走向我。此刻有谁在世上某处死，无缘无故在世上死，望着我。" class="headerlink" title="10.此刻有谁在世上某处哭，无缘无故在世上哭，在哭我。此刻有谁在夜间某处笑，无缘无故的在夜间笑，在笑我。此刻有谁在世上某处走，无缘无故的在世上走，走向我。此刻有谁在世上某处死，无缘无故在世上死，望着我。"></a>10.此刻有谁在世上某处哭，无缘无故在世上哭，在哭我。此刻有谁在夜间某处笑，无缘无故的在夜间笑，在笑我。此刻有谁在世上某处走，无缘无故的在世上走，走向我。此刻有谁在世上某处死，无缘无故在世上死，望着我。</h5><p>——里尔克</p><p><img src="https://upload-images.jianshu.io/upload_images/7326374-f33e20c34492e783.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="高山森林"></p><h5 id="11-不惋惜，不呼唤，我也不啼哭。一切将逝去。如苹果花丛的薄雾。金黄的落叶堆满心间，我已不再是青春少年"><a href="#11-不惋惜，不呼唤，我也不啼哭。一切将逝去。如苹果花丛的薄雾。金黄的落叶堆满心间，我已不再是青春少年" class="headerlink" title="11.不惋惜，不呼唤，我也不啼哭。一切将逝去。如苹果花丛的薄雾。金黄的落叶堆满心间，我已不再是青春少年"></a>11.不惋惜，不呼唤，我也不啼哭。一切将逝去。如苹果花丛的薄雾。金黄的落叶堆满心间，我已不再是青春少年</h5><p>——叶赛宁</p><h5 id="12-多希望我知道如何放弃你，你什么都没留给我却活在我心里。"><a href="#12-多希望我知道如何放弃你，你什么都没留给我却活在我心里。" class="headerlink" title="12.多希望我知道如何放弃你，你什么都没留给我却活在我心里。"></a>12.多希望我知道如何放弃你，你什么都没留给我却活在我心里。</h5><h5 id="13-最要紧的是，我们首先应该知道善良，其次要诚实，再其次是以后永远不要互相遗忘。"><a href="#13-最要紧的是，我们首先应该知道善良，其次要诚实，再其次是以后永远不要互相遗忘。" class="headerlink" title="13.最要紧的是，我们首先应该知道善良，其次要诚实，再其次是以后永远不要互相遗忘。"></a>13.最要紧的是，我们首先应该知道善良，其次要诚实，再其次是以后永远不要互相遗忘。</h5><h5 id="14-我向旧日的恋人道歉，因为我对新人如同初恋。"><a href="#14-我向旧日的恋人道歉，因为我对新人如同初恋。" class="headerlink" title="14.我向旧日的恋人道歉，因为我对新人如同初恋。"></a>14.我向旧日的恋人道歉，因为我对新人如同初恋。</h5><p>——辛波斯卡</p><h5 id="15-我永恒的灵魂，注视着你的心，纵然黑夜孤寂白昼如焚。"><a href="#15-我永恒的灵魂，注视着你的心，纵然黑夜孤寂白昼如焚。" class="headerlink" title="15.我永恒的灵魂，注视着你的心，纵然黑夜孤寂白昼如焚。"></a>15.我永恒的灵魂，注视着你的心，纵然黑夜孤寂白昼如焚。</h5><p>——兰波</p><h5 id="16-我常想，如果我拍够了足够的照片，我就不会再失去任何人。事实上，我的照片让我看到了我失去了多少"><a href="#16-我常想，如果我拍够了足够的照片，我就不会再失去任何人。事实上，我的照片让我看到了我失去了多少" class="headerlink" title="16.我常想，如果我拍够了足够的照片，我就不会再失去任何人。事实上，我的照片让我看到了我失去了多少"></a>16.我常想，如果我拍够了足够的照片，我就不会再失去任何人。事实上，我的照片让我看到了我失去了多少</h5><p>——南戈尔丁</p><h5 id="17-知识让我们愤世嫉俗，聪明让我们铁石心肠。我们想的太多，同情太少，除了机器我们更需要善良，没有这些品质，生命就没有意义。"><a href="#17-知识让我们愤世嫉俗，聪明让我们铁石心肠。我们想的太多，同情太少，除了机器我们更需要善良，没有这些品质，生命就没有意义。" class="headerlink" title="17.知识让我们愤世嫉俗，聪明让我们铁石心肠。我们想的太多，同情太少，除了机器我们更需要善良，没有这些品质，生命就没有意义。"></a>17.知识让我们愤世嫉俗，聪明让我们铁石心肠。我们想的太多，同情太少，除了机器我们更需要善良，没有这些品质，生命就没有意义。</h5><p>——卓别林</p><h5 id="18-你别赤脚走在这片草地上散步，我怕我的花园到处都是星星的碎片。"><a href="#18-你别赤脚走在这片草地上散步，我怕我的花园到处都是星星的碎片。" class="headerlink" title="18.你别赤脚走在这片草地上散步，我怕我的花园到处都是星星的碎片。"></a>18.你别赤脚走在这片草地上散步，我怕我的花园到处都是星星的碎片。</h5><p>——伊迪斯 索德格朗</p><h5 id="19-身体里的碳可以制成九千支铅笔，赠给诗人。身体里的铁，只够打成一枚铁钉，就钉在爱人的心上。"><a href="#19-身体里的碳可以制成九千支铅笔，赠给诗人。身体里的铁，只够打成一枚铁钉，就钉在爱人的心上。" class="headerlink" title="19.身体里的碳可以制成九千支铅笔，赠给诗人。身体里的铁，只够打成一枚铁钉，就钉在爱人的心上。"></a>19.身体里的碳可以制成九千支铅笔，赠给诗人。身体里的铁，只够打成一枚铁钉，就钉在爱人的心上。</h5><h5 id="20-岁月有加，并非垂老。理想丢弃，方坠暮年。岁月悠悠，衰微只及肌肤。热忱抛却，颓废必致灵魂。"><a href="#20-岁月有加，并非垂老。理想丢弃，方坠暮年。岁月悠悠，衰微只及肌肤。热忱抛却，颓废必致灵魂。" class="headerlink" title="20.岁月有加，并非垂老。理想丢弃，方坠暮年。岁月悠悠，衰微只及肌肤。热忱抛却，颓废必致灵魂。"></a>20.岁月有加，并非垂老。理想丢弃，方坠暮年。岁月悠悠，衰微只及肌肤。热忱抛却，颓废必致灵魂。</h5><p>——塞缪尔 厄尔曼</p><h5 id="21-情不知所起，一往而深"><a href="#21-情不知所起，一往而深" class="headerlink" title="21.情不知所起，一往而深"></a>21.情不知所起，一往而深</h5><p>——汤显祖</p><h5 id="22-渐渐觉得，友谊这个东西已经被世人捧的太高，它跟永恒其实没有太大关系。换了空间时间，总会有人离去。也总会有与当下的你心有相同的同伴不断出现，来陪你走接下来或短或长的人生。所以不要太念念不忘。也不要期待有什么回响。你要从同路者中寻找同伴，而非硬拽着旧人一起上路。"><a href="#22-渐渐觉得，友谊这个东西已经被世人捧的太高，它跟永恒其实没有太大关系。换了空间时间，总会有人离去。也总会有与当下的你心有相同的同伴不断出现，来陪你走接下来或短或长的人生。所以不要太念念不忘。也不要期待有什么回响。你要从同路者中寻找同伴，而非硬拽着旧人一起上路。" class="headerlink" title="22.渐渐觉得，友谊这个东西已经被世人捧的太高，它跟永恒其实没有太大关系。换了空间时间，总会有人离去。也总会有与当下的你心有相同的同伴不断出现，来陪你走接下来或短或长的人生。所以不要太念念不忘。也不要期待有什么回响。你要从同路者中寻找同伴，而非硬拽着旧人一起上路。"></a>22.渐渐觉得，友谊这个东西已经被世人捧的太高，它跟永恒其实没有太大关系。换了空间时间，总会有人离去。也总会有与当下的你心有相同的同伴不断出现，来陪你走接下来或短或长的人生。所以不要太念念不忘。也不要期待有什么回响。你要从同路者中寻找同伴，而非硬拽着旧人一起上路。</h5><h5 id="23-世界上最大的勇气，是压力下的优雅。"><a href="#23-世界上最大的勇气，是压力下的优雅。" class="headerlink" title="23.世界上最大的勇气，是压力下的优雅。"></a>23.世界上最大的勇气，是压力下的优雅。</h5><p>——海明威</p><h5 id="24-为你，千千万万遍"><a href="#24-为你，千千万万遍" class="headerlink" title="24.为你，千千万万遍"></a>24.为你，千千万万遍</h5><p>——卡勒德 胡塞尼</p><h5 id="25-你，一会看我一会看云；你看我时很远，你看云时很近"><a href="#25-你，一会看我一会看云；你看我时很远，你看云时很近" class="headerlink" title="25.你，一会看我一会看云；你看我时很远，你看云时很近"></a>25.你，一会看我一会看云；你看我时很远，你看云时很近</h5><p>——顾城</p><h5 id="26"><a href="#26" class="headerlink" title="26."></a>26.</h5><p>草在结它的种子</p><p>树在摇它的叶子</p><p>我们站着 不说话</p><p>就十分美好</p><p>——顾城《门前》</p><h5 id="27-曾国藩的交友原则，八交九不交："><a href="#27-曾国藩的交友原则，八交九不交：" class="headerlink" title="27.曾国藩的交友原则，八交九不交："></a>27.曾国藩的交友原则，八交九不交：</h5><p>八交：胜己者；盛德者；趣味者；肯吃亏者；直言者；志趣广大者；惠在当厄者；体人者</p><p>九不交：志不同者；谀人者；恩怨颠倒者；全无性情者；不孝不悌者；迂人者；落井下石者；德薄者；好占便宜者。</p><h5 id="28-那一天我二十一岁，在我一生的黄金时代。我有好多奢望。我想爱，我想吃，我还想一瞬间变成天上半明半暗的云。"><a href="#28-那一天我二十一岁，在我一生的黄金时代。我有好多奢望。我想爱，我想吃，我还想一瞬间变成天上半明半暗的云。" class="headerlink" title="28.那一天我二十一岁，在我一生的黄金时代。我有好多奢望。我想爱，我想吃，我还想一瞬间变成天上半明半暗的云。"></a>28.那一天我二十一岁，在我一生的黄金时代。我有好多奢望。我想爱，我想吃，我还想一瞬间变成天上半明半暗的云。</h5><p>——王小波《黄金时代》</p><h5 id="29-从童年起，我便独自一人照顾着历代星辰"><a href="#29-从童年起，我便独自一人照顾着历代星辰" class="headerlink" title="29.从童年起，我便独自一人照顾着历代星辰"></a>29.从童年起，我便独自一人照顾着历代星辰</h5><p>——《孤独》白鹤林</p><h5 id="30-这样看你，用所有的眼睛和所有距离，就像风住了，风又起"><a href="#30-这样看你，用所有的眼睛和所有距离，就像风住了，风又起" class="headerlink" title="30.这样看你，用所有的眼睛和所有距离，就像风住了，风又起"></a>30.这样看你，用所有的眼睛和所有距离，就像风住了，风又起</h5><p>——《沉溺》冯唐<br><img src="https://upload-images.jianshu.io/upload_images/7326374-abdbf1d8c37fcc71.jpeg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="蓝天海滩"></p><h5 id="31-人时已尽，人世很长。我在中间应当休息，走过的人说树枝低了，走过的人说树枝在长。"><a href="#31-人时已尽，人世很长。我在中间应当休息，走过的人说树枝低了，走过的人说树枝在长。" class="headerlink" title="31.人时已尽，人世很长。我在中间应当休息，走过的人说树枝低了，走过的人说树枝在长。"></a>31.人时已尽，人世很长。我在中间应当休息，走过的人说树枝低了，走过的人说树枝在长。</h5><p>——《墓床》顾城</p><h5 id="32-万物皆有裂痕，那是光进来的地方。"><a href="#32-万物皆有裂痕，那是光进来的地方。" class="headerlink" title="32.万物皆有裂痕，那是光进来的地方。"></a>32.万物皆有裂痕，那是光进来的地方。</h5><p>——莱昂纳德 科恩</p><h5 id="33-成功只有一种，那就是用自己喜欢的方式度过一生"><a href="#33-成功只有一种，那就是用自己喜欢的方式度过一生" class="headerlink" title="33.成功只有一种，那就是用自己喜欢的方式度过一生"></a>33.成功只有一种，那就是用自己喜欢的方式度过一生</h5><p>——《明朝那些事》原出于美国记者</p><h5 id="34-生活永远不可能像你想象的那么好，但也不会像你想象的那么糟，无论是好的还是糟糕的时候都需要坚强"><a href="#34-生活永远不可能像你想象的那么好，但也不会像你想象的那么糟，无论是好的还是糟糕的时候都需要坚强" class="headerlink" title="34.生活永远不可能像你想象的那么好，但也不会像你想象的那么糟，无论是好的还是糟糕的时候都需要坚强"></a>34.生活永远不可能像你想象的那么好，但也不会像你想象的那么糟，无论是好的还是糟糕的时候都需要坚强</h5><p>——《人生》莫泊桑</p><h5 id="35-谁这时没有房屋，就不必建筑；谁这时孤独，就永远孤独，就醒着，读着，写着长信。在林荫道上来回，不安的游荡，当落叶纷飞。"><a href="#35-谁这时没有房屋，就不必建筑；谁这时孤独，就永远孤独，就醒着，读着，写着长信。在林荫道上来回，不安的游荡，当落叶纷飞。" class="headerlink" title="35.谁这时没有房屋，就不必建筑；谁这时孤独，就永远孤独，就醒着，读着，写着长信。在林荫道上来回，不安的游荡，当落叶纷飞。"></a>35.谁这时没有房屋，就不必建筑；谁这时孤独，就永远孤独，就醒着，读着，写着长信。在林荫道上来回，不安的游荡，当落叶纷飞。</h5><p>——《秋日》里尔克</p><h5 id="36-也许，我太会隐藏自己的悲伤；也许我太会安慰自己的伤；从阴雨走到艳阳，我路过泥泞，路过风"><a href="#36-也许，我太会隐藏自己的悲伤；也许我太会安慰自己的伤；从阴雨走到艳阳，我路过泥泞，路过风" class="headerlink" title="36.也许，我太会隐藏自己的悲伤；也许我太会安慰自己的伤；从阴雨走到艳阳，我路过泥泞，路过风"></a>36.也许，我太会隐藏自己的悲伤；也许我太会安慰自己的伤；从阴雨走到艳阳，我路过泥泞，路过风</h5><p>——《你若懂我 该多好》</p><h5 id="37-我想无论是在塞纳河还是滹沱河边，我们两个人都已经放下彼此，所以我并没有等，她也不会在那个路灯下了，那个灯光下笑盈盈的她和慌张无力却又自大的我，永远属于了二十出头的我们，仅止于此我很满足，毕竟我们都要朝着让自己幸福努力。"><a href="#37-我想无论是在塞纳河还是滹沱河边，我们两个人都已经放下彼此，所以我并没有等，她也不会在那个路灯下了，那个灯光下笑盈盈的她和慌张无力却又自大的我，永远属于了二十出头的我们，仅止于此我很满足，毕竟我们都要朝着让自己幸福努力。" class="headerlink" title="37.我想无论是在塞纳河还是滹沱河边，我们两个人都已经放下彼此，所以我并没有等，她也不会在那个路灯下了，那个灯光下笑盈盈的她和慌张无力却又自大的我，永远属于了二十出头的我们，仅止于此我很满足，毕竟我们都要朝着让自己幸福努力。"></a>37.我想无论是在塞纳河还是滹沱河边，我们两个人都已经放下彼此，所以我并没有等，她也不会在那个路灯下了，那个灯光下笑盈盈的她和慌张无力却又自大的我，永远属于了二十出头的我们，仅止于此我很满足，毕竟我们都要朝着让自己幸福努力。</h5><h5 id="38-一个人有两个我，一个在黑暗中醒着，一个在光明中睡着"><a href="#38-一个人有两个我，一个在黑暗中醒着，一个在光明中睡着" class="headerlink" title="38.一个人有两个我，一个在黑暗中醒着，一个在光明中睡着"></a>38.一个人有两个我，一个在黑暗中醒着，一个在光明中睡着</h5><p>——纪伯伦</p><h5 id="39-若我会见到你，事隔经年，我如何向你招呼，以眼泪，以沉默"><a href="#39-若我会见到你，事隔经年，我如何向你招呼，以眼泪，以沉默" class="headerlink" title="39.若我会见到你，事隔经年，我如何向你招呼，以眼泪，以沉默"></a>39.若我会见到你，事隔经年，我如何向你招呼，以眼泪，以沉默</h5><p>——拜伦</p><h5 id="40-枕上诗书闲处好，门前风景雨来佳"><a href="#40-枕上诗书闲处好，门前风景雨来佳" class="headerlink" title="40.枕上诗书闲处好，门前风景雨来佳"></a>40.枕上诗书闲处好，门前风景雨来佳</h5><p>——李清照<br><img src="https://upload-images.jianshu.io/upload_images/7326374-87ba94de06d5cd74.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="夕阳风雪"></p><h2 id="文末"><a href="#文末" class="headerlink" title="文末"></a>文末</h2><blockquote><p>欢迎关注个人微信公众号：<strong>Coder编程</strong><br>欢迎关注<strong>Coder编程</strong>公众号，主要分享数据结构与算法、Java相关知识体系、框架知识及原理、Spring全家桶、微服务项目实战、DevOps实践之路、每日一篇互联网大厂面试或笔试题以及PMP项目管理知识等。更多精彩内容正在路上~<br>也分享一些杂文~</p></blockquote><blockquote><p>文章收录至<br>Github: <a href="https://github.com/CoderMerlin/coder-programming" target="_blank" rel="noopener">https://github.com/CoderMerlin/coder-programming</a><br>Gitee: <a href="https://gitee.com/573059382/coder-programming" target="_blank" rel="noopener">https://gitee.com/573059382/coder-programming</a><br>欢迎<strong>关注</strong>并star~<br><img src="https://upload-images.jianshu.io/upload_images/7326374-0c30c361239e4cca?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="微信公众号"></p></blockquote>]]></content>
<categories>
<category> 美文 </category>
</categories>
<tags>
<tag> 美文 </tag>
</tags>
</entry>
<entry>
<title>Java面试集锦：25道线程类相关面试题与答案（一）</title>
<link href="/2019/11/14/interview/java/A-thread01/"/>
<url>/2019/11/14/interview/java/A-thread01/</url>
<content type="html"><![CDATA[<p><img src="https://upload-images.jianshu.io/upload_images/7326374-333fa10a973e7519.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="Java面试集锦：25道线程类相关面试题与答案（一）.png"></p><blockquote><p>每天进步一点，不做curd工程师与Api调用工程师<br>欢迎访问个人网站：<a href="https://www.coder-programming.cn/" target="_blank" rel="noopener">https://www.coder-programming.cn/</a></p></blockquote><h3 id="1-线程是什么？进程是什么？二者有什么区别和联系？"><a href="#1-线程是什么？进程是什么？二者有什么区别和联系？" class="headerlink" title="1. 线程是什么？进程是什么？二者有什么区别和联系？"></a>1. 线程是什么？进程是什么？二者有什么区别和联系？</h3><p>（1）线程是CPU独立运行和独立调度的基本单位；<br>（2）进程是资源分配的基本单位；是执行着的应用程序<br>两者的联系：进程和线程都是操作系统所运行的程序运行的基本单元。</p><p><strong>区别：</strong><br>（1）进程具有独立的空间地址，一个进程崩溃后，在保护模式下不会对其它进程产生影响。<br>（2）线程只是一个进程的不同执行路径，线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉。</p><p>进程是执行着的应用程序，而线程是进程内部的一个执行序列。一个进程可以有多个线程。线程又叫做轻量级进程。</p><h3 id="2-线程和进程各自有什么区别和优劣呢？"><a href="#2-线程和进程各自有什么区别和优劣呢？" class="headerlink" title="2. 线程和进程各自有什么区别和优劣呢？"></a>2. 线程和进程各自有什么区别和优劣呢？</h3><p>进程是资源分配的最小单位，线程是程序执行的最小单位。</p><p>进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵。而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多。</p><p>线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式（IPC)进行。不过如何处理好同步与互斥是编写多线程程序的难点。</p><p>但是多进程程序更健壮，多线程程序只要有一个线程死掉，整个进程也死掉了，而一个进程死掉并不会对另外一个进程造成影响，因为进程有自己独立的地址空间。</p><p>可参考文章<a href=""></a></p><h3 id="3-创建线程有几种不同的方式？你喜欢哪一种？为什么？"><a href="#3-创建线程有几种不同的方式？你喜欢哪一种？为什么？" class="headerlink" title="3. 创建线程有几种不同的方式？你喜欢哪一种？为什么？"></a>3. 创建线程有几种不同的方式？你喜欢哪一种？为什么？</h3><p>有三种方式可以用来创建线程：</p><p>继承<code>Thread</code>类</p><p>实现<code>Runnable</code>接口</p><p>应用程序可以使用Executor框架来创建线程池</p><p>实现<code>Runnable接口</code>这种方式更受欢迎，因为这不需要继承<code>Thread</code>类。在应用设计中已经继承了别的对象的情况下，这需要多继承（而Java不支持多继承），只能实现接口。同时，线程池也是非常高效的，很容易实现和使用。</p><h3 id="4-概括的解释下线程的几种可用状态"><a href="#4-概括的解释下线程的几种可用状态" class="headerlink" title="4. 概括的解释下线程的几种可用状态?"></a>4. 概括的解释下线程的几种可用状态?</h3><p>线程在执行过程中，可以处于下面几种状态：</p><p><strong>就绪(Runnable)</strong>:线程准备运行，不一定立马就能开始执行。</p><p><strong>运行中(Running)</strong>：进程正在执行线程的代码。</p><p><strong>等待中(Waiting)</strong>:线程处于阻塞的状态，等待外部的处理结束。</p><p><strong>睡眠中(Sleeping)</strong>：线程被强制睡眠。</p><p><strong>I/O阻塞(Blocked on I/O)</strong>：等待I/O操作完成。</p><p><strong>同步阻塞(Blocked on Synchronization)</strong>：等待获取锁。</p><p><strong>死亡(Dead)</strong>：线程完成了执行。</p><h3 id="5-同步方法和同步代码块的区别是什么？"><a href="#5-同步方法和同步代码块的区别是什么？" class="headerlink" title="5. 同步方法和同步代码块的区别是什么？"></a>5. 同步方法和同步代码块的区别是什么？</h3><p>在Java语言中，每一个对象有一把锁。线程可以使用synchronized关键字来获取对象上的锁。synchronized关键字可应用在方法级别(粗粒度锁)或者是代码块级别(细粒度锁)。</p><p>Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。</p><p>（1）、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。</p><p>（2）、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。</p><p>（3）、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。</p><p>（4）、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。</p><p>（5）、以上规则对其它对象锁同样适用。</p><h3 id="6-在监视器-Monitor-内部，是如何做线程同步的？程序应该做哪种级别的同步？"><a href="#6-在监视器-Monitor-内部，是如何做线程同步的？程序应该做哪种级别的同步？" class="headerlink" title="6. 在监视器(Monitor)内部，是如何做线程同步的？程序应该做哪种级别的同步？"></a>6. 在监视器(Monitor)内部，是如何做线程同步的？程序应该做哪种级别的同步？</h3><p>监视器和锁在Java虚拟机中是一块使用的。监视器监视一块同步代码块，确保一次只有一个线程执行同步代码块。每一个监视器都和一个对象引用相关联。线程在获取锁之前不允许执行同步代码。</p><h3 id="7-什么是死锁-deadlock-？"><a href="#7-什么是死锁-deadlock-？" class="headerlink" title="7. 什么是死锁(deadlock)？"></a>7. 什么是死锁(deadlock)？</h3><p>两个进程都在等待对方执行完毕才能继续往下执行的时候就发生了死锁。结果就是两个进程都陷入了无限的等待中。</p><h3 id="8-如何确保N个线程可以访问N个资源同时又不导致死锁？"><a href="#8-如何确保N个线程可以访问N个资源同时又不导致死锁？" class="headerlink" title="8. 如何确保N个线程可以访问N个资源同时又不导致死锁？"></a>8. 如何确保N个线程可以访问N个资源同时又不导致死锁？</h3><p>使用多线程的时候，一种非常简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁了。</p><h3 id="9-如何避免死锁"><a href="#9-如何避免死锁" class="headerlink" title="9. 如何避免死锁?"></a>9. 如何避免死锁?</h3><p>多线程产生死锁的四个必要条件：<br><strong>互斥条件：</strong> 一个资源每次只能被一个进程使用。<br><strong>保持和请求条件：</strong> 一个进程因请求资源而阻塞时，对已获得资源保持不放。<br><strong>不可剥夺调教：</strong> 进程已获得资源，在未使用完成前，不能被剥夺。<br><strong>循环等待条件：</strong> 若干进程之间形成一种头尾相接的循环等待资源关系。</p><p>只要破坏其中任意一个条件，就可以避免死锁，其中最简单的就是破环循环等待条件。按同一顺序访问对象，加载锁，释放锁。</p><h3 id="10-Thread-类中的start-和-run-方法有什么区别？"><a href="#10-Thread-类中的start-和-run-方法有什么区别？" class="headerlink" title="10. Thread 类中的start() 和 run() 方法有什么区别？"></a>10. Thread 类中的start() 和 run() 方法有什么区别？</h3><p>start()方法被用来启动新创建的线程，使该被创建的线程状态变为可运行状态。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。如果我们调用了Thread的run()方法，它的行为就会和普通的方法一样，直接运行run（）方法。为了在新的线程中执行我们的代码，必须使用Thread.start()方法。</p><h3 id="11-Java中Runnable和Callable有什么不同？"><a href="#11-Java中Runnable和Callable有什么不同？" class="headerlink" title="11. Java中Runnable和Callable有什么不同？"></a>11. Java中Runnable和Callable有什么不同？</h3><p>Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了，Callable是在JDK1.5增加的。它们的主要区别是Callable的 call() 方法可以返回值和抛出异常，而Runnable的run()方法没有这些功能。Callable可以返回装载有计算结果的Future对象。</p><h3 id="12-Java中什么是竞态条件？"><a href="#12-Java中什么是竞态条件？" class="headerlink" title="12. Java中什么是竞态条件？"></a>12. Java中什么是竞态条件？</h3><p>在大多数实际的多线程应用中，两个或两个以上的线程需要共享对同一数据的存取。如果i线程存取相同的对象，并且每一个线程都调用了一个修改该对象状态的方法，将会发生什么呢？可以想象，线程彼此踩了对方的脚。根据线程访问数据的次序，可能会产生讹误的对象。这样的情况通常称为竞争条件。</p><h3 id="13-Java中如何停止一个线程？"><a href="#13-Java中如何停止一个线程？" class="headerlink" title="13. Java中如何停止一个线程？"></a>13. Java中如何停止一个线程？</h3><p><code>Java</code>提供了很丰富的API但没有为停止线程提供API。<br><code>JDK 1.0</code>本来有一些像<code>stop()</code>, <code>suspend()</code> 和 <code>resume()</code>的控制方法，但是由于潜在的死锁威胁。<br>因此在后续的JDK版本中他们被弃用了，之后Java API的设计者就没有提供一个兼容且线程安全的方法来停止一个线程。<br>当<code>run()</code>或者 <code>call()</code> 方法执行完的时候线程会自动结束，如果要手动结束一个线程，可以用<code>volatile</code> 布尔变量来退出<code>run()</code>方法的循环或者是取消任务来中断线程。</p><h3 id="14-Java中notify-和-notifyAll有什么区别？"><a href="#14-Java中notify-和-notifyAll有什么区别？" class="headerlink" title="14. Java中notify 和 notifyAll有什么区别？"></a>14. Java中notify 和 notifyAll有什么区别？</h3><p>一个很明显的原因是JAVA提供的锁是对象级的而不是线程级的，每个对象都有锁，通过线程获得。<br>如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了。如果wait()方法定义在Thread类中，线程正在等待的是哪个锁就不明显了。简单的说，由于wait，notify和notifyAll都是锁级别的操作，所以把他们定义在Object类中因为锁属于对象。</p><h3 id="15-Java中的同步集合与并发集合有什么区别？"><a href="#15-Java中的同步集合与并发集合有什么区别？" class="headerlink" title="15. Java中的同步集合与并发集合有什么区别？"></a>15. Java中的同步集合与并发集合有什么区别？</h3><p>同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合，不过并发集合的可扩展性更高。<br>在<code>Java1.5</code>之前程序员们只有同步集合来用且在多线程并发的时候会导致争用，阻碍了系统的扩展性。Java5介绍了并发集合像<code>ConcurrentHashMap</code>，不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。</p><h3 id="16-什么是线程池？"><a href="#16-什么是线程池？" class="headerlink" title="16. 什么是线程池？"></a>16. 什么是线程池？</h3><p>线程池是一种多线程处理形式，处理过程中将任务提交到线程池，任务的执行交由线程池来管理。<br>如果每个请求都创建一个线程去处理，那么服务器的资源很快就会被耗尽，使用线程池可以减少创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。</p><h3 id="17-为什么要使用线程池？"><a href="#17-为什么要使用线程池？" class="headerlink" title="17. 为什么要使用线程池？"></a>17. 为什么要使用线程池？</h3><p>创建线程和销毁线程的花销是比较大的，这些时间有可能比处理业务的时间还要长。这样频繁的创建线程和销毁线程，再加上业务工作线程，消耗系统资源的时间，可能导致系统资源不足。（我们可以把创建和销毁的线程的过程去掉）</p><h3 id="18-线程池有什么作用？"><a href="#18-线程池有什么作用？" class="headerlink" title="18. 线程池有什么作用？"></a>18. 线程池有什么作用？</h3><p>线程池作用就是限制系统中执行线程的数量。</p><p>1、提高效率 创建好一定数量的线程放在池中，等需要使用的时候就从池中拿一个，这要比需要的时候创建一个线程对象要快的多。</p><p>2、方便管理 可以编写线程池管理代码对池中的线程同一进行管理，比如说启动时有该程序创建100个线程，每当有请求的时候，就分配一个线程去工作，如果刚好并发有101个请求，那多出的这一个请求可以排队等候，避免因无休止的创建线程导致系统崩溃。</p><h3 id="19-说说几种常见的线程池及使用场景"><a href="#19-说说几种常见的线程池及使用场景" class="headerlink" title="19. 说说几种常见的线程池及使用场景?"></a>19. 说说几种常见的线程池及使用场景?</h3><p>1、<code>newSingleThreadExecutor</code>创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。</p><p>2、<code>newFixedThreadPool</code>创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。</p><p>3、<code>newCachedThreadPool</code>创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。</p><p>4、<code>newScheduledThreadPool</code>创建一个定长线程池，支持定时及周期性任务执行。</p><h3 id="20-线程池中的几种重要的参数"><a href="#20-线程池中的几种重要的参数" class="headerlink" title="20. 线程池中的几种重要的参数?"></a>20. 线程池中的几种重要的参数?</h3><p><code>corePoolSize</code>就是线程池中的核心线程数量，这几个核心线程，只是在没有用的时候，也不会被回收</p><p><code>maximumPoolSize</code>就是线程池中可以容纳的最大线程的数量</p><p><code>keepAliveTime</code>，就是线程池中除了核心线程之外的其他的最长可以保留的时间，因为在线程池中，除了核心线程即使在无任务的情况下也不能被清除，其余的都是有存活时间的，意思就是非核心线程可以保留的最长的空闲时间。<br><code>util</code>，就是计算这个时间的一个单位。</p><p><code>workQueue</code>，就是等待队列，任务可以储存在任务队列中等待被执行，执行的是FIFIO原则（先进先出）。</p><p><code>threadFactory</code>，就是创建线程的线程工厂。</p><p><code>handler</code>,是一种拒绝策略，我们可以在任务满了之后，拒绝执行某些任务。</p><h3 id="21-说说线程池的拒绝策略"><a href="#21-说说线程池的拒绝策略" class="headerlink" title="21. 说说线程池的拒绝策略?"></a>21. 说说线程池的拒绝策略?</h3><p>当请求任务不断的过来，而系统此时又处理不过来的时候，我们需要采取的策略是拒绝服务。RejectedExecutionHandler接口提供了拒绝任务处理的自定义方法的机会。在ThreadPoolExecutor中已经包含四种处理策略。</p><ul><li>AbortPolicy策略：该策略会直接抛出异常，阻止系统正常工作。</li></ul><ul><li><p>CallerRunsPolicy 策略：只要线程池未关闭，该策略直接在调用者线程中，运行当前的被丢弃的任务。</p></li><li><p>DiscardOleddestPolicy策略： 该策略将丢弃最老的一个请求，也就是即将被执行的任务，并尝试再次提交当前任务。</p></li></ul><ul><li>DiscardPolicy策略：该策略默默的丢弃无法处理的任务，不予任何处理。</li></ul><p>除了JDK默认提供的四种拒绝策略，我们可以根据自己的业务需求去自定义拒绝策略，自定义的方式很简单，直接实现<code>RejectedExecutionHandler</code>接口即可。</p><h3 id="22-execute和submit的区别？"><a href="#22-execute和submit的区别？" class="headerlink" title="22. execute和submit的区别？"></a>22. execute和submit的区别？</h3><p>我们执行任务是用的execute方法，除了execute方法，还有一个submit方法也可以执行我们提交的任务。</p><p>这两个方法有什么区别呢？分别适用于在什么场景下呢？<br>我们来做一个简单的分析。</p><ul><li><p>execute适用于不需要关注返回值的场景，只需要将线程丢到线程池中去执行就可以了。</p></li><li><p>submit方法适用于需要关注返回值的场景</p></li></ul><h3 id="23-五种线程池的使用场景"><a href="#23-五种线程池的使用场景" class="headerlink" title="23. 五种线程池的使用场景?"></a>23. 五种线程池的使用场景?</h3><ul><li><p>newSingleThreadExecutor：一个单线程的线程池，可以用于需要保证顺序执行的场景，并且只有一个线程在执行。</p></li><li><p>newFixedThreadPool：一个固定大小的线程池，可以用于已知并发压力的情况下，对线程数做限制。</p></li></ul><ul><li>newCachedThreadPool：一个可以无限扩大的线程池，比较适合处理执行时间比较小的任务。</li></ul><ul><li>newScheduledThreadPool：可以延时启动，定时启动的线程池，适用于需要多个后台线程执行周期任务的场景。</li><li>newWorkStealingPool：一个拥有多个任务队列的线程池，可以减少连接数，创建当前可用cpu数量的线程来并行执行。</li></ul><h3 id="24-线程池如何关闭-初始化线程池时线程数的选择？"><a href="#24-线程池如何关闭-初始化线程池时线程数的选择？" class="headerlink" title="24. 线程池如何关闭? 初始化线程池时线程数的选择？"></a>24. 线程池如何关闭? 初始化线程池时线程数的选择？</h3><p>关闭线程池可以调用shutdownNow和shutdown两个方法来实现</p><p>shutdownNow：对正在执行的任务全部发出interrupt()，停止执行，对还未开始执行的任务全部取消，并且返回还没开始的任务列表。</p><p>shutdown：当我们调用shutdown后，线程池将不再接受新的任务，但也不会去强制终止已经提交或者正在执行中的任务。</p><p>如果任务是IO密集型，一般线程数需要设置2倍CPU数以上，以此来尽量利用CPU资源。</p><p>如果任务是CPU密集型，一般线程数量只需要设置CPU数加1即可，更多的线程数也只能增加上下文切换，不能增加CPU利用率。</p><p>上述只是一个基本思想，如果真的需要精确的控制，还是需要上线以后观察线程池中线程数量跟队列的情况来定。</p><h3 id="25-线程池都有哪几种工作队列？"><a href="#25-线程池都有哪几种工作队列？" class="headerlink" title="25. 线程池都有哪几种工作队列？"></a>25. 线程池都有哪几种工作队列？</h3><p>1、<code>ArrayBlockingQueue</code></p><p>是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。</p><p>2、<code>LinkedBlockingQueue</code><br>一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列</p><p>3、<code>SynchronousQueue</code></p><p>一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。</p><p>4、<code>PriorityBlockingQueue</code></p><p>一个具有优先级的无限阻塞队列。</p><h2 id="推荐"><a href="#推荐" class="headerlink" title="推荐"></a>推荐</h2><p><a href="https://mp.weixin.qq.com/mp/homepage?__biz=MzIwMTg3NzYyOA==&hid=10&sn=34bfdf3ba4ff1ef1852e392195616f4e" target="_blank" rel="noopener">大厂笔试内容集合（内有详细解析）</a> 持续更新中….</p><p><a href="https://www.processon.com/i/5cd53c2fe4b01941c8cf1c21" target="_blank" rel="noopener">ProcessOn是一个在线作图工具的聚合平台~</a></p><h2 id="文末"><a href="#文末" class="headerlink" title="文末"></a>文末</h2><blockquote><p>欢迎关注个人微信公众号：<strong>Coder编程</strong><br>欢迎关注<strong>Coder编程</strong>公众号，主要分享数据结构与算法、Java相关知识体系、框架知识及原理、Spring全家桶、微服务项目实战、DevOps实践之路、每日一篇互联网大厂面试或笔试题以及PMP项目管理知识等。更多精彩内容正在路上~<br>新建了一个qq群：315211365，欢迎大家进群交流一起学习。谢谢了！也可以介绍给身边有需要的朋友。</p></blockquote><blockquote><p>文章收录至<br>Github: <a href="https://github.com/CoderMerlin/coder-programming" target="_blank" rel="noopener">https://github.com/CoderMerlin/coder-programming</a><br>Gitee: <a href="https://gitee.com/573059382/coder-programming" target="_blank" rel="noopener">https://gitee.com/573059382/coder-programming</a><br>欢迎<strong>关注</strong>并star~<br><img src="https://upload-images.jianshu.io/upload_images/7326374-fdefd65feb040355?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="微信公众号"></p></blockquote>]]></content>
<categories>
<category> Java </category>
<category> 面试 </category>
</categories>
<tags>
<tag> Java </tag>
<tag> 面试 </tag>
<tag> 多线程 </tag>
</tags>
</entry>
<entry>
<title>不可不说的Java“锁”事</title>
<link href="/2018/11/15/java/Lock/"/>
<url>/2018/11/15/java/Lock/</url>
<content type="html"><![CDATA[<p>来源：httpstech.meituan.com20181115java-lock.html</p><h2 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h2><p>Java提供了种类丰富的锁，每种锁因其特性的不同，在适当的场景下能够展现出非常高的效率。本文旨在对锁相关源码（本文中的源码来自JDK 8和Netty 3.10.6）、使用场景进行举例，为读者介绍主流锁的知识点，以及不同的锁的适用场景。</p><p>Java中往往是按照是否含有某一特性来定义锁，我们通过特性将锁进行分组归类，再使用对比的方式进行介绍，帮助大家更快捷的理解相关知识。下面给出本文内容的总体分类目录：</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-2a7d7fc194d95132.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><h3 id="1-乐观锁-VS-悲观锁"><a href="#1-乐观锁-VS-悲观锁" class="headerlink" title="1. 乐观锁 VS 悲观锁"></a>1. 乐观锁 VS 悲观锁</h3><p>乐观锁与悲观锁是一种广义上的概念，体现了看待线程同步的不同角度。在Java和数据库中都有此概念对应的实际应用。</p><p>先说概念。对于同一个数据的并发操作，悲观锁认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改。Java中，synchronized关键字和Lock的实现类都是悲观锁。</p><p>而乐观锁认为自己在使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有别的线程更新了这个数据。如果这个数据没有被更新，当前线程将自己修改的数据成功写入。如果数据已经被其他线程更新，则根据不同的实现方式执行不同的操作（例如报错或者自动重试）。</p><p>乐观锁在Java中是通过使用无锁编程来实现，最常采用的是CAS算法，Java原子类中的递增操作就通过CAS自旋实现的。</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-4222cbcec1119611.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>根据从上面的概念描述我们可以发现：</p><p> 悲观锁适合写操作多的场景，先加锁可以保证写操作时数据正确。<br> 乐观锁适合读操作多的场景，不加锁的特点能够使其读操作的性能大幅提升。</p><p>光说概念有些抽象，我们来看下乐观锁和悲观锁的调用方式示例：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"> ------------------------- 悲观锁的调用方式 -------------------------</span><br><span class="line"> synchronized</span><br><span class="line">public synchronized void testMethod() {</span><br><span class="line"> 操作同步资源</span><br><span class="line">}</span><br><span class="line"> ReentrantLock</span><br><span class="line">private ReentrantLock lock = new ReentrantLock(); 需要保证多个线程使用的是同一个锁</span><br><span class="line">public void modifyPublicResources() {</span><br><span class="line">lock.lock();</span><br><span class="line"> 操作同步资源</span><br><span class="line">lock.unlock();</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"> ------------------------- 乐观锁的调用方式 -------------------------</span><br><span class="line">private AtomicInteger atomicInteger = new AtomicInteger(); 需要保证多个线程使用的是同一个AtomicInteger</span><br><span class="line">atomicInteger.incrementAndGet(); 执行自增1</span><br></pre></td></tr></table></figure><p>通过调用方式示例，我们可以发现悲观锁基本都是在显式的锁定之后再操作同步资源，而乐观锁则直接去操作同步资源。那么，为何乐观锁能够做到不锁定同步资源也可以正确的实现线程同步呢？我们通过介绍乐观锁的主要实现方式 “CAS” 的技术原理来为大家解惑。</p><p>CAS全称 Compare And Swap（比较与交换），是一种无锁算法。在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。java.util.concurrent包中的原子类就是通过CAS来实现了乐观锁。</p><p>CAS算法涉及到三个操作数：</p><p> 需要读写的内存值 V。<br> 进行比较的值 A。<br> 要写入的新值 B。</p><p>当且仅当 V 的值等于 A 时，CAS通过原子方式用新值B来更新V的值（“比较+更新”整体是一个原子操作），否则不会执行任何操作。一般情况下，“更新”是一个不断重试的操作。</p><p>之前提到java.util.concurrent包中的原子类，就是通过CAS来实现了乐观锁，那么我们进入原子类AtomicInteger的源码，看一下AtomicInteger的定义：</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-b1e2a97ace67c994.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>根据定义我们可以看出各属性的作用：</p><p> unsafe： 获取并操作内存的数据。<br> valueOffset： 存储value在AtomicInteger中的偏移量。<br> value： 存储AtomicInteger的int值，该属性需要借助volatile关键字保证其在线程间是可见的。</p><p>接下来，我们查看AtomicInteger的自增函数incrementAndGet()的源码时，发现自增函数底层调用的是unsafe.getAndAddInt()。但是由于JDK本身只有Unsafe.class，只通过class文件中的参数名，并不能很好的了解方法的作用，所以我们通过OpenJDK 8 来查看Unsafe的源码：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br></pre></td><td class="code"><pre><span class="line"> ------------------------- JDK 8 -------------------------</span><br><span class="line"> AtomicInteger 自增方法</span><br><span class="line">public final int incrementAndGet() {</span><br><span class="line"> return unsafe.getAndAddInt(this, valueOffset, 1) + 1;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"> Unsafe.class</span><br><span class="line">public final int getAndAddInt(Object var1, long var2, int var4) {</span><br><span class="line"> int var5;</span><br><span class="line"> do {</span><br><span class="line"> var5 = this.getIntVolatile(var1, var2);</span><br><span class="line"> } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));</span><br><span class="line"> return var5;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"> ------------------------- OpenJDK 8 -------------------------</span><br><span class="line"> Unsafe.java</span><br><span class="line">public final int getAndAddInt(Object o, long offset, int delta) {</span><br><span class="line"> int v;</span><br><span class="line"> do {</span><br><span class="line"> v = getIntVolatile(o, offset);</span><br><span class="line"> } while (!compareAndSwapInt(o, offset, v, v + delta));</span><br><span class="line"> return v;</span><br><span class="line">}</span><br></pre></td></tr></table></figure><p>根据OpenJDK 8的源码我们可以看出，getAndAddInt()循环获取给定对象o中的偏移量处的值v，然后判断内存值是否等于v。如果相等则将内存值设置为 v + delta，否则返回false，继续循环进行重试，直到设置成功才能退出循环，并且将旧值返回。整个“比较+更新”操作封装在compareAndSwapInt()中，在JNI里是借助于一个CPU指令完成的，属于原子操作，可以保证多个线程都能够看到同一个变量的修改值。</p><p>后续JDK通过CPU的cmpxchg指令，去比较寄存器中的 A 和 内存中的值 V。如果相等，就把要写入的新值 B 存入内存中。如果不相等，就将内存值 V 赋值给寄存器中的值 A。然后通过Java代码中的while循环再次调用cmpxchg指令进行重试，直到设置成功为止。</p><p>CAS虽然很高效，但是它也存在三大问题，这里也简单说一下：</p><ol><li>ABA问题。CAS需要在操作值的时候检查内存值是否发生变化，没有发生变化才会更新内存值。但是如果内存值原来是A，后来变成了B，然后又变成了A，那么CAS进行检查时会发现值没有发生变化，但是实际上是有变化的。ABA问题的解决思路就是在变量前面添加版本号，每次变量更新的时候都把版本号加一，这样变化过程就从“A－B－A”变成了“1A－2B－3A”。<br> JDK从1.5开始提供了AtomicStampedReference类来解决ABA问题，具体操作封装在compareAndSet()中。compareAndSet()首先检查当前引用和当前标志与预期引用和预期标志是否相等，如果都相等，则以原子方式将引用值和标志的值设置为给定的更新值。</li><li>循环时间长开销大。CAS操作如果长时间不成功，会导致其一直自旋，给CPU带来非常大的开销。</li><li>只能保证一个共享变量的原子操作。对一个共享变量执行操作时，CAS能够保证原子操作，但是对多个共享变量操作时，CAS是无法保证操作的原子性的。<br> Java从1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，可以把多个变量放在一个对象里来进行CAS操作。</li></ol><h3 id="2-自旋锁-VS-适应性自旋锁"><a href="#2-自旋锁-VS-适应性自旋锁" class="headerlink" title="2. 自旋锁 VS 适应性自旋锁"></a>2. 自旋锁 VS 适应性自旋锁</h3><p>在介绍自旋锁前，我们需要介绍一些前提知识来帮助大家明白自旋锁的概念。</p><p>阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，这种状态转换需要耗费处理器时间。如果同步代码块中的内容过于简单，状态转换消耗的时间有可能比用户代码执行的时间还要长。</p><p>在许多场景中，同步资源的锁定时间很短，为了这一小段时间去切换线程，线程挂起和恢复现场的花费可能会让系统得不偿失。如果物理机器有多个处理器，能够让两个或以上的线程同时并行执行，我们就可以让后面那个请求锁的线程不放弃CPU的执行时间，看看持有锁的线程是否很快就会释放锁。</p><p>而为了让当前线程“稍等一下”，我们需让当前线程进行自旋，如果在自旋完成后前面锁定同步资源的线程已经释放了锁，那么当前线程就可以不必阻塞而是直接获取同步资源，从而避免切换线程的开销。这就是自旋锁。</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-a2f192c51e411949.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>自旋锁本身是有缺点的，它不能代替阻塞。自旋等待虽然避免了线程切换的开销，但它要占用处理器时间。如果锁被占用的时间很短，自旋等待的效果就会非常好。反之，如果锁被占用的时间很长，那么自旋的线程只会白浪费处理器资源。所以，自旋等待的时间必须要有一定的限度，如果自旋超过了限定次数（默认是10次，可以使用-XXPreBlockSpin来更改）没有成功获得锁，就应当挂起线程。</p><p>自旋锁的实现原理同样也是CAS，AtomicInteger中调用unsafe进行自增操作的源码中的do-while循环就是一个自旋操作，如果修改数值失败则通过循环来执行自旋，直至修改成功。</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-fa3edbba50f64469.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>自旋锁在JDK1.4.2中引入，使用-XX+UseSpinning来开启。JDK 6中变为默认开启，并且引入了自适应的自旋锁（适应性自旋锁）。</p><p>自适应意味着自旋的时间（次数）不再固定，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。如果在同一个锁对象上，自旋等待刚刚成功获得过锁，并且持有锁的线程正在运行中，那么虚拟机就会认为这次自旋也是很有可能再次成功，进而它将允许自旋等待持续相对更长的时间。如果对于某个锁，自旋很少成功获得过，那在以后尝试获取这个锁时将可能省略掉自旋过程，直接阻塞线程，避免浪费处理器资源。</p><p>在自旋锁中 另有三种常见的锁形式TicketLock、CLHlock和MCSlock，本文中仅做名词介绍，不做深入讲解，感兴趣的同学可以自行查阅相关资料。</p><h3 id="3-无锁-VS-偏向锁-VS-轻量级锁-VS-重量级锁"><a href="#3-无锁-VS-偏向锁-VS-轻量级锁-VS-重量级锁" class="headerlink" title="3. 无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁"></a>3. 无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁</h3><p>这四种锁是指锁的状态，专门针对synchronized的。在介绍这四种锁状态之前还需要介绍一些额外的知识。</p><p>首先为什么Synchronized能实现线程同步？</p><p>在回答这个问题之前我们需要了解两个重要的概念：“Java对象头”、“Monitor”。</p><h4 id="Java对象头"><a href="#Java对象头" class="headerlink" title="Java对象头"></a>Java对象头</h4><p>synchronized是悲观锁，在操作同步资源之前需要给同步资源先加锁，这把锁就是存在Java对象头里的，而Java对象头又是什么呢？</p><p>我们以Hotspot虚拟机为例，Hotspot的对象头主要包括两部分数据：Mark Word（标记字段）、Klass Pointer（类型指针）。</p><p>Mark Word：默认存储对象的HashCode，分代年龄和锁标志位信息。这些信息都是与对象自身定义无关的数据，所以Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据。它会根据对象的状态复用自己的存储空间，也就是说在运行期间Mark Word里存储的数据会随着锁标志位的变化而变化。</p><p>Klass Point：对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。</p><h4 id="Monitor"><a href="#Monitor" class="headerlink" title="Monitor"></a>Monitor</h4><p>Monitor可以理解为一个同步工具或一种同步机制，通常被描述为一个对象。每一个Java对象就有一把看不见的锁，称为内部锁或者Monitor锁。</p><p>Monitor是线程私有的数据结构，每一个线程都有一个可用monitor record列表，同时还有一个全局的可用列表。每一个被锁住的对象都会和一个monitor关联，同时monitor中有一个Owner字段存放拥有该锁的线程的唯一标识，表示该锁被这个线程占用。</p><p>现在话题回到synchronized，synchronized通过Monitor来实现线程同步，Monitor是依赖于底层的操作系统的Mutex Lock（互斥锁）来实现的线程同步。</p><p>如同我们在自旋锁中提到的“阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，这种状态转换需要耗费处理器时间。如果同步代码块中的内容过于简单，状态转换消耗的时间有可能比用户代码执行的时间还要长”。这种方式就是synchronized最初实现同步的方式，这就是JDK 6之前synchronized效率低的原因。这种依赖于操作系统Mutex Lock所实现的锁我们称之为“重量级锁”，JDK 6中为了减少获得锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁”。</p><p>所以目前锁一共有4种状态，级别从低到高依次是：无锁、偏向锁、轻量级锁和重量级锁。锁状态只能升级不能降级。</p><p>通过上面的介绍，我们对synchronized的加锁机制以及相关知识有了一个了解，那么下面我们给出四种锁状态对应的的Mark Word内容，然后再分别讲解四种锁状态的思路以及特点：</p><p> 锁状态 存储内容 存储内容 </p><hr><p> 无锁 对象的hashCode、对象分代年龄、是否是偏向锁（0） 01<br> 偏向锁 偏向线程ID、偏向时间戳、对象分代年龄、是否是偏向锁（1） 01<br> 轻量级锁 指向栈中锁记录的指针 00<br> 重量级锁 指向互斥量（重量级锁）的指针 10 </p><p>无锁</p><p>无锁没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功。</p><p>无锁的特点就是修改操作在循环内进行，线程会不断的尝试修改共享资源。如果没有冲突就修改成功并退出，否则就会继续循环尝试。如果有多个线程修改同一个值，必定会有一个线程能修改成功，而其他修改失败的线程会不断重试直到修改成功。上面我们介绍的CAS原理及应用即是无锁的实现。无锁无法全面代替有锁，但无锁在某些场合下的性能是非常高的。</p><p>偏向锁</p><p>偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁，降低获取锁的代价。</p><p>在大多数情况下，锁总是由同一线程多次获得，不存在多线程竞争，所以出现了偏向锁。其目标就是在只有一个线程执行同步代码块时能够提高性能。</p><p>当一个线程访问同步代码块并获取锁时，会在Mark Word里存储锁偏向的线程ID。在线程进入和退出同步块时不再通过CAS操作来加锁和解锁，而是检测Mark Word里是否存储着指向当前线程的偏向锁。引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径，因为轻量级锁的获取及释放依赖多次CAS原子指令，而偏向锁只需要在置换ThreadID的时候依赖一次CAS原子指令即可。</p><p>偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程不会主动释放偏向锁。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有字节码正在执行），它会首先暂停拥有偏向锁的线程，判断锁对象是否处于被锁定状态。撤销偏向锁后恢复到无锁（标志位为“01”）或轻量级锁（标志位为“00”）的状态。</p><p>偏向锁在JDK 6及以后的JVM里是默认启用的。可以通过JVM参数关闭偏向锁：-XX-UseBiasedLocking=false，关闭之后程序默认会进入轻量级锁状态。</p><p>轻量级锁</p><p>是指当锁是偏向锁的时候，被另外的线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，从而提高性能。</p><p>在代码进入同步块的时候，如果同步对象锁状态为无锁状态（锁标志位为“01”状态，是否为偏向锁为“0”），虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的Mark Word的拷贝，然后拷贝对象头中的Mark Word复制到锁记录中。</p><p>拷贝成功后，虚拟机将使用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指针，并将Lock Record里的owner指针指向对象的Mark Word。</p><p>如果这个更新动作成功了，那么这个线程就拥有了该对象的锁，并且对象Mark Word的锁标志位设置为“00”，表示此对象处于轻量级锁定状态。</p><p>如果轻量级锁的更新操作失败了，虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧，如果是就说明当前线程已经拥有了这个对象的锁，那就可以直接进入同步块继续执行，否则说明多个线程竞争锁。</p><p>若当前只有一个等待线程，则该线程通过自旋进行等待。但是当自旋超过一定的次数，或者一个线程在持有锁，一个在自旋，又有第三个来访时，轻量级锁升级为重量级锁。</p><p>重量级锁</p><p>升级为重量级锁时，锁标志的状态值变为“10”，此时Mark Word中存储的是指向重量级锁的指针，此时等待锁的线程都会进入阻塞状态。</p><p>整体的锁状态升级流程如下：</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-8cccea35d1ded08e.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>综上，偏向锁通过对比Mark Word解决加锁问题，避免执行CAS操作。而轻量级锁是通过用CAS操作和自旋来解决加锁问题，避免线程阻塞和唤醒而影响性能。重量级锁是将除了拥有锁的线程以外的线程都阻塞。</p><h3 id="4-公平锁-VS-非公平锁"><a href="#4-公平锁-VS-非公平锁" class="headerlink" title="4. 公平锁 VS 非公平锁"></a>4. 公平锁 VS 非公平锁</h3><p>公平锁是指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。公平锁的优点是等待锁的线程不会饿死。缺点是整体吞吐效率相对非公平锁要低，等待队列中除第一个线程以外的所有线程都会阻塞，CPU唤醒阻塞线程的开销比非公平锁大。</p><p>非公平锁是多个线程加锁时直接尝试获取锁，获取不到才会到等待队列的队尾等待。但如果此时锁刚好可用，那么这个线程可以无需阻塞直接获取到锁，所以非公平锁有可能出现后申请锁的线程先获取锁的场景。非公平锁的优点是可以减少唤起线程的开销，整体的吞吐效率高，因为线程有几率不阻塞直接获得锁，CPU不必唤醒所有线程。缺点是处于等待队列中的线程可能会饿死，或者等很久才会获得锁。</p><p>直接用语言描述可能有点抽象，这里作者用从别处看到的一个例子来讲述一下公平锁和非公平锁。</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-6a3ddeb06e5838dc.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>如上图所示，假设有一口水井，有管理员看守，管理员有一把锁，只有拿到锁的人才能够打水，打完水要把锁还给管理员。每个过来打水的人都要管理员的允许并拿到锁之后才能去打水，如果前面有人正在打水，那么这个想要打水的人就必须排队。管理员会查看下一个要去打水的人是不是队伍里排最前面的人，如果是的话，才会给你锁让你去打水；如果你不是排第一的人，就必须去队尾排队，这就是公平锁。</p><p>但是对于非公平锁，管理员对打水的人没有要求。即使等待队伍里有排队等待的人，但如果在上一个人刚打完水把锁还给管理员而且管理员还没有允许等待队伍里下一个人去打水时，刚好来了一个插队的人，这个插队的人是可以直接从管理员那里拿到锁去打水，不需要排队，原本排队等待的人只能继续等待。如下图所示：</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-8d42c8a9491835a6.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>接下来我们通过ReentrantLock的源码来讲解公平锁和非公平锁。</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-5b8e6375939b2ddb.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>根据代码可知，ReentrantLock里面有一个内部类Sync，Sync继承AQS（AbstractQueuedSynchronizer），添加锁和释放锁的大部分操作实际上都是在Sync中实现的。它有公平锁FairSync和非公平锁NonfairSync两个子类。ReentrantLock默认使用非公平锁，也可以通过构造器来显示的指定使用公平锁。</p><p>下面我们来看一下公平锁与非公平锁的加锁方法的源码</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-9046f9502ddee8ec.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>通过上图中的源代码对比，我们可以明显的看出公平锁与非公平锁的lock()方法唯一的区别就在于公平锁在获取同步状态时多了一个限制条件：hasQueuedPredecessors()。</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-89cfb096ee5dc994.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>再进入hasQueuedPredecessors()，可以看到该方法主要做一件事情：主要是判断当前线程是否位于同步队列中的第一个。如果是则返回true，否则返回false。</p><p>综上，公平锁就是通过同步队列来实现多个线程按照申请锁的顺序来获取锁，从而实现公平的特性。非公平锁加锁时不考虑排队等待问题，直接尝试获取锁，所以存在后申请却先获得锁的情况。</p><h3 id="5-可重入锁-VS-非可重入锁"><a href="#5-可重入锁-VS-非可重入锁" class="headerlink" title="5. 可重入锁 VS 非可重入锁"></a>5. 可重入锁 VS 非可重入锁</h3><p>可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提锁对象得是同一个对象或者class），不会因为之前已经获取过还没释放而阻塞。Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。下面用示例代码来进行分析：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line">public class Widget {</span><br><span class="line"> public synchronized void doSomething() {</span><br><span class="line"> System.out.println(方法1执行...);</span><br><span class="line"> doOthers();</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> public synchronized void doOthers() {</span><br><span class="line"> System.out.println(方法2执行...);</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure><p>在上面的代码中，类中的两个方法都是被内置锁synchronized修饰的，doSomething()方法中调用doOthers()方法。因为内置锁是可重入的，所以同一个线程在调用doOthers()时可以直接获得当前对象的锁，进入doOthers()进行操作。</p><p>如果是一个不可重入锁，那么当前线程在调用doOthers()之前需要将执行doSomething()时获取当前对象的锁释放掉，实际上该对象锁已被当前线程所持有，且无法释放。所以此时会出现死锁。</p><p>而为什么可重入锁就可以在嵌套调用时可以自动获得锁呢？我们通过图示和源码来分别解析一下。</p><p>还是打水的例子，有多个人在排队打水，此时管理员允许锁和同一个人的多个水桶绑定。这个人用多个水桶打水时，第一个水桶和锁绑定并打完水之后，第二个水桶也可以直接和锁绑定并开始打水，所有的水桶都打完水之后打水人才会将锁还给管理员。这个人的所有打水流程都能够成功执行，后续等待的人也能够打到水。这就是可重入锁。</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-7b6a99a8b4df6a74.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>但如果是非可重入锁的话，此时管理员只允许锁和同一个人的一个水桶绑定。第一个水桶和锁绑定打完水之后并不会释放锁，导致第二个水桶不能和锁绑定也无法打水。当前线程出现死锁，整个等待队列中的所有线程都无法被唤醒。</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-dbe856e410699b33.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>之前我们说过ReentrantLock和synchronized都是重入锁，那么我们通过重入锁ReentrantLock以及非可重入锁NonReentrantLock的源码来对比分析一下为什么非可重入锁在重复调用同步资源时会出现死锁。</p><p>首先ReentrantLock和NonReentrantLock都继承父类AQS，其父类AQS中维护了一个同步状态status来计数重入次数，status初始值为0。</p><p>当线程尝试获取锁时，可重入锁先尝试获取并更新status值，如果status == 0表示没有其他线程在执行同步代码，则把status置为1，当前线程开始执行。如果status != 0，则判断当前线程是否是获取到这个锁的线程，如果是的话执行status+1，且当前线程可以再次获取锁。而非可重入锁是直接去获取并尝试更新当前status的值，如果status != 0的话会导致其获取锁失败，当前线程阻塞。</p><p>释放锁时，可重入锁同样先获取当前status的值，在当前线程是持有锁的线程的前提下。如果status-1 == 0，则表示当前线程所有重复获取锁的操作都已经执行完毕，然后该线程才会真正释放锁。而非可重入锁则是在确定当前线程是持有锁的线程之后，直接将status置为0，将锁释放。</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-1989c019d2e8d880.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><h3 id="6-独享锁-VS-共享锁"><a href="#6-独享锁-VS-共享锁" class="headerlink" title="6. 独享锁 VS 共享锁"></a>6. 独享锁 VS 共享锁</h3><p>独享锁和共享锁同样是一种概念。我们先介绍一下具体的概念，然后通过ReentrantLock和ReentrantReadWriteLock的源码来介绍独享锁和共享锁。</p><p>独享锁也叫排他锁，是指该锁一次只能被一个线程所持有。如果线程T对数据A加上排它锁后，则其他线程不能再对A加任何类型的锁。获得排它锁的线程即能读数据又能修改数据。JDK中的synchronized和JUC中Lock的实现类就是互斥锁。</p><p>共享锁是指该锁可被多个线程所持有。如果线程T对数据A加上共享锁后，则其他线程只能对A再加共享锁，不能加排它锁。获得共享锁的线程只能读数据，不能修改数据。</p><p>独享锁与共享锁也是通过AQS来实现的，通过实现不同的方法，来实现独享或者共享。</p><p>下图为ReentrantReadWriteLock的部分源码：</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-eec1b90deff388d8.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>我们看到ReentrantReadWriteLock有两把锁：ReadLock和WriteLock，由词知意，一个读锁一个写锁，合称“读写锁”。再进一步观察可以发现ReadLock和WriteLock是靠内部类Sync实现的锁。Sync是AQS的一个子类，这种结构在CountDownLatch、ReentrantLock、Semaphore里面也都存在。</p><p>在ReentrantReadWriteLock里面，读锁和写锁的锁主体都是Sync，但读锁和写锁的加锁方式不一样。读锁是共享锁，写锁是独享锁。读锁的共享锁可保证并发读非常高效，而读写、写读、写写的过程互斥，因为读锁和写锁是分离的。所以ReentrantReadWriteLock的并发性相比一般的互斥锁有了很大提升。</p><p>那读锁和写锁的具体加锁方式有什么区别呢？在了解源码之前我们需要回顾一下其他知识。 在最开始提及AQS的时候我们也提到了state字段（int类型，32位），该字段用来描述有多少线程获持有锁。</p><p>在独享锁中这个值通常是0或者1（如果是重入锁的话state值就是重入的次数），在共享锁中state就是持有锁的数量。但是在ReentrantReadWriteLock中有读、写两把锁，所以需要在一个整型变量state上分别描述读锁和写锁的数量（或者也可以叫状态）。于是将state变量“按位切割”切分成了两个部分，高16位表示读锁状态（读锁个数），低16位表示写锁状态（写锁个数）。如下图所示：</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-cb7a10032f12d543.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>了解了概念之后我们再来看代码，先看写锁的加锁源码：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br></pre></td><td class="code"><pre><span class="line">protected final boolean tryAcquire(int acquires) {</span><br><span class="line">Thread current = Thread.currentThread();</span><br><span class="line">int c = getState(); 取到当前锁的个数</span><br><span class="line">int w = exclusiveCount(c); 取写锁的个数w</span><br><span class="line">if (c != 0) { 如果已经有线程持有了锁(c!=0)</span><br><span class="line"> (Note if c != 0 and w == 0 then shared count != 0)</span><br><span class="line">if (w == 0 current != getExclusiveOwnerThread()) 如果写线程数（w）为0（换言之存在读锁） 或者持有锁的线程不是当前线程就返回失败</span><br><span class="line">return false;</span><br><span class="line">if (w + exclusiveCount(acquires) MAX_COUNT) 如果写入锁的数量大于最大数（65535，2的16次方-1）就抛出一个Error。</span><br><span class="line"> throw new Error(Maximum lock count exceeded);</span><br><span class="line"> Reentrant acquire</span><br><span class="line"> setState(c + acquires);</span><br><span class="line"> return true;</span><br><span class="line"> }</span><br><span class="line"> if (writerShouldBlock() !compareAndSetState(c, c + acquires)) 如果当且写线程数为0，并且当前线程需要阻塞那么就返回失败；或者如果通过CAS增加写线程数失败也返回失败。</span><br><span class="line">return false;</span><br><span class="line">setExclusiveOwnerThread(current); 如果c=0，w=0或者c0，w0（重入），则设置当前线程或锁的拥有者</span><br><span class="line">return true;</span><br><span class="line">}</span><br></pre></td></tr></table></figure><p> 这段代码首先取到当前锁的个数c，然后再通过c来获取写锁的个数w。因为写锁是低16位，所以取低16位的最大值与当前的c做与运算（ int w = exclusiveCount©; ），高16位和0与运算后是0，剩下的就是低位运算的值，同时也是持有写锁的线程数目。<br> 在取到写锁线程的数目后，首先判断是否已经有线程持有了锁。如果已经有线程持有了锁(c!=0)，则查看当前写锁线程的数目，如果写线程数为0（即此时存在读锁）或者持有锁的线程不是当前线程就返回失败（涉及到公平锁和非公平锁的实现）。<br> 如果写入锁的数量大于最大数（65535，2的16次方-1）就抛出一个Error。<br> 如果当且写线程数为0（那么读线程也应该为0，因为上面已经处理c!=0的情况），并且当前线程需要阻塞那么就返回失败；如果通过CAS增加写线程数失败也返回失败。<br> 如果c=0,w=0或者c0,w0（重入），则设置当前线程或锁的拥有者，返回成功！</p><p>tryAcquire()除了重入条件（当前线程为获取了写锁的线程）之外，增加了一个读锁是否存在的判断。如果存在读锁，则写锁不能被获取，原因在于：必须确保写锁的操作对读锁可见，如果允许读锁在已被获取的情况下对写锁的获取，那么正在运行的其他读线程就无法感知到当前写线程的操作。</p><p>因此，只有等待其他读线程都释放了读锁，写锁才能被当前线程获取，而写锁一旦被获取，则其他读写线程的后续访问均被阻塞。写锁的释放与ReentrantLock的释放过程基本类似，每次释放均减少写状态，当写状态为0时表示写锁已被释放，然后等待的读写线程才能够继续访问读写锁，同时前次写线程的修改对后续的读写线程可见。</p><p>接着是读锁的代码：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br></pre></td><td class="code"><pre><span class="line">protected final int tryAcquireShared(int unused) {</span><br><span class="line"> Thread current = Thread.currentThread();</span><br><span class="line"> int c = getState();</span><br><span class="line"> if (exclusiveCount(c) != 0 &&</span><br><span class="line"> getExclusiveOwnerThread() != current)</span><br><span class="line"> return -1; 如果其他线程已经获取了写锁，则当前线程获取读锁失败，进入等待状态</span><br><span class="line"> int r = sharedCount(c);</span><br><span class="line"> if (!readerShouldBlock() &&</span><br><span class="line"> r MAX_COUNT &&</span><br><span class="line"> compareAndSetState(c, c + SHARED_UNIT)) {</span><br><span class="line"> if (r == 0) {</span><br><span class="line"> firstReader = current;</span><br><span class="line"> firstReaderHoldCount = 1;</span><br><span class="line"> } else if (firstReader == current) {</span><br><span class="line"> firstReaderHoldCount++;</span><br><span class="line"> } else {</span><br><span class="line"> HoldCounter rh = cachedHoldCounter;</span><br><span class="line"> if (rh == null rh.tid != getThreadId(current))</span><br><span class="line"> cachedHoldCounter = rh = readHolds.get();</span><br><span class="line"> else if (rh.count == 0)</span><br><span class="line"> readHolds.set(rh);</span><br><span class="line"> rh.count++;</span><br><span class="line"> }</span><br><span class="line"> return 1;</span><br><span class="line"> }</span><br><span class="line"> return fullTryAcquireShared(current);</span><br><span class="line">}</span><br></pre></td></tr></table></figure><p>可以看到在tryAcquireShared(int unused)方法中，如果其他线程已经获取了写锁，则当前线程获取读锁失败，进入等待状态。如果当前线程获取了写锁或者写锁未被获取，则当前线程（线程安全，依靠CAS保证）增加读状态，成功获取读锁。读锁的每次释放（线程安全的，可能有多个读线程同时释放读锁）均减少读状态，减少的值是“116”。所以读写锁才能实现读读的过程共享，而读写、写读、写写的过程互斥。</p><p>此时，我们再回头看一下互斥锁ReentrantLock中公平锁和非公平锁的加锁源码：</p><p><img src="httpsupload-images.jianshu.ioupload_images7326374-81114a2e13f10a1c.pngimageMogr2auto-orientstrip%7CimageView22w1240" alt="image"></p><p>我们发现在ReentrantLock虽然有公平锁和非公平锁两种，但是它们添加的都是独享锁。根据源码所示，当某一个线程调用lock方法获取锁时，如果同步资源没有被其他线程锁住，那么当前线程在使用CAS更新state成功后就会成功抢占该资源。而如果公共资源被占用且不是被当前线程占用，那么就会加锁失败。所以可以确定ReentrantLock无论读操作还是写操作，添加的锁都是都是独享锁。</p><h2 id="结语"><a href="#结语" class="headerlink" title="结语"></a>结语</h2><p>本文Java中常用的锁以及常见的锁的概念进行了基本介绍，并从源码以及实际应用的角度进行了对比分析。限于篇幅以及个人水平，没有在本篇文章中对所有内容进行深层次的讲解。</p><p>其实Java本身已经对锁本身进行了良好的封装，降低了研发同学在平时工作中的使用难度。但是研发同学也需要熟悉锁的底层原理，不同场景下选择最适合的锁。而且源码中的思路都是非常好的思路，也是值得大家去学习和借鉴的。</p><h2 id="参考资料"><a href="#参考资料" class="headerlink" title="参考资料"></a>参考资料</h2><ol><li>《Java并发编程艺术》</li><li><a href="httpsblog.csdn.netu013256816articledetails51204385">Java中的锁</a></li><li><a href="httpsjuejin.impost5a73cbbff265da4e807783f5">Java CAS 原理剖析</a></li><li><a href="httpsjuejin.impost5b42c2546fb9a04f8751eabc">Java并发——关键字synchronized解析</a></li><li><a href="httpszhuanlan.zhihu.comp29866981">Java synchronized原理总结</a></li><li><a href="httpwww.infoq.comcnarticlesjava-se-16-synchronized">聊聊并发（二）——Java SE1.6中的Synchronized</a></li><li><a href="httpsblog.csdn.netqq_19431333articledetails70568478">深入理解读写锁—ReadWriteLock源码分析</a></li><li><a href="httpswww.cnblogs.comtwoheadsp9635309.html">【JUC】JDK1.8源码分析之ReentrantReadWriteLock</a></li><li><a href="httpsmy.oschina.netadan1blog158107">Java多线程（十）之ReentrantReadWriteLock深入分析</a></li><li><a href="httpsmrdear.cn20180623javajava--readwritelock">Java–读写锁的实现原理</a></li></ol><h2 id="作者简介"><a href="#作者简介" class="headerlink" title="作者简介"></a>作者简介</h2><p> 家琪，美团点评后端工程师。2017 年加入美团点评，负责美团点评境内度假的业务开发。</p>]]></content>
<categories>
<category> Java </category>
<category> 面试 </category>
<category> 锁 </category>
</categories>
<tags>
<tag> Java </tag>
<tag> 面试 </tag>
<tag> 锁 </tag>
</tags>
</entry>
</search>