声明：本文是自己自学慕课网悟空老师的《玩转Java并发工具，精通JUC，成为并发多面手》的CAS以及final关键字部分后整理而成课程笔记。

如有侵权，请私信我并第一时间删除本文。

CAS原理

1.什么是CAS

◆运用领域：并发

◆我认为V的值应该是A ,如果是的话那我就把它改成B ，如果不是A (说明被别人修改过了) ，那我就不修改了，避免多人同时修改导致出错

◆CAS有三个操作数:内存值V、预期值A、要修改的值B，当且仅当预期值A和内存值V相同时，才将内存值修改为B ，否则什么都不做。最后返回现在的V值

◆需要利用CPU的特殊指令

◆CAS的等价代码(语义)

/**
 * 描述：     模拟CAS操作，等价代码
 */
public class SimulatedCAS {
    private volatile int value;

    public synchronized int compareAndSwap(int expectedValue, int newValue) {
        int oldValue = value;
        if (oldValue == expectedValue) {
            value = newValue;
        }
        return oldValue;
    }
}

2.案例演示

◆两个线程竞争, 其中一个落败

/**
 * 描述：     模拟CAS操作，等价代码
 */
public class TwoThreadsCompetition implements Runnable {

    private volatile int value;

    public synchronized int compareAndSwap(int expectedValue, int newValue) {
        int oldValue = value;
        if (oldValue == expectedValue) {
            value = newValue;
        }
        return oldValue;
    }

    public static void main(String[] args) throws InterruptedException {
        TwoThreadsCompetition r = new TwoThreadsCompetition();
        r.value = 0;
        Thread t1 = new Thread(r,"Thread 1");
        Thread t2 = new Thread(r,"Thread 2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(r.value);
    }

    @Override
    public void run() {
        compareAndSwap(0, 1);
    }
}

3.应用场景

乐观锁(数据库修改数据时候用版本号，不需要锁住这个表，这个思想也是CAS体现)
并发容器（比如ConcurrentHashMap）
原子类

4. 以AtomicInteger为例,分析在Java中是如何利用CAS实现原子操作的?

AtomicInteger加载Unsafe工具，用来直接操作内存数据
用Unsafe来实现底层操作
用volatile修饰value字段,保证可见性
getAndAddInt方法分析

AtomoicInteger类：

Unsafe类下：

5. 缺点

ABA问题

compareAndSwap先检查，先检查只是检查是不是和这个值相等，并不能说明中间没有任何线程修改过。

解决方法：用乐观锁的时候，类似数据库，添加版本号
自旋时间过长（消耗cpu，对性能有影响）

final关键字和不变性

1.什么是不变性( Immutable )

◆如果对象在被创建后，状态就不能被修改，那么它就是不可变的 ◆例子: person对象，age和name都不能再变 ◆具有不变性的对象一定是线程安全的 ,我们不需要对其采取任何额外的安全措施,也能保证线程安全

2.final的作用

◆早期

锁定
效率:早期的Java实现版本中，会将final方法转为内嵌调用

◆现在

类防止被继承、方法防止被重写、变量防止被修改
天生是线程安全的，而不需要额外的同步开销

3.3种用法:修饰变量、方法、类

3.1 final修饰变量

含义:被final修饰的变量,意味着值不能被修改。如果变量是对象，那么对象的引用不能变，但是对象自身的内容依然可以变化

◆final instance variable ( 类中的final属性) ◆final static variable (类中的static final属性) ◆final local variable (方法中的final变量)

◆final修饰变量:赋值时机属性被声明为final后,该变量则只能被赋值一次。且一旦被赋值,final的变量就不能再被改变，如论如何也不会变

为什么要规定赋值时机?

◆我们来思考一下为什么语法要这继承这样?

如果初始化不赋值,后续赋值,就是从null变成你的赋值, 这就违反final不变的原则了!

3.2 final修饰方法

构造方法不允许final修饰
不可被重写,也就是不能被override ,即便是子类有同样名字的方法,那也不是override , 这个和static方法是一个道理
引申: static方法不能被重写，但是父类和子类可以存在同一个重名静态方法，但是是属于不同的类，不是重写

3.3 final修饰类

◆不可被继承

例如典型的String类就是final的，我们从没见过哪个类是继承String类的

4.注意点

◆final修饰对象的时候，只是对象的引用不可变，而对象本身的属性是可以变化的

◆final使用原则：良好的编程习惯

5. 不变性和final的关系

◆不变性并不意味着，简单地用final修饰就是不可变

◆对于基本数据类型，确实被final修饰后就具有不变性

◆但是对于对象类型，需要该对象保证自身被创建后,状态永远不会变才可以

◆如何利用final实现对象不可变

把所有属性都声明为final ？（错误）
一个属性是对象类型的不可变对象的正确例子

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修饰的

◆对象创建过程中没有发生逸出

把变量写在线程内部一栈封闭:

在方法里新建的局部变量，实际上是存储在每个线程私有的栈空间，而每个栈的占空间是不能被其他线程所访问到的，所以不会有线程安全问题。这就是著名的"栈封闭”技术，是“线程封闭”技术的一种情况。

◆代码演示

/**
 * 描述：     演示栈封闭的两种情况，基本变量和对象 先演示线程争抢带来错误结果，然后把变量放到方法内，情况就变了
 */
public class StackConfinement implements Runnable {

    int index = 0;

    public void inThread() {
        int neverGoOut = 0;
            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);
    }
}

6. 面试题

/**
 * 描述：     TODO
 */
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));
    }
}

/**
 * 描述：     TODO
 */
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";
    }
}

JUC-CAS与final关键字解析