2. 程式人生 > >jdk鎖的使用

jdk鎖的使用

阿新 • • 發佈：2018-12-14 
ReentrantLock
public class JdkLockTest implements Runnable{

    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    private static int i = 0;

    public static void main(String[] args) {
        JdkLockTest jdkLockTest = new JdkLockTest();
        Thread t1 = new Thread(jdkLockTest);
        Thread t2 = new Thread(jdkLockTest);
        Thread t3 = new Thread(jdkLockTest);
        t1.start();
        t2.start();
        t3.start();
    }

    @Override
    public void run(){
        lock .lock();

        try {
            System.out.println("開始等待2s");
            condition.await(2, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("ThreadName=" + Thread.currentThread().getName());
        for(int j=0; j<1000000; j++){
            i++;
        }
        System.out.println("i = " + i);
        lock.unlock();
    }
}

ReentrantLock其他方法

  • getHoldCount() 查詢當前執行緒保持此鎖的次數，也就是執行此執行緒執行lock方法的次數
  • getQueueLength（）返回正等待獲取此鎖的執行緒估計數，比如啟動10個執行緒，1個執行緒獲得鎖，此時返回的是9
  • getWaitQueueLength（Condition condition）返回等待與此鎖相關的給定條件的執行緒估計數。比如10個執行緒，用同一個condition物件，並且此時這10個執行緒都執行了condition物件的await方法，那麼此時執行此方法返回10
  • hasWaiters(Condition condition)查詢是否有執行緒等待與此鎖有關的給定條件(condition)，對於指定contidion物件，有多少執行緒執行了condition.await方法
  • hasQueuedThread(Thread thread)查詢給定執行緒是否等待獲取此鎖
  • hasQueuedThreads()是否有執行緒等待此鎖
  • isFair()該鎖是否公平鎖
  • isHeldByCurrentThread() 當前執行緒是否保持鎖鎖定，執行緒的執行lock方法的前後分別是false和true
  • isLock()此鎖是否有任意執行緒佔用
  • lockInterruptibly（）如果當前執行緒未被中斷，獲取鎖
  • tryLock（）嘗試獲得鎖，僅在呼叫時鎖未被執行緒佔用，獲得鎖
  • tryLock(long timeout TimeUnit unit)如果鎖在給定等待時間內沒有被另一個執行緒保持，則獲取該鎖

 

 

Semaphore 
public class SemaphoreTest {

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for(int i=0; i<10; i++){
            executorService.execute(new Test(semaphore));
        }
        executorService.shutdown();
    }


}

class Test implements Runnable{

    private Semaphore semaphore;
    private int i=0;

    public Test(){}
    public Test(Semaphore semaphore){
        this.semaphore = semaphore;
    }

