Java中的Lock與synchronized

時間  2019-11-24
標籤 java lock synchronized 欄目 Java 简体版
原文   原文鏈接

併發編程學習筆記之Lock與synchronizedjava

1、什麼是可重入鎖面試

Lcok在Java中是一個接口，通常在面試問題中問到的多是ReentrantLock與synchronized的區別。ReentrantLock是Lock的一個實現類，字面意思的話就是可重入鎖，那麼什麼是可重入鎖呢。編程

可重入鎖是鎖的一個相關概念，並非特指咱們的ReentrantLock，而是若是一個鎖具有可重入性，那咱們就說這是一個可重入鎖。ReentrantLock和synchronized都是可重入鎖。至於什麼是可重入性，這裏舉個簡單的例子，如今在一個類裏咱們有兩個方法（代碼以下），一個叫作去北京，一個叫作買票，那咱們在去北京的方法裏能夠直接調用買票方法，假如兩個方法全都用synchronized修飾的話，在執行去北京的方法，線程獲取了對象的鎖，接着執行買票方法，若是synchronized不具有可重入性，那麼線程已經有這個對象的鎖了，如今又來申請，就會致使線程永遠等待沒法獲取到鎖。而synchronized和ReentrantLock都是可重入鎖，就不會出現上述的問題。併發

 1 class Trip {
 2     public synchronized void goToBeiJing() {
 3         // 去北京  
 4         buyATicket();
 5     }
 6      
 7     public synchronized void buyATicket() {
 8         // 買票
 9     }
10 }

2、Lock與synchronized的不一樣jvm

兩者都是可重入鎖，那麼爲何要有兩個呢？既然存在，那麼就必定是有意義的。synchronized是Java中的一個關鍵字，而Lock是Java1.5後在java.util.concurrent.locks包下提供的一種實現同步的方法，那麼顯然的，synchronized必定是有什麼作不到的或者缺陷，才致使了Lock的誕生。性能

1.synchronized的缺點學習

1）當一個代碼塊被synchronized修飾的時候，一個線程獲取到了鎖，而且執行代碼塊，那麼其餘的線程須要等待正在使用的線程釋放掉這個鎖，那麼釋放鎖的方法只有兩種，一種是代碼執行完畢自動釋放，一種是發生異常之後jvm會讓線程去釋放鎖。那麼若是這個正在執行的線程遇到什麼問題，好比等待IO或者調用sleep方法等等被阻塞了，沒法釋放鎖，而這時候其餘線程只能一直等待，將會特別影響效率。那麼有沒有一種辦法讓其餘線程沒必要一直傻乎乎的等在這裏嗎？spa

2）當一個文件，同時被多個線程操做時，讀操做和寫操做會發生衝突，寫操做和寫操做會發生衝突，而讀操做和讀操做並不會衝突，可是若是咱們用synchronized的話，會致使一個線程在讀的時候，其餘線程想要讀的話只能等待，那麼有什麼辦法能不鎖讀操做嗎？線程

3）在使用synchronized時，咱們沒法得知線程是否成功獲取到鎖，那麼有什麼辦法能知道是否獲取到鎖嗎？code

2.java.util.concurrent.locks包

1）Lock

Lock是一個接口，源碼以下

1 public interface Lock {
2     void lock();
3     void lockInterruptibly() throws InterruptedException;
4     boolean tryLock();
5     boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
6     void unlock();
7     Condition newCondition();
8 }

ReentrantLock是Lock的一個實現類（另外兩個實現類是ReentrantReadWriteLock類下的兩個靜態內部類：WriteLock和ReadLock），它的意思是可重入鎖，可重入鎖前面已經講過了。ReentrantLock中提供了更多的一些方法。不過經常使用的就是Lock中的這些。

來看一下Lock接口這些方法的使用，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用來獲取鎖的。unLock()方法是用來釋放鎖的。

這裏有四個方法來獲取鎖，那麼區別在哪裏呢？

lock()使咱們平時用的最多的，最用是用來獲取鎖，若是鎖已經被其餘線程獲取，那麼就等待。可是採用Lock必需要主動釋放鎖，因此咱們通常在try{}catch{}塊中處理而後在finally中釋放鎖，舉個例子：

1 lock.lock();
2 try{
3     // 處理
4 }catch(Exception ex){
5     // 捕獲異常
6 }finally{
7     // 釋放鎖
8     lock.unlock();   
9 }

 tryLock()是一個boolean類型的方法，當調用這個方法的時候，線程會去嘗試獲取鎖，若是獲取到的話會返回true，若是獲取不到返回false，也就是說這個方法會立馬返回一個結果，線程不會等待。

