摘要：異步線程運(yùn)行線程運(yùn)行我們創(chuàng)建兩個線程來調(diào)用同一業(yè)務(wù)對象的相同功能時可以看到下面輸出線程運(yùn)行線程運(yùn)行兩個線程在一起執(zhí)行方法并且交叉打印也就是說當(dāng)我們啟動一個線程執(zhí)行某個方法的時候就是異步執(zhí)行至于為啥要這樣演示是因為下面的同步同步將方法上加入關(guān)

public class PrintObject {
    public void printString(){
        System.out.println("begin");
        if(Thread.currentThread().getName().equals("a")){
            PrintStream printStream = System.out;
            printStream.println("線程 a 運(yùn)行");
        }
        if(Thread.currentThread().getName().equals("b")){
            System.out.println("線程 b 運(yùn)行");
        }
        System.out.println("end");
    }
}

public static void main(String[] a) {
    PrintObject pb = new PrintObject();

    Thread thread1 = new Thread(pb::printString);
    thread1.setName("a");
    thread1.start();

    Thread thread2 = new Thread(pb::printString);
    thread2.setName("b");
    thread2.start();
}

我們創(chuàng)建兩個線程來調(diào)用同一業(yè)務(wù)對象的相同功能時, 可以看到下面輸出.

begin
begin
線程 a 運(yùn)行
end
線程 b 運(yùn)行
end

兩個線程在一起執(zhí)行 printString 方法, 并且交叉打印. 也就是說當(dāng)我們啟動一個線程執(zhí)行某個方法的時候就是異步執(zhí)行, 至于為啥要這樣演示, 是因為下面的同步.

將 synchronized public void printString() 方法上加入 synchronized 關(guān)鍵字, 來使方法同步.

執(zhí)行結(jié)果:

begin
線程 a 運(yùn)行
end
begin
線程 b 運(yùn)行
end

那么為什么加入 synchronized 關(guān)鍵字后就會同步呢？ 這是因為關(guān)鍵字 synchronized 會取得一把對象鎖, 而不是把一段代碼或方法當(dāng)做鎖; 哪個線程先執(zhí)行帶 synchronized 關(guān)鍵字的方法, 哪個線程就持有該方法所屬的對象的鎖 Look, 那么其他線程只能呈等待狀態(tài).

這里有個前提是多個線程訪問同一個對象, 下面演示的是多個線程訪問不同的對象.

public class PrintObject {
    synchronized public void printString(){
        System.out.println("begin");
        if(Thread.currentThread().getName().equals("a")){
            PrintStream printStream = System.out;
            printStream.println("線程 a 運(yùn)行");
            try {
                Thread.sleep(100000);
            } catch (InterruptedException e) {
                
            }
        }
        if(Thread.currentThread().getName().equals("b")){
            System.out.println("線程 b 運(yùn)行");
        }
        System.out.println("end");
    }
}

    public static void main(String[] a) {
        PrintObject pb = new PrintObject();
        PrintObject pb1 = new PrintObject();

        Thread thread1 = new Thread(pb::printString);
        thread1.setName("a");
        thread1.start();

        Thread thread2 = new Thread(pb1::printString);
        thread2.setName("b");
        thread2.start();
    }

執(zhí)行結(jié)果

begin
線程 a 運(yùn)行
begin
線程 b 運(yùn)行
end

讓 a 線程睡眠 100000 毫秒, 可以看到 a 線程并沒有執(zhí)行完, b 線程就運(yùn)行了. 這也能夠證明 synchronized 關(guān)鍵字取得是對象鎖.

另外還需要注意一點(diǎn), 我們使用兩個線程執(zhí)行同一對象的不同同步方法時, 如果線程 a 在睡眠, 那么線程 b 也會一直等待, 線程 a 執(zhí)行完畢后再去執(zhí)行.

注: 同步方法一定是線程安全的.

如果一個獲取鎖的線程調(diào)用其它的synchronized修飾的方法, 會發(fā)生什么？

在一個線程使用synchronized方法時調(diào)用該對象另一個synchronized方法, 即一個線程得到一個對象鎖后再次請求該對象鎖, 是永遠(yuǎn)可以拿到鎖的.

在Java內(nèi)部, 同一個線程調(diào)用自己類中其他synchronized方法/塊時不會阻礙該線程的執(zhí)行, 同一個線程對同一個對象鎖是可重入的, 同一個線程可以獲取同一把鎖多次, 也就是可以多次重入. 原因是Java中線程獲得對象鎖的操作是以線程為單位的, 而不是以調(diào)用為單位的.

