Skip to main content
 首页 » 编程设计

java CAS无锁技术

2022年07月18日28over140

前言:关于同步,很多人都知道synchronized,Reentrantlock等加锁技术,这种方式也很好理解,是在线程访问的临界区资源上建立一个阻塞机制,需要线程等待

其它线程释放了锁,它才能运行。这种方式很显然是奏效的,但是它却带来一个很大的问题:程序的运行效率。线程的上下文切换是非常耗费资源的,而等待又会有一定的时间消耗,那么有没有一种方式既能控制程序的同步效果,又能避免这种锁带来的消耗呢?答案就是无锁技术,本篇博客讨论的中心就是无锁。

一:有锁与无锁

二:cas技术原理

三:AtomicInteger与unsafe类

四:经典的ABA问题与解决方法

五:总结

正文

一:有锁与无锁

1.1:悲观锁与乐观锁

 数据库有两种锁,悲观锁的原理是每次实现数据库的增删改的时候都进行阻塞,防止数据发生脏读;乐观锁的原理是在数据库更新的时候,用一个version字段来记录版本号,然后通过比较是不是自己要修改的版本号再进行修改。这其中就引出了一种比较替换的思路来实现数据的一致性,事实上,cas也是基于这样的原理。

二:CAS技术原理

2.1:cas是什么?

cas的英文翻译全称是compare and set ,也就是比较替换技术,·它包含三个参数,CAS(V,E,N),其中V(variile)表示欲更新的变量,E(Excepted)表示预期的值,N(New)表示新值,只有当V等于E值的时候吗,才会将V的值设为N,如果V值和E值不同,则说明已经有其它线程对该值做了更新,则当前线程什么都不做,直接返回V值。

举个例子,假如现在有一个变量int a=5;我想要把它更新为6,用cas的话,我有三个参数cas(5,5,6),我们要更新的值是5,找到了a=5,符合V值,预期的值也是5符合,然后就会把N=6更新给a,a的值就会变成6;

2.2:cas的优点

2.2.1cas是以乐观的态度运行的,它总是认为当前的线程可以完成操作,当多个线程同时使用CAS的时候只有一个最终会成功,而其他的都会失败。这种是由欲更新的值做的一个筛选机制,只有符合规则的线程才能顺利执行,而其他线程,均会失败,但是失败的线程并不会被挂起,仅仅是尝试失败,并且允许再次尝试(当然也可以主动放弃)

 2.2.2:cas可以发现其他线程的干扰,排除其他线程造成的数据污染

三:AtomicInteger与unsafe类

CAS在jdk5.0以后就被得到广泛的利用,而AtomicInteger是很典型的一个类,接下来我们就来着重研究一下这个类:

3.1:AtomicInteger

关于Integer,它是final的不可变类,AtomicInteget可以把它视为一种整数类,它并非是fianl的,但却是线程安全的,而它的实现就是著名的CAS了,下面是一些它的常用方法:

复制代码
public final int getAndSet(int newValue); 
public final boolean compareAndSet(int expect, int update); 
public final boolean weakCompareAndSet(int expect, int update); 
public final int getAndIncrement(); 
public final int getAndDecrement(); 
public final int addAndGet(int delta); 
public final int decrementAndGet(); 
public final int incrementAndGet()
复制代码

其中主要的方法就是compareAndSet,我们来测试一下这个方法,首先先给定一个值是5,我们现在要把它改成2,如果expect传的是1,程序会输出什么呢?

复制代码
public class TestAtomicInteger { 
 
    public static void main(String[] args) { 
 
        AtomicInteger atomicInteger = new AtomicInteger(5); 
 
        boolean isChange = atomicInteger.compareAndSet(1, 2); 
 
        int i = atomicInteger.get(); 
 
        System.out.println("是否变化:"+isChange); 
 
        System.out.println(i); 
    } 
}
复制代码
//outPut:
是否变化:false 5
boolean isChange = atomicInteger.compareAndSet(5, 2);

如果我们把期望值改成5的话,最后的输出结果将是: // 是否变化:true   2

结论:只有当期望值与要改的值一致的时候,cas才会替换原始的值,设置成新值

