鎖作為并發(fā)共享數(shù)據(jù)，保證一致性的工具，在JAVA平臺有多種實現(xiàn)(如 synchronized 和 ReentrantLock等等 ) 。這些已經(jīng)寫好提供的鎖為我們開發(fā)提供了便利，但是鎖的具體性質(zhì)以及類型卻很少被提及。本系列文章將分析JAVA下常見的鎖名稱以及特性，為大家答疑解惑。

1、自旋鎖
自旋鎖是采用讓當前線程不停地的在循環(huán)體內(nèi)執(zhí)行實現(xiàn)的，當循環(huán)的條件被其他線程改變時 才能進入臨界區(qū)。如下

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);
  }
}

使用了CAS原子操作，lock函數(shù)將owner設(shè)置為當前線程，并且預(yù)測原來的值為空。unlock函數(shù)將owner設(shè)置為null，并且預(yù)測值為當前線程。

當有第二個線程調(diào)用lock操作時由于owner值不為空，導(dǎo)致循環(huán)一直被執(zhí)行，直至第一個線程調(diào)用unlock函數(shù)將owner設(shè)置為null，第二個線程才能進入臨界區(qū)。

由于自旋鎖只是將當前線程不停地執(zhí)行循環(huán)體，不進行線程狀態(tài)的改變，所以響應(yīng)速度更快。但當線程數(shù)不停增加時，性能下降明顯，因為每個線程都需要執(zhí)行，占用CPU時間。如果線程競爭不激烈，并且保持鎖的時間段。適合使用自旋鎖。

注：該例子為非公平鎖，獲得鎖的先后順序，不會按照進入lock的先后順序進行。
可重入鎖，也叫做遞歸鎖，指的是同一線程 外層函數(shù)獲得鎖之后 ，內(nèi)層遞歸函數(shù)仍然有獲取該鎖的代碼，但不受影響。
在JAVA環(huán)境下 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();
        new Thread(ss).start();
        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();
        new Thread(ss).start();
        new Thread(ss).start();
    }
}

兩個例子最后的結(jié)果都是正確的，即 同一個線程id被連續(xù)輸出兩次。

結(jié)果如下：

Threadid: 8
Threadid: 8
Threadid: 10
Threadid: 10
Threadid: 9
Threadid: 9

可重入鎖最大的作用是避免死鎖
我們以自旋鎖作為例子，

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

對于自旋鎖來說，
1、若有同一線程兩調(diào)用lock() ，會導(dǎo)致第二次調(diào)用lock位置進行自旋，產(chǎn)生了死鎖
說明這個鎖并不是可重入的。（在lock函數(shù)內(nèi)，應(yīng)驗證線程是否為已經(jīng)獲得鎖的線程）
2、若1問題已經(jīng)解決，當unlock（）第一次調(diào)用時，就已經(jīng)將鎖釋放了。實際上不應(yīng)釋放鎖。
（采用計數(shù)次進行統(tǒng)計）
修改之后，如下：

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);
            }

        }

    }
}

該自旋鎖即為可重入鎖。