JAVA中的鎖機制

JUC ReentrantLock 默認內部使用的鎖即是 CLH鎖（有很多改進的地方，將自旋鎖換成了阻塞鎖等等）。

三、阻塞鎖：

阻塞鎖，與自旋鎖不同，改變了線程的運行狀態。在JAVA環境中，線程Thread有如下幾個狀態：

阻塞鎖，可以說是讓線程進入阻塞狀態進行等待，當獲得相應的信號（喚醒，時間）時，才可以進入線程的準備就緒狀態，準備就緒狀態的所有線程，通過競爭，進入運行狀態。JAVA中，能夠進入/退出、阻塞狀態或包含阻塞鎖的方法有，synchronized 關鍵字（其中的重量鎖），ReentrantLock，Object.wait()/notify(),LockSupport.park()/unpart()(j.u.c經常使用)

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;import java.util.concurrent.locks.LockSupport;public class CLHLock1 { public static class CLHNode { private volatile Thread isLocked; } @SuppressWarnings("unused") private volatile CLHNode tail; private static final ThreadLocal<CLHNode> LOCAL = new ThreadLocal<CLHNode>(); private static final AtomicReferenceFieldUpdater<CLHLock1, CLHNode> UPDATER = AtomicReferenceFieldUpdater.newUpdater(CLHLock1.class,CLHNode.class, "tail"); public void lock() { CLHNode node = new CLHNode(); LOCAL.set(node); CLHNode preNode = UPDATER.getAndSet(this, node); if (preNode != null) { preNode.isLocked = Thread.currentThread(); LockSupport.park(this); preNode = null; LOCAL.set(node); } } public void unlock() { CLHNode node = LOCAL.get(); if (!UPDATER.compareAndSet(this, node, null)) { System.out.println("unlock/t" + node.isLocked.getName()); LockSupport.unpark(node.isLocked); } node = null; }}

在這里我們使用了LockSupport.unpark()的阻塞鎖。該例子是將CLH鎖修改而成。

阻塞鎖的優勢在于，阻塞的線程不會占用cpu時間，不會導致 CPu占用率過高，但進入時間以及恢復時間都要比自旋鎖略慢。

在競爭激烈的情況下阻塞鎖的性能要明顯高于自旋鎖。

理想的情況則是; 在線程競爭不激烈的情況下，使用自旋鎖，競爭激烈的情況下使用，阻塞鎖。

四、可重入鎖：

本文里面講的是廣義上的可重入鎖，而不是單指JAVA下的ReentrantLock。

可重入鎖，也叫做遞歸鎖，指的是同一線程外層函數獲得鎖之后，內層遞歸函數仍然有獲取該鎖的代碼，但不受影響。在JAVA環境下 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();    }}
 
兩個例子最后的結果都是正確的，即 同一個線程id被連續輸出兩次。結果如下：Threadid: 8Threadid: 8Threadid: 10Threadid: 10Threadid: 9Threadid: 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、若有同一線程兩調用lock() ，會導致第二次調用lock位置進行自旋，產生了死鎖說明這個鎖并不是可重入的。（在lock函數內，應驗證線程是否為已經獲得鎖的線程）2、若1問題已經解決，當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);		}	}}
該自旋鎖即為可重入鎖。

JAVA中的鎖機制

1、自旋鎖

2.自旋鎖的其他種類

三、阻塞鎖：

四、可重入鎖：

JAVA中的鎖機制

1、自旋鎖

2.自旋鎖的其他種類

三、阻塞鎖：

四、可重入鎖：

1、自旋鎖

三、阻塞鎖：

四、可重入鎖：