tryLock(long time, TimeUnit unit)是上面tryLock()方法的一個重載方法，加了兩個參數，給定了等待的時間，若是在規定時間拿到鎖返回true，若是拿不到返回false。這兩個方法的通常用法和Lock相似。

 1 if (lock.tryLock()) {
 2     try{
 3         // 處理    
 4     }catch(Exception ex){
 5         // 捕獲異常
 6     }finally{
 7         // 釋放鎖
 8         lock.unlock();   
 9     }
10 }

lockInterruptibly()就比較特殊了，它表示可被中斷的，意思就是，當嘗試獲取鎖的時候，若是獲取不到的話就會等待，可是，在等待的過程當中它是能夠響應中斷的，也就是中斷線程的等待過程。使用形式的話同樣用try catch處理，就不貼代碼了。

2）ReadWriteLock

ReadWriteLock也是一個接口，這個接口中只有兩個方法，源碼以下：

1 public interface ReadWriteLock {
2     Lock readLock();
3  
4     Lock writeLock();
5 }

這個接口的從字面就能看出來他的用途，讀鎖和寫鎖，這時候是否是想起了前面我寫到的synchronized的第二條。

ReentrantReadWriteLock是ReadWriteLock的一個實現類，最經常使用到的也是獲取讀鎖和獲取寫鎖。下面看例子：

首先是使用synchronized的：

 1 public class Main {  
 2     public static void main(String[] args)  {
 3         final Main m = new Main();
 4        
 5         new Thread(){
 6             public void run() {
 7                 m.read(Thread.currentThread());
 8             };
 9         }.start();
10          
11         new Thread(){
12             public void run() {
13                 m.read(Thread.currentThread());
14             };
15         }.start(); 
16     }  
17      
18     public synchronized void read(Thread thread) {
19         long startTime = System.currentTimeMillis();
20         while(System.currentTimeMillis() - startTime <= 1) {
21             System.out.println(thread.getName()+"線程在進行讀操做");
22         }
23         System.out.println(thread.getName()+"線程完成讀操做");
24     }
25 }

這段代碼的執行結果是在一個線程打印出完成讀操做後，另外一條線程纔會開始進行讀操做。

Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程完成讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程完成讀操做

 

下面看若是用ReadWriteLock：

 1 public class Main {  
 2     public static void main(String[] args)  {
 3         private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
 4         final Main m = new Main();
 5        
 6         new Thread(){
 7             public void run() {
 8                 m.read(Thread.currentThread());
 9             };
10         }.start();
11          
12         new Thread(){
13             public void run() {
14                 m.read(Thread.currentThread());
15             };
16         }.start(); 
17     }  
18      
19     public void read(Thread thread) {
20         readWriteLock.readLock().lock();
21         try {
22         long startTime = System.currentTimeMillis();
23             while(System.currentTimeMillis() - startTime <= 1) {
24                 System.out.println(thread.getName()+"線程在進行讀操做");
25             }
26             System.out.println(thread.getName()+"線程完成讀操做");
27     } finally {
28         readWriteLock.unlock();
29         }
30     }
31 }

只是把以前的synchronized換成了ReadWriteLock，可是輸出結果倒是兩個線程在一塊兒進行讀操做

Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程在進行讀操做
Thread-1線程在進行讀操做
Thread-0線程完成讀操做
Thread-1線程完成讀操做

這個結果能夠看到兩個線程同時進行讀操做，效率大大的提高了。可是要注意的是，若是一個線程獲取了讀鎖，那麼另外的線程想要獲取寫鎖則須要等待釋放；而若是一個線程已經獲取了寫鎖，則另外的線程想獲取讀鎖或寫鎖都須要等待寫鎖被釋放。

3、總結

總結一下兩者：

1.synchronized是Java的關鍵字，是內置特性，而Lock是一個接口，能夠用它來實現同步。

2.synchronized同步的時候，其中一條線程用完會自動釋放鎖，而Lock須要手動釋放，若是不手動釋放，可能會形成死鎖。

3.使用synchronized若是其中一個線程不釋放鎖，那麼其餘須要獲取鎖的線程會一直等待下去，知道使用完釋放或者出現異常，而Lock可使用能夠響應中斷的鎖或者使用規定等待時間的鎖

4.synchronized沒法得知是否獲取到鎖，而Lcok能夠作到。

5.用ReadWriteLock能夠提升多個線程進行讀操做的效率。

因此綜上所述，在兩種鎖的選擇上，當線程對於資源的競爭不激烈的時候，效率差不太多，可是當大量線程同時競爭的時候，Lock的性能會遠高於synchronized。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程