自旋锁

2. 轻量级锁   倘若偏向锁失败， 虚拟机并不会立即升级为重量级锁 ，它还会尝试使用一种称为轻量级锁的优化手段(1.6之后加入的)。轻量级锁不是为了代替重量级锁，它的本意是 在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗，因为使用轻量级锁时，不需要申请互斥量   轻量级锁能够提升程序同步性能的依据是“对于绝大部分锁，在整个同步周期内都是不存在竞争的”，这是一个经验数据。如果没有竞争，轻量级锁使用 CAS 操作避免了使用互斥操作的开销。 但如果存在锁竞争，除了互斥量开销外，还会额外发生CAS操作，因此在有锁竞争的情况下，轻量级锁比传统的重量级锁更慢！ 如果锁竞争激烈，那么轻量级将很快膨胀为重量级锁！ 当有另外一个线程竞争锁时，由于该锁处于 偏向锁 状态 发现对象头Mark Word中的线程ID不是自己的线程ID，该线程就会执行CAS操作获取锁 如果获取 成功 ，直接替换Mark Word中的线程ID为自己的线程ID，该锁会***保持偏向锁状态*** 如果获取 失败 ，说明当前锁有一定的竞争，将偏向锁 升级 为轻量级锁 线程获取轻量级锁的步骤： 在加锁前，虚拟机需要在当前线程的栈帧中建立 锁记录 （Lock Record）的空间。Lock Record 中包含一个 _displaced_header 属性，用于存储锁对象的 Mark Word 的拷贝。

本文将为你介绍内核同步算法中的自旋锁和信号量。在这之前，先了解一些概念。 执行线程：thread of execution，指任何正在执行的代码实例，可能是一个正在内核线程，一个中断处理程序等。有时候会将执行线程简称为线程。 临界区：critical region，即访问和操作共享数据的代码段。 多个执行线程并发访问同一资源通常是不安全的，通常使用自旋锁和信号量来实现对临界区互斥的访问。 自旋锁 自旋锁(spin lock)是一个对临界资源进行互斥访问的典型手段。自旋锁至多只能被一个执行线程持有。当一个执行线程想要获得一个已被使用的自旋锁时，该线程就会一直进行忙等待直至该锁被释放，就如同“自旋”所表达的意思那样：在原地打转。 我们也可以这么理解自旋锁：它如同一把门锁，而临界区就如同门后面的房间。当一个线程A进入房间后，它会关闭房门，使得其他线程不得进入。此时如果其他某个进程B需要进入房间，那么只能在门外“打转”。当A进程打开们后，进程B才能进入房间。 自旋锁的使用 1.定义初始化自旋锁 使用下面的语句就可以先定一个自旋锁变量，再对其进行初始化： 1 spinlock_t lock; 2 spin_lock_init(&lock); 也可以这样初始化一个自旋锁： 1 spinlock_t lock=SPIN_LOCK_UNLOCKED; 2.获得自旋锁 1 void spin

一 原子操作 指令以原子的方式执行——执行过程不被打断。 1 原子整数操作 原子操作函数接收的操作数类型——atomic_t //定义 atomic_t v;//初始化 atomic_t u = ATOMIC_INIT(0); //操作 atomic_set(&v,4); // v = 4 atomic_add(2,&v); // v = v + 2 = 6 atomic_inc(&v); // v = v + 1 = 7 //实现原子操作函数实现 static inline void atomic_add(int i, atomic_t *v) { unsigned long tmp; int result; __asm__ __volatile__("@ atomic_add\n" 　　　　"1: ldrex %0, [%3]\n" 　　　　" add %0, %0, %4\n" 　　　　" strex %1, %0, [%3]\n" 　　　　" teq %1, #0\n" 　　　　" bne 1b" 　　: "=&r" (result), "=&r" (tmp), "+Qo" (v->counter) 　　: "r" (&v->counter), "Ir" (i) 　　: "cc"); } 2 原子位操作 //定义 unsigned long word = 0; //操作

自旋锁（spinlock)与互斥锁(mutex)是并发编程中两个重要的概念。它们的主要作用是：对共享资源加锁以阻止数据的并发访问，从而保证数据一致性。但是它们也有一些不同点。本文主要介绍这些不同点，并说明我们什么时候该用自旋锁，什么时候该用互斥锁。 理论基础 理论上，当一个线程尝试去获取一个互斥锁，但由于该互斥锁已经被其它线程获取而没有成功时，它会立刻进入休眠状态，从而让出CPU时间，允许其它线程运行。它将持续休眠直到最终被唤醒，唤醒的条件是之前获取到该互斥锁的线程释放了互斥锁； 对比一下，当一个线程尝试去获取一个自旋锁，但由于该自旋锁已经被其它线程获取而没有成功时， 它将会反复获取它(在英文中叫polling)，直到最终成功。因此在获取自旋锁的时候，该线程不会让出CPU时间，其它线程将不能运行，当然，操作系统不会允许一个线程一直阻塞整个系统的运行，在某个线程花完了它的CPU运行总时间后，它会强制切换到另外线程执行。（注：线程一次使用的CPU总时间的最大上限可以通过ulimit -t查看，单位为秒） 问题 对于互斥锁，使线程进入休眠以及唤醒线程都是比较昂贵的操作，需要相当多的CPU指令，花费较长的CPU时间。如果A线程获取到该互斥锁后，只是持有了很短的一段时间就释放，那么B线程在获取互斥锁的过程中，B线程进入休眠以及被唤醒花费的CPU时间可能超过了B线程休眠的时间

