這篇文章將為大家詳細講解有關(guān)怎么深入理解Java中的鎖，文章內(nèi)容質(zhì)量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關(guān)知識有一定的了解。
曲麻萊網(wǎng)站制作公司哪家好，找成都創(chuàng)新互聯(lián)！從網(wǎng)頁設(shè)計、網(wǎng)站建設(shè)、微信開發(fā)、APP開發(fā)、成都響應(yīng)式網(wǎng)站建設(shè)公司等網(wǎng)站項目制作，到程序開發(fā)，運營維護。成都創(chuàng)新互聯(lián)于2013年開始到現(xiàn)在10年的時間，我們擁有了豐富的建站經(jīng)驗和運維經(jīng)驗，來保證我們的工作的順利進行。專注于網(wǎng)站建設(shè)就選成都創(chuàng)新互聯(lián)。
代碼示例：
重慶分公司
重慶分公司
public class GetLockDemo {
// 公平鎖 // static Lock lock =new ReentrantLock(true);
// 非公平鎖 static Lock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
// 主線程 拿到鎖 lock.lock();
Thread thread =
new Thread(
() -> {
// 子線程 獲取鎖（不死不休） System.out.println("begain to get lock...");
lock.lock();
System.out.println("succeed to get lock...");
// // 子線程 獲取鎖(淺嘗輒止)
// boolean result = lock.tryLock();
// System.out.println("是否獲得到鎖：" + result);
//
// // 子線程 獲取鎖(過時不候)
// try {
// boolean result1 = lock.tryLock(5, TimeUnit.SECONDS);
// System.out.println("是否獲得到鎖：" + result1);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
//
// // 子線程 獲取鎖（任人擺布） // try {
// System.out.println("start to get lock Interruptibly");
// lock.lockInterruptibly();
// } catch (InterruptedException e) {
// e.printStackTrace();
// System.out.println("dad asked me to stop...");
// }
});
thread.start();
Thread.sleep(10000L);
lock.unlock();
}
}結(jié)論：
lock() 最常用
lockInterruptibly() 方法一般更昂貴，有的實現(xiàn)類可能沒有實現(xiàn) lockInterruptible() 方法。
只有真的需要用中斷時，才使用，使用前應(yīng)看清實現(xiàn)類對該方法的描述。
condition代碼示例：
public class ConditionDemo {
static Lock lock = new ReentrantLock();
static Condition condition = lock.newCondition();
public static void main(String[] args) throws InterruptedException {
Thread thread =
new Thread(
() -> {
lock.lock();
System.out.println("condition.await()");
try {
condition.await();
System.out.println("here i am...");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
});
thread.start();
Thread.sleep(2000L);
lock.lock();
condition.signalAll();
lock.unlock();
}
}ReentrantLock是可重入鎖，同一線程可以多次獲取到鎖
ReentrantLock需要一個owner用來標記那個線程獲取到了鎖，一個count用來記錄加鎖的次數(shù)和一個waiters等待隊列用來存放沒有搶到鎖的線程列表
當(dāng)有線程進來時，會先判斷count的值，如果count為0說明鎖沒有被占用
然后通過CAS操作進行搶鎖
如果搶到鎖則count的值會加1，同時將owner設(shè)置為當(dāng)前線程的引用
如果count不為0同時owner指向當(dāng)前線程的引用，則將count的值加1
如果count不為0同時owner指向的不是當(dāng)前線程的引用，則將線程放入等待隊列waiters中
如果CAS搶鎖失敗，則將線程放入等待隊列waiters中
當(dāng)線程使用完鎖后，會釋放其持有的鎖，釋放鎖時會將count的值減1，如果count值為0則將owner設(shè)為null
如果count值不為0則會喚醒等待隊列頭部的線程進行搶鎖
手動實現(xiàn)ReentrantLock代碼示例：
public class MyReentrantLock implements Lock {
// 標記重入次數(shù)的count值 private AtomicInteger count = new AtomicInteger(0);
// 鎖的擁有者 private AtomicReference owner = new AtomicReference<>();
// 等待隊列 private LinkedBlockingDeque waiters = new LinkedBlockingDeque<>();
@Override
public boolean tryLock() {
// 判斷count是否為0，若count！=0，說明鎖被占用 int ct = count.get();
if (ct != 0) {
// 判斷鎖是否被當(dāng)前線程占用，若被當(dāng)前線程占用，做重入操作，count+=1
if (owner.get() == Thread.currentThread()) {
count.set(ct + 1);
return true;
} else {
// 若不是當(dāng)前線程占用，互斥，搶鎖失敗，return false
return false;
}
} else {
// 若count=0， 說明鎖未被占用，通過CAS（0，1） 來搶鎖 if (count.compareAndSet(ct, ct + 1)) {
// 若搶鎖成功，設(shè)置owner為當(dāng)前線程的引用 owner.set(Thread.currentThread());
return true;
} else {
return false;
}
}
}
@Override
public void lock() {
// 嘗試搶鎖 if (!tryLock()) {
// 如果失敗，進入等待隊列 waiters.offer(Thread.currentThread());
// 自旋 for (; ; ) {
// 判斷是否是隊列頭部，如果是 Thread head = waiters.peek();
if (head == Thread.currentThread()) {
// 再次嘗試搶鎖 if (!tryLock()) {
// 若搶鎖失敗，掛起線程，繼續(xù)等待 LockSupport.park();
} else {
// 若成功，就出隊列 waiters.poll();
return;
}
} else {
// 如果不是隊列頭部，就掛起線程 LockSupport.park();
}
}
}
}
public boolean tryUnlock() {
// 判斷，是否是當(dāng)前線程占有鎖，若不是，拋異常 if (owner.get() != Thread.currentThread()) {
throw new IllegalMonitorStateException();
} else {
// 如果是，就將count-1 若count變?yōu)? ，則解鎖成功 int ct = count.get();
int nextc = ct - 1;
count.set(nextc);
// 判斷count值是否為0
if (nextc == 0) {
owner.compareAndSet(Thread.currentThread(), null);
return true;
} else {
return false;
}
}
}
@Override
public void unlock() {
// 嘗試釋放鎖 if (tryUnlock()) {
// 獲取隊列頭部， 如果不為null則將其喚醒 Thread thread = waiters.peek();
if (thread != null) {
LockSupport.unpark(thread);
}
}
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public void lockInterruptibly() throws InterruptedException {}
@Override
public Condition newCondition() {
return null;
}
} synchronized：
優(yōu)點：
使用簡單，語義清晰，哪里需要點哪里
由JVM提供，提供了多種優(yōu)化方案（鎖粗化，鎖消除，偏向鎖，輕量級鎖）
鎖的釋放由虛擬機完成，不用人工干預(yù)，降低了死鎖的可能性
缺點：
悲觀的排他鎖，無法實現(xiàn)鎖的高級功能如公平鎖，讀寫鎖等
Lock：
優(yōu)點：可以實現(xiàn)synchronized無法實現(xiàn)的鎖的高級功能如公平鎖，讀寫鎖等，同時還可以實現(xiàn)更多的功能
缺點：需手動釋放鎖unlock，使用不當(dāng)容易造成死鎖
結(jié)論: 兩者都是可重入鎖，synchronized可以類比為傻瓜相機，提供了固定的功能，而Lock可以類比為單方，可以根據(jù)需要調(diào)節(jié)所需的功能
關(guān)于怎么深入理解Java中的鎖就分享到這里了，希望以上內(nèi)容可以對大家有一定的幫助，可以學(xué)到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。
