Java中的鎖實(shí)現(xiàn)原理及優(yōu)缺點(diǎn)

本篇內(nèi)容介紹了“Java中的鎖實(shí)現(xiàn)原理及優(yōu)缺點(diǎn)”的有關(guān)知識(shí)，在實(shí)際案例的操作過(guò)程中，不少人都會(huì)遇到這樣的困境，接下來(lái)就讓小編帶領(lǐng)大家學(xué)習(xí)一下如何處理這些情況吧！希望大家仔細(xì)閱讀，能夠?qū)W有所成！

創(chuàng)新互聯(lián)是一家專(zhuān)業(yè)提供鄞州企業(yè)網(wǎng)站建設(shè),專(zhuān)注與成都網(wǎng)站制作、成都做網(wǎng)站、H5建站、小程序制作等業(yè)務(wù)。10年已為鄞州眾多企業(yè)、政府機(jī)構(gòu)等服務(wù)。創(chuàng)新互聯(lián)專(zhuān)業(yè)網(wǎng)站設(shè)計(jì)公司優(yōu)惠進(jìn)行中。

locks包結(jié)構(gòu)層次

Lock 接口

方法簽名	描述
void lock();	獲取鎖（不死不休）
boolean tryLock();	獲取鎖（淺嘗輒止）
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;	獲取鎖（過(guò)時(shí)不候）
void lockInterruptibly() throws InterruptedException;	獲取鎖（任人擺布）
void unlock();	釋放鎖
Condition newCondition();

代碼示例：

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);
              //
              //              // 子線程 獲取鎖(過(guò)時(shí)不候)
              //              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() 方法一般更昂貴，有的實(shí)現(xiàn)類(lèi)可能沒(méi)有實(shí)現(xiàn) lockInterruptible() 方法。只有真的需要用中斷時(shí)，才使用，使用前應(yīng)看清實(shí)現(xiàn)類(lèi)對(duì)該方法的描述。

Condition

Object中的wait(), notify(), notifyAll()方法是和synchronized配合使用的可以喚醒一個(gè)或者多個(gè)線程。Condition是需要與Lock配合使用的，提供多個(gè)等待集合和更精確的控制（底層是park/unpark機(jī)制）； | 協(xié)作方式 | 死鎖方式1 （鎖） | 死鎖方式2（先喚醒，再掛起）| 備注 | | ---- | ---- | ---- |---- | | suspend/resume | 死鎖 | 死鎖 | 棄用 | | wait/notify | 不死鎖 | 死鎖 | 只用于synchronized關(guān)鍵字 | | park/unpark | 死鎖 | 不死鎖 | | | condition | 不死鎖 | 死鎖 | |

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

ReetrantLock

ReentrantLock是可重入鎖，同一線程可以多次獲取到鎖 Java中的鎖實(shí)現(xiàn)原理及優(yōu)缺點(diǎn)

ReentrantLock實(shí)現(xiàn)原理分析

ReentrantLock需要一個(gè)owner用來(lái)標(biāo)記那個(gè)線程獲取到了鎖，一個(gè)count用來(lái)記錄加鎖的次數(shù)和一個(gè)waiters等待隊(duì)列用來(lái)存放沒(méi)有搶到鎖的線程列表
當(dāng)有線程進(jìn)來(lái)時(shí)，會(huì)先判斷count的值，如果count為0說(shuō)明鎖沒(méi)有被占用
然后通過(guò)CAS操作進(jìn)行搶鎖
如果搶到鎖則count的值會(huì)加1，同時(shí)將owner設(shè)置為當(dāng)前線程的引用
如果count不為0同時(shí)owner指向當(dāng)前線程的引用，則將count的值加1
如果count不為0同時(shí)owner指向的不是當(dāng)前線程的引用，則將線程放入等待隊(duì)列waiters中
如果CAS搶鎖失敗，則將線程放入等待隊(duì)列waiters中
當(dāng)線程使用完鎖后，會(huì)釋放其持有的鎖，釋放鎖時(shí)會(huì)將count的值減1，如果count值為0則將owner設(shè)為null
如果count值不為0則會(huì)喚醒等待隊(duì)列頭部的線程進(jìn)行搶鎖

