最有用的东西,是你手里的钱,有钱就有底气,还不快去挣钱~

---

---

CAS 和 Synchronized 优化过程

1. CAS

1.1 CAS的原理

CAS的具体操作是,有一个变量值i为A,想要将值A修改为新值B.
1.compare: 比较 if( i == A ).
2.swap : 如果相等,就把i的值改为B
3.返回此操作是否成功
CAS操作具有原子性,即这三个操作会通过一个指令完成三条操作,在一定程度上规避了线程安全问题.

1.2 CAS实现自增自减的原子性

如下代码,AtomicInteger,AtomicLong等类运用了CAS机制,实现变量自增自减的原子性.
a.getAndIncrement(); //a++
a.getAndDecrement(); //a–
a.incrementAndGet(); //++a
a.decrementAndGet(); //- -a
a.addAndGet(3); //a += 3

import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicInteger;
public class MyAtomicInteger {public static void main(String[] args) throws InterruptedException{//AtomicInteger,AtomicLong,AtomicBoolean,AtomicIntegerArrayAtomicInteger a = new AtomicInteger(0);Thread t1 = new Thread(()->{a.getAndIncrement();   //a++a.getAndDecrement();   //a--a.incrementAndGet();   //++aa.decrementAndGet();   //--aa.addAndGet(3);        //a += 3});Thread t2 = new Thread(()->{a.getAndIncrement();});t1.start();t2.start();t1.join();t2.join();System.out.println(a.get());}
}

1.3 CAS实现自旋锁

如下图,是CAS实现自旋锁的伪代码
while(!CAS(this.owner,null,Thread.currentThread()))
1.线程owner初始化为null
2.进入循环,先判断线程owner是否为null,如果owner不为空,代表owner正在被其他线程占用,则需要阻塞等待.
3.线程解锁后,又被设为null,这时可以把当前线程赋值给owner.

1.4 CAS针对ABA问题的优化

CAS的核心机制,检查变量i和旧值A是否相等,但如果变量i中途被修改了,后来又恢复成了A,系统是无法察觉的.
例如去银行取钱,原来1000,要取出500.银行系统慢,这个人多点了两下取钱键.
1.先比较钱数是否为1000,是,取出500.
2.但取钱的同时有位有人给卡充了500,使钱恢复成了1000
3.系统第二次比较,发现钱是1000,又取出了500
很明显,在这卡bug呢.

优化机制
给操作加一个版本号,每执行一次操作,版本号加1.执行的次数以版本号为主.就不会出现执行多次的情况

2. synchronized

2.1 synchronized加锁阶段分析

synchronized加锁有一个过程
1.无锁状态
2.偏向锁,先给要加锁的对象一个标记,看对象是否存在锁竞争,若执行过程中没有出现锁竞争,在执行synchronized之后取消偏向锁即可.如果出现另外的线程去竞争锁,需要迅速把偏向锁升级成真正的加锁状态.
3.轻量级锁,当synchronized发生锁竞争时,偏向锁升级为轻量级锁(加锁方式为自旋锁).
4.如果一直拿不到锁,自旋了一定时间后,锁就会升级为重量级锁(挂起等待锁).进入阻塞队列等待,直到锁被释放,线程才有机会获取锁.
注意:锁只能升级,没办法降级.

2.2 synchronized优化

1.锁清除
对对象加锁后,编译器可以去自动判定,若当前场景不需要加锁,编译器会把锁清除.
2.锁粗化
如果一段代码中,出现了多个锁,加锁解锁频繁,并且每个锁之间距离很近.这时可以用一个大锁直接包含这些小锁,减少频繁加锁解锁的开销.

本文完

---