无锁并发-CAS机制

示例代码

package thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author pangjian
 * @Interface Account
 * @Description 比较线程不安全，无锁安全并发和有锁安全并发
 * @date 2021/11/4 12:44
 */

public interface Account {

    Integer getBalance();

    void withdraw(Integer amount);

    /**
     * @Description: 启动一千个线程去并发，一个线程花掉10块钱，计算并发时间和结果，理想应该是为0
     * @Param account:账户类
     * @date 2021/11/4 13:00
    */
    static void demo(Account account) {
        List<Thread> threadList = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            threadList.add(new Thread(() -> {
                account.withdraw(10);
            }));
        }
        threadList.forEach(Thread::start);
        threadList.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(account.toString() + "余额为：" + account.getBalance() + "cost:" + (end - start)/1000_00 + "ms");
    }

}

class AccountUnsafe implements Account {

    private Integer balance;

    public AccountUnsafe(Integer balance) {
        this.balance = balance;
    }

    @Override
    public Integer getBalance() {
        return balance;
    }
    @Override
    public void withdraw(Integer amount) {
        balance -= amount;
    }

}


class AccountLock implements Account {

    private Integer balance;

    public AccountLock(Integer balance) {
        this.balance = balance;
    }

    @Override
    public Integer getBalance() {
        return balance;
    }

    /**
     * @Description: 加锁防止线程不安全
     * @Param amount:
     * @return void
     * @date 2021/11/4 13:16
    */
    @Override
    public void withdraw(Integer amount) {
        synchronized (this) {
            balance -= amount;
        }
    }

}


class AccountCAS implements Account {

    private AtomicInteger balance;

    public AccountCAS(Integer balance) {
        this.balance = new AtomicInteger(balance);
    }

    @Override
    public Integer getBalance() {
        return balance.get();
    }

    /**
     * @Description: 使用CAS机制
     * @Param amount:
     * @return void
     * @date 2021/11/4 13:16
    */
    @Override
    public void withdraw(Integer amount) {
        while (true) {
            // 取到最新值
            int prev = balance.get();
            // 要修改的余额
            int next = prev - amount;
            // 真正修改，第一个参数值是用来比较原始值的，如果有其他线程修改了原先值就会返回false
            // 第二个参数next会根据比较返回的布尔值看是否要更新到余额里面，如果是true则更新到第一个参数值里面
            if (balance.compareAndSet(prev, next)) {
                break;
            }
        }
    }

}


class TestCompare {

    /**
     * @Description:线程加锁,无锁安全和不安全演示，账号余额为10000
     * @date 2021/11/4 13:00
     */
    public static void main(String[] args) {
        Account.demo(new AccountCAS(10000));
        Account.demo(new AccountLock(10000));
        Account.demo(new AccountUnsafe(10000));
    }

}

compareAndSet，它的简称就是 CAS （也有 Compare And Swap 的说法），它必须是原子操作，其实 CAS 的底层是 lock cmpxchg 指令（X86 架构），在单核 CPU 和多核 CPU 下都能够保证【比较-交
换】的原子性。

---

volatile

获取共享变量时，为了保证该变量的可见性，需要使用 volatile 修饰。它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存。即一个线程对 volatile 变量的修改，对另一个线程可见。volatile 仅仅保证了共享变量的可见性，让其它线程能够看到最新值，但不能解决指令交错问题（不能保证原子性）CAS 必须借助 volatile 才能读取到共享变量的最新值来实现【比较并交换】的效果

---

无锁的效率

无锁情况下，因为线程要保持运行，需要额外CPU的支持，CPU在这里就好比高速跑道，没有额外的跑道，线程想高速运行也无从谈起，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还是会导致上下文切换。线程太多不一定比加锁效率高

---

CAS特点

结合CAS和volatile可以实现无锁并发，适用于线程数少、多核CPU的场景下。

• CAS是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再重试呗。
• synchronized是基于悲观锁的思想：最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁，你们才有机会。
• CAS体现的是无锁并发、无阻塞并发，请仔细体会这两句话的意思
• 因为没有使用synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一
• 但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响