什么是CAS？
概述
并发场景下：
-
我认为V的值应该是A，如果是的话那我就把它改成B，如果不是A（说明被别人修改过了），那我就不修改了，避免多人同时修改导致出错
-
CAS有三个操作数：内存值V、预期值A、要修改的值B，当且仅当预期值A和内存值V相同时，才将内存值修改为B，否则什么都不做。最后返回现在的V值
应用场景
- 乐观锁
- 并发容器
- 原子类
分析在Java中是如何利用CAS实现原子操作的？
- AtomicInteger加载Unsafe工具，用来直接操作内存数据用Unsafe来实现底层操作
- 用volatile修饰value字段，保证可见性
getAndAddInt方法分析
Unsafe类
Unsafe是CAS的核心类。Java无法直接访问底层操作系统，而是通过本地（native）方法来访问。不过尽管如此，JVM还是开了一个后门，JDK中有一个类Unsafe，它提供了硬件级别的原子操作。
valueOffset表示的是变量值在内存中的偏移地址，因为
Unsafe就是根据内存偏移地址获取数据的原值的，这样我们就能通过unsafe来实现CAS了
Unsafe类中的compareAndSwaplnt方法：
方法中先想办法拿到变量value在内存中的地址。
通过Atomic::cmpxchg实现原子性的比较和替换，其中参数x是即将更新的值，参数e是原内存的值。至此，最终完成了CAS的全过程。
CAS缺点
ABA问题：获取到值还未修改已经被其他线程修改导致一致不会修改（可用版本后方法解决）
自旋时间过长（do while循环）
final关键字和不变性
什么是不变性（Immutable）
如果对象在被创建后，状态就不能被修改，那么它就是不可变的
例子：person对象，age和name都不能再变
具有不变性的对象一定是线程安全的，我们不需要对其采取任何额外的安全措施，也能保证线程安全
final的作用
早期
锁定
效率：早期的Java实现版本中，会将final方法转为内嵌调用
现在
类防止被继承、方法防止被重写、变量防止被修改
天生是线程安全的，而不需要额外的同步开销
final修饰变量
含义：被final修饰的变量，意味着值不能被修改。如果变量是对象，那么对象的引用不能变，但是对象自身的内容依然可以变化
赋值时机
属性被声明为final后，该变量则只能被赋值一次。且一旦被赋值，final的变量就不能再被改变，如论如何也不会变
final instance variable （类中的final属性）
第一种是在声明变量的等号右边直接赋值
第二种就是构造函数中赋值
第三就是在类的初始代码块中赋值（不常用）
final static variable（类中的static final属性）
两个赋值时机：除了在声明变量的等号右边直接赋值外，static final变量还可以用static初始代码块赋值，但是不能用普通的初始代码块赋值
final local variable（方法中的final变量）
和前面两种不同，由于这里的变量是在方法里的，所以没有构造函数，也不存在初始代码块
final local variable不规定赋值时机，只要求在使用前必须赋值，这和方法中的非final变量的要求也是一样的
为什么要规定赋值时机？
如果初始化不赋值，后续赋值，就是从null变成你的赋值，这就违反final不变的原则了！
final修饰方法
- 构造方法不允许final修饰
- 不可被重写，也就是不能被override，即便是子类有同样名字的方法，那也不是override，这个和static方法是一个道理
- 引申：static方法不能被重写（但是可以有同名的方法，是因为static声明方法时与主类绑定了，继承后该方法后的同名方法和主类的同名方法是独立的，没有关系）
final修饰类
不可被继承
例如典型的String类就是final的，我们从没见过哪个类是继承String类的
final的注意点：
final修饰对象的时候，只是对象的引用不可变，而对象本身的属性是可以变化的
final使用原则：良好的编程习惯
不变性和final的关系
如何利用final实现对象不可变
把所有属性都声明为final?
答案是不行的，有属性是对象被final修饰，仍然是可变的。
一个属性是对象类型的不可变对象的正确例子
使用private修饰对象属性
package immutable;
import java.util.HashSet;
import java.util.Set;
/**
* 描述： 一个属性是对象，但是整体不可变，其他类无法修改set里面的数据
*/
public class ImmutableDemo {
private final Set<String> students = new HashSet<>();
public ImmutableDemo() {
students.add("李小美");
students.add("王壮");
students.add("徐福记");
}
public boolean isStudent(String name) {
return students.contains(name);
}
}
对象不可变需要满足条件：
对象创建后，其状态就不能修改
所有属性都是final修饰的
对象创建过程中没有发生逸出
把变量写在线程内部一栈封闭
在方法里新建的局部变量，实际上是存储在每个线程私有的栈空间，而每个栈的占空间是不能被其他线程所访问到的，所以不会有线程安全问题。这就是著名的“栈封闭〞技术，是“线程封闭〞技术的一种情况。
代码案例
package immutable;
/**
* 描述： 演示栈封闭的两种情况，基本变量和对象 先演示线程争抢带来错误结果，然后把变量放到方法内，情况就变了
*/
public class StackConfinement implements Runnable {
int index = 0;
public void inThread() {
int neverGoOut = 0;
synchronized (this) {
for (int i = 0; i < 10000; i++) {
neverGoOut++;
}
}
System.out.println("栈内保护的数字是线程安全的：" + neverGoOut);
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
index++;
}
inThread();
}
public static void main(String[] args) throws InterruptedException {
StackConfinement r1 = new StackConfinement();
Thread thread1 = new Thread(r1);
Thread thread2 = new Thread(r1);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println(r1.index);
}
}
运行结果：
final修饰String注意点
案例一：
public class FinalStringDemo1 {
public static void main(String[] args) {
String a = "wukong2";
final String b = "wukong";
String d = "wukong";
String c = b + 2;
String e = d + 2;
System.out.println((a == c));
System.out.println((a == e));
}
}
结果输出：
原因是final修饰时，b是不可变的，在计算结果已经固定了，发现和a一致，就不会重新创建新的String对象。
案例二：
public class FinalStringDemo2 {
public static void main(String[] args) {
String a = "wukong2";
final String b = getDashixiong();
String c = b + 2;
System.out.println(a == c);
}
private static String getDashixiong() {
return "wukong";
}
}
原因是final修饰的是方法，返回的结果具有不确定性，是运行时生成的String，所以创建了新的Sting对象。
