使用加锁操作和解锁操作可以解决并发线程/进程的互斥问题。任何想进入临界区的线程，必须先执行加锁操作。若加锁操作顺利通过，则线程可进入临界区；在完成对临界资源的访问后再执行解锁操作，以释放该临界资源。

一、互斥锁与自旋锁

        最底层的两种锁是互斥锁和自旋锁，很多高级的锁都是基于它们实现的。当已经有一个线程加锁后，其他线程加锁则就会失败，互斥锁和自旋锁对于加锁失败后的处理方式是不一样的：

• 互斥锁加锁失败后，线程会释放 CPU ，给其他线程；
• 自旋锁加锁失败后，线程会忙等待，直到它拿到锁；

互斥锁

        互斥锁是一种「独占锁」，在抢锁失败的情况下主动放弃CPU进⼊睡眠状态，直到锁的状态改变时再唤醒。为了实现锁的状态发生改变时唤醒阻塞的线程或者进程，需要把锁交给操作系统管理，所以互斥锁在加锁操作时涉及两次上下⽂的切换：

• 当线程加锁失败时，内核会把线程的状态从「运行」状态设置为「睡眠」状态，然后把 CPU 切换给其他线程运行；
• 接着，当锁被释放时，之前「睡眠」状态的线程会变为「就绪」状态，然后内核会在合适的时间，把 CPU 切换给该线程运行。

        线程的上下文切换的是什么？

        当两个线程是属于同一个进程，因为虚拟内存是共享的，所以在切换时，虚拟内存这些资源就保持不动，只需要切换线程的私有数据、寄存器等不共享的数据。

自旋锁

        自旋锁是通过 CPU 提供的CAS函数（Compare And Swap），在用户态完成加锁和解锁操作，不会主动产生线程上下文切换，所以相比互斥锁来说，速度更快，开销更小。

一般加锁的过程，包含两个步骤：

• 第一步，查看锁的状态，如果锁是空闲的，则执行第二步；
• 第二步，将锁设置为当前线程持有；

         CAS 函数就把这两个步骤合并成一条硬件级指令，形成原子指令，这样就保证了这两个步骤是不可分割的，要么一次性执行完两个步骤，要么两个步骤都不执行。

        使用自旋锁的时候，当发生多线程竞争锁的情况，加锁失败的线程会忙等待，直到它拿到锁。这里的忙等待可以用 while 循环等待实现，不过最好是使用 CPU 提供的PAUSE 指令来实现忙等待，可以减少循环等待时的耗电量。

        自旋锁是最比较简单的一种锁，一直自旋，利用 CPU 周期，直到锁可用。需要注意，在单核 CPU 上，需要抢占式的调度器（即不断通过时钟中断一个线程，运行其他线程）。否则，自旋锁在单 CPU 上无法使用，因为一个自旋的线程永远不会放弃 CPU。

        自旋锁开销少，在多核系统下一般不会主动产生线程切换，适合异步、协程等在用户态切换请求的编程方式，但如果被锁住的代码执行时间过长，自旋的线程会长时间占用 CPU 资源。

小结

        互斥锁和自旋锁是锁的最基本处理方式，更高级的锁都会选择其中一个来实现。互斥锁实际的效率还是可以让人接受的，加锁的时间⼤概100ns左右，实际上互斥锁的⼀种可能的实现是先⾃旋⼀段时间，当⾃旋的时间超过阈值后再将线程投⼊睡眠中，因此在并发运算中使⽤互斥锁（每次占⽤锁的时间很短）的效果可能不亚于使用自旋锁。

二、读写锁

        读写锁从字面意思我们也可以知道，它由读锁和写锁两部分构成，如果只读取共享资源用读锁加锁，如果要修改共享资源则用写锁加锁。所以，读写锁适用于能明确区分读操作和写操作的场景。

        读写锁的工作原理是：

• 当「写锁」没有被线程持有时，多个线程能够并发地持有读锁，这大大提高了共享资源的访问效率，因为「读锁」是用于读取共享资源的场景，所以多个线程同时持有读锁也不会破坏共享资源的数据。
• 但是，一旦「写锁」被线程持有后，读线程的获取读锁的操作会被阻塞，而且其他写线程的获取写锁的操作也会被阻塞。

      写锁是独占锁，因为任何时刻只能有一个线程持有写锁，类似互斥锁和自旋锁，而读锁是共享锁，因为读锁可以被多个线程同时持有。读写锁在读多写少的场景，能发挥出优势。

        另外，根据实现的不同，读写锁可以分为「读优先锁」和「写优先锁」。

        读优先锁期望的是，读锁能被更多的线程持有，以便提高读线程的并发性，它的工作方式是：当读线程 A 先持有了读锁，写线程 B 在获取写锁的时候，会被阻塞，并且在阻塞过程中，后续来的读线程 C 仍然可以成功获取读锁，最后直到读线程 A 和 C 释放读锁后，写线程 B 才可以成功获取写锁。

        写优先锁是优先服务写线程，其工作方式是：当读线程 A 先持有了读锁，写线程 B 在获取写锁的时候，会被阻塞，并且在阻塞过程中，后续来的读线程 C 获取读锁时会失败，于是读线程 C 将被阻塞在获取读锁的操作，这样只要读线程 A 释放读锁后，写线程 B 就可以成功获取写锁。

        公平读写锁比较简单的一种方式是：用队列把获取锁的线程排队，不管是写线程还是读线程都按照先进先出的原则加锁即可，这样读线程仍然可以并发，也不会出现「饥饿」的现象。

三、乐观锁与悲观锁

        乐观锁和悲观锁用于解决并发场景下的数据竞争问题。

        乐观锁操作数据时比较乐观，它假定冲突的概率很低，乐观锁不会上锁，知识在执行更新的时候判断一下在此期间是否发生冲突（他人修改数据），如果没有其他线程在修改资源，那么操作完成，如果发现有其他线程已经修改过这个资源，就放弃本次操作。

        悲观锁做事比较悲观，它认为多线程同时修改共享资源的概率比较高，于是很容易出现冲突，所以访问共享资源前，先要上锁。互斥锁、自旋锁、读写锁，都是属于悲观锁。

乐观锁实现机制

1. CAS（Compare And Swap）机制

（1）CAS操作包括3个操作数：

        需要读写的内存位置（V）

        进行比较的预期值（A）

        拟写入的新值（B）

（2）操作逻辑：如果内存位置V的值等于预期值A，则将该位置更新为B，否则不进行任何操作。许多CAS是自旋，如果操作不成功，会一直重试，直到操作成功为止。

ABA问题

        假设有两个线程：线程1和线程2，两个线程按照顺序进行以下操作：

1. 线程1读取内存中数据A
2. 线程2修改该数据为B
3. 线程2修改该数据为A
4. 线程1对数据进行CAS操作

        在第四步操作中，由于内存中数据仍然为A，因此CAS操作成功，但实际上该数据已经被线程2修改过。这种现象称为ABA问题，乐观锁并不知道数据已经改变，仅仅基于值是否变化作为判断依据。

2. 版本号机制

        在数据中增加一个字段Version，表示该数据的版本号，每当数据被修改，版本号+1。当某个线程查询数据时，将该数据的版本号一起取出，当线程更新数据时，判断当前版本号与之前读取的版本是否一致，如果一致再进行以下操作。