并发编程之CAS操作

Dear 丶 2022-11-21 11:33 236阅读 0赞

### 文章目录 ###

*  CAS操作
 *   *  概念
     *  CAS原理
     *  synchronized的底层实现
     *  ReentrantLock
     *  ReadWriteLock

# CAS操作 #

## 概念 ##

java并发编程中，必不可少的会提到“锁”，而且会立刻想到synchronized，lock这两把锁，今天提到的这个CAS操作号称无锁优化，或者叫自旋，它是一种计算方式，比如Atomic开头的类，都是用到CAS操作保证线程的安全性。

Atomic意思就是原子性，经常面试中会问到i++ 和 ++i 是不是原子性的问题，答案肯定为不是，原因就是

无论是 ++i 还是 i++ ，都是使用三个指令来实现的：

1.  将值从内存拷贝到寄存器；
2.  寄存器自增；
3.  将值从寄存器拷贝到内存；

多线程下是不安全的，若i为整数的话，我们可以通过AtomicInteger来实现，高并发下AtomicInteger可以保证线程安全。

AtomicInteger atomicInteger = new AtomicInteger(0);
            for(int i=0;i<1000;i++){
                atomicInteger.incrementAndGet();
            }
            System.out.println(atomicInteger);
            
            并发编程下结果也是：1000

那么incrementAndGet()怎么实现的呢?

public final int incrementAndGet() {
            return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
        }

这里用到Unsafe类，此类的计算方法通过native修改

public final int getAndAddInt(Object var1, long var2, int var4) {
            int var5;
            do {
                var5 = this.getIntVolatile(var1, var2);
            } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    
            return var5;
        }

其中compareAndSwapInt这类型的方法还有compareAndSwapLong，compareAndSwapObject，他们就是CAS操作，compareAndSwap字面意思就是比较和交换

## CAS原理 ##

cas(v, expected, newValue)
        if v==expected
        v=newValue
        otherwise try again or fail

v第一个参数是要改的值，expected第二个参数是期望当前的值是几，newValue是要设定的新值

比如：现在v值是2，这个线程要在原来的基础上添加1，结果要称为3，那么它期望现在的值就应该是2，所以expected值是2，newValue值是3，但是当它执行到这里的时候，结果有另外一个线程过来了，将v值添加了1，已经变成了3，那么3就与当前线程的期望不一样，那么就不会再将newValue值赋值给v，而是会继续重试，当前线程将期望值改成3，也就是expected ，而newValue变成了4，然后再执行CAS，结果此时v==expected，那么就会将newValue赋值给v，重要的是CAS是cpu的语言支持，也就是CAS操作是cpu执行级别上的支持，中间不能打断，因此保证了原子性，线程安全。

## synchronized的底层实现 ##

不是CAS的效率就一定比系统锁要高，区分实际情况：

1.  执行时间短(加锁代码)，线程数少，用自旋
2.  执行时间长，线程数多，用系统锁

synchronized早期底层实现是重量级锁，重量级到这个synchronized要去操作系统去申请锁，造成其效率非常低，后来做了优化，引出了“锁升级”的概念

当我们使用synchronized时候，HotSpot实现是这样的，上来之后第一个去访问某把锁的线程，比如sync(object)，来了之后先在这个object的头上面MarkWord记录这个线程的id，也就是偏向锁，如果有线程争用的话就升级为自旋锁，自旋锁转圈十次以后就升级为重量级锁，重量级锁就会去操作系统申请资源。

## ReentrantLock ##

ReentrantLock和synchronized都是可重入锁

两个示例体会

示例1：
    public class ReenTrantLockTest {
    
        public synchronized void m1(){
            for (int i=0;i<10;i++){
                try {
                    System.out.println(Thread.currentThread().getName()+"执行m1——"+i);
                    Thread.sleep(1000);
                }catch (Exception e){
                    e.printStackTrace();
                }
    
            }
            m2();
        }
    
        public synchronized void m2(){
            System.out.println(Thread.currentThread().getName()+"执行m2");
        }
    }
    
    测试类：
        public static void main(String[] args) {
            ReenTrantLockTest reenTrantLockTest = new ReenTrantLockTest();
            ReenTrantLockTest reenTrantLockTest1 = new ReenTrantLockTest();
            new Thread(reenTrantLockTest::m1).start();
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
                
            }
            new Thread(reenTrantLockTest1::m2).start();
        }
        
    结果：
    Thread-0执行m1——0
    Thread-1执行m2
    Thread-0执行m1——1
    Thread-0执行m1——2
    Thread-0执行m1——3
    Thread-0执行m1——4
    Thread-0执行m1——5
    Thread-0执行m1——6
    Thread-0执行m1——7
    Thread-0执行m1——8
    Thread-0执行m1——9
    Thread-0执行m2

