自旋锁

自旋锁和互斥锁的区别 自旋锁是一种互斥锁的实现方式而已，相比一般的互斥锁会在等待期间放弃cpu，自旋锁（spinlock）则是不断循环并测试锁的状态，这样就一直占着cpu。 互斥锁：用于保护临界区，确保同一时间只有一个线程访问数据。对共享资源的访问，先对互斥量进行加锁，如果互斥量已经上锁，调用线程会阻塞，直到互斥量被解锁。在完成了对共享资源的访问后，要对互斥量进行解锁。 临界区：每个进程中访问临界资源的那段程序称为临界区，每次只允许一个进程进入临界区，进入后不允许其他进程进入。 自旋锁：与互斥量类似，它不是通过休眠使进程阻塞，而是在获取锁之前一直处于忙等(自旋)阻塞状态。用在以下情况：锁持有的时间短，而且线程并不希望在重新调度上花太多的成本。“原地打转”。 自旋锁与互斥锁的区别：线程在申请自旋锁的时候，线程不会被挂起，而是处于忙等的状态。 信号量：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。 来源： CSDN 作者： erciyuan_ 链接： https://blog.csdn.net/erciyuan_/article/details/104683420

本文来自个人博客： https://dunkwan.cn 文章目录 线程同步 互斥量 函数`pthread_mutex_timedlock` 读写锁 带有超时的读写锁 条件变量 自旋锁 屏障 线程同步 互斥量 互斥量从本质上来说是一把锁，在访问共享资源前对互斥量进行设置，在访问完成后释放互斥量。互斥量使用 pthread_mutex_t 数据类型表示的。在使用互斥量以前，必须首先对它进行初始化，可以把它设置为常量 PTHREAD_MUTEX_INITIALIZER （只适用于静态分配的互斥量），也可以通过调用 pthread_mutex_init 函数进行初始化。如果动态分配互斥量（例如通过调用 malloc 函数），在释放内存前需要调用 pthread_mutex_detroy 。 # include <pthread.h> int pthread_mutex_init ( pthread_mutex_t * restrict mutex , const pthread_mutexattr_t * restrict attr ) ; int pthread_mutex_destroy ( pthread_mutex_t * mutex ) ; 两个函数的返回值：若成功，返回 0 ；否则，返回错误编号。 要用默认的属性初始化互斥量，只需把 attr 设为 NULL 。

今天总结了锁升级（偏向锁、轻量级锁、重量级锁）和锁优化下面开始总结。 其实这些内容都是JVM对锁进行的一些优化，为什么分开讲，原因是锁升级比较重要，也比较难。 一、锁升级 在1.6之前java中不存在只存在重量级锁，这种锁直接对接底层操作系统中的互斥量（mutex），这种同步成本非常高，包括操作系统调用引起的内核态与用户态之间的切换。线程阻塞造成的线程切换等。因此在jdk 1.6中将锁分为四种状态：由低到高分别为：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态。 1. 偏向锁。什么是偏向锁呢？为什么要引入偏向锁呢？ 偏向锁是如果一个线程获取到了偏向锁，在没有其他线程竞争的情况下，如果下次再执行该同步块时则只需要简单判断当前偏向锁所偏向的对象是否是当前线程，如果是则不需要再进行任何获取锁与释放锁的过程，直接执行同步块。至于为什么引入偏向锁，是因为经过JVM的开发人员大量的研究发现大多数时候都是不存在锁竞争的，通常都是一个线程在使用锁的时候没有其他线程来竞争，然而每次都要进行加锁和解锁就会额外增加一些没有必要的资源浪费。为了降低这些浪费，JVM引入了偏向锁。 a) 偏向锁的获取以及升级过程如下： 当一个线程在执行同步块时，它会先获取该对象头的MarkWord，通过MarkWord来判断当前虚拟机是否支持偏向锁（因为偏向锁是可以手动关闭的），如果不支持则直接进入轻量级锁获取过程

