Synchronized和Lock介面_ZenDei技術網路在線

Synchronized Synchronized關鍵字回顧 synchronized是java中的關鍵字，是一種同步鎖。它修飾的對象有以下幾種： 1.修飾一個代碼塊，被修飾的代碼塊稱為同步代碼塊，其作用的範圍是大括弧{}，括起來的代碼，作用的對象是調用這個代碼塊的對象，synchronized不能 ...

Synchronized

Synchronized關鍵字回顧

synchronized是java中的關鍵字，是一種同步鎖。它修飾的對象有以下幾種：

1.修飾一個代碼塊，被修飾的代碼塊稱為同步代碼塊，其作用的範圍是大括弧{}，括起來的代碼，作用的對象是調用這個代碼塊的對象，synchronized不能修飾靜態代碼塊。
2.修飾一個方法，被修飾的方法稱為同步方法，其作用的範圍是整個方法，作用的對象是調用這個方法的對象。
3.修飾一個靜態方法，其作用範圍是整個靜態方法，作用的對象是這個類的所有對象。
4.修飾一個類，其作用範圍是synchronized後面括弧括起來的部分，作用主要的對象是這個類的所有對象。

作用的對象，有點不瞭解。以及synchronized鎖作用在this對象，和作用在類.class上有什麼區別？學完後面的課程，記得來回答這個問題。

關於synchronized的理解，共有兩種類型的鎖：

（1）類鎖：只有synchronized修飾靜態方法或者修飾一個類的class對象時，才是類鎖。
（2）對象鎖：除了類鎖，所有其他的上鎖方式都認為是對象鎖。比如synchronized修飾普通方法或者synchronized（this)給代碼塊上鎖等。
應該註意的是，因為一個類只有一個class對象，因此所有的訪問者在訪問被加了類鎖的代碼時，都是共用同一把鎖，而類的實例卻可以有很多個，因此不同對象訪問加了對象鎖的代碼，它們的訪問互不幹擾。

synchronized鎖的訪問規則

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

判斷是否同一把synchronized鎖

（1）不同類型的鎖不是同一把鎖。
（2）加的是對象鎖，那麼必須是同一個對象實例才是同一把鎖。
（3）加的是類鎖，那必須是同一類才是同一把鎖。

對於sysnchronized修飾的代碼能否訪問

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();//這裡這個方法的調用，才是完成線程的創建
        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。

只是為了記錄自己的學習歷程，且本人水平有限，不對之處，請指正。