两个不同的示例分别调用两个synchronized方法，不会阻塞，因为此时synchronized锁的是调用对象，那么如果是同一个实例对象呢？

public static void main(String[] args) {
            ReenTrantLockTest reenTrantLockTest = new ReenTrantLockTest();
            new Thread(reenTrantLockTest::m1).start();
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
                
            }
            new Thread(reenTrantLockTest::m2).start();
        }
    结果：
    Thread-0执行m1——0
    Thread-0执行m1——1
    Thread-0执行m1——2
    Thread-0执行m1——3
    Thread-0执行m1——4
    Thread-0执行m1——5
    Thread-0执行m1——6
    Thread-0执行m1——7
    Thread-0执行m1——8
    Thread-0执行m1——9
    Thread-0执行m2
    Thread-1执行m2

此时发现必须当第一个线程执行完成，第二个线程才会执行，因为用的同一个实例，线程一已经获得锁，锁定了这个实例，而线程二想要获取到这个锁，那么就得等线程一释放之后，同时发现线程1调用了方法2，也就是synchronized可重入，执行完方法2才释放的锁

在举个例子

public static synchronized void m1(){
            for (int i=0;i<10;i++){
                try {
                    System.out.println(Thread.currentThread().getName()+"执行m1——"+i);
                    Thread.sleep(1000);
                }catch (Exception e){
                    e.printStackTrace();
                }
    
            }
        }
    
        public static synchronized void m2(){
            System.out.println(Thread.currentThread().getName()+"执行m2");
        }
        
    测试类：
        public static void main(String[] args) {
            new Thread(ReenTrantLockTest::m1).start();
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
                
            }
            new Thread(ReenTrantLockTest::m2).start();
        }
    结果：
    Thread-0执行m1——0
    Thread-0执行m1——1
    Thread-0执行m1——2
    Thread-0执行m1——3
    Thread-0执行m1——4
    Thread-0执行m1——5
    Thread-0执行m1——6
    Thread-0执行m1——7
    Thread-0执行m1——8
    Thread-0执行m1——9
    Thread-1执行m2

两个静态方法被synchronized修饰，此时synchronized锁定的是类，所以和锁定同一个实例相似，当第一个线程锁定了本类以后，第二个线程想要调用那就得等待锁被释放

当然若一个方法是静态的并且使用synchronized修饰，另外一个是非静态的方法也被synchronized修改，那么静态方法通过类调用，非静态方法使用实例对象调用，两个线程就没有影响了

public static synchronized void m1(){
            for (int i=0;i<10;i++){
                try {
                    System.out.println(Thread.currentThread().getName()+"执行m1——"+i);
                    Thread.sleep(1000);
                }catch (Exception e){
                    e.printStackTrace();
                }
    
            }
        }
    
        public  synchronized void m2(){
            System.out.println(Thread.currentThread().getName()+"执行m2");
        }
    测试类：
        public static void main(String[] args) {
            ReenTrantLockTest reenTrantLockTest = new ReenTrantLockTest();
            ReenTrantLockTest reenTrantLockTest1 = new ReenTrantLockTest();
            new Thread(ReenTrantLockTest::m1).start();
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
                
            }
            new Thread(reenTrantLockTest::m2).start();
        }
    结果：
    Thread-0执行m1——0
    Thread-0执行m1——1
    Thread-1执行m2
    Thread-0执行m1——2
    Thread-0执行m1——3
    Thread-0执行m1——4
    Thread-0执行m1——5
    Thread-0执行m1——6
    Thread-0执行m1——7
    Thread-0执行m1——8
    Thread-0执行m1——9

上面介绍的都是synchronized,其实ReentrantLock是可以替代synchronized的，而且ReentrantLock比synchronized功能更多，原来synchronized的地方可以通过lock.lock()代替，加完锁以后必须得lock.unlock()解锁，所以try…finally里面的必须解锁，也就是不论是否发生异常都要解锁，否则如果发生异常会导致一直阻塞“死在那里”，其他线程永远拿到锁，但是synchronized如果发生异常会自动解锁，而且方法执行完成也会自动解锁。

