X Tutup
Skip to content

Commit eb18610

Browse files
dunwudunwu
committed
🚚 Change path
1 parent 16b8716 commit eb18610

20 files changed

+67
-67
lines changed

‎README.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
1-
# javase-notes
1+
# JavaSE
22

3-
> javase-notes 是一个 javase 学习笔记。
3+
> JavaSE 是一个 javase 学习笔记。
44
55
| Ⅰ | Ⅱ | Ⅲ | Ⅳ | Ⅴ | Ⅵ |
66
| :---------------------: | :---------------------: | :---------------------: | :-----------------: | :-------------------------: | :-----------------------------: |

‎docs/advanced/Java反射.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -254,9 +254,9 @@ System.out.println(constructor);
254254

255255
## 推荐阅读
256256

257-
本文示例代码见：[源码](https://github.com/dunwu/javase-notes/tree/master/codes/advanced/src/main/java/io/github/dunwu/javase)
257+
本文示例代码见：[源码](https://github.com/dunwu/JavaSE/tree/master/codes/advanced/src/main/java/io/github/dunwu/javase)
258258

259-
本文同步维护在：[Java 系列教程](https://github.com/dunwu/javase-notes)
259+
本文同步维护在：[Java 系列教程](https://github.com/dunwu/JavaSE)
260260

261261
## 参考资料
262262

‎docs/advanced/Java序列化.md‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -40,7 +40,7 @@ tags:
4040
**反序列化**：反序列化是将字节流转换为对象。
4141

4242
<div align="center">
43-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/advanced/序列化与反序列化.jpg" />
43+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/advanced/序列化与反序列化.jpg" />
4444
</div>
4545

4646
### 1.2. 用途
@@ -479,14 +479,14 @@ true
479479
通过上面的内容，相各位已经了解了 Java 序列化的使用。这里用一张脑图来总结知识点。
480480

481481
<div align="center">
482-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/advanced/Java序列化脑图.png" />
482+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/advanced/Java序列化脑图.png" />
483483
</div>
484484

485485
## 7. 推荐阅读
486486

487-
本文示例代码见：[源码](https://github.com/dunwu/javase-notes/tree/master/codes/advanced/src/main/java/io/github/dunwu/javase)
487+
本文示例代码见：[源码](https://github.com/dunwu/JavaSE/tree/master/codes/advanced/src/main/java/io/github/dunwu/javase)
488488

489-
本文同步维护在：[Java 系列教程](https://github.com/dunwu/javase-notes)
489+
本文同步维护在：[Java 系列教程](https://github.com/dunwu/JavaSE)
490490

491491
## 8. 参考资料
492492

‎docs/concurrent/1-并发简介.md‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ tags:
5252
* 最关键的点就是：是否是**同时**。
5353

5454
<p align="center">
55-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/concurrent-vs-parallel.jpg">
55+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/concurrent-vs-parallel.jpg">
5656
</p>
5757

5858
### 同步和异步
@@ -65,7 +65,7 @@ tags:
6565
* 异步则是相反，调用在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果。而是在调用发出后，被调用者通过状态、通知来通知调用者，或通过回调函数处理这个调用。
6666

6767
<p align="center">
68-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/synchronous-vs-asynchronous.gif">
68+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/synchronous-vs-asynchronous.gif">
6969
</p>
7070

7171
### 阻塞和非阻塞
@@ -91,7 +91,7 @@ tags:
9191
* 进程是一个实体，拥有独立的资源；而同一个进程中的多个线程共享进程的资源。
9292

9393
<p align="center">
94-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/processes-vs-threads.jpg">
94+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/processes-vs-threads.jpg">
9595
</p>
9696

9797
JVM 在单个进程中运行，JVM 中的线程共享属于该进程的堆。这就是为什么几个线程可以访问同一个对象。线程共享堆并拥有自己的堆栈空间。这是一个线程如何调用一个方法以及它的局部变量是如何保持线程安全的。但是堆不是线程安全的并且为了线程安全必须进行同步。
@@ -229,7 +229,7 @@ A: 回写寄存器值(3)到内存. this.count 现在等于 3
229229
死锁是当线程进入无限期等待状态时发生的情况，因为所请求的锁被另一个线程持有，而另一个线程又等待第一个线程持有的另一个锁。
230230

231231
<p align="center">
232-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/deadlock.png">
232+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/deadlock.png">
233233
</p>
234234

235235
##### 避免死锁的方法
@@ -268,7 +268,7 @@ A: 回写寄存器值(3)到内存. this.count 现在等于 3
268268
想象这样一个例子：两个人在狭窄的走廊里相遇，二者都很礼貌，试图移到旁边让对方先通过。但是他们最终在没有取得任何进展的情况下左右摇摆，因为他们都在同一时间向相同的方向移动。
269269

270270
<p align="center">
271-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/livelock.png">
271+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/livelock.png">
272272
</p>
273273

274274
如图所示：两个线程想要通过一个 Worker 对象访问共享公共资源的情况，但是当他们看到另一个 Worker（在另一个线程上调用）也是“活动的”时，它们会尝试将该资源交给其他工作者并等待为它完成。如果最初我们让两名工作人员都活跃起来，他们将会面临活锁问题。
@@ -286,7 +286,7 @@ A: 回写寄存器值(3)到内存. this.count 现在等于 3
286286
* 线程在等待一个本身(在其上调用 wait())也处于永久等待完成的对象，因为其他线程总是被持续地获得唤醒。
287287

288288
<p align="center">
289-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/starvation-and-fairness.png">
289+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/starvation-and-fairness.png">
290290
</p>
291291

292292
饥饿问题最经典的例子就是哲学家问题。如图所示：有五个哲学家用餐，每个人要活得两把叉子才可以就餐。当 2、4 就餐时，1、3、5 永远无法就餐，只能看着盘中的美食饥饿的等待着。

‎docs/concurrent/2-线程基础.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ tags:
4646
### 线程生命周期
4747

4848
<p align="center">
49-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/thread-state.png">
49+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/thread-state.png">
5050
</p>
5151

5252
线程的生命周期有 6 种不同的状态，在给定的一个时刻，线程只能处于其中的一个状态。

‎docs/concurrent/3-并发机制的底层实现.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,7 @@ tags:
5858
AQS，非阻塞数据结构和原子变量类（Java.util.concurrent.atomic 包中的类），这些 concurrent 包中的基础类都是使用这种模式来实现的，而 concurrent 包中的高层类又是依赖于这些基础类来实现的。从整体来看，concurrent 包的实现示意图如下：
5959

6060
<p align="center">
61-
<img src="https://raw.githubusercontent.com/dunwu/Javase-notes/master/images/concurrent/juc-architecture.png">
61+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/juc-architecture.png">
6262
</p>
6363

6464
## synchronized

‎docs/concurrent/4-内存模型.md‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -61,15 +61,15 @@ Java 内存模型把 Java 虚拟机内部划分为线程栈和堆。
6161
* 存放在堆上的对象可以被所有持有对这个对象引用的线程访问。当一个线程可以访问一个对象时，它也可以访问这个对象的成员变量。如果两个线程同时调用同一个对象上的同一个方法，它们将会都访问这个对象的成员变量，但是每一个线程都拥有这个本地变量的私有拷贝。
6262

6363
<p align="center">
64-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/java-memory-model-3.png">
64+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/java-memory-model-3.png">
6565
</p>
6666

6767
## 硬件内存架构
6868

6969
现代硬件内存模型与 Java 内存模型有一些不同。理解内存模型架构以及 Java 内存模型如何与它协同工作也是非常重要的。这部分描述了通用的硬件内存架构，下面的部分将会描述 Java 内存是如何与它“联手”工作的。
7070

7171
<p align="center">
72-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/java-memory-model-4.png">
72+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/java-memory-model-4.png">
7373
</p>
7474

7575
一个现代计算机通常由两个或者多个 CPU。其中一些 CPU 还有多核。从这一点可以看出，在一个有两个或者多个 CPU 的现代计算机上同时运行多个线程是可能的。每个 CPU 在某一时刻运行一个线程是没有问题的。这意味着，如果你的 Java 程序是多线程的，在你的 Java 程序中每个 CPU 上一个线程可能同时（并发）执行。
@@ -89,7 +89,7 @@ Java 内存模型把 Java 虚拟机内部划分为线程栈和堆。
8989
上面已经提到，Java 内存模型与硬件内存架构之间存在差异。硬件内存架构没有区分线程栈和堆。对于硬件，所有的线程栈和堆都分布在主内中。部分线程栈和堆可能有时候会出现在 CPU 缓存中和 CPU 内部的寄存器中。如下图所示：
9090

9191
<p align="center">
92-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/java-memory-model-5.png">
92+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/java-memory-model-5.png">
9393
</p>
9494

9595
当对象和变量被存放在计算机中各种不同的内存区域中时，就可能会出现一些具体的问题。主要包括如下两个方面：
@@ -98,7 +98,7 @@ Java 内存模型把 Java 虚拟机内部划分为线程栈和堆。
9898
* 当读，写和检查共享变量时出现 race conditions
9999

100100
<p align="center">
101-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/java-memory-model-6.png">
101+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/java-memory-model-6.png">
102102
</p>
103103

104104
### 共享对象可见性

‎docs/concurrent/5-同步容器和并发容器.md‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -181,7 +181,7 @@ JDK 的 `java.util.concurrent` 包（即 juc）中提供了几个非常有用的
181181
ConcurrentHashMap 类在 jdk1.7 中的设计，其基本结构如图所示：
182182

183183
<p align="center">
184-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/ConcurrentHashMap-jdk7.png">
184+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/ConcurrentHashMap-jdk7.png">
185185
</p>
186186

187187
每一个 segment 都是一个 HashEntry<K,V>[] table， table 中的每一个元素本质上都是一个 HashEntry 的单向队列。比如 table[3]为首节点，table[3]->next 为节点 1，之后为节点 2，依次类推。
@@ -332,7 +332,7 @@ public class ConcurrentHashMapDemo {
332332
* 写时复制集合返回的迭代器不会抛出 ConcurrentModificationException，因为它们在数组的快照上工作，并且无论后续的修改（2,4）如何，都会像迭代器创建时那样完全返回元素。
333333

334334
<p align="center">
335-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/CopyOnWriteArrayList.png">
335+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/CopyOnWriteArrayList.png">
336336
</p>
337337

338338
#### 源码
@@ -492,4 +492,4 @@ public class CopyOnWriteArrayListDemo {
492492
* https://www.cnblogs.com/xrq730/p/5020760.html
493493
* https://www.cnblogs.com/leesf456/p/5547853.html
494494
* http://www.cnblogs.com/chengxiao/p/6881974.html
495-
* http://www.cnblogs.com/dolphin0520/p/3933404.html
495+
* http://www.cnblogs.com/dolphin0520/p/3933404.html

‎docs/concurrent/6-锁.md‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -203,7 +203,7 @@ public ReentrantLock(boolean fair) {}
203203
* `NonfairSync` - 非公平锁版本。
204204

205205
<p align="center">
206-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/ReentrantLock-diagram.png">
206+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/ReentrantLock-diagram.png">
207207
</p>
208208

209209
### 示例
@@ -237,7 +237,7 @@ public class ReentrantLockDemo {
237237
}
238238
```
239239

240-
:point_right: [更多示例](https://github.com/dunwu/javase-notes/tree/master/codes/concurrent/src/main/java/io/github/dunwu/javase/concurrent/lock)
240+
:point_right: [更多示例](https://github.com/dunwu/JavaSE/tree/master/codes/concurrent/src/main/java/io/github/dunwu/javase/concurrent/lock)
241241

242242
## ReadWriteLock 和 ReentrantReadWriteLock
243243

@@ -254,7 +254,7 @@ ReentrantReadWriteLock 实现了 ReadWriteLock 接口，所以它是一个读写
254254
“读-写”线程、“写-写”线程之间存在互斥关系。
255255

256256
<p align="center">
257-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/ReadWriteLock.jpg">
257+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/ReadWriteLock.jpg">
258258
</p>
259259

260260
### 源码
@@ -479,7 +479,7 @@ final boolean acquireQueued(final Node node, int arg) {
479479
acquireQueued Before
480480

481481
<p align="center">
482-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/aqs-acquireQueued-before.png">
482+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/aqs-acquireQueued-before.png">
483483
</p>
484484

485485
`setHead` 方法
@@ -495,7 +495,7 @@ private void setHead(Node node) {
495495
将当前节点通过 setHead 方法设置为队列的头结点，然后将之前的头结点的 next 域设置为 null，并且 pre 域也为 null，即与队列断开，无任何引用方便 GC 时能够将内存进行回收。
496496

497497
<p align="center">
498-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/aqs-acquireQueued-after.png">
498+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/aqs-acquireQueued-after.png">
499499
</p>
500500

501501
##### shouldParkAfterFailedAcquire
@@ -537,7 +537,7 @@ private final boolean parkAndCheckInterrupt() {
537537
综上所述，就是 acquire 的完整流程。可以以一幅图来说明：
538538

539539
<p align="center">
540-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/aqs-acquire-flow.png">
540+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/aqs-acquire-flow.png">
541541
</p>
542542

543543
#### 释放独占锁
@@ -717,7 +717,7 @@ private boolean doAcquireNanos(int arg, long nanosTimeout)
717717
```
718718

719719
<p align="center">
720-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/aqs-doAcquireNanos-flow.png">
720+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/aqs-doAcquireNanos-flow.png">
721721
</p>
722722

723723
#### 获取共享锁

‎docs/concurrent/8-并发工具类.md‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@ JDK 的 `java.util.concurrent` 包（即 juc）中提供了几个非常有用的
4141
* 原理：`CountDownLatch` 维护一个计数器 count，表示需要等待的事件数量。`countDown` 方法递减计数器，表示有一个事件已经发生。调用 `await` 方法的线程会一直阻塞直到计数器为零，或者等待中的线程中断，或者等待超时。
4242

4343
<p align="center">
44-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/CountdownLatch.png" alt="CountdownLatch">
44+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/CountdownLatch.png" alt="CountdownLatch">
4545
</p>
4646

4747
### 源码
@@ -115,7 +115,7 @@ public class CountDownLatchDemo {
115115
* 场景：`CyclicBarrier` 在并行迭代算法中非常有用。
116116

117117
<p align="center">
118-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/CyclicBarrier.png" alt="CyclicBarrier">
118+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/CyclicBarrier.png" alt="CyclicBarrier">
119119
</p>
120120

121121
### 源码
@@ -204,7 +204,7 @@ public class CyclicBarrierDemo02 {
204204
* `Semaphore` 可以用于将任何一种容器变成有界阻塞容器。
205205

206206
<p align="center">
207-
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/semaphore.png" alt="semaphore">
207+
<img src="https://raw.githubusercontent.com/dunwu/JavaSE/master/images/concurrent/semaphore.png" alt="semaphore">
208208
</p>
209209

210210
### 源码

0 commit comments

Comments
 (0)
X Tutup