java自旋锁 的实现原理:如果自旋锁被另外一个线程对象持有,那么当前获取锁的线程将陷入while循环等待,直到那个持有自旋锁的线程对象释放它所持有的自旋锁,那么那些想要获取该自旋锁的线程对象 将会有一个获得该自旋锁。
基于他这种原理,等待的时候,并不释放cpu时间片,相比synchronized wait()操作,减小了释放,重新获取的消耗。 该自旋锁适用于,当前线程竞争不强烈的时候使用。
代码:
public class Test implements Runnable {
static int sum;
private SpinLock lock;
public Test(SpinLock lock) {
this.lock = lock;
}
/**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
SpinLock lock = new SpinLock();
for (int i = 0; i < 100; i++) {
Test test = new Test(lock);
Thread t = new Thread(test);
t.start();
}
Thread.currentThread().sleep(1000);
System.out.println(sum);
}
@Override
public void run() {
this.lock.lock();
this.lock.lock();
sum++;
this.lock.unLock();
this.lock.unLock();
}
}
<pre name="code" class="java">package optimiz_spinlock;
import java.util.concurrent.atomic.AtomicReference;
/**
* 可重入的自旋锁 (重新进入 不会出现死锁)
* @author Administrator
*
*/
public class SpinLock {
AtomicReference<Thread> owner = new AtomicReference<Thread>();//持有自旋锁的线程对象
private int count;//用一个计数器 来做 重入锁获取次数的计数
public void lock() {
Thread cur = Thread.currentThread();
if (cur == owner.get()) {
count++;
return;
}
while (!owner.compareAndSet(null, cur)) {//当线程越来越多 由于while循环 会浪费CPU时间片,CompareAndSet 需要多次对同一内存进行访问
//会造成内存的竞争,然而对于X86,会采取竞争内存总线的方式来访问内存,所以会造成内存访问速度下降(其他线程老访问缓存),因而会影响整个系统的性能
}
}
public void unLock() {
Thread cur = Thread.currentThread();
if (cur == owner.get()) {
if (count > 0) {
count--;
} else {
owner.compareAndSet(cur, null);
}
}
}
}
为何说它是可重入的?我们接下来看一个不可重入的自旋锁(不可重入的自旋锁,如果再次去获取锁的话 很有可能出现死锁)。
不可重入的自旋锁的实现:
package optimiz_spinlock;
import java.util.concurrent.atomic.AtomicReference;
public class BadSpinLock {
AtomicReference<Thread> owner = new AtomicReference<Thread>();//持有自旋锁的线程对象
public void lock() {
Thread cur = Thread.currentThread();
while (!owner.compareAndSet(null, cur)) {
System.out.println(cur.getName()+ " wait lock release");
}
}
public void unLock() {
Thread cur = Thread.currentThread();
if (cur == owner.get()) {
owner.compareAndSet(cur, null);
System.out.println(cur.getName()+ " release lock");
}
}
}
package optimiz_spinlock;
public class BadTestTask implements Runnable{
static int sum;
private BadSpinLock lock;
public BadTestTask(BadSpinLock lock) {
this.lock = lock;
}
/**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
BadSpinLock lock = new BadSpinLock();
for (int i = 0; i < 2; i++) {
BadTestTask test = new BadTestTask(lock);
Thread t = new Thread(test);
t.start();
}
}
@Override
public void run() {
this.lock.lock();
this.lock.lock();
sum++;
this.lock.unLock();
this.lock.unLock();
}
}
当一个线程 调用这个不可重入的自旋锁去加锁的时候没问题,当再次调用lock()的时候,因为自旋锁的持有引用已经不为空了,该线程对象会误认为是别人的线程持有了自旋锁,我等我等!,等到地老天荒,哎呦妈啊,原来是自己拿着了,所以这是非常傻逼的问题。 出现这种问题的时候,持有自旋锁的那个线程不会释放该自旋锁,导致所有线程都会停留在while()循环里,后果不敢想了。