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

并发编程 专栏收录该内容
23 篇文章 0 订阅

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,所有线程不会陷入阻塞,这是效率提升的因素之一
    • 单如果竞争激烈,重试必然频繁发生,反而效率会受影响。
  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值