2. 程式人生 > >深入理解Java多執行緒（四）

深入理解Java多執行緒（四）

阿新 • • 發佈：2018-11-28

關於java多執行緒的概念以及基本用法：java多執行緒基礎

4，Lock的使用

  • ReentrantLook類的使用
  • ReentrantReadWriteLock類的使用
4.1，ReentrantLook類的使用

新建MyService類：

public class MyService {

    private Lock lock = new ReentrantLock();
    public void testMethod() {
        lock.lock();//獲取鎖
        for(int
 
 i=0;i<5;i++) {
            System.out.println("ThreadName="+Thread.currentThread().getName()+(" "+(i+1)));
        }
        lock.unlock();//解鎖
    }
}

MyThread類：

public class MyThread extends Thread{

    private MyService service;
    public MyThread(MyService service) {
        super();
        this
 
.service = service;
    }
    @Override
    public void run() {
        service.testMethod();
    }

}

測試類：

public class Run {

    public static void main(String[] args) {
        MyService service = new MyService();
        MyThread a1 = new MyThread(service);
        MyThread a2 = new MyThread(service);
        MyThread a3 = new
 
 MyThread(service);
        MyThread a4 = new MyThread(service);
        MyThread a5 = new MyThread(service);
        a1.start();
        a2.start();
        a3.start();
        a4.start();
        a5.start();
    }
}

結果：

ThreadName=Thread-1 1
ThreadName=Thread-1 2
ThreadName=Thread-1 3
ThreadName=Thread-1 4
ThreadName=Thread-1 5
ThreadName=Thread-3 1
ThreadName=Thread-3 2
ThreadName=Thread-3 3
ThreadName=Thread-3 4
ThreadName=Thread-3 5
ThreadName=Thread-2 1
ThreadName=Thread-2 2
ThreadName=Thread-2 3
ThreadName=Thread-2 4
ThreadName=Thread-2 5
ThreadName=Thread-0 1
ThreadName=Thread-0 2
ThreadName=Thread-0 3
ThreadName=Thread-0 4
ThreadName=Thread-0 5
ThreadName=Thread-4 1
ThreadName=Thread-4 2
ThreadName=Thread-4 3
ThreadName=Thread-4 4
ThreadName=Thread-4 5

由結果可以看到一個執行緒列印完將鎖釋放，其他執行緒才可以繼續列印，但是執行緒間的順序是隨機的

4.2，Condition實現等待/通知

關鍵字synchronized與wait()和notify()/notifyAll()方法結合可以實現等待/通知模式，ReentrantLock藉助Condition物件可以實現相同的功能。一個Lock物件裡面可以建立多個Condition(即物件監視器)例項，執行緒物件可以註冊在指定的Condition中，從而可以自由選擇執行緒通知，使用notify()/notifyAll()方法進行通知時，被通知的執行緒是由JVM隨機選擇的

新建MyService類：

public class MyService {

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

    public void await() {
        try {
            lock.lock();
            System.out.println("wait 時間為："+System.currentTimeMillis());
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void signal() {
        try {
            lock.lock();
            System.out.println("signal時間為："+System.currentTimeMillis());
            condition.signal();
        } finally{
            lock.unlock();
        }
    }
}

ThreadA類：

public class ThreadA extends Thread{

    private MyService service;

    public ThreadA(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.await();
    }

}

測試類：

public class Run {

    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        ThreadA a = new ThreadA(service);
        a.start();
        Thread.sleep(3000);
        service.signal();
    }
}

結果：

wait 時間為：1534645646731
signal時間為：1534645649731

Objectl類中wait()方法相當於Condition類中的await()方法
Objectl類中notify()方法相當於Condition類中的signal()方法

4.3，多個Condition實現通知部分執行緒

新建MyService類：

public class MyService {

    private Lock lock = new ReentrantLock();
    public Condition conditionA = lock.newCondition();
    public Condition conditionB = lock.newCondition();

