Java多線程之synchronized同步代碼塊的示例分析

小編給大家分享一下Java多線程之synchronized同步代碼塊的示例分析，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

1. 同步方法和同步塊，哪種更好？

同步塊更好，這意味著同步塊之外的代碼是異步執行的，這比同步整個方法更提升代碼的效率。請知道一條原則：同步的范圍越小越好。

對于小的臨界區，我們直接在方法聲明中設置synchronized同步關鍵字，可以避免競態條件的問題。但是對于較大的臨界區代碼段，為了執行效率，最好將同步方法分為小的臨界區代碼段。

public class TwoPlus {
    private int num1 = 0;
    private int num2 = 0;
    public synchronized void plus(int val1,int val2){
        this.num1 = num1+val1;
        this.num2 = num2+val2;
    }
}

臨界區代碼段包含對兩個臨界區資源的操作，這兩個臨界區資源分別為sum1和sum2。使用synchronized對plus(int val1,int val2)進行同步保護之后，進入臨界區代碼段的線程擁有sum1和sum2的操作權，并且是全部占用。一旦線程進入，當線程在操作sum1而沒有操作sum2時，也將sum2的操作權白白占用，其他的線程由于沒有進入臨界區，只能看著sum2被閑置而不能去執行操作。

所以，將synchronized加在方法上，如果其保護的臨界區代碼段包含的臨界區資源多于一個，就會造成臨界區資源的閑置等待，進而會影響臨界區代碼段的吞吐量。為了提升吞吐量，可以將synchronized關鍵字放在函數體內，同步一個代碼塊。synchronized同步塊的寫法是：

synchronized (syncObject){
    // 臨界區代碼段的代碼塊
}

在synchronized同步塊后邊的括號中是一個syncObject對象，代表著進入臨界區代碼段需要獲取syncObject對象的監視鎖，由于每一個Java對象都有一把監視鎖，因此任何Java對象都能作為synchronized的同步鎖。

使用synchronized同步塊對上面的TwoPlus類進行吞吐量的提升改造，具體的代碼如下：

public class TwoPlus {
    private int num1 = 0;
    private int num2 = 0;
    // 兩把不同的鎖對象
    private Object object1 = new Object();
    private Object object2 = new Object();
    public  void plus(int val1,int val2){
        synchronized (object1){
            this.num1 = num1+val1;
        }
        synchronized (object2){
            this.num2 = num2+val2;
        }
    }
}

改造之后，對兩個獨立的臨界區資源sum1和sum2的加法操作可以并發執行了，在某一個時刻，不同的線程可以對sum1和sum2同時進行加法操作，提升了plus()方法的吞吐量。

synchronized方法和synchronized同步塊有什么區別呢？

總體來說，synchronized方法是一種粗粒度的并發控制，某一時刻只能有一個線程執行該synchronized方法；而synchronized代碼塊是一種細粒度的并發控制，處于synchronized塊之外的其他代碼是可以被多個線程并發訪問的。在一個方法中，并不一定所有代碼都是臨界區代碼段，可能只有幾行代碼會涉及線程同步問題。所以synchronized代碼塊比synchronized方法更加細粒度地控制了多個線程的同步訪問。

synchronized方法的同步鎖實質上使用了this對象鎖，這樣就免去了手工設置同步鎖的工作。而使用synchronized代碼塊需要手工設置同步鎖。

2. synchronized同步代碼塊

public class RoomDemo {
    private static int count = 0;
    // 創建鎖對象，同步代碼塊需要手動設置對象鎖
    private static Object object = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for(int i=0;i<5000;i++){
                // 使用object對象鎖住臨界區資源
                synchronized (object){
                    count++;
                }
            }
        },"t1");
        Thread t2 = new Thread(()->{
            // 使用object對象鎖住臨界區資源
            for(int i=0;i<5000;i++){
                synchronized (object){
                    count--;
                }
            }
        },"t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);// 0
    }
}

你可以做這樣的類比： synchronized(對象) 中的對象，可以想象為一個房間，線程 t1，t2 想象成兩個人

(1) 當線程 t1 執行到 synchronized(object) 時就好比 t1 進入了這個房間，并鎖住了門拿走了鑰匙，在門內執行 count++ 代碼 ;

(2) 這時候如果 t2 也運行到了 synchronized(object) 時，它發現門被鎖住了，只能在門外等待，發生了上下文切換，阻塞住了 ;

(3) 這中間即使 t1 的 cpu 時間片不幸用完，被踢出了門外 （不要錯誤理解為鎖住了對象就能一直執行下去哦） ， 這時門還是鎖住的，t1 仍拿著鑰匙，t2 線程還在阻塞狀態進不來，只有下次輪到 t1 自己再次獲得時間片時才 能開門進入

(4) 當 t1 執行完 synchronized{} 塊內的代碼，這時候才會從 obj 房間出來并解開門上的鎖，喚醒 t2 線程并把鑰匙給他。t2 線程這時才可以進入 obj 房間，鎖住了門拿上鑰匙，執行它的 count-- 代碼；

3. 如果同步塊內的線程拋出異常會發生什么？

public class ExceptionDemo {
    private static int count = 1;
    // 創建鎖對象
    private static Object object = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            synchronized (object){
                System.out.println("線程t1正在執行");
                // 死循環
                while (count==1){
                }
            }
        },"t1");
        Thread t2 = new Thread(()->{
            synchronized (object) {
                System.out.println("線程t2正在執行");
                count--;
            }
        },"t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

執行結果：

可以看出線程t1執行的是死循環，所以每次線程上下文切換，線程t2都被阻塞了，拿不到鎖，從而無法執行。

假如我們在線程執行過程中制造一個異常：

public class ExceptionDemo {
    private static int count = 1;
    // 創建鎖對象
    private static Object object = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            synchronized (object){
                System.out.println("線程t1正在執行");
                while (count==1){
                    // 死循環中制造異常
                    Integer.parseInt("a");
                }
            }
        },"t1");
        Thread t2 = new Thread(()->{
            synchronized (object) {
                System.out.println("線程t2正在執行");
                count--;
            }
        },"t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

執行結果：

當持有鎖對象的線程在執行同步代碼快中的代碼時，如果出現異常，會釋放鎖，從而線程t2就可以拿到鎖對象去執行自己同步代碼塊中的代碼了。

以上是“Java多線程之synchronized同步代碼塊的示例分析”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！