内核同步措施：为了避免并发防止竞争，内核提供了一组同步方法来提供对共享数据的保护。 Linux同步机制从2.0到2.6以来不断发展完善。从最初的原子操作，到后来的信号量，从大内核锁到自旋锁。这些同步机制的发展伴随 Linux 从单处理器到对称多处理器 的过度，伴随着从非抢占内核到抢占内核的过度。锁机制越来越有效，也越来越复杂。 目前，内核中原子操作多用来做计数使用，其它情况最常用的是两种锁及它们的变种: 一个是自旋锁，另一个是信号量。 自旋锁 ：专为防止多处理器并发而引入的一种锁，它在内核中大量应用于中断处理等部分(对于单处理器来说，防止中断处理中的并发可简单采用关闭中断的方式，不需要自旋锁)。 自旋锁最多只能被一个内核任务持有 ，如果一个内核任务试图请求一个已被争用(已经被持有)的自旋锁，那么这个任务就会一直进行忙循环——旋转——等待锁重新可用。要是锁未被争用，请求它的内核任务便能立刻得到它并且继续进行。自旋锁可以在任何时刻防止多于一个的内核任务同时进入临界区，因此这种锁可有效地避免多处理器上并发运行的内核任务竞争共享资源。 事实上，自旋锁的初衷就是：在短期间内进行轻量级的锁定。一个被争用的自旋锁使得请求它的线程在等待锁重新可用的期间进行自旋(特别浪费处理器时间)，所以 自旋锁不应该被持有时间过长 。如果需要长时间锁定的话, 最好使用信号量。 自旋锁的基本形式如下： spin

内核同步措施 为了避免并发，防止竞争。内核提供了一组同步方法来提供对共享数据的保护。 我们的重点不是介绍这些方法的详细用法，而是强调为什么使用这些方法和它们之间的差别。 Linux 使用的同步机制可以说从2.0到2.6以来不断发展完善。从最初的原子操作，到后来的信号量，从大内核锁到今天的自旋锁。这些同步机制的发展伴随 Linux从单处理器到对称多处理器的过度；伴随着从非抢占内核到抢占内核的过度。锁机制越来越有效，也越来越复杂。 目前来说内核中原子操作多用来做计数使用，其它情况最常用的是两种锁以及它们的变种:一个是自旋锁，另一个是信号量。我们下面就来着重介绍一下这两种锁机制。 自旋锁 ------------------------------------------------------ 自旋锁是专为防止多处理器并发而引入的一种锁，它在内核中大量应用于中断处理等部分(对于单处理器来说，防止中断处理中的并发可简单采用关闭中断的方式，不需要自旋锁)。 自旋锁最多只能被一个内核任务持有，如果一个内核任务试图请求一个已被争用(已经被持有)的自旋锁，那么这个任务就会一直进行忙循环——旋转——等待锁重新可用。要是锁未被争用，请求它的内核任务便能立刻得到它并且继续进行。自旋锁可以在任何时刻防止多于一个的内核任务同时进入临界区，因此这种锁可有效地避免多处理器上并发运行的内核任务竞争共享资源。

为了避免并发，防止竞争。内核提供了一组同步方法来提供对共享数据的保护。 我们的重点不是介绍这些方法的详细用法，而是强调为什么使用这些方法和它们之间的差别。 Linux 使用的同步机制可以说从2.0到2.6以来不断发展完善。从最初的原子操作，到后来的信号量，从大内核锁到今天的自旋锁。这些同步机制的发展伴随 Linux从单处理器到对称多处理器的过度；伴随着从非抢占内核到抢占内核的过度。锁机制越来越有效，也越来越复杂。 目前来说内核中原子操作多用来做计数使用，其它情况最常用的是两种锁以及它们的变种:一个是自旋锁，另一个是信号量。我们下面就来着重介绍一下这两种锁机制。 自旋锁 ------------------------------------------------------ 自旋锁是专为防止多处理器并发而引入的一种锁，它在内核中大量应用于中断处理等部分(对于单处理器来说，防止中断处理中的并发可简单采用关闭中断的方式，不需要自旋锁)。 自旋锁最多只能被一个内核任务持有，如果一个内核任务试图请求一个已被争用(已经被持有)的自旋锁，那么这个任务就会一直进行忙循环——旋转——等待锁重新可用。要是锁未被争用，请求它的内核任务便能立刻得到它并且继续进行。自旋锁可以在任何时刻防止多于一个的内核任务同时进入临界区，因此这种锁可有效地避免多处理器上并发运行的内核任务竞争共享资源。 事实上

https://www.cnblogs.com/fengzheng/p/9018152.html https://www.jianshu.com/p/f714c440d0cb CAS在jdk应用 ConcurrentHashMap1.7使用lock锁实现，1.8使用cas+synchronized CAS（Compare and swap），即比较并交换，也是实现我们平时所说的自旋锁或乐观锁的核心操作。 它的实现很简单，就是用一个预期的值和内存值进行比较，如果两个值相等，就用预期的值替换内存值，并返回 true。否则，返回 false。 保证原子操作 任何技术的出现都是为了解决某些特定的问题， CAS 要解决的问题就是保证原子操作。原子操作是什么，原子就是最小不可拆分的，原子操作就是最小不可拆分的操作，也就是说操作一旦开始，就不能被打断，直到操作完成。在多线程环境下，原子操作是保证线程安全的重要手段。举个例子来说，假设有两个线程在工作，都想对某个值做修改，就拿自增操作来说吧，要对一个整数 i 进行自增操作，需要基本的三个步骤： 1、读取 i 的当前值； 2、对 i 值进行加 1 操作； 3、将 i 值写回内存； 假设两个进程都读取了 i 的当前值，假设是 0，这时候 A 线程对 i 加 1 了，B 线程也 加 1，最后 i 的是 1 ，而不是 2。这就是因为自增操作不是原子操作

