# 一、synchronized
synchronized是Java中的关键字， ：
1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
```java
class SyncLock implements Runnable{
@Override
public void run() {
synchronized (this){
for (int i = 0; i < 5 ; i + + ) {
try {
System.out.println("线程名:"+Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
```
synchronized (this)锁定的是当前对象， ，
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
```java
public synchronized void run() {
{
for (int i = 0; i < 5 ; i + + ) {
try {
System.out.println("线程名:"+Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
```
在用synchronized修饰方法时要注意以下几点：
+ synchronized关键字不能继承
+ 在定义接口方法时不能使用synchronized关键字
+ 构造方法不能使用synchronized关键字，
3. 修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
静态方法是属于类的而不属于对象的。同样的，
```java
class SyncThread implements Runnable {
private static int count;
public SyncThread() {
count = 0;
}
public synchronized static void method() {
for (int i = 0; i < 5 ; i + + ) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void run() {
method();
}
}
```
假如创建了2个SyncThread对象， ， ，
4. 修饰一个类， ，
```java
class SyncThread implements Runnable {
private static int count;
public SyncThread() {
count = 0;
}
public static void method() {
synchronized(SyncThread.class) {
for (int i = 0; i < 5 ; i + + ) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public synchronized void run() {
method();
}
}
```
效果与修饰静态方法相同
# 二、volatile
不能用于自增操作，
作用如下：
1. 保证可见性，不保证原子性
当写一个volatile变量时， ；
这个写会操作会导致其他线程中的volatile变量缓存无效。
2. 禁止指令重排
重排序在单线程下一定能保证结果的正确性，但是在多线程环境下，可能发生重排序，影响结果
假设线程A先执行writer方法， ， ，
![[Snipaste_2023-02-28_13-09-43 2.png]]
当volatile变量写后， ，
![[Snipaste_2023-02-28_13-09-43 3.png]]
从横向来看， ， ， ， ， ？
# 三、ReentrantLock
```java
public class ReentrantLockDemo {
// 实例化一个非公平锁， ，
private final ReentrantLock lock = new ReentrantLock(false);
private int i;
public void testLock() {
// 拿锁，如果拿不到会一直等待
lock.lock();
try {
// 再次尝试拿锁(可重入)，
if (lock.tryLock(100, TimeUnit.MILLISECONDS))
i++;
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放锁
lock.unlock();
lock.unlock();
}
}
}
```
代码中创建了非公平锁， ， ， ， ， ， ， ， ， ， ， （ ， ， ， ， ）
另外， ， ，
## 3.1 公平与非公平
**公平锁**是指多个线程按照申请锁的顺序来获取锁，线程直接进入同步队列中排队，队列中最先到的线程先获得锁。**非公平锁**是多个线程加锁时每个线程都会先去尝试获取锁，如果刚好获取到锁，那么线程无需等待，直接执行，如果获取不到锁才会被加入同步队列的队尾等待执行。
公平锁的优点在于各个线程公平平等， ， ， ， ，
而非公平锁非公平锁的优点是可以减少唤起线程的开销， ， ， ，
## 3.2 可重入与非可重入
可重入锁不会阻塞
**可重入锁**又名递归锁， ， （ ） ，
synchronized与本篇讲的ReentrantLock都属于可重入锁。可重入锁可以有效避免死锁的产生。
# 四、CAS与原子类
原子操作类， ， ， ， ， ，
## 4.1 CAS机制
CAS是英文单词Compare And Swap的缩写，
CAS机制当中使用了3个基本操作数： ， ，
更新一个变量的时候， ，
用伪代码解释就是：
if(V=A){ ----- 比较相等
swap() ----- 替换旧值， ， ，
}else {
retry() ----- 重试（自旋）
}
在 Java 中， ， （ ） ， ， （ ）
![[Snipaste_2023-02-28_13-09-43 5.png]]
```cpp
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
// alternative for InterlockedCompareExchange
int mp = os::is_MP();
__asm {
mov edx,
dest mov ecx,
exchange_value mov eax,
compare_value LOCK_IF_MP(mp)
cmpxchg dword ptr [edx], ecx
}
}
```
如上面源代码所示， ， （ ） ， ， （ ， ）
## 4.2 示例
1. 在内存地址V中，
![[5630287-350bc3c474eef0e8.jpg]]
2. 此时线程1想要把变量的值增加1。对线程1来说， ，
![[5630287-350bc3c474eef0e8 1.jpg]]
3. 在线程1要提交更新之前， ，
![[5630287-350bc3c474eef0e8 2.jpg]]
4. 线程1开始提交更新， （ ） ， ，
![[5630287-350bc3c474eef0e8 3.jpg]]
5. 线程1重新获取内存地址V的当前值， ， ，
![[5630287-f638cadea7b6cb96.webp]]
6. 这一次比较幸运， ，
![[5630287-0a3d0b3926366d63.jpg]]
7. 线程1进行SWAP， ，
![[5630287-0a3d0b3926366d63 1.jpg]]
## 4.3 优缺点
#### 优点：
- 可以保证变量操作的原子性；
- 并发量不是很高的情况下， ；
- 在线程对共享资源占用时间较短的情况下，
#### 缺点：
1. CPU开销较大
在并发量比较高的情况下，如果许多线程反复尝试更新（自旋锁
） ， ， ，
2. 不能保证代码块的原子性
CAS机制所保证的只是一个变量的原子性操作， ，
3. ABA问题
CAS在操作的时候会检查变量的值是否被更改过， ， ， ， ， ， ， ， ， ， ， ， ， ， ， ， ，
# 五、AQS
CAS中的自旋锁有2个缺点：
+ 第一个是锁饥饿问题。在锁竞争激烈的情况下，可能存在一个线程一直被其他线程”插队“而一直获取不到锁的情况。
+ 第二是性能问题。在实际的多核上运行的自旋锁在锁竞争激烈时性能较差。
TASLock 和 TTASLock 与上文代码类似，都是针对**一个原子状态变量**轮询的自旋锁实现，显然，自旋锁的性能和理想情况相距甚远。这是因为自旋锁锁状态中心化，在竞争激烈的情况下，锁状态变更会导致多个 CPU 的高速缓存的频繁同步，从而拖慢 CPU 效率。
为了解决这2个问题就有了CLH锁，
![[721070-20170504110246211-10684485.png]]
CLH 锁是对自旋锁的一种改进，有效的解决了以上的两个缺点。首先它将线程组织成一个队列，保证先请求的线程先获得锁，避免了饥饿问题。其次锁状态去中心化，**让每个线程在不同的状态变量中自旋**，这样当一个线程释放它的锁时，只能使其后续线程的高速缓存失效，缩小了影响范围，从而减少了 CPU 的开销。
CLH 锁数据结构很简单， ， ， ， ， ，
AQS定义两种资源共享方式： （ ， ， ） （ ， ， ）
不同的自定义同步器争用共享资源的方式也不同。**自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可**，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等） ， ：
- isHeldExclusively()：
- tryAcquire(int)： ， ，
- tryRelease(int)： ， ，
- tryAcquireShared(int)： ； ， ； ，
- tryReleaseShared(int)： ， ，
**以ReentrantLock为例， （ ） ， ， ， ， （ ） ， ， ， （ ） ， ， ，
再以CountDownLatch以例， ， （ ） ， ， ， ，
## 5.1 CLH的数据结构
CLH中的节点表示待获取锁的对象，
| 方法和属性值 | 含义 |
| ------------ | ------------ |
| waitStatus | 当前节点在队列中的状态 |
| thread | 表示处于该节点的线程 |
| prev | 前驱指针 |
| predecessor | 返回前驱节点，
| nextWaiter | 指向下一个处于CONDITION状态的节点|
| next | 后继指针 |
waitStatus有下面几个枚举值：
| 枚举 | 含义 |
| --------- | ---------------------------------------------- |
| 0 | 当一个Node被初始化的时候的默认值 |
| CANCELLED | 为1，
| CONDITION | 为-2， ，
| PROPAGATE | 为-3， ，
| SIGNAL | 为-1， ，
## 5.2 同步状态State
AQS中维护了一个名为state的字段， ， ，
| 方法名 | 描述 |
| ------------------------------------------------------------------ | -------------------- |
| protected final int getState() | 获取State的值 |
| protected final void setState(int newState) | 设置State的值 |
| protected final boolean compareAndSetState(int expect, int update) | 使用CAS方式更新State |
可以通过修改State字段表示的同步状态来实现多线程的独占模式和共享模式（ ）
### 5.2.1 独占模式
![[27605d483e8935da683a93be015713f331378.png]]
以ReentrantLock为例， （ ） ， ， ， ， （ ） ， ， ， （ ） ， ， ，
举个例子：排队打饭，只有一个窗口(state)， （ ， ， ） ， （ ， ）
#### 线程加入等待队列
当其他线程tryAcquire()失败时， ， ， ， ， （ ）
### 5.2.2 共享模式
![[27605d483e8935da683a93be015713f331378 1.png]]
以CountDownLatch以例， ， （ ） ， ， ， ，
