合集 - JUC基礎(13)

vbcjnmkk發表於2024-09-01

合集 - JUC基礎(13)
1.
JUC前置知識
2023-10-23
2.
Synchronized和Lock介面
2023-10-25
3.
執行緒間通訊
2023-10-28
4.
Lock實現執行緒間定製化通訊
2023-10-30
5.
常用集合執行緒安全分析
2023-11-02
6.
多執行緒鎖
2023-11-12
7.
Callable介面和Future介面
2023-11-20
8.
JUC的強大輔助類
2023-11-22
9.
ReentrantReadWriteLock讀寫鎖
2023-11-24
10.
BlockingQueue阻塞佇列
2023-11-26
11.
執行緒池
2023-11-28
12.
Fork/Join
2023-12-01
13.
CompletableFuture非同步回撥
2023-12-01
收起
Synchronized
Synchronized關鍵字回顧
synchronized是java中的關鍵字，是一種同步鎖。它修飾的目標有以下幾種：

1.修飾一個程式碼塊，被修飾的程式碼塊稱為同步程式碼塊，其作用的範圍是大括號{}，括起來的程式碼，作用的物件是呼叫這個程式碼塊的物件，synchronized不能修飾靜態程式碼塊。
2.修飾一個方法，被修飾的方法稱為同步方法，其作用的範圍是整個方法，作用的物件是所有呼叫這個方法的物件。
3.修飾一個靜態方法，其作用範圍是整個靜態方法，作用的物件是這個類的所有物件。
4.修飾一個類物件(類的class物件)，其作用範圍是synchronized後面括號括起來的部分，作用物件是這個類的所有物件。
對於，在靜態方法，或類物件加synchronized關鍵字的理解，synchronized關鍵字就是同步，當其是一個類鎖時，就保證同一時間只能有一個執行緒訪問，其修飾的程式碼。此時，無論是類名.方法名或者物件.方法名的方式，呼叫該方法，本質上獲取的就是這個類.class物件的鎖，一個類只有在類載入的時候，生成一個class物件，所以無論是類名還是物件的方法呼叫，同一時刻只能有一個執行緒獲取該物件的鎖，也就是同一時刻最多一個執行緒執行該方法。如果是修飾在類變數的程式碼塊，最多隻有一個執行緒方法該程式碼塊。
作用的物件，有點不瞭解。以及synchronized鎖作用在this物件，和作用在類.class上有什麼區別？學完後面的課程，記得來回答這個問題。
關於synchronized的理解，共有兩種型別的鎖：
（1）類鎖：只有synchronized修飾靜態方法或者修飾一個類的class物件時，才是類鎖。
（2）物件鎖：除了類鎖，所有其他的上鎖方式都認為是物件鎖。比如synchronized修飾普通方法或者synchronized（this)給程式碼塊上鎖等。
應該注意的是，因為一個類只有一個class物件，因此所有的訪問者在訪問被加了類鎖的程式碼時，都是共用同一把鎖，而類的例項卻可以有很多個，因此不同物件訪問加了物件鎖的程式碼，它們的訪問互不干擾。

synchronized鎖的訪問規則
（1）加了相同鎖的程式碼，它們的訪問規則是相同的，即當某個訪問者獲得該鎖時，它們一起向該訪問者開放訪問，向其他沒有獲得該鎖的訪問者關閉訪問。
（2）加了不同鎖的程式碼訪問互相不干擾。
（3）而沒有加鎖的程式碼隨時都可以任意訪問，不受任何限制。

判斷是否同一把synchronized鎖
（1）不同型別的鎖不是同一把鎖。
（2）加的是物件鎖，那麼必須是同一個物件例項才是同一把鎖。
（3）加的是類鎖，那必須是同一類才是同一把鎖。

對於synchronized修飾的程式碼能否訪問
1.首先判斷是不是同一把鎖。
2.然後判斷各自的訪問規則。

注意事項
雖然synchronized關鍵字可以來修飾方法，但synchronized關鍵字不屬於方法定義的一部分。synchronized關鍵字不能被繼承。如果在父類中的某個方法使用了synchronized關鍵字，子類又覆蓋了該方法，在子類中的方法預設情況下是不進行同步的，而必須顯示在子類的方法上也加上synchronized關鍵字才可以。當然，也可以在子類中直接呼叫父類方法，這樣雖然子類方法不同步但是方法體的內容，是同步的，因此相當於子類方法也同步。

