首页 / JAVA / Java并发编程——深入理解自旋锁
Java并发编程——深入理解自旋锁
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Java并发编程——深入理解自旋锁,小编现在分享给大家,供广大互联网技能从业者学习和参考。文章包含6206字,纯文字阅读大概需要9分钟。
内容图文
![Java并发编程——深入理解自旋锁](/upload/InfoBanner/zyjiaocheng/624/53e21fc4238144d8ad8425aee1ea1b5c.jpg)
1.什么是自旋锁
自旋锁(spinlock):是指当一个线程在获取锁的时候,如果锁已经被其它线程获取,那么该线程将循环等待,然后不断的判断锁是否能够被成功获取,直到获取到锁才会退出循环。
获取锁的线程一直处于活跃状态,但是并没有执行任何有效的任务,使用这种锁会造成busy-waiting。
2.Java如何实现自旋锁?
先看一个实现自旋锁的例子,java.util.concurrent包里提供了很多面向并发编程的类. 使用这些类在多核CPU的机器上会有比较好的性能.主要原因是这些类里面大多使用(失败-重试方式的)乐观锁而不是synchronized方式的悲观锁.
class spinlock {
private AtomicReference<Thread> cas;
spinlock(AtomicReference<Thread> cas){
this.cas = cas;
}
public void lock() {
Thread current = Thread.currentThread();
// 利用CAS
while (!cas.compareAndSet(null, current)) { //为什么预期是null??
// DO nothing
System.out.println("I am spinning");
}
}
public void unlock() {
Thread current = Thread.currentThread();
cas.compareAndSet(current, null);
}
}
lock()方法利用的CAS,当第一个线程A获取锁的时候,能够成功获取到,不会进入while循环,如果此时线程A没有释放锁,另一个线程B又来获取锁,此时由于不满足CAS,所以就会进入while循环,不断判断是否满足CAS,直到A线程调用unlock方法释放了该锁。
自旋锁验证代码
package ddx.多线程;
import java.util.concurrent.atomic.AtomicReference;
public class 自旋锁 {
public static void main(String[] args) {
AtomicReference<Thread> cas = new AtomicReference<Thread>();
Thread thread1 = new Thread(new Task(cas));
Thread thread2 = new Thread(new Task(cas));
thread1.start();
thread2.start();
}
}
//自旋锁验证
class Task implements Runnable {
private AtomicReference<Thread> cas;
private spinlock slock ;
public Task(AtomicReference<Thread> cas) {
this.cas = cas;
this.slock = new spinlock(cas);
}
@Override
public void run() {
slock.lock(); //上锁
for (int i = 0; i < 10; i++) {
//Thread.yield();
System.out.println(i);
}
slock.unlock();
}
}
通过之前的AtomicReference类创建了一个自旋锁cas,然后创建两个线程,分别执行,结果如下:
0
I am spin
I am spin
I am spin
I am spin
I am spin
I am spin
I am spin
I am spin
I am spin
I am spin
I am spin
I am spin
I am spin
I am spin
I am spin
I am spin
1
I am spin
I am spin
I am spin
I am spin
I am spin
2
3
4
5
6
7
8
9
I am spin
0
1
2
3
4
5
6
7
8
9
通过对输出结果的分析我们可以得知,首先假定线程一在执行lock方法的时候获得了锁,通过方法
cas.compareAndSet(null, current)
将引用改为线程一的引用,跳过while循环,执行打印函数
而线程二此时也进入lock方法,在执行比较操作的时候发现,expect value != update value,于是进入while循环,打印
i am spinning。由以下红字可以得出结论,Java中的一个线程并不是总是占着cpu时间片不放,一直执行完的,而是采用抢占式调度,所以出现了上面两个线程交替执行的现象
Java线程的实现是通过映射到系统的轻量级线程上,轻量级线程有对应系统的内核线程,内核线程的调度由系统调度器来调度的,所以Java的线程调度方式取决于系统内核调度器,只不过刚好目前主流操作系统的线程实现都是抢占式的。
3.自旋锁存在的问题
使用自旋锁会有以下一个问题:
1. 如果某个线程持有锁的时间过长,就会导致其它等待获取锁的线程进入循环等待,消耗CPU。使用不当会造成CPU使用率极高。
2. 上面Java实现的自旋锁不是公平的,即无法满足等待时间最长的线程优先获取锁。不公平的锁就会存在“线程饥饿”问题。
4.自旋锁的优点
- 自旋锁不会使线程状态发生切换,一直处于用户态,即线程一直都是active的;不会使线程进入阻塞状态,减少了不必要的上下文切换,执行速度快
- 非自旋锁在获取不到锁的时候会进入阻塞状态,从而进入内核态,当获取到锁的时候需要从内核态恢复,需要线程上下文切换。 (线程被阻塞后便进入内核(Linux)调度状态,这个会导致系统在用户态与内核态之间来回切换,严重影响锁的性能)
5.可重入的自旋锁和不可重入的自旋锁
文章开始的时候的那段代码,仔细分析一下就可以看出,它是不支持重入的,即当一个线程第一次已经获取到了该锁,在锁释放之前又一次重新获取该锁,第二次就不能成功获取到。由于不满足CAS,所以第二次获取会进入while循环等待,而如果是可重入锁,第二次也是应该能够成功获取到的。
而且,即使第二次能够成功获取,那么当第一次释放锁的时候,第二次获取到的锁也会被释放,而这是不合理的。
例如将代码改成如下:
@Override
public void run() {
slock.lock(); //上锁
slock.lock(); //再次获取自己的锁!由于不可重入,则会陷入循环
for (int i = 0; i < 10; i++) {
//Thread.yield();
System.out.println(i);
}
slock.unlock();
}
则运行结果将会无限打印,陷入无终止的循环!
为了实现可重入锁,我们需要引入一个计数器,用来记录获取锁的线程数。
public class ReentrantSpinLock {
private AtomicReference<Thread> cas = new AtomicReference<Thread>();
private int count;
public void lock() {
Thread current = Thread.currentThread();
if (current == cas.get()) { // 如果当前线程已经获取到了锁,线程数增加一,然后返回
count++;
return;
}
// 如果没获取到锁,则通过CAS自旋
while (!cas.compareAndSet(null, current)) {
// DO nothing
}
}
public void unlock() {
Thread cur = Thread.currentThread();
if (cur == cas.get()) {
if (count > 0) {// 如果大于0,表示当前线程多次获取了该锁,释放锁通过count减一来模拟
count--;
} else {// 如果count==0,可以将锁释放,这样就能保证获取锁的次数与释放锁的次数是一致的了。
cas.compareAndSet(cur, null);
}
}
}
}
同样lock方法会先判断是否当前线程已经拿到了锁,拿到了就让count加一,可重入,然后直接返回!而unlock方法则会首先判断当前线程是否拿到了锁,如果拿到了,就会先判断计数器,不断减一,不断解锁!
可重入自旋锁代码验证
//可重入自旋锁验证
class Task1 implements Runnable{
private AtomicReference<Thread> cas;
private ReentrantSpinLock slock ;
public Task1(AtomicReference<Thread> cas) {
this.cas = cas;
this.slock = new ReentrantSpinLock(cas);
}
@Override
public void run() {
slock.lock(); //上锁
slock.lock(); //再次获取自己的锁!没问题!
for (int i = 0; i < 10; i++) {
//Thread.yield();
System.out.println(i);
}
slock.unlock(); //释放一层,但此时count为1,不为零,导致另一个线程依然处于忙循环状态,所以加锁和解锁一定要对应上,避免出现另一个线程永远拿不到锁的情况
slock.unlock();
}
}
6.自旋锁与互斥锁异同点
- 自旋锁与互斥锁都是为了实现保护资源共享的机制。
- 无论是自旋锁还是互斥锁,在任意时刻,都最多只能有一个保持者。
- 获取互斥锁的线程,如果锁已经被占用,则该线程将进入睡眠状态;获取自旋锁的线程则不会睡眠,而是一直循环等待锁释放。
7.总结
- 自旋锁:线程获取锁的时候,如果锁被其他线程持有,则当前线程将循环等待,直到获取到锁。
- 自旋锁等待期间,线程的状态不会改变,线程一直是用户态并且是活动的(active)。
- 自旋锁如果持有锁的时间太长,则会导致其它等待获取锁的线程耗尽CPU。
- 自旋锁本身无法保证公平性,同时也无法保证可重入性。
- 基于自旋锁,可以实现具备公平性和可重入性质的锁
结尾
本文到这里就结束了,感谢看到最后的朋友,都看到最后了,点个赞再走啊,如有不对之处还请多多指正。
内容总结
以上是互联网集市为您收集整理的Java并发编程——深入理解自旋锁全部内容,希望文章能够帮你解决Java并发编程——深入理解自旋锁所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错,欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 gblab@vip.qq.com 举报,一经查实,本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。