3.2:测试AtomicInteger的线程安全性

为此我新建了10个线程,每个线程对它的值自增5000次,如果是线程安全的,应该输出:50000

复制代码
public class TestAtomicInteger { 
 
   static AtomicInteger number=new AtomicInteger(0); 
 
   public static class AddThread implements Runnable{ 
 
       @Override 
       public void run() { 
 
           for (int i = 0; i < 5000; i++) { 
 
               number.incrementAndGet(); 
           } 
 
       } 
   } 
 
    public static void main(String[] args) throws InterruptedException { 
 
       Thread[] threads=new Thread[10]; 
 
        for (int i = 0; i < threads.length; i++) { 
 
            threads[i]=new Thread(new AddThread()); 
 
        } 
 
        for (int i = 0; i < threads.length; i++) { 
 
            threads[i].start(); 
 
        } 
 
        for (int i = 0; i < threads.length; i++) { 
 
            threads[i].join(); 
 
        } 
 
        System.out.println(number); 
    } 
}
复制代码

最后重复执行了很多次都是输出:50000 

3.3:unsafe类

翻以下这个方法的源码,可以看到其中是这样实现的:

public final boolean compareAndSet(int expect, int update) { 
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update); 
    }
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

主要交给了unsafe类的compareAndSwapInt的方法,再翻以下可以看到是native的,也就是本地调用C++实现的源码,这里我们就不深究了。关于unsafe类,它有一个最重要的点就是jdk的开发人员认为这个类是很危险的,所以是unsafe!因此不建议程序员调用这个类,为此他们还对这个类做了一个绝妙的处理,让你无法使用它:

复制代码
public static Unsafe getUnsafe() { 
        Class class= Reflection.getCallerClass(); 
        if (!VM.isSystemDomainLoader(class.getClassLoader())) { 
            throw new SecurityException("Unsafe"); 
        } else { 
            return theUnsafe; 
        } 
    }
public static boolean isSystemDomainLoader(ClassLoader var0) {
return var0 == null;
}
复制代码
//outPut
Exception in thread "main" java.lang.SecurityException: Unsafe at sun.misc.Unsafe.getUnsafe(Unsafe.java:90)

这个方法实现的原理主要是类的加载机制,应用类的类加载器是有applicationClassLoder加载的,而jdk的类,比如关键库,rt.jar是由Bootstrap加载的,而BootStrapclassLoader是最上层加载库,它其实是没有java对象的,因为jdk的常用类比如(AtomicInteger)加载的时候它会返回null,而我们自定义的类一定不会返回null,就会抛出异常!

3.4:compareAndSet的方法原理

复制代码
 public final int incrementAndGet(){ 
         
        for(;;){ 
            int current=get(); 
            int next=current+1; 
            if(compareAndSet(current,next)){
return next; } } }
复制代码

可以看出这是在一个无限的for循环里,然后获取当前的值,再给他加1(固定写死的值,每次自增1)。然后通过comePareandSet把当前的值和通过+1获取的值经过cas设值,这个方法返回一个boolean值,当成功的时候就返回当前的值,这样就保证了只有一个线程可以设值成功。注意:这里是一个死循环,只有当前值等于设置后的+1的值时,它才会跳出循环。这也证明cas是一个不断尝试的过程

四:经典的ABA问题与解决方法

4.2:AbA问题的产生

    要了解什么是ABA问题,首先我们来通俗的看一下这个例子,一家火锅店为了生意推出了一个特别活动,凡是在五一期间的老用户凡是卡里余额小于20的,赠送10元,但是这种活动没人只可享受一次。然后火锅店的后台程序员小王开始工作了,很简单就用cas技术,先去用户卡里的余额,然后包装成AtomicInteger,写一个判断,开启10个线程,然后判断小于20的,一律加20,然后就很开心的交差了。可是过了一段时间,发现账面亏损的厉害,老板起先的预支是2000块,因为店里的会员总共也就100多个,就算每人都符合条件,最多也就2000啊,怎么预支了这么多。小王一下就懵逼了,赶紧debug,tail -f一下日志,这不看不知道,一看吓一跳,有个客户被充值了10次!

阐述:

