乐观锁和悲观锁学习

什么是悲观锁？

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改。所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）

互斥锁的同步方式是就悲观的，就是操作系统认为如果不严格进行线程调用，那么一定会产生异常，所以互斥锁就会把资源锁定，只供一个线程调用，将其他线程阻塞。例如Java中的synchronized就是一种悲观锁。

使用悲观锁的例子

public class Test {
    //开三个线程 将一个值从0累加到1000

    static Integer num = 0;

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                  //互斥锁
                    synchronized (Test.class){
                        while (num<=1000){
                            System.out.println(Thread.currentThread().getName()+"  数字："+num);
                            num++;
                        }
                    }
                }
            });
            thread.start();
        }
    }
}

在有些情况下，例如线程大部分执行的都是读操作，或者是同步代码块的执行耗时远远小于线程切换耗时，使用互斥锁就不合适了。

什么是乐观锁？

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

乐观锁虽然称为锁，但实际是实现了一种无锁的同步方式

CAS(Compare And Swap)

即compare and swap（比较与交换），是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blocking Synchronization）。CAS算法涉及到三个操作数

1. 需要读写的内存值 V
2. 进行比较的值 A
3. 拟写入的新值 B

当且仅当 V 的值等于 A时，CAS通过原子方式用新值B来更新V的值，否则不会执行任何操作（比较和替换是一个原子操作）。一般情况下是一个自旋操作，即不断的重试。

• 保证CAS的原子性：不同架构的CPU都提供了指令级别的CAS原子操作，也就是不需要通过操作系统的同步原语（如mutex），CPU已经原生的支持了CAS，上层直接调用即可，这样就实现了不依赖锁来进行线程同步。
• 通过CAS来实现同步的工具，不会锁定资源，当线程要修改共享资源的对象时，总是乐观的认为对象状态值没有被修改过，每次自己主动去尝试compare状态值（自旋，自旋次数可以通过参数配置，不会出现死循环），所以叫做乐观锁。

java中使用乐观锁的例子

import java.util.concurrent.atomic.AtomicInteger;

public class Test {
    //开三个线程 将一个值从0累加到1000

    //AtomicInteger:底层通过CAS实现的同步计数器
    static AtomicInteger num = new AtomicInteger(0);

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (num.get() <= 1000){
                        //num.getAndIncrement() 返回当前值 并且num加一
                        System.out.println(Thread.currentThread().getName()+"  数字："+ num.getAndIncrement());
                    }
                }
            });
            thread.start();
        }
    }

}

总的来说两种锁各有优缺点，像乐观锁适用于读多写比较少的情况下，即冲突很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果是多写的情况，一般会经常产生冲突，这就会导致不断的进行自旋操作，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。