    public void awaitA() {
        try {
            lock.lock();
            System.out.println("begin awaitA時間為："+System.currentTimeMillis()
            +"ThreadName="+Thread.currentThread().getName());
            conditionA.await();
            System.out.println("end awaitA時間為："+System.currentTimeMillis()
            +"ThreadName="+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void awaitB() {
        try {
            lock.lock();
            System.out.println("begin awaitB時間為："+System.currentTimeMillis()
            +"ThreadName="+Thread.currentThread().getName());
            conditionB.await();
            System.out.println("end awaitB時間為："+System.currentTimeMillis()
            +"ThreadName="+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void signalAll_A() {
        try {
            lock.lock();
            System.out.println("signalAll_A時間為："+System.currentTimeMillis()
            +"ThreadName="+Thread.currentThread().getName());
            conditionA.signalAll();
        } finally{
            lock.unlock();
        }
    }

    public void signalAll_B() {
        try {
            lock.lock();
            System.out.println("signalAll_B時間為："+System.currentTimeMillis()
            +"ThreadName="+Thread.currentThread().getName());
            conditionB.signalAll();
        } finally{
            lock.unlock();
        }
    }

}

兩個執行緒類：

public class ThreadA extends Thread{

    private MyService service;

    public ThreadA(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.awaitA();
    }

}
public class ThreadB extends Thread {
    private MyService service;

    public ThreadB(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.awaitB();
    }
}

測試類：

public class Run {

    public static void main(String[] args) throws InterruptedException{
        MyService service = new MyService();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();
        ThreadB b= new ThreadB(service);
        b.setName("B");
        b.start();
        Thread.sleep(3000);
        service.signalAll_A();
    }
}

結果：

begin awaitA時間為：1534648259058ThreadName=A
begin awaitB時間為：1534648259058ThreadName=B
signalAll_A時間為：1534648262059ThreadName=main
end awaitA時間為：1534648262059ThreadName=A
4.4，公平鎖與非公平鎖

鎖Lock分為公平鎖與非公平鎖，公平鎖表示執行緒獲取鎖的順序是按照執行緒加鎖的順序來分配的，非公平鎖是一種獲取鎖的搶佔機制，是隨機獲得鎖的

新建Service類：

public class Service {

    private ReentrantLock lock;

    public Service(boolean isFair) {
        super();
        lock = new ReentrantLock(isFair);
    }
    public void serviceMethod() {
        try {
            lock.lock();
            System.out.println("ThreadName="+Thread.currentThread().getName()+"獲得鎖定");
        }finally{
            lock.unlock();
        }
    }

}

RunFair類：

public class RunFair {

    public static void main(String[] args) throws InterruptedException{
        final Service service = new Service(true);
        Runnable runnable = new Runnable() {

            @Override
            public void run() {
                System.out.println("*執行緒"+Thread.currentThread().getName()+"運行了");
                service.serviceMethod();

            }
        };
        Thread[] threadArray = new Thread[10];
        for(int i=0;i<10;i++) {
            threadArray[i] = new Thread(runnable);
        }
        for(int i=0;i<10;i++) {
            threadArray[i].start();
        }
    }
}

RunNoFair類：

public class RunNoFair {

    public static void main(String[] args) throws InterruptedException{
        final Service service = new Service(false);
        Runnable runnable = new Runnable() {

            @Override
            public void run() {
                System.out.println("*執行緒"+Thread.currentThread().getName()+"運行了");
                service.serviceMethod();

            }
        };
        Thread[] threadArray = new Thread[10];
        for(int i=0;i<10;i++) {
            threadArray[i] = new Thread(runnable);
        }
        for(int i=0;i<10;i++) {
            threadArray[i].start();
        }
    }
}

執行結果：

RunFair類：基本有序
RunNoFair類：基本無序
4.5，lock的一些方法
  • 方法int getHoldCount()的作用是查詢當前執行緒保持此鎖定的個數，也就是鎖的個數
  • 方法int getQueueLength()的作用是返回正等待獲取此鎖定的執行緒估計數，也就是等待鎖的執行緒
  • 方法int getWaitQueueLength(Condition condition)的作用是返回等待與此鎖定相關的給定條件condition的執行緒估計數，也就是執行了同一個condition物件的await()方法的執行緒數
  • 方法boolean hasQueuedThread(Thread thread)的作用是查詢指定的執行緒是否正在等待獲取此執行緒
  • 方法 boolean hasQueuedThreads()的作用是查詢是否有執行緒正在等待獲取此鎖定
  • 方法boolean hasWaiters(Condition condition)的作用是查詢是否有執行緒正在等待與此鎖定有關的condition條件
  • 方法boolean isFair()的作用是判斷是不是公平鎖
  • 方法boolean isHeldByCurrentThread()的作用是查詢當前執行緒是否保持此鎖定
  • 方法boolean isLocked()的作用是查詢此鎖定是否由任意執行緒保持
  • 方法 void lockInterruptibly()的作用是：如果當前執行緒未被中斷，則獲取鎖定，否則出現異常
  • 方法boolean tryLock()的作用是：僅在呼叫時鎖定未被另一個執行緒保持的情況下，才獲取該鎖定
  • 方法 boolean tryLock(long timeout,TimeUnit unit)的作用是，如果鎖定在給定等待時間內沒有被另一個執行緒保持，且當前執行緒未被中斷，則獲取該鎖定

使用Lock+Condition實現執行緒順序執行：點這裡

4.6，ReentranReadWriteLock類

同一時間只有一個執行緒在執行ReentranLock.lock()方法後面的任務，這樣確實保證了執行緒的安全，但是效率很低，ReentranReadWriteLock類可以提高效率
讀寫鎖有兩個鎖，一個讀操作相關的鎖，也稱為共享鎖，一個寫操作相關的鎖，也稱為排他鎖。讀鎖與寫鎖互斥，寫鎖與寫鎖互斥，但是讀鎖與讀鎖不互斥，也就是沒寫操作的情況下可以進行很多的讀操作

1，讀讀共享
Service類:

public class Service {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read() {
        try {
            try {
                lock.readLock().lock();
                System.out.println("獲得鎖"+Thread.currentThread().getName()
                        +" "+System.currentTimeMillis());
                Thread.sleep(10000);
            } finally {
                lock.readLock().unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

兩個執行緒類：

public class ThreadA extends Thread {

    private Service service;
    public ThreadA(Service service) {
        super();
        this.service = service;
    }

    public void run() {
        service.read();
    }
}
public class ThreadB extends Thread {

    private Service service;
    public ThreadB(Service service) {
        super();
        this.service = service;
    }

    public void run() {
        service.read();
    }
}

測試類：

public class Run {

    public static void main(String[] args) {
        Service service = new Service();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        ThreadB b= new ThreadB(service);
        b.setName("B");
        a.start();
        b.start();
    }
}

結果：

獲得鎖B 1534681602545
獲得鎖A 1534681602545

由結果可以看到，兩個執行緒幾乎同時進入lock（）後的程式碼

2，寫寫互斥

保持上面程式碼不變，更改Service類：

public class Service {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void write() {
        try {
            try {
                lock.writeLock().lock();
                System.out.println("獲得寫鎖"+Thread.currentThread().getName()
                        +" "+System.currentTimeMillis());
                Thread.sleep(10000);
            } finally {
                lock.writeLock().unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

結果：

獲得寫鎖A 1534681950514
獲得寫鎖B 1534681960516

顯然寫操作同一時間只允許一個執行緒執行

3，讀寫互斥
更改Service類和測試類：

public class Service {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read() {
        try {
            try {
                lock.readLock().lock();
                System.out.println("獲得鎖"+Thread.currentThread().getName()
                        +" "+System.currentTimeMillis());
                Thread.sleep(10000);
            } finally {
                lock.readLock().unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void write() {
        try {
            try {
                lock.writeLock().lock();
                System.out.println("獲得寫鎖"+Thread.currentThread().getName()
                        +" "+System.currentTimeMillis());
                Thread.sleep(10000);
            } finally {
                lock.writeLock().unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Run {

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();
        Thread.sleep(1000);
        ThreadB b= new ThreadB(service);
        b.setName("B");
        b.start();
    }
}

結果：

獲得鎖A 1534682422325
獲得鎖B 1534682423326

4，寫讀互斥
更改測試類;

public class Run {

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();

        ThreadB b= new ThreadB(service);
        b.setName("B");
        b.start();
        Thread.sleep(1000);
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();

    }
}

結果：

獲得鎖B 1534682527683
獲得鎖A 1534682528683

綜上：只有讀讀操作是非同步且非互斥的，其他的都是互斥的

相關推薦

深入理解Java多執行緒（四）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 4，Lock的使用 ReentrantLook類的使用 ReentrantReadWriteLock類的使用 4.1，ReentrantLook類的使用 新建MySe

深入理解java多執行緒（六）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 6，單例模式與多執行緒 如何使單例模式遇到多執行緒是安全的這是下面要討論的內容 6.1，立即載入 立即載入就是在使用類的時候已經將物件建立完畢，例如String s = new Stri

深入理解Java多執行緒（五）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 5，定時器Timer JDK中Timer類主要是負責計劃任務的功能，也就是在指定的時間開始執行某一個任務，封裝任務的類是TimerTask類，執行計劃任務的程式碼要放進TimerTask的子類，因為它一個抽象

深入理解Java多執行緒（三）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 3, 執行緒間通訊 執行緒在作業系統中是獨立的個體，經過特殊的處理，執行緒間可以實現通訊，進而成為一個整體，提高CPU利用率 3.1，等待/通知機制 等待：wait()方法作用是使當前執

深入理解Java多執行緒（二）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 2，多執行緒的同步 多個執行緒對同一物件的變數進行同時訪問時會引發執行緒的安全問題，即一個執行緒對一個變數修改後，其他執行緒可能會讀取到修改後的變數值，所以我們要對獲得的例項變數的值進行同步處理，保證其原子性

深入理解Java多執行緒（一）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 1，停止執行緒 停止執行緒意味著線上程執行完之前停止正在做的操作，即立刻放棄當前的操作，這並不容易。停止執行緒可以用Thread.stop()方法，但是這個方法不安全，所以不建議使用，還有一個方法就是Thre

Java 多執行緒（四）—— 單例模式

這篇部落格介紹執行緒安全的應用——單例模式。 單例模式   單例模式，是一種常用的軟體設計模式。在它的核心結構中只包含一個被稱為單例的特殊類。通過單例模式可以保證系統中，應用該模式的類一個類只有一個例項。即一個類只有一個物件例項。 例項: /** * @author

Java多執行緒（四）java中的Sleep方法

點我跳過黑哥的卑鄙廣告行為，進入正文。 Java多執行緒系列更新中~ 　　正式篇： Java多執行緒（一） 什麼是執行緒 Java多執行緒（二）關於多執行緒的CPU密集型和IO密集型這件事 Java多執行緒（三）如何建立執行緒 Java多執行緒（四）java中的Sleep方法 　

（2.1.2.4）Java多執行緒（四）、執行緒池

系統啟動一個新執行緒的成本是比較高的，因為它涉及到與作業系統的互動。在這種情況下，使用執行緒池可以很好的提供效能，尤其是當程式中需要建立大量生存期很短暫的執行緒時，更應該考慮使用執行緒池。 與資料庫連線池類似的是，執行緒池在系統啟動時即建立大量空閒的執行緒，程

Java多執行緒（四）、執行緒池

系統啟動一個新執行緒的成本是比較高的，因為它涉及到與作業系統的互動。在這種情況下，使用執行緒池可以很好的提供效能，尤其是當程式中需要建立大量生存期很短暫的執行緒時，更應該考慮使用執行緒池。 與資料庫連線池類似的是，執行緒池在系統啟動時即建立大量空閒的執行緒，程式將一個Runnable物件傳給

Java總結篇系列：Java多執行緒（四）

多個執行緒同步執行ping ip示例package com.ebao.pojo;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import j

深入理解多執行緒（四）—— Moniter的實現原理

在深入理解多執行緒（一）——Synchronized的實現原理中介紹過關於Synchronize的實現原理，無論是同步方法還是同步程式碼塊，無論是ACC_SYNCHRONIZED還是monitorenter、monitorexit都是基於Monitor實現的，那麼這篇來介紹下什麼是Monitor。

深入理解Java多執行緒--執行緒池（ThreadPool）

在java多執行緒開發中，我們需要使用執行緒的時候一般是建立一個Thread物件，然後呼叫start（）方法去執行執行緒操作。這樣做沒有什麼問題，但是如果我們有很多工需要多個執行緒來非同步執行的時候，在我們建立了很多執行緒的情況下，會造成很大的效能方面的問題。 1.大量的執行緒的建立和銷燬，

深入理解系列之JAVA多執行緒（2）——synchronized同步原理

多執行緒中為了解決執行緒安全問題，一個重要的手段就是同步！所謂同步其實就是使得原本各個執行緒交叉執行（非同步），變成排隊執行（同步）。同步策略使得不同執行緒操作共享資料遵循“先來後到“，從而避免某個執行緒沒有處理完資料就被另一執行緒搶佔操作出現資料被覆蓋或

java多執行緒（六）深入理解volitale關鍵字

一、java記憶體模型與多執行緒程式設計中的三個感念 1、原子性 原子性是指一些操作或者全都執行，要麼或者全都不執行，整個操作作為一個整體是不可分割的，例如，一個銀行中有兩個賬戶A，B，現在要從A賬戶中轉賬500元到B賬戶，那麼一共可以分為兩個步驟：

併發程式設計之美，帶你深入理解java多執行緒原理

1.什麼是多執行緒？ 多執行緒是為了使得多個執行緒並行的工作以完成多項任務，以提高系統的效率。執行緒是在同一時間需要完成多項任務的時候被實現的。 2.瞭解多執行緒 瞭解多執行緒之前我們先搞清楚幾個重要的概念！ 如上圖所示：對我們的專案有一個主記憶體，這個主記憶體裡面存放了我們的共享變數、方法區、堆中的物件等

深入理解Java多執行緒--synchronized的實現原理

執行緒安全是多執行緒程式設計中的一個重要的知識點，何為執行緒安全？在多執行緒併發中，有很多資料是執行緒共享的，當我們某個執行緒去操作共享資料的時候，需要先將共享資料複製到當前執行緒的記憶體空間中來，然後進行操作完畢之後再將資料更新到共享空間中去。這就造成了一個問題，當我們有多個執行緒去讀取和操作

JAVA基礎24-多執行緒（四）【讀寫鎖，阻塞佇列，執行緒池】

一、讀寫鎖   使用步驟 二、阻塞佇列 (BlockingQueue) 提供執行緒安全的佇列訪問方式； 當阻塞佇列進行插入資料時，若佇列滿，則執行緒阻塞，直到佇列非滿的時候 當阻塞佇列取資料時，若佇列為空，則執行緒阻塞直到佇列非空時候。

Java多執行緒（六）之Deque與LinkedBlockingDeque深入分析

1、LinkedBlockingDeque資料結構 雙向併發阻塞佇列。所謂雙向是指可以從佇列的頭和尾同時操作，併發只是執行緒安全的實現，阻塞允許在入隊出隊不滿足條件時掛起執行緒，這裡說的佇列是指支援FIFO/FILO實現的連結串列。 首先看下LinkedBlockingDeque的資料結構。通常情況

理解多執行緒（四）--原子量和原子操作

原子量 互斥量可以對於共享變數的訪問進行加鎖，可以保證對臨界區的互斥訪問，但加鎖總是繁瑣的，所以提供了更簡單的共享變數保護訪問的操作，原子量和原子操作。 原子量的構造 原子量包含在#include 中，對於基本型別，我們可以這樣定義原子變數 std::atomic_b