一踊赠、synchronized簡介

能夠保證在同一時刻最多只有一個線程執(zhí)行該段代碼狐肢，以達到保證并發(fā)安全的效果（當被sync修飾之后巩螃，將會以原子方式執(zhí)行）

地位

• 是Java的關鍵字媒峡，被Java語言原生支持
• 是最基本的同步互斥手段
• 是并發(fā)編程中的元老級角色翠桦，是并發(fā)編程的必學內容

二苟蹈、synchronized兩種用法

1糊渊、對象鎖

對象鎖：包括方法鎖（默認鎖對象為this當前實例對象）和同步代碼塊鎖（自己制定鎖對象）

• 代碼塊形式：手動指定鎖對象

• 方法鎖形式：synchronized修飾普通方法，鎖對象默認為this

生命周期

Debug調試：

Debug調試查看線程所處狀態(tài).png

代碼實戰(zhàn)

• 代碼塊形式：

/**
 * 對象鎖：代碼塊
 */
public class SynchronizedObjectCodeBlock02 implements Runnable {

    static SynchronizedObjectCodeBlock02 instance = new SynchronizedObjectCodeBlock02();

    Object lock1 = new Object();
    Object lock2 = new Object();

    @Override
    public void run() {
        // 同一個對象慧脱，則運行結果同this
        synchronized (lock1) {

            System.out.println("我是對象鎖的代碼塊形式渺绒，我是Lock1，我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "Lock1部分，運行結束宗兼。");
        }

        // 兩把鎖會出現(xiàn)并行躏鱼，若為同一把鎖，則串行
        synchronized (lock2) {

            System.out.println("我是對象鎖的代碼塊形式殷绍，我是Lock2染苛，我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "Lock2部分，運行結束主到。");
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while(t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("Finished");
    }
}

• 方法鎖形式

/**
 * 對象鎖：代碼塊
 */
public class SynchronizedObjectMethod03 implements Runnable {

    static SynchronizedObjectMethod03 instance = new SynchronizedObjectMethod03();

    Object lock1 = new Object();
    Object lock2 = new Object();

    @Override
    public void run() {
        try {
            method();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void method() throws InterruptedException {
        System.out.println("我是對象所得方法修飾符形式茶行，我叫" + Thread.currentThread().getName());
        Thread.sleep(3000);
        System.out.println(Thread.currentThread().getName() + "，運行結束登钥。");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while(t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("Finished");
    }
}

2畔师、類鎖

類鎖：指synchronized修飾靜態(tài)的方法或指定鎖對象為Class對象

概念

• 只有一個Class對象：Java類可能有很多歌對象但是只有一個Class對象
• 本質：所以所謂的類鎖，不過是Class對象的鎖而已
• 用法和效果：類鎖只能在同一時刻被一個對象擁有

兩種形式

• synchronized加在static方法上

/**
 * 類鎖的第一種形式牧牢，static形式
 */
public class SynchronizedClassStatic04 implements Runnable {
    static SynchronizedClassStatic04 instance1 = new SynchronizedClassStatic04();
    static SynchronizedClassStatic04 instance2 = new SynchronizedClassStatic04();

    @Override
    public void run() {
        try {
            method();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 此處不加static看锉，會并行，加static會順序串行執(zhí)行
     * @throws InterruptedException
     */
    public static synchronized void method() throws InterruptedException {
        System.out.println("我是類鎖的第一種形式static形式塔鳍，我叫" + Thread.currentThread().getName());
        Thread.sleep(3000);
        System.out.println(Thread.currentThread().getName() + "伯铣，運行結束。");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while(t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("Finished");
    }
}

• synchronized（*.class）代碼塊

/**
 * 類鎖的第一種形式献幔，static形式
 */
public class SynchronizedClassClass05 implements Runnable {
    static SynchronizedClassClass05 instance1 = new SynchronizedClassClass05();
    static SynchronizedClassClass05 instance2 = new SynchronizedClassClass05();

    @Override
    public void run() {
        try {
            method();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void method() throws InterruptedException {
        /**
         * 此處若為this懂傀，則并行，*.class則串行
         */
        synchronized (SynchronizedClassClass05.class) {

            System.out.println("我是類鎖的第二種形式static形式：synchronized(*.class)蜡感，我叫" + Thread.currentThread().getName());
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + "蹬蚁，運行結束。");
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while(t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("Finished");
    }
}

三郑兴、性質

可重入性

指的是同一線程的外層函數獲得鎖之后犀斋，內層函數可以直接再次獲取該鎖

好處：避免死鎖，提升封裝性

粒度：線程而非調用（用3種情況來說明和pthread的區(qū)別）
3種情況：
1情连、證明同一個方法是可重入的
2叽粹、證明可重入不要求是同一個方法
3、證明可重入不要求是同一個類中的

不可中斷性

一旦這個鎖被別人獲得了却舀，如果我還想獲得虫几，我只能選擇等待或者阻塞，直到別的線程釋放這個鎖挽拔，如果別人永遠不釋放鎖辆脸，那么我只能永遠的等下去

相比之下，Lock類螃诅，可以擁有中斷的能力啡氢，第一點：如果我覺得我等的時間太長了状囱，有權中斷現(xiàn)在已經獲取到鎖的線程的執(zhí)行；第二點：如果我覺得我等的時間太長了倘是，不想再等了亭枷，可以退出

四、Synchronized原理

加鎖和釋放鎖的原理：現(xiàn)象搀崭、時機叨粘、深入JVM看字節(jié)碼
可重入原理：加鎖次數計數器
保證可見性的原則：內存模型

1、加鎖和釋放鎖的原理

• 現(xiàn)象
• 獲取和釋放鎖的時機：內置鎖
• 等價代碼
• 深入JVM看字節(jié)碼:反編譯看monitor指令

深入JVM看字節(jié)碼

• 概況

/**
 * 反編譯字節(jié)碼
 */
public class Decompilation4 {
    private Object object = new Object();

    public void insert(Thread thread) {
        synchronized (object) {

        }
    }
}

• 如何反編譯

javac Decompilation4.java
javap -verose Decompilation4.class

看到如下條目6瘤睹、8宣鄙、14

image.png

• monitorenter和monitorexit指令

2、可重入原理：加鎖次數計數器

• JVM負責跟蹤對象被加鎖的次數
• 線程第一次給對象加鎖的時候默蚌，計數變?yōu)?.每當這個相同的線程在此對象上在此獲得鎖時，計數會遞增
• 每當任務離開時苇羡，計數遞減绸吸，當計數為0時，這把鎖被完全釋放

3设江、可見性的原理：Java內存模型

線程間通信圖.png

Synchronized修飾的代碼塊锦茁，在鎖釋放之前寫入到主內存中，保證了本地內存和主內存一致性叉存。

五码俩、Synchronized缺陷

• 效率低：鎖的釋放情況少、試圖獲得鎖時不能設定超時歼捏，不能中斷一個正在糊涂獲得鎖的線程

• 不夠靈活（讀寫鎖更靈活）：加鎖和釋放的時機單一稿存，每個鎖僅有單一的條件（某個對象），可能是不夠的

• 無法直到是否成功獲取到鎖

以上內容整理自網絡