多執行緒程式設計步驟(上)
第一，建立資源類，建立屬性和操作方法。第二 建立多執行緒呼叫資源類的方法。

售票案例
sale 銷售 ticket 票
案例要求，3個售票員進行售票，共售賣30張票。

程式碼
/**

  • @author 長名06

  • @version 1.0

  • 多執行緒程式設計步驟，第一步 建立資源類，定義屬性和方法

  • 第二步，建立多個執行緒，呼叫資源類的操作方法
    */
    public class SaleTickets {
    public static void main(String[] args) {
    Ticket ticket = new Ticket();
    new Thread(() -> {
    for (int i = 0; i < 40; i++){
    ticket.sale();
    }
    }, "aa").start();

     new Thread(() -> {
     for (int i = 0; i < 40; i++){
         ticket.sale();
     }
 }, "bb").start();

 new Thread(() -> {
     for (int i = 0; i < 40; i++){
         ticket.sale();
     }
 }, "cc").start();

    }
    }

class Ticket {
//票數
private static int number = 30;

public synchronized void sale() {
    if (number > 0) {
        System.out.println(Thread.currentThread().getName() + "\t 賣出一張票"
                + "剩下票數為" + --number);
    }
}

}
程式碼分析
1.synchronized關鍵字修飾的非靜態方法，此時這個方法的鎖就是synchronized(this)鎖，就是對呼叫當前方法的物件上鎖。案例中的aa，bb，cc執行緒都是使用ticket這同一個物件，呼叫的sale()方法，所以這三個執行緒是互斥的，同時只能由三個中的一個，使用sale()方法。從輸出結果，也可以看出，是互斥訪問的。

2.當一個執行緒獲取了對應的鎖，可以訪問對應鎖的程式碼塊，其他需要訪問該程式碼塊的執行緒，就要等待。等待獲取鎖的執行緒釋放鎖，但是獲取到鎖的執行緒的執行有兩種情況。
1）獲取鎖的執行緒，執行對應的程式碼塊，然後執行緒釋放鎖，無事發生，正常情況；
2）擁有鎖的執行緒執行中，出現了異常，此時JVM會讓執行緒自動釋放鎖。

3.但如果獲取鎖的執行緒的操作，需要等待IO或者其他原因(如sleep方法)被阻塞了，但是執行緒沒有釋放鎖，其他的執行緒就只能等待，會很影響執行效率。所以需要一種機制可以不讓等待的執行緒一直無限的等待下去(等待一定的時間，就能響應中斷)，透過Lock(java.util.concurrent.locks包下的介面)就可以實現。

4.以上鎖都是synchronized鎖。

Lock
基本介紹
Lock鎖實現，並提供了比使用同步方法和語句可以獲得的更廣泛的鎖操作。它們允許更靈活的結構，可能具有非常不同的屬性，並且可能支援多個關聯的條件物件。Lock提供了比synchronized更多的功能。

Lock和synchronized的區別
1.Lock不是java語言內建的關鍵字，synchronized是Java語言的關鍵字，是內建特性。Lock是一個介面，可以透過其實現類實現非同步訪問。
2.採用synchronized關鍵字，不需要使用者去手動釋放鎖，當synchronized關鍵字修飾的方法或程式碼塊執行完之後，有JVM自動讓執行緒釋放鎖。但是Lock則必須讓使用者手動釋放鎖，如果沒有主動釋放鎖，就可能會出現死鎖現象。
使用Lock實現sale_ticket案例
import java.util.concurrent.locks.ReentrantLock;
/**

  • @author 長名06

  • @version 1.0

  • 多執行緒程式設計步驟，第一步 建立資源類，定義屬性和方法

  • 第二步，建立多個執行緒，呼叫資源類的操作方法
    */
    public class SaleTickets {
    public static void main(String[] args) {
    Ticket ticket = new Ticket();
    new Thread(() -> {
    for (int i = 0; i < 40; i++){
    ticket.sale();
    }
    }, "aa").start();

     new Thread(() -> {
     for (int i = 0; i < 40; i++){
         ticket.sale();
     }
 }, "bb").start();

 new Thread(() -> {
     for (int i = 0; i < 40; i++){
         ticket.sale();
     }
 }, "cc").start();

    }
    }