1.自旋锁定义 自旋锁是转为防止多处理器并发而引入的一种锁，它在内核中大量应用与中断处理等部分（对于单处理器，防治中断处理的并发可简单采用关闭中断的方式，即在标志寄存器中关闭/打开中断标志位，不需要自旋锁）。自旋锁与互斥锁的区别：（1）对于互斥所，若资源已被占用，资源申请者只能进入睡眠状态；（2）但自旋锁不会引起调用者睡眠，若自旋锁已被别的执行单元保持，调用者就一直循环查看是否该自旋锁的保持者已释放了锁。 2.原理 跟 互斥锁 一样，一个执行单元要想访问被自旋锁保护的 共享资源 ，必须先得到锁，在访问完共享资源后，必须释放锁。如果在获取自旋锁时，没有任何执行单元保持该锁，那么将立即得到锁；如果在获取自旋锁时锁已经有保持者，那么获取锁操作将自旋在那里，直到该自旋锁的保持者释放了锁。 3.存在的问题 （1） 死锁 。试图递归地获得自旋锁必然会引起 死锁 ：递归程序的持有实例在第二个实例循环，以试图获得相同自旋锁时，不会释放此自旋锁。在递归程序中使用自旋锁应遵守下列策略：递归程序决不能在持有自旋锁时调用它自己，也决不能在 递归调用 时试图获得相同的自旋锁。此外如果一个进程已经将资源锁定，那么，即使其它申请这个资源的进程不停地疯狂“自旋”,也无法获得资源，从而进入 死循环 。 （2）过多占用 cpu 资源。如果不加限制，由于申请者一直在循环等待，因此自旋锁在锁定的时候,如果不成功,不会睡眠

个人博客 http://www.milovetingting.cn Java多线程(二) 前言 本文为学习Java相关知识所作笔记，参考以下资料: https://github.com/Snailclimb/JavaGuide ,感谢原作者的分享! JAVA 锁 乐观锁 乐观锁是一种乐观思想，即认为读多写少，遇到并发写的可能性低，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，采取在写时先读出当前版本号，然后加锁操作（比较跟上一次的版本号，如果一样则更新），如果失败则要重复读-比较-写的操作。 java 中的乐观锁基本都是通过 CAS 操作实现的，CAS 是一种更新的原子操作，比较当前值跟传入值是否一样，一样则更新，否则失败。 悲观锁 悲观锁是就是悲观思想，即认为写多，遇到并发写的可能性高，每次去拿数据的时候都认为别人会修改，所以每次在读写数据的时候都会上锁，这样别人想读写这个数据就会 block 直到拿到锁。java中的悲观锁就是Synchronized,AQS框架下的锁则是先尝试cas乐观锁去获取锁，获取不到，才会转换为悲观锁，如 RetreenLock。 自旋锁 自旋锁原理非常简单，如果持有锁的线程能在很短时间内释放锁资源，那么那些等待竞争锁的线程就不需要做内核态和用户态之间的切换进入阻塞挂起状态

这篇文章分为六个部分，不同特性的锁分类，并发锁的不同设计，Synchronized中的锁升级，ReentrantLock和ReadWriteLock的应用，帮助你梳理 Java 并发锁及相关的操作。 一、锁有哪些分类 一般我们提到的锁有以下这些： 乐观锁/悲观锁 公平锁/非公平锁 可重入锁 独享锁/共享锁 互斥锁/读写锁 分段锁 偏向锁/轻量级锁/重量级锁 自旋锁 上面是很多锁的名词，这些分类并不是全是指锁的状态，有的指锁的特性，有的指锁的设计，下面分别说明。 1、乐观锁 VS 悲观锁 乐观锁与悲观锁是一种广义上的概念，体现了看待线程同步的不同角度，在Java和数据库中都有此概念对应的实际应用。 （1）乐观锁 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。 乐观锁适用于多读的应用类型，乐观锁在Java中是通过使用无锁编程来实现，最常采用的是CAS算法，Java原子类中的递增操作就通过CAS自旋实现的。 CAS全称 Compare And Swap（比较与交换），是一种无锁算法。在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。java.util.concurrent包中的原子类就是通过CAS来实现了乐观锁。 简单来说，CAS算法有3个三个操作数：