    @Override
    public void run() {
        try {
            semaphore.acquire();
            for(int j=0; j<1000000; j++){
                i++;
            }
            System.out.println("i = " + i);
            System.out.println("當前執行緒=====》"+ Thread.currentThread().getName());
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

其他方法，（摘自網路）

Semaphore的方法如下：

——Semaphore(permits)  初始化許可證數量的建構函式

——Semaphore(permits,fair)  初始化許可證數量和是否公平模式的建構函式

——isFair()  是否公平模式FIFO

——availablePermits()  獲取當前可用的許可證數量

——acquire()

當前執行緒嘗試去阻塞的獲取1個許可證。

此過程是阻塞的，它會一直等待許可證，直到發生以下任意一件事：

當前執行緒獲取了1個可用的許可證，則會停止等待，繼續執行。
當前執行緒被中斷，則會丟擲InterruptedException異常，並停止等待，繼續執行。
——acquire(permits)

當前執行緒嘗試去阻塞的獲取permits個許可證。

此過程是阻塞的，它會一直等待許可證，直到發生以下任意一件事：

當前執行緒獲取了n個可用的許可證，則會停止等待，繼續執行。
當前執行緒被中斷，則會丟擲InterruptedException異常，並停止等待，繼續執行。

——acquierUninterruptibly()

當前執行緒嘗試去阻塞的獲取1個許可證(不可中斷的)。

此過程是阻塞的，它會一直等待許可證，直到發生以下任意一件事：

當前執行緒獲取了1個可用的許可證，則會停止等待，繼續執行。
——acquireUninterruptibly(permits)

當前執行緒嘗試去阻塞的獲取permits個許可證。

此過程是阻塞的，它會一直等待許可證，直到發生以下任意一件事：

當前執行緒獲取了n個可用的許可證，則會停止等待，繼續執行。
——tryAcquire()

當前執行緒嘗試去獲取1個許可證。

此過程是非阻塞的，它只是在方法呼叫時進行一次嘗試。

如果當前執行緒獲取了1個可用的許可證，則會停止等待，繼續執行，並返回true。

如果當前執行緒沒有獲得這個許可證，也會停止等待，繼續執行，並返回false。

——tryAcquire(permits)

當前執行緒嘗試去獲取permits個許可證。

此過程是非阻塞的，它只是在方法呼叫時進行一次嘗試。

如果當前執行緒獲取了permits個可用的許可證，則會停止等待，繼續執行，並返回true。

如果當前執行緒沒有獲得permits個許可證，也會停止等待，繼續執行，並返回false。

——tryAcquire(timeout,TimeUnit)

當前執行緒在限定時間內，阻塞的嘗試去獲取1個許可證。

此過程是阻塞的，它會一直等待許可證，直到發生以下任意一件事：

當前執行緒獲取了可用的許可證，則會停止等待，繼續執行，並返回true。
當前執行緒等待時間timeout超時，則會停止等待，繼續執行，並返回false。
當前執行緒在timeout時間內被中斷，則會丟擲InterruptedException一次，並停止等待，繼續執行。
——tryAcquire(permits,timeout,TimeUnit)

當前執行緒在限定時間內，阻塞的嘗試去獲取permits個許可證。

此過程是阻塞的，它會一直等待許可證，直到發生以下任意一件事：

當前執行緒獲取了可用的permits個許可證，則會停止等待，繼續執行，並返回true。
當前執行緒等待時間timeout超時，則會停止等待，繼續執行，並返回false。
當前執行緒在timeout時間內被中斷，則會丟擲InterruptedException一次，並停止等待，繼續執行。
——release() 當前執行緒釋放1個可用的許可證。

——release(permits) 當前執行緒釋放permits個可用的許可證。

——drainPermits() 當前執行緒獲得剩餘的所有可用許可證。

——hasQueuedThreads() 判斷當前Semaphore物件上是否存在正在等待許可證的執行緒。

——getQueueLength() 獲取當前Semaphore物件上是正在等待許可證的執行緒數量。

 

ReadWriteLock   當寫操作時，其他執行緒無法讀取或寫入資料，而當讀操作時，其它執行緒無法寫入資料，但卻可以讀取資料 。

public class ReadWriteLockTest {

    public static void main(String[] args) {
        TestReadWrite testReadWrite = new TestReadWrite();

        for(int i=0; i<10; i++){
            new Thread(testReadWrite::read).start();
        }

        for(int j=0; j<10; j++) {
            new Thread(() -> testReadWrite.write("你好")).start();
        }
    }

}

class TestReadWrite{
    private String data;
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void read(){
        readWriteLock.readLock().lock();//執行緒只能讀，不能寫
        System.out.println(Thread.currentThread().getName() + "讀取資料========");
        try {
            Thread.sleep((long)(Math.random()*1000));
            System.out.println(Thread.currentThread().getName() + "讀取完資料 :" + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }

    public void write(String data){
        readWriteLock.writeLock().lock();//不允許其他執行緒讀寫操作
        System.out.println(Thread.currentThread().getName() + "寫資料========");
        try {
            Thread.sleep((long) (Math.random() * 1000));
            this.data = data;
            System.out.println(Thread.currentThread().getName() + "寫資料完成 ==" + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }

    }
}
CountDownLacth

某一執行緒在開始執行前等待n個執行緒執行完畢。將CountDownLatch的計數器初始化為n new CountDownLatch(n) ，每當一個任務執行緒執行完畢，就將計數器減1 countdownlatch.countDown()，當計數器的值變為0時，在CountDownLatch上 await() 的執行緒就會被喚醒。

public class CountDownLacthTest {

    public static void main(String[] args) {
        final CountDownLatch countDown = new CountDownLatch(2);

        Thread t1 = new Thread(() -> {
            System.out.println("執行緒t1開始執行-------------");
            try {
                System.out.println("執行緒t1等待其他執行緒-------------");
                countDown.await();
                System.out.println("執行緒t1繼續執行-------------");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1");

        Thread t2 = new Thread(() -> {
            try {
                System.out.println("執行緒t2開始執行-------------");
                Thread.sleep((long) (Math.random()*1000));
                System.out.println("執行緒t2執行完畢-------------");
                countDown.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2");

        Thread t3 = new Thread(() -> {
            try {
                System.out.println("執行緒t3開始執行-------------");
                Thread.sleep((long) (Math.random()*1000));
                System.out.println("執行緒t3執行完畢-------------");
                countDown.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t3");

        t1.start();
        t2.start();
        t3.start();

    }
}

CyclicBarrier   注意：當執行緒數和parties不一致的時候有可能發生阻塞問題！最後剩下的執行緒數不足parties，無法繼續執行下去

public class CyclicBarrierTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final CyclicBarrier cb = new CyclicBarrier(3);//當有3個執行緒到達時，共同執行
//final CyclicBarrier cb = new CyclicBarrier(3, () -> System.out.println("********我最先執行***********"));
        for (int i = 0; i < 3; i++) {
            Runnable runnable = () -> {
                try {
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("執行緒" + Thread.currentThread().getName() +
                            "即將到達集合地點1，當前已有" + cb.getNumberWaiting() + "個已經到達，正在等候");
                    cb.await();//到此如果沒有達到公共屏障點，則該執行緒處於等待狀態，如果達到公共屏障點則所有處於等待的執行緒都繼續往下執行

                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("執行緒" + Thread.currentThread().getName() +
                            "即將到達集合地點2，當前已有" + cb.getNumberWaiting() + "個已經到達，正在等候");
                    cb.await();
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("執行緒" + Thread.currentThread().getName() +
                            "即將到達集合地點3，當前已有" + cb.getNumberWaiting() + "個已經到達，正在等候");
                    cb.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            };
            service.execute(runnable);
        }
        service.shutdown();
    }
}

 

 

 

 

 

 

 

相關推薦

jdk鎖相關

鎖型別 可重入鎖：在執行物件中所有同步方法不用再次獲得鎖 可中斷鎖：在等待獲取鎖過程中可中斷 公平鎖： 按等待獲取鎖的執行緒的等待時間進行獲取，等待時間長的具有優先獲取鎖權利 讀寫鎖：對資源讀取和寫入的時候拆分為2部分處理，讀的時候可以多執行緒一起讀，寫的時候必須同步地寫

jdk鎖的使用

ReentrantLock public class JdkLockTest implements Runnable{ private ReentrantLock lock = new ReentrantLock(); private Condition condition

JDK鎖的基礎－－AQS實現原理（三）

本文主要來分析一下AQS共享模式鎖的獲取和釋放，AQS其實只是一個框架，它主要提供了一個int型別的state欄位，子類繼承時用於儲存子類的狀態，並且提供了一個等待佇列以及維護等待佇列的方法。至於如何使用這個狀態值和等待佇列，就需要子類根據自己的需求來實現了。

如何手寫JDK鎖

main toa http lean on() cep eth 結果 stack 手寫JDK鎖 需要三個步驟： 手寫一個類MyLock，實現Lock接口 重寫lock()方法 重寫unlock()方法 代碼： public class MyLock implements

死鎖排查的小竅門 --使用jdk自帶管理工具jstack

pre ble new deadlock 一段 指令 tro bject print 本文版權歸 遠方的風lyh和博客園共有，歡迎轉載，但須保留此段聲明，並給出原文鏈接，謝謝合作。 開發時間久了，難免會寫出一些一些死鎖的代碼，自己明明調用該方法可該方法就是不執行、不進該

【JDK源碼分析】通過源碼徹底理解ReentrantLock顯示鎖

線程封裝 rac syn next 之前 線程 vat 喚醒 current 前言ReentrantLock和synchronized一樣是一個可重入的互斥鎖，但ReentrantLock功能更強大，它提供了非公平和公平兩種鎖爭用策略供使用者選擇，而synchronized

zbb20180913 java thread JDK-Lock鎖

val nal 關鍵字 cell sign wait 接口 jdk 線程安全 JDK1.5-Lock 在 jdk1.5 之後，並發包中新增了 Lock 接口(以及相關實現類)用來實現鎖功能，Lock 接口提供了與 synchronized 關鍵字類似的同步功能，但需要在使用

JDK併發包--重入鎖

重入鎖基本使用：    使用java.util.concurrent.locks.ReentrantLock 類來實現，可以替代synchronized關鍵字。如下例，重入鎖有著顯示的操作過程，開發者可以手動指定在哪裡加鎖，在哪裡釋放（退出臨界區時必須釋放，不然其他執行緒沒有機會

CAS無鎖演算法：ReentrantLock，synchronized(JDK 1.6)，悲觀鎖/樂觀鎖

> 悲觀鎖/樂觀鎖  悲觀鎖：總是假設最壞的情況，每次去拿資料的時候都認為別人會修改，所以每次在拿資料的時候都會上鎖，這樣別人想拿這個資料就會阻塞直到它拿到鎖。傳統的關係型資料庫裡邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前先上鎖。再比如J

JDK的sql設計不合理導致的驅動類初始化死鎖問題

問題描述 當我們一個系統既需要mysql驅動，也需要oracle驅動的時候，在併發載入初始化這些驅動類的過程中產生死鎖的可能性非常大，下面是一個模擬的例子，對於Thread2的實現其實是jdk裡java.sql.DriverService的邏輯，也是我們第一次呼叫java.sql.Driver

jdk原始碼解析（十二）——執行緒安全與鎖優化

上一節我們說了Java記憶體模型與執行緒、那麼我們這節來了解一下執行緒安全與鎖優化 1 概述 在軟體業發展的初期，程式編寫都是以演算法為核心的，程式設計師會把資料和過程分別作為獨立的部分來考慮，資料代表問題空間中的客體，程式程式碼則用於處理這些資料，這種思維方式直接站在計算機的角度去抽象問題

JUC之JDK自帶鎖StampedLock

一、初見 StampedLock是JDK 1.8的一把新鎖，同樣出自Doug Lee之手。這貨高階了，出身顯赫、自帶光環，有著光輝的使命。她是一把不一樣的鎖，前面我們所整理過的兩把鎖(ReentantLock&ReentrantReadWriteLock)都是基於AQS框架實

JUC之JDK自帶鎖ReentrantReadWriteLock

一、Hello World! Java紀年1.5年，ReentrantReadWriteLock誕生於J·U·C。此後，國人一般稱它為讀寫鎖。人如其名，人如其名，她就是一個可重入鎖，同時她還是一個讀、寫鎖。 1.1 跟ReentrantLock並沒有親屬關係 因為Reentr

JUC之JDK自帶鎖ReentrantLock

一、初識 ReentrantLock 出身自Java 1.5，中文名可重入鎖 是Java JDK自帶獨佔鎖的唯一實現，也是最常用的鎖，是synchronized的升級版。 1. 我們中間有個synchronized 我們已經認識過synchronized了，知道她能幫我

jdk 原始碼分析（8）java synchronized和鎖lock對比

因為synchronized 是關鍵字，無法看到原始碼，所以只能做一個簡單的分析對比了， synchronized 能鎖方法，也能鎖程式碼塊，其實也是一種重入鎖(也就是自己的鎖，自己可以進去)，程式碼塊或方法離開，自動釋放鎖。 lock：lock能做synchro

java執行緒學習(六)：JDK併發包之重入鎖-ReentrantLock

本章將學習重入鎖的以下方法： lock(): 獲得鎖，如果鎖已被佔用，則等待； lockInterruptbly(): 獲得鎖，但優先響應中斷； tryLock(): 嘗試獲得鎖，如果成功，返回true，反之返回false，該方法不會等待，執行則立即返回，可用tryL

JDK讀寫鎖ReadWriteLock的升級和降級問題

JDK提供了寫鎖介面ReadWriteLock和它的實現ReentrantReadWriteLock。要實現一個讀寫鎖，需要考慮很多細節，其中之一就是鎖升級和鎖降級的問題。什麼是升級和降級呢？Read

java高併發程式設計總結三：JDK併發包之ReentrantLock重入鎖

為了更好的支援併發程式，jdk內部提供了大量實用的API和框架，重入鎖就是一種對同步的擴充套件 ReentrantLock起源 在1.5的時候，synchronized關鍵的效能不是很好，這也是concurrent併發包出現的一種潛在原因，而新出

JDK基礎--Java中的鎖概念

Java中的鎖概念 掌握Java中鎖是Java多執行緒程式設計中繞不開的知識，只有知道理解Java各種鎖才能在編碼過程中靈活運

JDK併發包溫故知新系列（五）—— 顯式鎖與顯式條件

ReentrantReadWriteLock 兩把鎖共享一個等待佇列，兩把鎖的狀態都由一個原子變量表示，特有的獲取鎖和釋放鎖邏輯。 ReentrantReadWriteLock的基本原理： 讀鎖的獲取,只要求寫鎖沒有被執行緒持有就可以獲取，檢查等待佇列，逐個喚醒等待讀鎖執行緒，遇到等待寫鎖執行緒則停止.