假设有个线程A去判断账户里的钱此时是15,满足条件,直接+20,这时候卡里余额是35.但是此时不巧,正好在连锁店里,这个客人正在消费,又消费了20,此时卡里余额又为15,线程B去执行扫描账户的时候,发现它又小于20,又用过cas给它加了20,这样的话就相当于加了两次,这样循环往复肯定把老板的钱就坑没了!

本质:

ABA问题的根本在于cas在修改变量的时候,无法记录变量的状态,比如修改的次数,否修改过这个变量。这样就很容易在一个线程将A修改成B时,另一个线程又会把B修改成A,造成casd多次执行的问题。

4.3:AtomicStampReference 

AtomicStampReference在cas的基础上增加了一个标记stamp,使用这个标记可以用来觉察数据是否发生变化,给数据带上了一种实效性的检验。它有以下几个参数:

复制代码
//参数代表的含义分别是 期望值,写入的新值,期望标记,新标记值 
public boolean compareAndSet(V expected,V newReference,int expectedStamp,int newStamp); 
 
public V getRerference(); 
 
public int getStamp(); 
 
public void set(V newReference,int newStamp);
复制代码

4.4:AtomicStampReference的使用实例

我们定义了一个money值为19,然后使用了stamp这个标记,这样每次当cas执行成功的时候都会给原来的标记值+1。而后来的线程来执行的时候就因为stamp不符合条件而使cas无法成功,这就保证了每次

只会被执行一次。

复制代码
public class AtomicStampReferenceDemo { 
 
    static AtomicStampedReference<Integer>  money =new AtomicStampedReference<Integer>(19,0); 
 
    public static void main(String[] args) { 
 
        for (int i = 0; i < 3; i++) { 
 
            int stamp = money.getStamp(); 
 
            System.out.println("stamp的值是"+stamp); 
 
            new Thread(){         //充值线程 
 
                @Override 
                public void run() { 
 
                        while (true){ 
 
                            Integer account = money.getReference(); 
 
                            if (account<20){ 
 
                                if (money.compareAndSet(account,account+20,stamp,stamp+1)){ 
 
                                    System.out.println("余额小于20元,充值成功,目前余额:"+money.getReference()+"元"); 
                                    break; 
                                } 
                            }else { 
 
                                System.out.println("余额大于20元,无需充值"); 
                            } 
                        } 
                    } 
                }.start(); 
            } 
 
 
            new Thread(){ 
 
                @Override 
                public void run() {    //消费线程 
 
                    for (int j = 0; j < 100; j++) { 
 
                        while (true){ 
 
                            int timeStamp = money.getStamp();//1 
 
                            int currentMoney =money.getReference();//39 
 
                            if (currentMoney>10){ 
                                System.out.println("当前账户余额大于10元"); 
                                if (money.compareAndSet(currentMoney,currentMoney-10,timeStamp,timeStamp+1)){ 
 
                                    System.out.println("消费者成功消费10元,余额"+money.getReference()); 
 
                                    break; 
                                } 
                            }else { 
                                System.out.println("没有足够的金额"); 
 
                                break; 
                            } 
                            try { 
                                Thread.sleep(1000); 
                            }catch (Exception ex){ 
                                ex.printStackTrace(); 
                                break; 
                            } 
 
                        } 
 
                    } 
                } 
            }.start(); 
 
        } 
    }
复制代码

 这样实现了线程去充值和消费,通过stamp这个标记属性来记录cas每次设置值的操作,而下一次再cas操作时,由于期望的stamp与现有的stamp不一样,因此就会设值失败,从而杜绝了ABA问题的复现。

 五:总结

      本篇博文主要分享了cas的技术实现原理,对于无锁技术,它有很多好处。同时,指出了它的弊端ABA问题,与此同时,也给出了解决方法。jdk源码中很多用到了cas技术,而我们自己如果使用无锁技术,一定要谨慎处理ABA问题,最好使用jdk现有的api,而不要尝试自己去做,无锁是一个双刃剑,用好了,绝对可以让性能比锁有很大的提升,用不好就很容易造成数据污染与脏读,望谨慎之。


本文参考链接:https://www.cnblogs.com/maohuidong/p/10027104.html