自旋锁、阻塞锁、可重入锁使用解析

喜欢ヅ旅行 2022-02-26 11:10 168阅读 0赞

常听见有人在问这几种类型的锁有什么区别，所以整理了这一篇文章。

## 自旋锁 ##

`自旋锁`是采用让当前线程不停地的在循环体内执行实现的，当循环的条件被其他线程改变时 才能进入临界区。如下：

public class SpinLock { 
     
      private AtomicReference<Thread> sign =new AtomicReference<>();
     
      public void lock(){ 
        Thread current = Thread.currentThread();
        while(!sign .compareAndSet(null, current)){ 
        }
      }
     
      public void unlock (){ 
        Thread current = Thread.currentThread();
        sign .compareAndSet(current, null);
      }
    }

注：（该例子为非公平锁，获得锁的先后顺序，不会按照进入lock的先后顺序进行。
    ）

使用了CAS原子操作，lock函数将`owner`设置为当前线程，并且预测原来的值为空。unlock函数将`owner`设置为null，并且预测值为当前线程。  
当有第二个线程调用lock操作时由于`owner`值不为空，导致循环一直被执行，直至第一个线程调用unlock函数将`owner`设置为null，第二个线程才能进入临界区。

###### `TIP:` ######

由于自旋锁只是将当前线程不停地执行循环体，不进行线程状态的改变，所以响应速度更快。但当线程数不停增加时，性能下降明显，因为每个线程都需要执行，占用CPU时间。  
所以当线程竞争不激烈，并且保持锁的时间段，适合使用自旋锁。

--------------------

## 阻塞锁 ##

阻塞锁，与自旋锁不同，改变了线程的运行状态。阻塞锁，可以说是让线程进入阻塞状态进行等待，当获得相应的信号（唤醒，时间） 时，才可以进入线程的准备就绪状态，准备就绪状态的所有线程，通过竞争，进入运行状态。  
在JAVA环境中，线程Thread有如下几个状态：

*  新建状态
 *  就绪状态
 *  运行状态
 *  阻塞状态
 *  死亡状态  
    JAVA中，能够`进入\退出`、`阻塞状态`或`包含阻塞锁`的方法有 ，`synchronized` 关键字，`ReentrantLock`，`Object.wait()\notify()`，`LockSupport.park() / unpark()`等。

参考Jdk文档中的一个示例就是使用了LockSupport的阻塞锁：

class FIFOMutex { 
       private final AtomicBoolean locked = new AtomicBoolean(false);
       private final Queue<Thread> waiters
         = new ConcurrentLinkedQueue<Thread>();
    
       public void lock() { 
         boolean wasInterrupted = false;
         Thread current = Thread.currentThread();
         waiters.add(current);
    
         // Block while not first in queue or cannot acquire lock
         while (waiters.peek() != current ||
                !locked.compareAndSet(false, true)) { 
            LockSupport.park(this);
            if (Thread.interrupted()) // ignore interrupts while waiting
              wasInterrupted = true;
         }
    
         waiters.remove();
         if (wasInterrupted)          // reassert interrupt status on exit
            current.interrupt();
       }
    
       public void unlock() { 
         locked.set(false);
         LockSupport.unpark(waiters.peek());
       }
     }

阻塞锁的优势在于，阻塞的线程不会占用cpu时间， 不会导致 cpu占用率过高，但进入时间以及恢复时间都要比自旋锁略慢，因为线程的状态需要切换。

###### `TIP`： ######

在竞争激烈的情况下 `阻塞锁`的性能要明显高于 `自旋锁`。  
所以在线程竞争不激烈的情况下，使用`自旋锁`，竞争激烈的情况下使用，`阻塞锁`。

--------------------

## 可重入锁 ##

可重入锁，也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。在JDK中 `ReentrantLock` 和`synchronized` 都是可重入锁。

两个使用示例：

public class Test implements Runnable{ 
     
        public synchronized void get(){ 
            System.out.println(Thread.currentThread().getId());
            set();
        }
     
        public synchronized void set(){ 
            System.out.println(Thread.currentThread().getId());
        }
     
        @Override
        public void run() { 
            get();
        }
        public static void main(String[] args) { 
            Test ss=new Test();
            new Thread(ss).start();
        }
    }

public class Test implements Runnable { 
        ReentrantLock lock = new ReentrantLock();
     
        public void get() { 
            lock.lock();
            System.out.println(Thread.currentThread().getId());
            set();
            lock.unlock();
        }
     
        public void set() { 
            lock.lock();
            System.out.println(Thread.currentThread().getId());
            lock.unlock();
        }
     
        @Override
        public void run() { 
            get();
        }
     
        public static void main(String[] args) { 
            Test ss = new Test();
            new Thread(ss).start();
        }
    }

上面两个示例都会打印出两次相同的结果。所以这样的锁叫可重入锁。可重入锁最大的作用是`避免死锁。`

如果我们以`上面示例的自旋锁`，在同一个线程内，两次调用`lock()`，会导致第二次调用`lock`位置进行自旋，产生了死锁。当`unlock`（）第一次调用时，就已经将所有锁都释放。`说明这个锁并不是可重入的。`

我们可以把上面的自旋锁，采用计数的方式改造成`可重入锁。`  
修改之后，如下：

public class SpinLock1 { 
        private AtomicReference<Thread> owner =new AtomicReference<>();
        private int count =0;
        public void lock(){ 
            Thread current = Thread.currentThread();
            if(current==owner.get()) { 
                count++;
                return ;
            }
     
            while(!owner.compareAndSet(null, current)){ 
    
            }
        }
        public void unlock (){ 
            Thread current = Thread.currentThread();
            if(current==owner.get()){ 
                if(count!=0){ 
                    count--;
                }else{ 
                    owner.compareAndSet(current, null);
                }
     
            }
     
        }
    }