這種情況也可以發(fā)生在繼承中, 也就是說子類的同步方法調(diào)用父類的同步方式時, 時可以鎖重入的. 
但是, 如果子類重寫了父類的方法, 并沒有使用 synchronized 關(guān)鍵字, 則同步就失效了. 因為子類重寫父類的方法, 當(dāng)我們調(diào)用方法執(zhí)行代碼時, 執(zhí)行的是子類的方法, 所以變成了異步執(zhí)行.

public class PrintObject {
     public synchronized void printString(){
        try {
            System.out.println(Thread.currentThread().getName() + " 執(zhí)行");
            System.out.println(Thread.currentThread().getName() + " 插入數(shù)據(jù)到數(shù)據(jù)庫");
            // 讓線程休眠, 模擬出網(wǎng)絡(luò)延時
            Thread.sleep(5000);

            System.out.println(Thread.currentThread().getName() + " 共享數(shù)據(jù)減1");
            Thread.sleep(5000);

            System.out.println(Thread.currentThread().getName() + " 插入數(shù)據(jù)到數(shù)據(jù)庫");
            Thread.sleep(5000);

            if (Thread.currentThread().getName().equals("b")) {
                SimpleDateFormat df = new SimpleDateFormat("mm:ss");
                System.out.println(df.format(new Date()));
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

PrintObject pb = new PrintObject();

Thread thread1 = new Thread(pb::printString);
thread1.setName("a");

Thread thread2 = new Thread(pb::printString);
thread2.setName("b");

SimpleDateFormat df = new SimpleDateFormat("mm:ss");
System.out.println(df.format(new Date()));

thread1.start();
thread2.start();

執(zhí)行結(jié)果

47:34
a 執(zhí)行
a 插入數(shù)據(jù)到數(shù)據(jù)庫
a 共享數(shù)據(jù)減1
a 插入數(shù)據(jù)到數(shù)據(jù)庫
b 執(zhí)行
b 插入數(shù)據(jù)到數(shù)據(jù)庫
b 共享數(shù)據(jù)減1
b 插入數(shù)據(jù)到數(shù)據(jù)庫
48:04

我們上面這段程序兩個線程全部執(zhí)行完所用的時間為 30 秒, 這里可以看出同步方法存在一個很大的弊端.

就是說我們的某個線程開始執(zhí)行方法時, 無論我們操作的是不是共享數(shù)據(jù), 別的線程都會等待此線程釋放鎖. 然后繼續(xù)執(zhí)行.

可是我們在插入數(shù)據(jù)到數(shù)據(jù)庫的時候, 并不是在操作共享數(shù)據(jù), 那么我們有沒有什么辦法, 只同步操作共享數(shù)據(jù)的那部分代碼呢?

我們就可以使用 synchronized 同步代碼塊, 將程序修改成下面樣子.

public class PrintObject {
     public void printString(){
        try {
            System.out.println(Thread.currentThread().getName() + " 執(zhí)行");
            System.out.println(Thread.currentThread().getName() + " 插入數(shù)據(jù)到數(shù)據(jù)庫");
            // 讓線程休眠, 模擬出網(wǎng)絡(luò)延時
            Thread.sleep(5000);

            synchronized(this) {
                System.out.println(Thread.currentThread().getName() + " 共享數(shù)據(jù)減1");
                Thread.sleep(5000);
            }


            System.out.println(Thread.currentThread().getName() + " 插入數(shù)據(jù)到數(shù)據(jù)庫");
            Thread.sleep(5000);

            if (Thread.currentThread().getName().equals("b")) {
                SimpleDateFormat df = new SimpleDateFormat("mm:ss");
                System.out.println(df.format(new Date()));
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

執(zhí)行結(jié)果

54:12
b 執(zhí)行
a 執(zhí)行
b 插入數(shù)據(jù)到數(shù)據(jù)庫
a 插入數(shù)據(jù)到數(shù)據(jù)庫
a 共享數(shù)據(jù)減1
a 插入數(shù)據(jù)到數(shù)據(jù)庫
b 共享數(shù)據(jù)減1
b 插入數(shù)據(jù)到數(shù)據(jù)庫
54:32

減少了10秒的執(zhí)行時間, 提高了執(zhí)行效率.

同步方法和同步代碼塊的鎖都是同一把鎖. 同步方法獲取的是該方法的對象鎖, 而同步代碼塊獲取中的參數(shù)是 this, 表示當(dāng)前對象. 所以獲取的是同一把鎖.

synchronized 關(guān)鍵字可以應(yīng)用在 static 靜態(tài)方法上, 表示當(dāng)前的 *.java 文件對應(yīng)的 Class 類進(jìn)行持鎖.

雖然運(yùn)行結(jié)果與 synchronized 關(guān)鍵字加到非 static 靜態(tài)方法上的結(jié)果類似, 但是是對 Class 類進(jìn)行加鎖, 而 Class 鎖可以對類的所有對象起作用.

synchronized (DemoApplication.class) {
            
}