手動(dòng)實(shí)現(xiàn)ReentrantLock代碼示例：

public class MyReentrantLock implements Lock {

  // 標(biāo)記重入次數(shù)的count值
  private AtomicInteger count = new AtomicInteger(0);

  // 鎖的擁有者
  private AtomicReference<Thread> owner = new AtomicReference<>();

  // 等待隊(duì)列
  private LinkedBlockingDeque<Thread> waiters = new LinkedBlockingDeque<>();

  @Override
  public boolean tryLock() {
    // 判斷count是否為0，若count！=0，說(shuō)明鎖被占用
    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， 說(shuō)明鎖未被占用，通過(guò)CAS（0，1） 來(lái)?yè)屾i
      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()) {
      // 如果失敗，進(jìn)入等待隊(duì)列
      waiters.offer(Thread.currentThread());

      // 自旋
      for (; ; ) {
        // 判斷是否是隊(duì)列頭部，如果是
        Thread head = waiters.peek();
        if (head == Thread.currentThread()) {
          // 再次嘗試搶鎖
          if (!tryLock()) {
            // 若搶鎖失敗，掛起線程，繼續(xù)等待
            LockSupport.park();
          } else {
            // 若成功，就出隊(duì)列
            waiters.poll();
            return;
          }
        } else {
          // 如果不是隊(duì)列頭部，就掛起線程
          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()) {
      // 獲取隊(duì)列頭部， 如果不為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 VS Lock

synchronized：優(yōu)點(diǎn)：

使用簡(jiǎn)單，語(yǔ)義清晰，哪里需要點(diǎn)哪里
由JVM提供，提供了多種優(yōu)化方案（鎖粗化，鎖消除，偏向鎖，輕量級(jí)鎖）
鎖的釋放由虛擬機(jī)完成，不用人工干預(yù)，降低了死鎖的可能性

缺點(diǎn)：悲觀的排他鎖，無(wú)法實(shí)現(xiàn)鎖的高級(jí)功能如公平鎖，讀寫(xiě)鎖等

Lock：優(yōu)點(diǎn)：可以實(shí)現(xiàn)synchronized無(wú)法實(shí)現(xiàn)的鎖的高級(jí)功能如公平鎖，讀寫(xiě)鎖等，同時(shí)還可以實(shí)現(xiàn)更多的功能　

缺點(diǎn)：需手動(dòng)釋放鎖unlock，使用不當(dāng)容易造成死鎖

結(jié)論: 兩者都是可重入鎖，synchronized可以類(lèi)比為傻瓜相機(jī)，提供了固定的功能，而Lock可以類(lèi)比為單方，可以根據(jù)需要調(diào)節(jié)所需的功能

“Java中的鎖實(shí)現(xiàn)原理及優(yōu)缺點(diǎn)”的內(nèi)容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業(yè)相關(guān)的知識(shí)可以關(guān)注創(chuàng)新互聯(lián)網(wǎng)站，小編將為大家輸出更多高質(zhì)量的實(shí)用文章！

網(wǎng)頁(yè)名稱：Java中的鎖實(shí)現(xiàn)原理及優(yōu)缺點(diǎn)
文章位置：http://muchs.cn/article16/jpgddg.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供搜索引擎優(yōu)化、定制開(kāi)發(fā)、微信公眾號(hào)、Google、動(dòng)態(tài)網(wǎng)站、網(wǎng)站收錄

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請(qǐng)盡快告知，我們將會(huì)在第一時(shí)間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如需處理請(qǐng)聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時(shí)需注明來(lái)源：創(chuàng)新互聯(lián)

猜你還喜歡下面的內(nèi)容