什么是CAS机制？

╰+攻爆jí腚メ 2022-01-17 07:25 280阅读 0赞

先看下面一段代码：

public class VolatileTest {
        private static int count = 0;
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        for (int j = 0; j < 100; j++) {
                                count++;
                        }
                    }
                }).start();
            }
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(count);
        }
    }

上述代码线程不安全，结果很可能会小于1000，加上Synchronized同步锁再看一下效果：

public class VolatileTest {
        private static int count = 0;
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        for (int j = 0; j < 100; j++) {
                                synchronized(VolatileTest.class){
                                count++;
                            }
                        }
                    }
                }).start();
            }
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(count);
        }
    }

加上同步锁之后，count自增操作变成了原子性操作，所以最终输出的结果一定是1000。

**Synchronized关键字会让没有得到锁资源的线程进入BLOCKED装填，而后在争夺到锁资源后恢复为RUNNABLE状态，这个过程中涉及到操作系统用户模式和内核模式的转换，代价较高。**

## 原子操作类： ##

所谓原子操作类，指的是java.util.concurrent.atomic包下，一系列以Atomic开头的包装类。例如：AtomicBoolean,AtomicInteger,AtomicLong等。  
我们在代码中引入AtomicInteger类：

public class VolatileTest {
        private static AtomicInteger count = new AtomicInteger();
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        for (int j = 0; j < 100; j++) {
                                count.getAndIncrement();
                        }
                    }
                }).start();
            }
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(count);
        }
    }