码迷,mamicode.com
首页 > 其他好文 > 详细

JUC之CAS

时间:2020-05-08 16:02:20      阅读:55      评论:0      收藏:0      [点我收藏+]

标签:反射   vat   方法   硬件   操作系统   integer   system   catch   cas   

  CAS(全称为CompareAndSwap,也有说是CompareAndSet,都差不多)是一条CPU并发原语,它的功能是判断内存某个位置的值是否为预期值,如果是则更改为新的值,判断预期值和更改新值的整个过程是原子的。在JAVA中,CAS的实现全部在sun.misc.Unsafe类中的各个方法,调用UnSafe类中的CAS方法,JVM会帮我们实现出CAS汇编指令,这是一种完全依赖于硬件的功能。

  在传统方式中实现并发的手段是加锁,JAVA中的锁有synchronized和Lock(jdk1.5才有)。Lock是基于AQS和CAS实现的,这里先跳过。对于synchronized锁,JVM在执行它的时候会依赖操作系统的临界区机制。这样的话,每次执行到synchronized锁,都会经历用户态和内核态之间的切换。这个过程的消耗是很大的。而且,大多数时候synchronized锁住的操作是很细粒度的。为了细粒度的操作去经历用户态和内核态之间的切换是低效的做法。

  其实最常见的就是我们需要并发修改某个变量值,举个常见的例子,窗口售票,不加锁的代码如下所示:

public class Test {

    public static void main(String[] args) {
        Stock stock = new Stock(10);
        for (int i = 0; i < 5; i++) {
            new Thread(stock, "窗口" + (++i)).start();
        }
    }

    private static class Stock implements Runnable {
        private volatile int count;

        public Stock(int count) {
            this.count = count;
        }

        @Override
        public void run() {
            for (;;) {
                count--;
                if (count < 0) {
                    return;
                }
                System.out.println(Thread.currentThread().getName() + "售出一张票,剩余票数:" + count);
                try {
                    Thread.sleep(100L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

得到的结果:
技术图片(票数和线程太少,需要多跑几遍,多了几乎一遍就可以看出问题)

得到的结果很明显,一共卖出了12张票,其中红框中出现的数字就可以说明问题。出现问题的原因很简单,因为--count这个算式表达式并不是原子的。在一个线程对count进行计算赋值后,但还没有将新值推送到内存中时,另一个线程获取的count值还是原来的值,当这个线程拿着这个值去进行计算,就会出现上面的问题。(这个涉及到Java的内存模型JMM,有兴趣的可以自行了解)
在JDK1.5之前,我们想要解决这个问题,就只能使用synchronized进行加锁,如下:

public void run() {
for (;;) {
synchronized (this) {
count--;
}
if (count < 0) {
return;
}
System.out.println(Thread.currentThread().getName() + "售出一张票,剩余票数:" + count);
try {
Thread.sleep(100L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

但是如果仅仅是类似于--count这种并发计数功能,需要进行同步的操作粒度很细时,使用synchronized就大材小用了,不高效(即便现在synchronized经过很多优化,不再想最初那样耗资源,但是它毕竟是个锁,而且多个线程进行竞争的时候还是会变成重量级锁),而使用CAS来实现就会更加的轻量级,性能更好。先上代码再说

public class Test {

    private static Unsafe unsafe;

    public static void main(String[] args) throws Exception {
        Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafeField.setAccessible(true);
        unsafe = (Unsafe) theUnsafeField.get(null);
        Stock stock = new Stock(10);
        for (int i = 0; i < 5; i++) {
            new Thread(stock, "窗口" + (++i)).start();
        }
    }

    private static class Stock implements Runnable {
        private volatile int count;
        private static long countOffset;
        public Stock(int count) {
            this.count = count;
            try {
                countOffset = unsafe.objectFieldOffset(this.getClass().getDeclaredField("count"));
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            for (;;) {
                int x = this.count;
                int y = x - 1;
                if (!unsafe.compareAndSwapInt(this, countOffset, x, y)) {
                    continue;
                }
                if (y < 0) {
                    return;
                }
                System.out.println(Thread.currentThread().getName() + "售出一张票,剩余票数:" + y);
                try {
                    Thread.sleep(100L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

像上面代码一样,当我们使用CAS进行操作时,出现的效果和使用synchronized一样的。代码中使用了JAVA提供的sun.misc.Unsafe进行CAS操作,而且在代码总我使用反射进行获取Unsafe实例,之所以这样做,是因为JDK不想让我们开发者去直接使用Unsafe这个类,而且使用起来比较繁琐,他们给我们提供了一些封装好的类来供我们开发者使用,比如常用的java.util.concurrent.atomic.AtomicInteger、java.util.concurrent.atomic.AtomicBoolean、java.util.concurrent.atomic.AtomicIntegerArray。这些类中都有相同的特点,就是使用sun.misc.Unsafe进行CAS操作,内部进行了一些类似上面代码的封装,我们就以AtomicInteger进行代码演示。

public class Test {

    public static void main(String[] args) throws Exception {
        Stock stock = new Stock(10);
        for (int i = 0; i < 5; i++) {
            new Thread(stock, "窗口" + (++i)).start();
        }
    }

    private static class Stock implements Runnable {
        private volatile AtomicInteger count;
        public Stock(int count) {
            this.count = new AtomicInteger(count);
        }

        @Override
        public void run() {
            for (;;) {
                int x = count.get();
                int y = x - 1;
                if (!count.compareAndSet(x, y)) {
                    continue;
                }
                if (y < 0) {
                    return;
                }
                System.out.println(Thread.currentThread().getName() + "售出一张票,剩余票数:" + y);
                try {
                    Thread.sleep(100L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

就像上面的代码一样,我们不必进行反射获取Unsafe,然后在获取字段在class中的偏移量这些繁琐的操作了,下面我们就去看看AtomicInteger的源码 

  技术图片

 

 

   看上面AtomicInteger的源码我们可以很明显的看的出来,在AtomicInteger进行类加载的时候,会通过sun.misc.Unsafe获取value这个变量在类文件中的偏移量,进行保存,跟我们直接使用Unsafe的操作是一样的。我们找到刚才使用的compareAndSet(x, y)方法的源码,技术图片可以看到底层就是使用unsafe实例进行CAS操作。

AtomicInteger还有一些别的方法,比如getAndIncrement、getAndDecrement、getAndAdd、incrementAndGet、decrementAndGet等等,底层实际上还是使用的unsafe实例进行CAS操作,有兴趣的同学可以自己翻下源码看看,这里就不多说了。

总结:CAS的出现就是为了解决一些简单的并发操作,将比较、赋值作为一个原子操作记性处理,实现无锁化处理,节省资源开销。

 

JUC之CAS

标签:反射   vat   方法   硬件   操作系统   integer   system   catch   cas   

原文地址:https://www.cnblogs.com/zzw-blog/p/12850730.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!