阅读目录： 基础 自旋锁示例 SpinLock 继续SpinLock 总结 基础 内核锁：基于内核对象构造的锁机制，就是通常说的内核构造模式。 用户模式构造和内核模式构造 优点：cpu利用最大化。它发现资源被锁住，请求就排队等候。线程切换到别处干活，直到接受到可用信号，线程再切回来继续处理请求。 缺点：托管代码->用户模式代码->内核代码损耗、线程上下文切换损耗。 在锁的时间比较短时，系统频繁忙于休眠、切换，是个很大的性能损耗。 自旋锁：原子操作+自循环。通常说的用户构造模式。 线程不休眠，一直循环尝试对资源访问，直到可用。 优点：完美解决内核锁的缺点。 缺点：长时间一直循环会导致cpu的白白浪费，高并发竞争下、CPU的消耗特别严重。 混合锁：内核锁+自旋锁。 混合锁是先自旋锁一段时间或自旋多少次，再转成内核锁。 优点：内核锁和自旋锁的折中方案，利用前二者优点，避免出现极端情况（自旋时间过长，内核锁时间过短）。 缺点： 自旋多少时间、自旋多少次，这些策略很难把控。 在操作系统及net框架层，这块算法策略做的已经非常优了，有些API函数也提供了时间及次数可配置项，让使用者根据需求自行判断。 自旋锁示例 来看下我们自己简单实现的自旋锁： 　　　　　 int signal = 0; var li = new List<int>(); Parallel.For(0, 1000 *

一、什么是自旋锁？ 自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。 获取锁的线程一直处于活跃状态，但是并没有执行任何有效的任务，使用这种锁会造成 busy-waiting 。 它是为实现保护共享资源而提出一种锁机制。其实，自旋锁与互斥锁比较类似，它们都是为了解决对某项资源的互斥使用。无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。但是两者在调度机制上略有不同。对于互斥锁，如果资源已经被占用，资源申请者只能进入睡眠状态。但是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，”自旋”一词就是因此而得名。 二、Java如何实现自旋锁？ 下面是个简单的例子： public class SpinLock { private AtomicReference<Thread> cas = new AtomicReference<Thread>(); public void lock() { Thread current = Thread.currentThread(); // 利用CAS while (!cas.compareAndSet(null,

什么是自旋锁？ 自旋锁（spinlock） ：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。 获取锁的线程一直处于活跃状态，但是并没有执行任何有效的任务，使用这种锁会造成busy-waiting。 Java如何实现自旋锁？ 下面是个简单的例子： /** * Date: 2016年1月4日 下午4:41:50 * * @author medusar */ public class SpinLock { private AtomicReference cas = new AtomicReference(); public void lock() { Thread current = Thread.currentThread(); // 利用CAS while (!cas.compareAndSet(null, current)) { // DO nothing } } public void unlock() { Thread current = Thread.currentThread(); cas.compareAndSet(current, null); } } ock（)方法利用的CAS，当第一个线程A获取锁的时候，能够成功获取到，不会进入while循环，如果此时线程A没有释放锁

本文内容 在读很多并发文章中，会提及各种各样锁如公平锁，乐观锁等等，这篇文章介绍各种锁的分类。介绍的内容如下： 1.公平锁 / 非公平锁 2.可重入锁 / 不可重入锁 3.独享锁 / 共享锁 4.互斥锁 / 读写锁 5.乐观锁 / 悲观锁 6.分段锁 7.偏向锁 / 轻量级锁 / 重量级锁 8.自旋锁 上面是很多锁的名词，这些分类并不是全是指锁的状态，有的指锁的特性，有的指锁的设计，下面总结的内容是对每个锁的名词进行一定的解释。 公平锁 / 非公平锁 公平锁 公平锁是指多个线程按照申请锁的顺序来获取锁。 非公平锁 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。 对于 Java ReentrantLock 而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。 对于 Synchronized 而言，也是一种非公平锁。由于其并不像 ReentrantLock 是通过 AQS 的来实现线程调度，所以并没有任何办法使其变成公平锁。 可重入锁 / 不可重入锁 可重入锁 广义上的可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class），这样的锁就叫做可重入锁。 ReentrantLock 和

参考： https://blog.csdn.net/fuyuwei2015/article/details/83387536 自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。 获取锁的线程一直处于活跃状态，但是并没有执行任何有效的任务，使用这种锁会造成busy-waiting。 自旋锁的缺点 使用自旋锁会有以下一个问题： 1. 如果某个线程持有锁的时间过长，就会导致其它等待获取锁的线程进入循环等待，消耗CPU。使用不当会造成CPU使用率极高。 2. 上面Java实现的自旋锁不是公平的，即无法满足等待时间最长的线程优先获取锁。不公平的锁就会存在“线程饥饿”问题。 自旋锁的优点 自旋锁不会使线程状态发生切换，一直处于用户态，即线程一直都是active的；不会使线程进入阻塞状态，减少了不必要的上下文切换，执行速度快 非自旋锁在获取不到锁的时候会进入阻塞状态，从而进入内核态，当获取到锁的时候需要从内核态恢复，需要线程上下文切换。 （线程被阻塞后便进入内核（Linux）调度状态，这个会导致系统在用户态与内核态之间来回切换，严重影响锁的性能） 来源： CSDN 作者： 不带刺仙人球 链接： https://blog.csdn.net/zyzn1425077119

In software engineering, a spinlock is a lock which causes a thread trying to acquire it to simply wait in a loop (“spin”) while repeatedly checking if the lock is available. Since the thread remains active but is not performing a useful task, the use of such a lock is a kind of busy waiting. Once acquired, spinlocks will usually be held until they are explicitly released, although in some implementations they may be automatically released if the thread being waited on (the one which holds the lock) blocks, or “goes to sleep”. 来源： CSDN 作者： michaelforgood 链接： https://blog.csdn.net