ReentrantLock可以尝试锁定tryLock，不管锁定与否，方法都会继续执行，如果synchronized，线程获取不到锁就会阻塞，比如上面两个线程同一个实例对象或者同一个类争夺一个synchronized，第二个线程就得阻塞，等第一个执行完成才会执行。但是ReentrantLock可以选择是否要等待。

private static void test2(){
            Lock lock = new ReentrantLock();
    
            new Thread(()->{
                lock.lock();
                System.out.println("线程1执行开始");
                try {
                    TimeUnit.SECONDS.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }).start();
    
            Thread thread = new Thread(() -> {
                boolean b = false;
                try {
                    int i = 0;
                    while (true){
                        i++;
                        b = lock.tryLock();
                        if (b){
                            System.out.println("线程2，第"+i+"次才拿到锁，开始执行");
                            return;
                        }else {                       System.out.println("线程2重新获取锁，第"+i+"次，没有拿到锁");
                        }
                        TimeUnit.SECONDS.sleep(4);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if (b){
                        lock.unlock();
                    }
                }
            });
            thread.start();
        }
    结果：
    线程1执行开始
    线程2重新获取锁，第1次，没有拿到锁
    线程2重新获取锁，第2次，没有拿到锁
    线程2重新获取锁，第3次，没有拿到锁
    线程2重新获取锁，第4次，没有拿到锁
    线程2重新获取锁，第5次，没有拿到锁
    线程2，第6次才拿到锁，开始执行

ReentrantLock还可以被指定为公平锁，默认是非公平锁，如果想要设置为公平锁可以通过构造函数

ReentrantLock reentrantLock = new ReentrantLock(true);

什么是公平锁呢？

公平锁反过来就是非公平锁，synchronized就是非公平锁，ReentrantLock默认也是非公平锁，也就是并发是所有线程想要获取锁，那么就得通过争夺，谁抢到就是谁的，不论先来后到，而公平锁就是通过队列，谁先来谁获得锁，排队获取。

## ReadWriteLock ##

通过名字就能看出来ReadWritLock叫读写锁，读写锁其实分为读锁和写锁，读锁即共享锁，写锁即排他锁

ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
            Lock readLock = readWriteLock.readLock();
            Lock writeLock = readWriteLock.writeLock();

通过一下实例可以看出效果，创建5个读线程和3个写线程，同时启动，看结果注意打印的时间

private static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        private static Lock readLock = readWriteLock.readLock();
        private static Lock writeLock = readWriteLock.writeLock();
    
        public static void main(String[] args) {
            for(int i=0;i<5;i++){
                new Thread(() -> read(readLock)).start();
            }
    
            for (int i=0;i<3;i++){
                new Thread(() -> write(writeLock)).start();
            }
    
    
        }
    
        private static void read(Lock lock) {
            try {
                lock.lock();
                System.out.println("线程"+Thread.currentThread().getName()+"开始读数据，大概5秒,当前时间"+new Date().toString());
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        private static void write(Lock lock) {
            try {
                lock.lock();
                System.out.println("线程"+Thread.currentThread().getName()+"开始写数据，大概10秒,当前时间"+new Date().toString());
                TimeUnit.SECONDS.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
        
    结果：
    线程Thread-0开始读数据，大概5秒,当前时间Tue Sep 15 23:55:55 CST 2020
    线程Thread-2开始读数据，大概5秒,当前时间Tue Sep 15 23:55:55 CST 2020
    线程Thread-3开始读数据，大概5秒,当前时间Tue Sep 15 23:55:55 CST 2020
    线程Thread-4开始读数据，大概5秒,当前时间Tue Sep 15 23:55:55 CST 2020
    线程Thread-1开始读数据，大概5秒,当前时间Tue Sep 15 23:55:55 CST 2020
    线程Thread-5开始写数据，大概10秒,当前时间Tue Sep 15 23:56:00 CST 2020
    线程Thread-6开始写数据，大概10秒,当前时间Tue Sep 15 23:56:10 CST 2020
    线程Thread-7开始写数据，大概10秒,当前时间Tue Sep 15 23:56:20 CST 2020

通过结果发现读线程的打印时间都相同，也就是并发读取数据，而写线程是读完以后每隔10秒打印一次，也就是写线程是一个个写入数据的，而且是等读完以后才开始写，当然这是因为先开启了读线程，同样的如果先开启写线程，结果就是先写，都写完了，才会读。