-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathindex.html
488 lines (397 loc) · 35.1 KB
/
index.html
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
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<meta name="description" content="王某人的技术博客">
<title>
elysium-w
</title>
<!-- Icon -->
<link rel="shortcut icon" href="/favicon.ico">
<link rel="stylesheet" href="/css/style.css">
<link rel="stylesheet" href="/fancybox/jquery.fancybox.min.css">
<script src="/js/pace.min.js"></script>
<meta name="generator" content="Hexo 7.1.1"></head>
<body>
<main class="content">
<section class="jumbotron">
<div class="video">
<div class="video-frame">
<img src="/images/ocean/overlay-hero.png" alt="Decorative image frame">
</div>
<div class="video-media">
<video playsinline="" autoplay="" loop="" muted="" data-autoplay="" poster="/images/ocean/ocean.png"
x5-video-player-type="h5">
<source src="/images/ocean/ocean.mp4" type="video/mp4">
<source src="/images/ocean/ocean.ogv" type="video/ogg">
<source src="/images/ocean/ocean.webm" type="video/webm">
<p>Your user agent does not support the HTML5 Video element.</p>
</video>
<div class="video-overlay"></div>
</div>
<div class="video-inner text-center text-white">
<h1><a href="/">elysium-w</a></h1>
<p>elysium-w</p>
<div><img src="/images/hexo-inverted.svg" class="brand" alt="elysium-w"></div>
</div>
<div class="video-learn-more">
<a class="anchor" href="#landingpage"><i class="fe fe-mouse"></i></a>
</div>
</div>
</section>
<div id="landingpage">
<section class="outer">
<article class="articles">
<h1 class="page-type-title"></h1>
<article id="post-JUC——Java内存模型" class="article article-type-post" itemscope
itemprop="blogPost" data-scroll-reveal>
<div class="article-inner">
<header class="article-header">
<h2 class="article-title" itemprop="name">
<a href="/2023/08/28/JUC%E2%80%94%E2%80%94Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B/">JUC——Java内存模型</a>
</h2>
</header>
<div class="article-meta">
<a href="/2023/08/28/JUC%E2%80%94%E2%80%94Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B/" class="article-date">
<time datetime="2023-08-28T04:00:00.000Z" itemprop="datePublished">2023-08-28</time>
</a>
</div>
<div class="article-entry" itemprop="articleBody">
<h1 id="JUC——Java内存模型"><a href="#JUC——Java内存模型" class="headerlink" title="JUC——Java内存模型"></a>JUC——Java内存模型</h1><blockquote>
<p>任何语言都是抽象自操作系统底层，而操作系统建构在硬件之上，所以语言的一些操作特性，一定抽象自系统底层硬件的运行特点</p>
<p>Java的并发编程有三要素，原子性、可见性、有序性，JMM解决了这个问题</p>
</blockquote>
<h2 id="CPU缓存"><a href="#CPU缓存" class="headerlink" title="CPU缓存"></a>CPU缓存</h2><p><img src="/home/illumwang/blog/hexo-blog/source/_posts/pictures/cache.jpg" alt="cpus.webp"></p>
<p>CPU缓存分为三层，I/O的速度从高到低根据距离CPU核心的远近而逐渐降低，CPU缓存出现的目的是为了解决CPU读取速度与内存的I/O速度不匹配的关系，CPU会将数据按照访问的频率从内存中读取出来，放在缓存的不同位置，这样当CPU读取数据的时候，就会优先读取缓存的，提高了读取速度，提高了CPU的利用率。</p>
<h3 id="L1——一级缓存"><a href="#L1——一级缓存" class="headerlink" title="L1——一级缓存"></a>L1——一级缓存</h3><p>属于近核缓存，是内存最小的一层，也是三级缓存中最快的一层，L1缓存分为两种，一种是指令缓存，一种是数据缓存，两种缓存可以同时被CPU访问，而不会相互产生数据干扰，这样减少了CPU多核心、多线程争用缓存造成的冲突，提高了处理器的效率。</p>
<h3 id="L2——二级缓存"><a href="#L2——二级缓存" class="headerlink" title="L2——二级缓存"></a>L2——二级缓存</h3><p>CPU如果没有在L1中查询到想要的数据，就会来查询L2，这是CPU的第二层高速缓存，内存大于L1，但是访问速度比L1也慢，L1读取速度为4个时钟周期，L2为11个时钟周期。</p>
<h3 id="L3——三级缓存"><a href="#L3——三级缓存" class="headerlink" title="L3——三级缓存"></a>L3——三级缓存</h3><p>属于远核缓存，是三级缓存中最慢的一层，也是多CPU共享的缓存层，当L1、L2都没有命中后，就会到L3中进行查询，L3是所有CPU共享的，访问周期在107个时钟周期左右，L1、L2均为内置缓存，L3早期外置，现在大多数也不外置了，大多改成了内置缓存，L3的应用可以进一步降低内存延迟。</p>
<h3 id="工作原理"><a href="#工作原理" class="headerlink" title="工作原理"></a>工作原理</h3><p>当所需要的数据在CPU缓存中的时候，CPU直接从缓存中读取，如果不在缓存中，则耗费一定的时间从内存中读取，同时把这段数据从内存中加载到缓存中，保存一份<strong>副本</strong>；</p>
<p>缓存的读取有两大原则：</p>
<ul>
<li>时间局部性原则：某个数据被访问，将来的某个时刻一定会被再次访问</li>
<li>空间局部性原则：某个数据被访问，紧邻着它的数据很快也会被访问</li>
</ul>
<p>在缓存中数据被访问的同时，为了保证缓存内的数据的一定量，缓存也会按照访问频率的减少进行数据的淘汰，从L1淘汰至L2，从L2淘汰至L3，在进一步淘汰到内存中。</p>
<h3 id="缓存一致性协议MESI"><a href="#缓存一致性协议MESI" class="headerlink" title="缓存一致性协议MESI"></a>缓存一致性协议MESI</h3><p>MESI是一种<strong>基于失效</strong>的缓存一致性协议</p>
<p>缓存一致性协议就是为了保证多个CPU内核之间保存的数据副本是一致的，这就涉及到了内存可见性问题的解决，比如说目前CPU内存储的数据为<code>int a= 0;</code>，Core1提出修改a为1，那么所有Core都要得知这个结果，全部修改a为1</p>
<p>为什么说MESI是基于失效的呢？这就不得不讲到MESI的协<em>写回<strong>机制了，数据从缓存修改，同步到内存，有两种方法，一种是</strong>直写*</em><code>「Write-Though」</code>，就是每次修改都会将数据同步到内存中，还有一种是<strong>写回</strong><code>「Write-Back」</code>，在缓存中修改完之后，不立即同步到内存中，而是<strong>等到缓存行将要被替代时才会更新到内存上</strong>，这就是MESI的更新时机；所谓基于缓存失效，则是一个共有缓存在Core0被更新，所有其他CPU上有关的缓存全部失效，当需要读取这段数据的时候，让Core0将数据写入内存，再从内存中读取就好。</p>
<h4 id="缓存行"><a href="#缓存行" class="headerlink" title="缓存行"></a>缓存行</h4><p><img src="/home/illumwang/blog/hexo-blog/source/_posts/pictures/cache.jpg" alt="cache"></p>
<p>高速缓存就是一组缓存行组成的数据块，<strong>缓存行是CPU缓存中可分配的最小资源</strong>，通常是64个字节，当CPU从内存中读取数据到缓存的时候，每一次就是读取一个缓存行大小，缓存相当于是内存数据的一个映射，所以缓存行的地址是和内存中的地址是相同的</p>
<ul>
<li>工作方式：CPU从缓存中读取数据的时候，<strong>会比较待访问的内存地址和缓存行的地址块是否相同</strong>，如果<strong>地址相同，则检查缓存行状态</strong>，状态有效则读取该条缓存行，无效则从主存中读取，或者根据一致性协议发生一次cache-to-cache之间的数据推送</li>
</ul>
<h4 id="MESI"><a href="#MESI" class="headerlink" title="MESI"></a>MESI</h4><p>在CPU内核中，无论哪片CPU的缓存内容出现改变，也就是发生了数据不一致的问题，这个协议就是为了保证缓存数据一致性而产生的。</p>
<p>CPU的缓存一致性协议听起来很像MySQL的查询缓存，当Core0修改缓存中的数据的时候，其他CPU都会收到消息，告知它们的缓存都已经视为无效，然后Core0将自己的数据写入内存，其他CPU发现自己的缓存失效之后就会去内存中读取。</p>
<p>MESI描述的是缓存行的<strong>状态</strong>情况（在比较完地址段映射后，查看缓存状态是否正常），状态共有四种，见如下列表。</p>
<p>正是有了MESI协议的存在，才能使多级缓存的使用体验和一级缓存一样，<strong>MESI协议是针对缓存行的</strong>，简而言之，和总线锁不同，MESI是给缓存行加锁 >_<</p>
<table>
<thead>
<tr>
<th>状态</th>
<th>描述</th>
<th>监听任务</th>
</tr>
</thead>
<tbody><tr>
<td>M 修改 (Modified)</td>
<td>该缓存行状态有效，只是数据被修改了，和内存中数据不一致</td>
<td>该状态下处理器必须监听其他缓存是否需要操作这行数据，这种操作必须等到该行数据写入到内存中，状态变成S时才可以进行</td>
</tr>
<tr>
<td>E 独享、互斥 (Exclusive)</td>
<td>该行缓存有效，数据和内存中一致，但是数据只存在于本缓存中</td>
<td>当前处理器对该缓存行独占处理，，其他处理器不会有相同数据，相当于加独占锁，当其他处理器需要读取这一行数据时，会先收到这行数据已经失效的信号，和M状态操作相同，成为S状态之后才可以被访问</td>
</tr>
<tr>
<td>S 共享 (Shared)</td>
<td>该行缓存有效，数据和内存中一致，但是数据存在于多缓存中</td>
<td>S状态下数据是只读的，所以S状态下，处理器需要监听其他处理器的写操作，如果其他缓存行状态变E或者M,则将该行缓存状态变为I</td>
</tr>
<tr>
<td>I 无效 (Invalid)</td>
<td>缓存行无效</td>
<td>无</td>
</tr>
</tbody></table>
<h5 id="状态转换"><a href="#状态转换" class="headerlink" title="状态转换"></a>状态转换</h5><p><code>CPU cache</code>引起状态转换的操作有四种，与CPU读取或写入的请求类型相关：</p>
<table>
<thead>
<tr>
<th>操作</th>
<th>描述</th>
</tr>
</thead>
<tbody><tr>
<td>本地读取「Local Read」，LR</td>
<td>当前核读取本地高速缓存的数据</td>
</tr>
<tr>
<td>本地写入「Local Write」，LW</td>
<td>当前核将数据写入到本地高速缓存</td>
</tr>
<tr>
<td>远程读取「Remote Read」，RR</td>
<td>将其他核将主内存中的数据读取到高速缓存中来</td>
</tr>
<tr>
<td>远程写入「Remote Write」，RW</td>
<td>其他核将高速缓存中的数据写回到主存里面去</td>
</tr>
</tbody></table>
<p><img src="/home/illumwang/blog/hexo-blog/source/_posts/pictures/mesi.jpg" alt="mesi"></p>
<h6 id="1-Modify："><a href="#1-Modify：" class="headerlink" title="1. Modify："></a>1. Modify：</h6><p>场景：当前CPU中数据的状态是Modifiy，表示当前CPU中拥有最新数据，虽然主存中的数据和当前CPU中的数据不一致，但是以当前CPU中的数据为准；</p>
<ul>
<li>LR：此时如果发生local read，即当前CPU读数据，直接从cache中获取数据，拥有最新数据，因此状态不变；</li>
<li>LW：直接修改本地cache数据，修改后也是当前CPU拥有最新数据，因此状态不变；</li>
<li>RR：因为本地内存中有最新数据，当本地cache控制器监听到总线上有RR发生的时，必然是其他CPU发生了读主存的操作，此时为了保证一致性，当前CPU应该将数据写回主存，而随后的RR将会使得其他CPU和当前CPU拥有共同的数据，因此状态修改为S；</li>
<li>RW：当cache控制器监听到总线发生RW，当前CPU会将数据写回主存，因为随后的RW将会导致主存的数据修改，因此状态修改成I；</li>
</ul>
<h6 id="2-Exclusive："><a href="#2-Exclusive：" class="headerlink" title="2. Exclusive："></a>2. Exclusive：</h6><p>场景：当前CPU中的数据状态是exclusive，表示当前CPU独占数据（其他CPU没有数据），并且和主存的数据一致；</p>
<ul>
<li>LR：直接从本地cache中直接获取数据，状态不变；</li>
<li>LW：修改本地cache中的数据，状态修改成M（因为其他CPU中并没有该数据，不存在共享问题，因此不需要通知其他CPU修改cache line的状态为I）；</li>
<li>RR：本地cache中有最新数据，当cache控制器监听到总线上发生RR的时候，必然是其他CPU发生了读取主存的操作，而RR操作不会导致数据修改，因此两个CPU中的数据仍和主存中的数据一致，此时cache line状态修改为S；</li>
<li>RW：同RR，当cache控制器监听到总线发生RW，必然是其他CPU将最新数据写回到主存，此时为了保证缓存一致性，当前CPU的数据状态修改为I；</li>
</ul>
<h6 id="3-Shared："><a href="#3-Shared：" class="headerlink" title="3. Shared："></a>3. Shared：</h6><p>场景：当前CPU中的数据状态是shared，表示当前CPU和其他CPU共享数据，且数据在多个CPU之间一致、多个CPU之间的数据和主存一致；</p>
<ul>
<li>LR：直接从cache中读取数据，状态不变；</li>
<li>LW：发生本地写，并不会将数据立即写回主存，而是在稍后的一个时间再写回主存，因此为了保证缓存一致性，当前CPU的cache line状态修改为M，并通知其他拥有该数据的CPU该数据失效，其他CPU将cache line状态修改为I；</li>
<li>RR：状态不变，因为多个CPU中的数据和主存一致；</li>
<li>RW：当监听到总线发生了RW，意味着其他CPU发生了写主存操作，此时本地cache中的数据既不是最新数据，和主存也不再一致，因此当前CPU的cache line状态修改为I；</li>
</ul>
<h6 id="4-Invalid："><a href="#4-Invalid：" class="headerlink" title="4. Invalid："></a>4. Invalid：</h6><p>场景：当前CPU中的数据状态是invalid，表示当前CPU中是脏数据，不可用，其他CPU可能有数据、也可能没有数据；</p>
<ul>
<li><p>LR：因为当前CPU的cache line数据不可用，因此会发生读内存，此时的情形如下。</p>
<ol>
<li>如果其他CPU中无数据则状态修改为E；</li>
<li>如果其他CPU中有数据且状态为S或E则状态修改为S；</li>
<li>如果其他CPU中有数据且状态为M，那么其他CPU首先发生RW将M状态的数据写回主存并修改状态为S，随后当前CPU读取主存数据，也将状态修改为S；</li>
</ol>
</li>
<li><p>LW：因为当前CPU的cache line数据无效，因此发生LW会直接操作本地cache，此时的情形如下。</p>
<ol>
<li>如果其他CPU中无数据，则将本地cache line的状态修改为M；</li>
<li>如果其他CPU中有数据且状态为S或E，则修改本地cache，通知其他CPU将数据修改为I，当前CPU中的cache line状态修改为M；</li>
<li>如果其他CPU中有数据且状态为M，则其他CPU首先将数据写回主存，并将状态修改为I，当前CPU中的cache line转台修改为M；</li>
</ol>
</li>
<li><p>RR：监听到总线发生RR操作，表示有其他CPU读取内存，和本地cache无关，状态不变；</p>
</li>
<li><p>RW：监听到总线发生RW操作，表示有其他CPU写主存，和本地cache无关，状态不变；</p>
</li>
</ul>
<h2 id="重排序"><a href="#重排序" class="headerlink" title="重排序"></a>重排序</h2><p>代码执行的时候，编译器有可能会为了执行的性能而重新排列指令执行的顺序，代码可能会经历三个排序的过程： </p>
<p><strong>编译重排序 -> 指令并行重排 -> 内存系统重排</strong> </p>
<ul>
<li><p><strong>编译器优化重排</strong>：编译器（包括 JVM、JIT 编译器等）在不改变单线程程序语义的前提下，重新安排语句的执行顺序。</p>
</li>
<li><p><strong>指令并行重排</strong>：现代处理器采用了指令级并行技术(Instruction-Level <code>Parallelism</code>，ILP)来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。</p>
</li>
</ul>
<p>编译优化重排一般采用<strong>内存屏障</strong>指令来禁止特定的编译器进行重排序</p>
<h3 id="内存屏障"><a href="#内存屏障" class="headerlink" title="内存屏障"></a>内存屏障</h3><p>内存屏障分为读屏障和写屏障两种，是位于硬件之上，操作系统或JVM之下的对并发做出的最后一层支持。</p>
<p>所谓内存屏障，其实就是一种防止高级语言编译为汇编语言时指令颠倒的工具，</p>
<h2 id="JMM内存模型"><a href="#JMM内存模型" class="headerlink" title="JMM内存模型"></a>JMM内存模型</h2><p>JMM是一种抽象的概念，它是为了<strong>规范线程间如何对主存内的共享变量进行读取和写入操作</strong>而产生的，JVM是针对不同操作系统编译语言的抽象，实现一次编译到处执行；<strong>JMM是针对不同的操作系统的内存模型，定义内存的访问规则</strong>，JMM遵守<strong>最终一致性</strong></p>
<p>在并发条件下，我们需要解决两个问题，<strong>线程同步问题</strong>和<strong>线程通信问题</strong>，为此抽象出来两种并发模型：</p>
<ul>
<li>共享内存并发模型：线程通信是隐式的，通过对共享内存的读写完成线程间的通信；线程同步是显式的，必须指定那段代码是互斥操作的</li>
<li>消息传递并发模型：线程通信是显式的，不同线程必须相互发送消息实现通信；线程同步是隐式的，在消息传递的过程中，就已经包含了线程内数据的变化信息，而且是顺序且原子的</li>
</ul>
<p><img src="/home/illumwang/blog/hexo-blog/source/_posts/pictures/model.jpg" alt="model"></p>
<p>JMM的内存同步规则抽象自CPU的缓存一致性原则，不同的是，硬件架构并不区分堆栈，而JMM为了应对Java程序中不同类型内存区域的划分抽象了线程堆栈和堆内存的概念</p>
<p><img src="/home/illumwang/blog/hexo-blog/source/_posts/pictures/jmm_model.jpg" alt="jmm_model"></p>
<ul>
<li><p>线程堆栈：每一个线程都有一个独立的线程堆栈，存储的是由这个线程创建或操作的局部变量，这个局部变量只对读写和创建它的线程可见，通过八种同步操作<code>读-写</code>共享内存来达到线程间的数据一致性</p>
</li>
<li><p>堆内存：共享内存，存储的是共享的局部变量，内存可见性问题发生在对共享变量的操作中</p>
</li>
</ul>
<p><img src="/home/illumwang/blog/hexo-blog/source/_posts/pictures/heap.jpg" alt="heap"></p>
<p>以上是JMM内存模型的抽象示意图，线程对于局部变量的操作是通过本地内存进行的</p>
<h3 id="JMM如何解决并发问题"><a href="#JMM如何解决并发问题" class="headerlink" title="JMM如何解决并发问题"></a>JMM如何解决并发问题</h3><p>JMM从两个维度来理解，一方面是JMM的核心体系，三大关键字和Happens-Before原则，一方面是从JMM的三大特性来理解</p>
<h4 id="关键字"><a href="#关键字" class="headerlink" title="关键字"></a>关键字</h4><p>单开了一章</p>
<h4 id="Happens-Before原则"><a href="#Happens-Before原则" class="headerlink" title="Happens-Before原则"></a>Happens-Before原则</h4><p>Happens-Before原则实际上就是线程顺序先后的定义，直译为“先行发生”，描述了JMM中两项操作的先后关系和可见性的联系。Happens-Before原则定义如下：</p>
<blockquote>
<ul>
<li>如果一个操作Happens-Before另一个操作，那么第一个操作的执行结果对第二个操作可见，第一个操作的执行顺序排在第二个操作之前</li>
<li>两个操作存在Happens-Before关系，但不意味着操作的实现必须按照Happens-Before原则执行，如果重排序后和Happens-Before关系执行结果一致，则这种重排序并不非法</li>
</ul>
</blockquote>
<p>Happens-Before提供<strong>跨线程的内存可见性保证</strong>，上文提到的操作可以发生在一个线程内，也可以发生在不同线程中。</p>
<p>针对这个第 1 条定义，我来举个例子：</p>
<figure class="highlight java"><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"></span><br><span class="line">复制代码</span><br><span class="line"><span class="comment">// 以下操作在线程 A 中执行</span></span><br><span class="line">i = <span class="number">1</span>; <span class="comment">// a</span></span><br><span class="line"></span><br><span class="line"><span class="comment">// 以下操作在线程 B 中执行</span></span><br><span class="line">j = i; <span class="comment">// b</span></span><br><span class="line"></span><br><span class="line"><span class="comment">// 以下操作在线程 C 中执行</span></span><br><span class="line">i = <span class="number">2</span>; <span class="comment">// c</span></span><br></pre></td></tr></table></figure>
<p>假设线程 A 中的操作 a Happens-before 线程 B 的操作 b，那我们就可以确定操作 b 执行后，变量 j 的值一定是等于 1。</p>
<p>得出这个结论的依据有两个：一是根据 Happens-before 原则，a 操作的结果对 b 可见，即 “i=1” 的结果可以被观察到；二是线程 C 还没运行，线程 A 操作结束之后没有其他线程会修改变量 i 的值。</p>
<p>现在再来考虑线程 C，我们依然保持 a Happens-before b ，而 c 出现在 a 和 b 的操作之间，但是 c 与 b 没有 Happens-before 关系，也就是说 b 并不一定能看到 c 的操作结果。那么 b 操作的结果也就是 j 的值就不确定了，可能是 1 也可能是 2，那这段代码就是线程不安全的。</p>
<p>我们接下来来看第二条定义，这条定义讲述了JMM的基本原则：<strong>只要不改变程序执行结果，编译器怎么优化都可以</strong>，在前文我们曾经提到过——JMM是最终一致性的，就是自Happens-before的定义的出来的结论。</p>
<p>happens-before 与 JMM 的关系如下图所示：</p>
<p><img src="/home/illumwang/blog/hexo-blog/source/_posts/pictures/happensbefore.jpg" alt="happensbefore"></p>
<p>由此可见，<strong>happens-before就是JMM抽象的灵魂</strong></p>
<h5 id="8-条-Happens-before-规则"><a href="#8-条-Happens-before-规则" class="headerlink" title="8 条 Happens-before 规则"></a>8 条 Happens-before 规则</h5><blockquote>
<p><strong>单一线程原则</strong>：在同一个线程内，程序次第执行</p>
</blockquote>
<blockquote>
<p><strong>管程锁定原则</strong>：一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。这里必须强调的是 “同一个锁”，而 “后面” 是指时间上的先后。</p>
</blockquote>
<p>这个规则针对的是<code>synchronized</code>，具体过程就是A线程对变量<code>i = 1</code>加锁，改成<code>i = 2</code>后释放锁，B线程进入代码块时就可以发现A线程读变量i的操作</p>
<blockquote>
<p><strong>volatile 变量规则</strong>：使用volatile内存屏障完成读写操作的排序，对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。（就是写屏障）</p>
</blockquote>
<p>这个规则就是 JDK 1.5 版本对 volatile 语义的增强，意义极其重大，举个例子</p>
<figure class="highlight java"><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 class="type">int</span> <span class="variable">a</span> <span class="operator">=</span> <span class="number">0</span>;</span><br><span class="line"><span class="keyword">volatile</span> <span class="type">boolean</span> <span class="variable">falg</span> <span class="operator">=</span> <span class="literal">false</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">public</span> <span class="keyword">void</span> <span class="title function_">writer</span><span class="params">()</span>{</span><br><span class="line"> a = <span class="number">22</span>; <span class="comment">// 1</span></span><br><span class="line"> flag = <span class="literal">true</span>; <span class="comment">// 2</span></span><br><span class="line">}</span><br><span class="line"><span class="keyword">public</span> <span class="keyword">void</span> <span class="title function_">reader</span><span class="params">()</span>{</span><br><span class="line"> <span class="keyword">if</span>(flag == <span class="literal">true</span>){ <span class="comment">// 3</span></span><br><span class="line"> <span class="type">int</span> <span class="variable">i</span> <span class="operator">=</span> a; <span class="comment">// 4</span></span><br><span class="line"> }</span><br><span class="line">}</span><br><span class="line"></span><br></pre></td></tr></table></figure>
<p>假设线程 A 执行 writer() 方法之后，线程 B 执行 reader() 方法。</p>
<p>根据根据程序次序规则：1 Happens-before 2；3 Happens-before 4。</p>
<p>根据 volatile 变量规则：2 Happens-before 3。</p>
<p>根据传递性规则：1 Happens-before 3；1 Happens-before 4。</p>
<p>也就是说，如果线程 B 读到了 <code>flag==true</code> 或者<code>int i = a</code> 那么线程 A 设置的<code>a=22</code>对线程 B 是可见的。</p>
<blockquote>
<p><strong>线程启动规则</strong>:Thread 对象的 start() 方法先行发生于此线程的每一个动作。</p>
</blockquote>
<p>比如主线程先启动A线程再启动B线程，启动B线程之前的所有操作都对B可见</p>
<blockquote>
<p><strong>线程终止规则</strong>:线程中的所有操作都先行发生于对此线程的终止检测，我们可以通过 Thread 对象的 join() 方法是否结束、Thread 对象的 isAlive() 的返回值等手段检测线程是否已经终止执行。</p>
</blockquote>
<blockquote>
<p><strong>线程中断规则</strong>:对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 Thread 对象的 interrupted() 方法检测到是否有中断发生。</p>
</blockquote>
<blockquote>
<p><strong>对象终结规则</strong>:一个对象的初始化完成（构造函数执行结束）先行发生于它的 finalize() 方法的开始。</p>
</blockquote>
<blockquote>
<p><strong>传递性</strong>:如果操作 A 先行发生于操作 B，操作 B 先行发生于操作 C，那就可以得出操作 A 先行发生于操作 C 的结论。</p>
</blockquote>
<h6 id="时间顺序与先行发生"><a href="#时间顺序与先行发生" class="headerlink" title="时间顺序与先行发生"></a>时间顺序与先行发生</h6><p><strong>一个操作 “时间上的先发生” 是否就代表这个操作会是“先行发生” 呢？一个操作 “先行发生” 是否就能推导出这个操作必定是“时间上的先发生”呢？</strong></p>
<p>不能这样理解，<em><strong>一个操作 “时间上的先发生” 不代表这个操作会是 “先行发生（Happens-before）</strong></em>，很简单，所谓时间上先发生是指主线程刚好运行到这里，但是并不代表在执行上是这样操作的，一个是开始调用，一个是编译执行，两者层次不同，自然也互不相通</p>
<hr>
<h4 id="三大特性"><a href="#三大特性" class="headerlink" title="三大特性"></a>三大特性</h4><h5 id="原子性"><a href="#原子性" class="headerlink" title="原子性"></a>原子性</h5><p>在线程和主存的拷贝操作中，<strong>必须保证一个变量从主内存拷贝到工作内存、以及从工作内存同步回主内存这一类的实现是原子的、不可再分的</strong>，也就是要么全部执行成功，要么全部失败，不存在中间状态</p>
<h6 id="JMM原子操作"><a href="#JMM原子操作" class="headerlink" title="JMM原子操作"></a>JMM原子操作</h6><ul>
<li><code>lock</code>（锁定）：作用于主内存的变量，它把一个变量标识为一条线程独占的状态。</li>
<li><code>unlock</code>（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。</li>
<li><code>read</code>（读取）：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用。</li>
<li><code>load</code>（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。</li>
<li><code>use</code>（使用）：作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。</li>
<li><code>assign</code>（赋值）：作用于工作内存的变量，它把一个从执行引擎接收的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。</li>
<li><code>store</code>（存储）：作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存中，以便随后的write操作使用。</li>
<li><code>write</code>（写入）：作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量</li>
</ul>
<p><img src="/home/illumwang/blog/hexo-blog/source/_posts/pictures/mecro.jpg" alt="mecro"></p>
<p>实现原子性除了对变量的原子操作以外，还有使用锁和CAS的方式来解决这个问题</p>
<h5 id="可见性"><a href="#可见性" class="headerlink" title="可见性"></a>可见性</h5><p>联系前文MESI协议，当一个CPU修改了变量，其他CPU必须立即得知该变量发生了修改，并且采用失效的方式解决这个问题。</p>
<p>在JMM中，可见性问题源于工作内存与主内存的同步延迟，解决可见性的方法除了<code>volatile</code>之外，还有<code>synchronized</code>和<code>final</code></p>
<h5 id="有序性"><a href="#有序性" class="headerlink" title="有序性"></a>有序性</h5><p>CPU有指令优化，JVM也有指令重排序，重排序并不是不受限制的，在单线程的时候，必须要遵守<strong>as-if-serial 语义</strong>：不管怎么重排序，<strong>单线程</strong>环境下程序的执行结果不能被改变。</p>
<p>为了遵守 as-if-serial 语义，<strong>CPU 和编译器不会对存在数据依赖关系的操作做重排序</strong>，因为这种重排序会改变执行结果。</p>
<p>这就引出了<strong>数据依赖性</strong>的概念</p>
<table>
<thead>
<tr>
<th>数据依赖性</th>
<th>代码示例</th>
<th>说明</th>
</tr>
</thead>
<tbody><tr>
<td><strong>写后读</strong></td>
<td>a = 1; b = a;</td>
<td>写一个变量，在读取</td>
</tr>
<tr>
<td><strong>写后写</strong></td>
<td>a = 1; a = 2;</td>
<td>写一个变量，然后修改</td>
</tr>
<tr>
<td><strong>读后写</strong></td>
<td>a = b; b = 1;</td>
<td>读出来一个变量，然后写入一个变量</td>
</tr>
</tbody></table>
<p>数据依赖性是针对单线程的，<strong>不同 CPU 之间和不同线程之间的数据依赖性是不被 CPU 和编译器考虑的</strong>。</p>
<p>Java 语言提供了 <code>volatile</code> 和 <code>synchronized</code> 两个关键字来保证线程之间操作的有序性。</p>
</div>
<footer class="article-footer">
<a data-url="http://example.com/2023/08/28/JUC%E2%80%94%E2%80%94Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B/" data-id="cm0cpr04r0000ldi53vom4h4k" class="article-share-link">
分享
</a>
<ul class="article-tag-list" itemprop="keywords"><li class="article-tag-list-item"><a class="article-tag-list-link" href="/tags/Java/" rel="tag">Java</a></li><li class="article-tag-list-item"><a class="article-tag-list-link" href="/tags/%E5%B9%B6%E5%8F%91%E7%BC%96%E7%A8%8B/" rel="tag">并发编程</a></li></ul>
</footer>
</div>
</article>
</article>
</section>
</div>
<footer class="footer">
<div class="outer">
<ul class="list-inline">
<li>elysium-w © 2024</li>
<li>
<a href="https://beian.miit.gov.cn/" target="_blank"></a>
</li>
<li>Powered by <a href="http://hexo.io/" target="_blank">Hexo</a></li>
<li>theme <a target="_blank" rel="noopener" href="https://github.com/zhwangart/hexo-theme-ocean">Ocean</a></li>
</ul>
<p><ul class="list-inline">
<li><i class="fe fe-bar-chart tooltip" data-tooltip="PV"></i> <span id="busuanzi_value_site_pv"></span></li>
<li><i class="fe fe-smile-alt tooltip" data-tooltip="UV"></i> <span id="busuanzi_value_site_uv"></span></li>
</ul></p>
</div>
</footer>
</main>
<aside class="sidebar">
<button class="navbar-toggle"></button>
<nav class="navbar">
<div class="logo">
<a href="/"><img src="/images/hexo.svg" alt="elysium-w"></a>
</div>
<ul class="nav nav-main">
<li class="nav-item">
<a class="nav-item-link" href="/">Home</a>
</li>
<li class="nav-item">
<a class="nav-item-link" href="/archives">Archives</a>
</li>
<li class="nav-item">
<a class="nav-item-link" href="/gallery">Gallery</a>
</li>
<li class="nav-item">
<a class="nav-item-link" href="/about">About</a>
</li>
<li class="nav-item">
<a class="nav-item-link nav-item-search" title="搜索">
<i class="fe fe-search"></i>
搜索
</a>
</li>
</ul>
</nav>
<nav class="navbar navbar-bottom">
<ul class="nav">
<li class="nav-item">
<div class="totop" id="totop">
<i class="fe fe-rocket"></i>
</div>
</li>
<li class="nav-item">
<a class="nav-item-link" target="_blank" href="/atom.xml" title="RSS Feed">
<i class="fe fe-feed"></i>
</a>
</li>
</ul>
</nav>
<div class="search-form-wrap">
<div class="local-search local-search-plugin">
<input type="search" id="local-search-input" class="local-search-input" placeholder="Search...">
<div id="local-search-result" class="local-search-result"></div>
</div>
</div>
</aside>
<script src="/js/jquery-2.0.3.min.js"></script>
<script src="/js/jquery.justifiedGallery.min.js"></script>
<script src="/js/lazyload.min.js"></script>
<script src="/js/busuanzi-2.3.pure.min.js"></script>
<script src="/fancybox/jquery.fancybox.min.js"></script>
<script src="/js/ocean.js"></script>
</body>
</html>