class Ticket {
//票數
private static int number = 30;

private final ReentrantLock lock = new ReentrantLock();

public void sale() {
    lock.lock();//開啟鎖
    try {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "\t 賣出一張票"
                    + "剩下票數為" + --number);
        }
    }finally {
        lock.unlock();//釋放鎖
    }

}

}
關於Thread#start()&start0()
public synchronized void start() {//這個方法，完成執行緒的啟動，但是實際建立執行緒是start0()方法完成的
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();

/* Notify the group that this thread is about to be started
 * so that it can be added to the group's list of threads
 * and the group's unstarted count can be decremented. */
group.add(this);

boolean started = false;
try {
    start0();//這裡這個方法的呼叫，才是完成執行緒的建立

//程式碼效果參考：http://www.92demo.com/sitemap/post.html
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}

private native void start0();//此方法，java程式碼無法完成，而是用native關鍵字修飾的方法，就是使用jvm底層的JNI(Java Native Interface)機制呼叫c語言庫完成的。這個建立執行緒的方法，以及是否建立，建立順序，不是由java程式決定的，而是由程式執行的OS決定的。
lock介面方法
public interface Lock {
void lock();//獲取鎖
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();//釋放鎖
Condition newCondition();
}
lock方法
lock()方法使用最多的方法，功能，獲取鎖，如果鎖被其他執行緒獲取，則進行等待。
使用Lock，必須主動去釋放鎖，並且發生異常時，不會自動釋放鎖。因此一般來說，使用Lock必須在try{}catch{}finally{}塊中進行，並且將釋放鎖的操作在finally塊中，用來保證鎖一定被釋放，防止死鎖的發生。通常使用Lock實現同步的，是以如下形式的。

lock.lock();//開啟鎖
try {
//...具體程式碼
}catch(Exception e){

}
finally {
lock.unlock();//釋放鎖
}
newCondition方法
關鍵字synchronized和wait()/notify()這兩個方法一起使用，可實現等待/通知模式。Lock鎖的newCondition()方法返回Condition物件，Condition類也可以實現等待/通知的模式。wait()和notify()是Object類下的方法，notify()被呼叫時，JVM會隨機的喚醒某個等待的執行緒，使用Condition類可進行選擇性通知，Condition常用的方法，awiat()方法，會使當前執行緒等待，同時會釋放當前執行緒持有的鎖，當其他執行緒呼叫signal()時，執行緒會重新獲得鎖並繼續執行。signal()用於喚醒等待的執行緒。

注意，在使用Condition介面(使用其具體的實現類)的await()和signa()方法前，需要執行緒持有相關的Lock鎖，呼叫await()後執行緒會釋放這個鎖，在signal()呼叫後會從當前Condition物件的等待佇列中，喚醒一個執行緒，喚醒的執行緒嘗試獲得鎖，一旦獲得鎖成功，就執行。

小結
Lock和synchronized有以下幾點不同

1.Lock是一個介面，而synchronized是Java中的關鍵字，synchronized是內建的語言實現的。
2.synchronized在發生異常時，會自動釋放執行緒佔有的鎖，因此不會導致死鎖現象發生。Lock在發生異常時，如果沒有主動透過unLock()會釋放鎖，則很可能會造成死鎖現象，因此使用Lock時需要在finally塊中釋放鎖。
3.Lock可以讓等待鎖的執行緒響應中斷，而synchronized卻不行，使用synchronized時，等待的執行緒會一致等待，不能夠使用中斷。
4.透過Lock可以知道有沒有成功獲取鎖，而synchronized卻無法辦到。
5.Lock可以提高多個執行緒進行讀操作的效率。
在效能上來說，如果資源競爭不激烈，二者的效能是差不多的，而當資源競爭激烈時，此時Lock的效能要遠遠優於synchronized。

相關文章