Java 併發--- Lock
從Java 5以後，在java.util.concurrent.locks包下提供了另一種方式來實現同步訪問，那就是Lock。java
synchronized的缺陷
若是一個代碼塊被synchronized修飾了，當一個線程獲取了對應的鎖，並執行該代碼塊時，其餘線程便只能一直等待，等待獲取鎖的線程釋放鎖，而這裏獲取鎖的線程釋放鎖只會有兩種狀況：ide
- 獲取鎖的線程執行完了該代碼塊，而後線程釋放對鎖的佔有；
- 線程執行發生異常，此時JVM會讓線程自動釋放鎖。
那麼若是這個獲取鎖的線程因爲要等待IO或者其餘緣由（好比調用sleep方法）被阻塞了，可是又沒有釋放鎖，其餘線程便只能等待。this
所以就須要有一種機制能夠不讓等待的線程一直無期限地等待下去。線程
再舉個例子：當有多個線程讀寫文件時，讀操做和寫操做會發生衝突現象，寫操做和寫操做會發生衝突現象，可是讀操做和讀操做不會發生衝突現象。code
可是採用synchronized關鍵字來實現同步的話，就會致使一個問題：若是多個線程都只是進行讀操做，因此當一個線程在進行讀操做時，其餘線程只能等待沒法進行讀操做。排序
所以就須要一種機制來使得多個線程都只是進行讀操做時，線程之間不會發生衝突，經過Lock就能夠辦到。接口
另外，經過Lock能夠知道線程有沒有成功獲取到鎖。這個是synchronized沒法辦到的。進程
總結一下，也就是說Lock提供了比synchronized更多的功能。可是要注意如下幾點：資源
- Lock不是Java語言內置的，synchronized是Java語言的關鍵字，所以是內置特性。Lock是一個類，經過這個類能夠實現同步訪問；
- Lock和synchronized有一點很是大的不一樣，採用synchronized不須要用戶去手動釋放鎖，當synchronized方法或者synchronized代碼塊執行完以後，系統會自動讓線程釋放對鎖的佔用；而Lock則必需要用戶去手動釋放鎖，若是沒有主動釋放鎖，就有可能致使出現死鎖現象。
java.util.concurrent.locks包下經常使用的類
Lock
Lock是一個接口：get
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();
}
lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用來獲取鎖的。unLock()方法是用來釋放鎖的。
***
lock方法用來獲取鎖，若是鎖已被其餘線程獲取，則進行等待。
使用Lock必須在try{}catch{}塊中進行，而且將釋放鎖的操做放在finally塊中進行，以保證鎖必定被被釋放，防止死鎖的發生。一般使用Lock來進行同步的話，是如下面這種形式去使用的：
Lock lock = ...;
lock.lock();
try{
//處理任務
}catch(Exception ex){
}finally{
lock.unlock(); //釋放鎖
}
tryLock()方法是有返回值的，它表示用來嘗試獲取鎖，若是獲取成功，則返回true，若是獲取失敗（即鎖已被其餘線程獲取），則返回false，也就說這個方法不管如何都會當即返回。在拿不到鎖時不會一直在那等待。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是相似的，只不過區別在於這個方法在拿不到鎖時會等待必定的時間，在時間期限以內若是還拿不到鎖，就返回false。若是一開始拿到鎖或者在等待期間內拿到了鎖，則返回true。
通常狀況下經過tryLock來獲取鎖時是這樣使用的：
Lock lock = ...;
if(lock.tryLock()) {
try{
//處理任務
}catch(Exception ex){
}finally{
lock.unlock(); //釋放鎖
}
}else {
//若是不能獲取鎖，則直接作其餘事情
}
lockInterruptibly()方法比較特殊，當經過這個方法去獲取鎖時，若是線程正在等待獲取鎖，則這個線程可以響應中斷，即中斷線程的等待狀態。也就是說，當兩個線程同時經過lock.lockInterruptibly()想獲取某個鎖時，倘若此時線程A獲取到了鎖，而線程B只有在等待，那麼對線程B調用threadB.interrupt()方法可以中斷線程B的等待過程。
因爲lockInterruptibly()的聲明中拋出了異常，因此lock.lockInterruptibly()必須放在try塊中或者在調用lockInterruptibly()的方法外聲明拋出InterruptedException。
所以lockInterruptibly()通常的使用形式以下：
public void method() throws InterruptedException {
lock.lockInterruptibly();
try {
//.....
}
finally {
lock.unlock();
}
}
注意，當一個線程獲取了鎖以後，是不會被interrupt()方法中斷的。由於自己在前面的文章中講過單獨調用interrupt()方法不能中斷正在運行過程當中的線程，只能中斷阻塞過程當中的線程。
所以當經過lockInterruptibly()方法獲取某個鎖時，若是不能獲取到，只有進行等待的狀況下，是能夠響應中斷的。
而用synchronized修飾的話，當一個線程處於等待某個鎖的狀態，是沒法被中斷的，只有一直等待下去。
ReentrantLock
ReentrantLock，意思是「可重入鎖」，ReentrantLock是惟一實現了Lock接口的類，而且ReentrantLock提供了更多的方法。
示例1 lock()的正確使用方法
public class Test {
private ArrayList<Integer> arrayList = new ArrayList<Integer>();
public static void main(String[] args) {
final Test test = new Test();
new Thread(){
public void run() {
test.insert(Thread.currentThread());
};
}.start();
new Thread(){
public void run() {
test.insert(Thread.currentThread());
};
}.start();
}
public void insert(Thread thread) {
Lock lock = new ReentrantLock(); //注意這個地方
lock.lock();
try {
System.out.println(thread.getName()+"獲得了鎖");
for(int i=0;i<5;i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
}finally {
System.out.println(thread.getName()+"釋放了鎖");
lock.unlock();
}
}
}
輸出結果爲：
Thread-0獲得了鎖 Thread-1獲得了鎖 Thread-0釋放了鎖 Thread-1釋放了鎖
第二個線程怎麼會在第一個線程釋放鎖以前獲得了鎖？緣由在於，在insert方法中的lock變量是局部變量，每一個線程執行該方法時都會保存一個副本，那麼理所固然每一個線程執行到lock.lock()處獲取的是不一樣的鎖，因此就不會發生衝突。
因此，只須要將lock聲明爲類的屬性便可。
示例2 tryLock()的使用方法
public class Test {
private ArrayList<Integer> arrayList = new ArrayList<Integer>();
private Lock lock = new ReentrantLock(); //注意這個地方
public static void main(String[] args) {
final Test test = new Test();
new Thread(){
public void run() {
test.insert(Thread.currentThread());
};
}.start();
new Thread(){
public void run() {
test.insert(Thread.currentThread());
};
}.start();
}
public void insert(Thread thread) {
if(lock.tryLock()) {
try {
System.out.println(thread.getName()+"獲得了鎖");
for(int i=0;i<5;i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
}finally {
System.out.println(thread.getName()+"釋放了鎖");
lock.unlock();
}
} else {
System.out.println(thread.getName()+"獲取鎖失敗");
}
}
}
輸出結果爲：
Thread-0獲得了鎖 Thread-1獲取鎖失敗 Thread-0釋放了鎖
示例3 lockInterruptibly()響應中斷的使用方法
public class Test {
private Lock lock = new ReentrantLock();
public static void main(String[] args) {
Test test = new Test();
MyThread thread1 = new MyThread(test);
MyThread thread2 = new MyThread(test);
thread1.start();
thread2.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread2.interrupt();
}
public void insert(Thread thread) throws InterruptedException{
lock.lockInterruptibly(); //注意，若是須要正確中斷等待鎖的線程，必須將獲取鎖放在外面，而後將InterruptedException拋出
try {
System.out.println(thread.getName()+"獲得了鎖");
long startTime = System.currentTimeMillis();
for( ; ;) {
if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)
break;
//插入數據
}
}
finally {
System.out.println(Thread.currentThread().getName()+"執行finally");
lock.unlock();
System.out.println(thread.getName()+"釋放了鎖");
}
}
}
class MyThread extends Thread {
private Test test = null;
public MyThread(Test test) {
this.test = test;
}
@Override
public void run() {
try {
test.insert(Thread.currentThread());
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName()+"被中斷");
}
}
}
運行以後，發現thread2可以被正確中斷。
ReadWriteLock
ReadWriteLock是一個接口，在它裏面只定義了兩個方法：
public interface ReadWriteLock {
Lock readLock();
Lock writeLock();
}
一個用來獲取讀鎖，一個用來獲取寫鎖。也就是說將文件的讀寫操做分開，分紅2個鎖來分配給線程，從而使得多個線程能夠同時進行讀操做。
ReentrantReadWriteLock
ReentrantReadWriteLock實現了ReadWriteLock接口，經過例子來看ReentrantReadWriteLock具體用法。
public class Test {
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
public static void main(String[] args) {
final Test test = new Test();
new Thread(){
public void run() {
test.get(Thread.currentThread());
};
}.start();
new Thread(){
public void run() {
test.get(Thread.currentThread());
};
}.start();
}
public void get(Thread thread) {
rwl.readLock().lock();
try {
long start = System.currentTimeMillis();
while(System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName()+"正在進行讀操做");
}
System.out.println(thread.getName()+"讀操做完畢");
} finally {
rwl.readLock().unlock();
}
}
}
輸出結果顯示thread1和thread2在同時進行讀操做。而若是get方法改爲synchronized，輸出結果爲：thread1先執行完讀操做，而後thread2再執行讀操做。
public synchronized void get(Thread thread) {
long start = System.currentTimeMillis();
while(System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName()+"正在進行讀操做");
}
System.out.println(thread.getName()+"讀操做完畢");
}
不過要注意的是，若是有一個線程已經佔用了讀鎖，此時其餘線程若是要申請寫鎖，則申請寫鎖的線程會一直等待釋放讀鎖。若是有一個線程已經佔用了寫鎖，則此時其餘線程若是申請寫鎖或者讀鎖，則申請的線程會一直等待釋放寫鎖。
Lock和synchronized的選擇
Lock和synchronized有如下幾點不一樣：
- Lock是一個接口，而synchronized是Java中的關鍵字，synchronized是內置的語言實現；
- synchronized在發生異常時，會自動釋放線程佔有的鎖，所以不會致使死鎖現象發生；而Lock在發生異常時，若是沒有主動經過unLock()去釋放鎖，則極可能形成死鎖現象，所以使用Lock時須要在finally塊中釋放鎖；
- Lock可讓等待鎖的線程響應中斷，而synchronized卻不行，使用synchronized時，等待的線程會一直等待下去，不可以響應中斷；
- 經過Lock能夠知道有沒有成功獲取鎖，而synchronized卻沒法辦到。
- Lock能夠提升多個線程進行讀操做的效率。
鎖的相關概念
可重入鎖
synchronized和ReentrantLock都是可重入鎖。當一個線程執行到某個synchronized方法時，好比說method1，而在method1中會調用另一個synchronized方法method2，此時線程沒必要從新去申請鎖，而是能夠直接執行方法method2。可重入鎖最大的做用是避免死鎖。
可中斷鎖
就是能夠相應中斷的鎖。在Java中，synchronized就不是可中斷鎖，而Lock是可中斷鎖。
若是某一線程A正在執行鎖中的代碼，另外一線程B正在等待獲取該鎖，可能因爲等待時間過長，線程B不想等待了，想先處理其餘事情，咱們可讓它中斷本身或者在別的線程中中斷它，這種就是可中斷鎖。
lockInterruptibly()的用法體現了Lock的可中斷性。
公平鎖
公平鎖即儘可能以請求鎖的順序來獲取鎖。好比同是有多個線程在等待一個鎖，當這個鎖被釋放時，等待時間最久的線程（最早請求的線程）會得到該鎖，這種就是公平鎖。
非公平鎖即沒法保證鎖的獲取是按照請求鎖的順序進行的。這樣就可能致使某個或者一些線程永遠獲取不到鎖。
公平鎖的好處是等待鎖的線程不會餓死，可是總體效率相對低一些；非公平鎖的好處是總體效率相對高一些，可是有些線程可能會餓死或者說很早就在等待鎖，但要等好久纔會得到鎖。
在Java中，synchronized就是非公平鎖，它沒法保證等待的線程獲取鎖的順序。而對於ReentrantLock和ReentrantReadWriteLock，它默認狀況下是非公平鎖，可是能夠設置爲公平鎖。
公平鎖可使用new ReentrantLock(true)實現。
讀寫鎖
讀寫鎖將對一個資源（好比文件）的訪問分紅了2個鎖，一個讀鎖和一個寫鎖。正由於有了讀寫鎖，才使得多個線程之間的讀操做不會發生衝突。
ReadWriteLock就是讀寫鎖，它是一個接口，ReentrantReadWriteLock實現了這個接口。能夠經過readLock()獲取讀鎖，經過writeLock()獲取寫鎖。
死鎖
死鎖是指兩個或兩個以上的進程在執行過程當中，因爭奪資源而形成的一種互相等待的現象，若無外力做用，他們都將沒法推動下去。這是一個嚴重的問題，由於死鎖會讓你的程序掛起沒法完成任務，死鎖的發生必須知足如下4個條件：
- 互斥條件：一個資源每次只能被一個進程使用。
- 請求與保持條件：一個進程因請求資源而阻塞時，對已得到的資源保持不放。
- 不剝奪條件：進程已得到的資源，在未使用完以前，不能強行剝奪。
- 循環等待條件：若干進程之間造成一種頭尾相接的循環等待資源關係。
避免死鎖最簡單的方法就是阻止循環等待條件，將系統中全部的資源設置標誌位、排序，規定全部的進程申請資源必須以必定的順序作操做來避免死鎖。
- 1. java併發 —— Lock
- 2. java併發——Lock
- 3. Java併發（二）——Lock
- 4. Java併發編程：Lock
- 5. 【轉】Java併發編程：Lock
- 6. java併發包中的Lock
- 7. Java併發之Condition與Lock
- 8. 5、Java併發編程：Lock
- 9. java併發鎖之Lock
- 10. Java併發處理鎖 Lock
- 更多相關文章...
- • Rust 併發編程 - RUST 教程
- • SQLite - Java - SQLite教程
- • 算法總結-歸併排序
- • PHP開發工具
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. No provider available from registry 127.0.0.1:2181 for service com.ddbuy.ser 解決方法
- 2. Qt5.7以上調用虛擬鍵盤(支持中文)，以及源碼修改(可拖動，水平縮放)
- 3. 軟件測試面試- 購物車功能測試用例設計
- 4. ElasticSearch（概念篇）：你知道的, 爲了搜索…
- 5. redux理解
- 6. gitee創建第一個項目
- 7. 支持向量機之硬間隔（一步步推導，通俗易懂）
- 8. Mysql 異步複製延遲的原因及解決方案
- 9. 如何在運行SEPM配置嚮導時將不可認的複雜數據庫密碼改爲簡單密碼
- 10. windows系統下tftp服務器使用
- 1. java併發 —— Lock
- 2. java併發——Lock
- 3. Java併發（二）——Lock
- 4. Java併發編程：Lock
- 5. 【轉】Java併發編程：Lock
- 6. java併發包中的Lock
- 7. Java併發之Condition與Lock
- 8. 5、Java併發編程：Lock
- 9. java併發鎖之Lock
- 10. Java併發處理鎖 Lock