CAS入门-乐观锁-并发编程(Java)

1、保护共享资源

模拟银行账户取款操作，设置一个账户接口以及一个非线程的账户类实现。代码如下：

/**
 * 账户接口
 */
public interface Account {
    // 获取余额
    Integer getBalance();
    // 取款
    void withdraw(Integer amount);
    // 模拟多个线程取款操作
    static void multiWithdraw(Account account) {
        List<Thread> ts = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(10);
            }));
        }
        long start = System.currentTimeMillis();
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.currentTimeMillis();
        System.out.println("balance: "+ account.getBalance() + " cost: " + (end - start) + " ms");
    }
}

/**
 * 非线程安全的实现类
 */
public class AccountUnsafe implements Account{

    private Integer balance;

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

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

    @Override
    public void withdraw(Integer amount) {
        this.balance -= amount;
    }
}

/**
 * 测试类
 */
public class TestAccount {
    public static void main(String[] args) {
        Account account1 = new AccountUnsafe(10000);
        Account.multiWithdraw(account1);
    }
}

结果不可预测，次实现类为非线程安全的。

1.1、加锁实现

public class AccountSynchronized implements Account{
    private Integer balance;

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

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

    @Override
    public synchronized void withdraw(Integer amount) {
        this.balance -= amount;
    }
}

1.2、无锁实现

import java.util.concurrent.atomic.AtomicInteger;

public class AccountCAS implements Account{

    private final AtomicInteger balance;

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

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

    @Override
    public void withdraw(Integer amount) {
        while (true) {
            int prev = balance.get();
            int next = prev - amount;
            if (balance.compareAndSet(prev, next)) {
                break;
            }
        }
    }
}

对比结果：

• 加锁和无锁实现都可以保证线程安全性
• 无锁实现比加锁实现效率高

2、CAS

2.0、工作方式

无锁实现，并没有加锁，它是如何保证共享变量的线程安全的呢？

其中关键是compareAndSet方法，简称CAS，它是原子操作。下面简单分析：

while (true) {
            int prev = balance.get();
            int next = prev - amount;
            if (balance.compareAndSet(prev, next)) {
                break;
            }
        }

• compareAndSet比较并更新，当第一个参数与balance（主存中获取）的余额相同时，才更新或者设置balance新的余额并返回true,否则返回false;
• 如果当前线程要设置balance新的值，同时其他线程先与当前线程更改了balance的值，那么设置失败，返回false，继续循环
• 直至当前线程设置balance值时，没有其他线程干扰，设置值成功，返回true，循环结束。

2.1、CAS与volatile

查看AtomaticInteger源码可发现

private volatile int value;

共享变量是由volatile修饰的，获取共享变量时，为了保证该变量的可见性，需要volatile修饰。

它可以用来修饰成员变量和静态成员变量，可以避免线程从自己的工作缓存中获取变量的值，必须到主存中获取它的最新值，线程操作volatile变量都是直接 操作主存。即一个线程对volatile变量的修改，对另外一个线程可见。

CAS必须借助volatile才能读取到共享变量的最新值来实现【比较并交互】的效果。

2.2、效率分析

• 无锁情况下，即时重试失败，线程始终在高速运行，不会停歇，而synchronized会让线程在没有获取锁的时候，发生上下文切换，进入阻塞。
• 但无锁情况下，因为线程要保持运行，需要额外的CPU支持。如果是单核CPU或者线程过多，虽然不会进入阻塞但是由于没有分到时间片，仍然会进入可运行状态，还是会导致上下文切换。

2.3、特点

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

• CAS是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就是改了也没关系，当前线程可以在重试
• synchronized基于悲观锁的思想：最悲观的估计，得防这其他线程来修改共享变量，当前线程通过加锁，在当前线程没有修改完成前，别的线程没有机会；只有我改完释放了锁，别的线程才有机会。
• CAS体现的是无锁并发、无阻塞并发
  • 因为没有使用synchronized,所有线程不会陷入阻塞，这是效率提升的因素之一
  • 单如果竞争激烈，重试必然频繁发生，反而效率会受影响。