Java并發(fā)系列番外篇——同步機(jī)制（一）

隱式鎖，又稱線程同步synchronized衰琐。保證在同一時(shí)刻最多只有一個(gè)線程執(zhí)行該段代碼

前言

在上篇文章《線程安全性》中，提到了Java提供了一種內(nèi)置的鎖機(jī)制來支持原子性性坊夫，也就是使用synchronized修飾代碼塊或者方法：

synchronized (lock){
    //被保護(hù)的代碼塊
}
public synchronized void method() {
    被保護(hù)的方法
}

每個(gè)Java對(duì)象都可以用來作為一個(gè)同步鎖搬葬，即內(nèi)置鎖（監(jiān)視器鎖）。線程在進(jìn)入同步代碼塊之前會(huì)自動(dòng)獲取鎖绍移，并且在退出的時(shí)候釋放鎖悄窃。獲得鎖唯一的方法就是進(jìn)入由這個(gè)鎖保護(hù)的同步代碼塊或者方法。Synchronized是Java中解決并發(fā)問題的一種最常用最簡單的方法蹂窖，它可以確保線程互斥的訪問同步代碼轧抗。

synchronized同步方法

非線程安全問題存在于實(shí)例變量中，如果變量是方法內(nèi)部的私有變量瞬测，則這個(gè)變量是安全的横媚，不存在線程安全問題：

public void add() {
        int a = 0;
        if (a < 200) {
            a++;
        } else {
            todo()
        }

    }

add就是一個(gè)線程安全的方法，因?yàn)樗膬?nèi)部變量a是私有的月趟，而且它不持有外部變量灯蝴。如果沒有共享資源，就沒有同步的必要孝宗。

用synchronized修飾方法

如果多個(gè)線程共同訪問同一個(gè)對(duì)象中的實(shí)例變量穷躁，就有可能出現(xiàn)非線程安全的問題，例如下面的代碼因妇，兩個(gè)線程對(duì)同一個(gè)對(duì)象中的變量各進(jìn)行加一操作兩萬次：

public class AddTest {
    private int num = 0;

    public int getNum(){
        return num;
    }
    public void addOne(){
        num++;
    }
}

public class ThreadAdd extends Thread {

    private AddTest mAddTest;

    public ThreadAdd(AddTest addTest){
        this.mAddTest = addTest;
    }

    @Override
    public void run() {
        super.run();
        for (int i = 0;i<20000;i++) {
            mAddTest.addOne();
        }
        System.out.println("ThreadAdd:"+mAddTest.getNum());
    }
}

public static void main(String[] args) {
    AddTest addTest = new AddTest();
    ThreadAdd threadAdd1 = new ThreadAdd(addTest);
    ThreadAdd threadAdd2 = new ThreadAdd(addTest);
    threadAdd1.start();
    threadAdd2.start();
}

上述代碼的輸出結(jié)果是無法確定的问潭，下面是它的執(zhí)行結(jié)果之一：

image

public class AddTest {
    private int num = 0;

    public int getNum(){
        return num;
    }
    public synchronized void addOne(){
        num++;
    }
}

代碼執(zhí)行結(jié)果如下：

image

AddTest addTest1 = new AddTest();
AddTest addTest2 = new AddTest();
ThreadAdd threadAdd1 = new ThreadAdd(addTest1);
ThreadAdd threadAdd2 = new ThreadAdd(addTest2);
threadAdd1.start();
threadAdd2.start();

這段代碼創(chuàng)建了兩個(gè)實(shí)例，并分別在兩個(gè)線程執(zhí)行它們各自的方法录粱。代碼執(zhí)行輸出如下：

image

兩個(gè)線程互不干擾（實(shí)際上他們是交替異步執(zhí)行的）腻格。當(dāng)多個(gè)線程訪問多個(gè)對(duì)象的，JVM會(huì)創(chuàng)建多個(gè)鎖啥繁，每個(gè)鎖只是鎖著它對(duì)應(yīng)的實(shí)例菜职。不同的線程持有不同的鎖，訪問不同的對(duì)象旗闽。
在調(diào)用synchronized修飾的方法時(shí)酬核，線程一定是排隊(duì)運(yùn)行的，只有共享資源的讀寫才需要同步适室，如果不是共享資源嫡意，根本就沒有同步的必要。
接下來我們修改一下AddTest：

public class AddTest {
    private static int num = 0;

    public int getNum(){
        return num;
    }
    public static synchronized void addOne(){
        num++;
    }
}

AddTest addTest1 = new AddTest();
AddTest addTest2 = new AddTest();
ThreadAdd threadAdd1 = new ThreadAdd(addTest1);
ThreadAdd threadAdd2 = new ThreadAdd(addTest2);
threadAdd1.start();
threadAdd2.start();

我們使用synchronized修飾靜態(tài)方法捣辆，

public class AddTest {
    private static int num = 0;

    public int getNum(){

        return num;
    }
    public static synchronized void addOne(String name){
        num++;
        System.out.println(name+":"+num);
    }
}

public class ThreadAdd extends Thread {

    private AddTest mAddTest;
    private String name;

    public ThreadAdd(AddTest addTest,String name){
        this.mAddTest = addTest;
        this.name = name;
    }

    @Override
    public void run() {
        super.run();
        for (int i = 0;i<10;i++) {
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            mAddTest.addOne(name);
        }
        System.out.println(name + "------:"+mAddTest.getNum());
    }
}

public static void main(String[] args) {
        AddTest addTest1 = new AddTest();
        AddTest addTest2 = new AddTest();
        ThreadAdd threadAdd1 = new ThreadAdd(addTest1,"A");
        ThreadAdd threadAdd2 = new ThreadAdd(addTest2,"B");
        threadAdd1.start();
        threadAdd2.start();
    }

代碼的執(zhí)行結(jié)果如下：

image

盡管第一個(gè)執(zhí)行完的線程打印的結(jié)果總是不確定的蔬螟，但是最后一個(gè)線程的結(jié)果總是40000叁鉴。因?yàn)檫@兩個(gè)線程持有的是同一把鎖咸产，此時(shí)它們持有的鎖不再是對(duì)象鎖澡腾，而是類鎖挨厚，也就是Class對(duì)象鎖彩郊，這把鎖不管當(dāng)前有多少實(shí)例存在呈队，都確保了只有一個(gè)線程可以放完這個(gè)類惭每。

鎖重入

關(guān)鍵字synchronized有用鎖重入的功能熙宇，在使用synchronized時(shí)坐昙，當(dāng)一個(gè)線程得到一個(gè)對(duì)象鎖后绳匀，再次請(qǐng)求次對(duì)象鎖是可以再次得到鎖的（自己可以再次得到自己持有的鎖）。這也使得：在一個(gè)synchronized方法/代碼塊中調(diào)用同一把鎖保護(hù)的synchronized方法/代碼塊是可行的：

public class AddTest {
    private int num = 0;

    public int getNum(){
        return num;
    }
    public synchronized void addOne(){
        num++;
        cutOne();
    }
    public synchronized void cutOne(){
        num--;
    }
}

執(zhí)行這段代碼，獲取的num值為0疾棵，在線程持有鎖并執(zhí)行addOne方法內(nèi)部調(diào)用cutOne時(shí)戈钢，該線程并未釋放鎖，調(diào)用cutOne方法時(shí)是尔，可再次獲得鎖殉了。
可重入鎖支持繼承

public class Human {
    public synchronized void method(){

    }
}

public class Student extends Human {
    @Override
    public synchronized void method() {
        //調(diào)用父類的同步方法
        super.method();
    }
}

子類可以通過可重入鎖低啊用父類的同步方法。
當(dāng)同步方法或者代碼塊執(zhí)行完畢的時(shí)候拟枚，鎖就會(huì)被釋放薪铜。而當(dāng)線程執(zhí)行代碼時(shí)發(fā)生異常，鎖也會(huì)被自動(dòng)釋放恩溅。
雖然鎖重入支持繼承隔箍，但是<u>同步不支持繼承</u>，如上文中的代碼：盡管父類Human的method方法是同步方法脚乡。但是子類Student必須使用synchronized修飾method方法蜒滩，才能確保該它的method方法是同步方法。

synchronized方法的弊端

觀察下面的代碼：

class Run {
    public static void main(String[] args) {
        AddTest addTest = new AddTest();
        ThreadAdd threadAdd1 = new ThreadAdd(addTest,"A");
        ThreadAdd threadAdd2 = new ThreadAdd(addTest,"B");
        threadAdd1.start();
        threadAdd2.start();
    }
}

public class AddTest {
    private int num = 0;

    public int getNum(){
        return num;
    }
    public void addOne(){

        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num++;
    }
}

public class ThreadAdd extends Thread {

    private AddTest mAddTest;
    private String name;
    public ThreadAdd(AddTest addTest,String name){
        this.mAddTest = addTest;
        this.name = name;
    }

    @Override
    public void run() {
        super.run();
        Long start = System.currentTimeMillis();
        for (int i = 0;i<100;i++) {
            mAddTest.addOne();
        }
System.out.println("ThreadAdd:" + mAddTest.getNum() + name + ":" + String.valueOf(System.currentTimeMillis() - start));
    }
}

打印他們的執(zhí)行結(jié)果和時(shí)間：

image

這個(gè)代碼是非線程安全的奶稠，將addOne方法改為同步方法：

public synchronized void addOne(){

        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num++;
    }

image

此時(shí)線程變得安全了俯艰，但是代碼執(zhí)行的時(shí)間卻增加了很多。

使用同步方法的策略可以簡單確保線程安全锌订，但是這種粗粒度的實(shí)現(xiàn)方式帶來的代價(jià)是慘痛的竹握。假如我們我個(gè)Service實(shí)現(xiàn)對(duì)某頁面的訪問量。但當(dāng)我們將它設(shè)計(jì)成一個(gè)同步方法時(shí)瀑志，就使得每次只有一個(gè)線程可以訪問它涩搓，這在高負(fù)載的情況下會(huì)使得程序的執(zhí)行時(shí)間變得很長——因?yàn)樗械恼?qǐng)求都必須排隊(duì)執(zhí)行污秆。這完全背離了我們程序設(shè)計(jì)的初衷劈猪，而解決這個(gè)問題的方法就是同步代碼塊。

synchronized同步代碼塊

上文中講述synchronized同步方法的弊端中良拼，我們可以發(fā)現(xiàn)战得，在同步的時(shí)候，線程在Thread.sleep(10)時(shí)也是需要阻塞并同步執(zhí)行的庸推。而這塊代碼并不需要保證是安全常侦，假如我們可以使用異步的方式進(jìn)行這個(gè)等待操作，代碼的執(zhí)行效率就會(huì)有很大的提升贬媒。

實(shí)例鎖

修改addOne方法：

public void addOne() {

        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (this) {
            num++;
        }
    }

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

image

AddTest addTest = new AddTest();
AddTest addTest2 = new AddTest();
ThreadAdd threadAdd1 = new ThreadAdd(addTest,"A");
ThreadAdd threadAdd2 = new ThreadAdd(addTest2,"B");
threadAdd1.start();
threadAdd2.start();

代碼執(zhí)行結(jié)果如下：

image

public class AddTest {
    private int num = 0;
    private Object mObject = new Object();
    public int getNum() {
        return num;
    }
    public void addOne() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (mObject) {
            num++;
        }
    }
}

AddTest addTest = new AddTest();
ThreadAdd threadAdd1 = new ThreadAdd(addTest,"A");
ThreadAdd threadAdd2 = new ThreadAdd(addTest,"B");
threadAdd1.start();
threadAdd2.start();

執(zhí)行結(jié)果如下：

image

Object o = new Object();
AddTest addTest = new AddTest(o);
AddTest addTest2 = new AddTest(o);
ThreadAdd threadAdd1 = new ThreadAdd(addTest,"A");
ThreadAdd threadAdd2 = new ThreadAdd(addTest2,"B");
threadAdd1.start();
threadAdd2.start();

public class AddTest {

    private Object mObject;
    private int    num = 0;

    public AddTest(Object object) {

        this.mObject = object;
    }

    public int getNum() {

        return num;
    }

    public void addOne() {

        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num++;
        
    }
}

image

public void addOne() {
        synchronized (mObject) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num++;
        }
    }

執(zhí)行結(jié)果如下：

image

仍然是各自線程訪問自己各自的對(duì)象實(shí)例腮考，但是執(zhí)行時(shí)間卻大幅上漲——這是因?yàn)閮蓚€(gè)線程持有同一把鎖雇毫，當(dāng)一個(gè)線程A持有該鎖時(shí)，線程B無法訪問用該鎖保護(hù)的任何代碼塊踩蔚。即使這段代碼塊和線程A沒有任何關(guān)系棚放，也不會(huì)被線程A訪問。

Class鎖

接著上述代碼馅闽，繼續(xù)修改addOne方法：

public void addOne() {
        synchronized (AddTest.class) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num++;
        }
    }

其它代碼保持不變飘蚯，僅僅將synchronized(mObject)用synchronized (AddTest.class)替換，會(huì)產(chǎn)生同樣效果福也。因?yàn)橛脕肀Ｗo(hù)代碼塊的是同一把鎖——類鎖局骤。鎖是加持在類上的，用synchronized static或者synchronized(class)方法使用的鎖都是類鎖暴凑，因?yàn)閏lass和靜態(tài)方法在系統(tǒng)中只會(huì)產(chǎn)生一份峦甩，所以在單系統(tǒng)環(huán)境中使用類鎖是線程安全的。
類鎖和上面的對(duì)象鎖唯一不同的區(qū)別是现喳，類鎖只有一把凯傲，無論你創(chuàng)建多少實(shí)例對(duì)象，它們都公用一把鎖嗦篱。而對(duì)象鎖你可以動(dòng)態(tài)的使用不同的鎖冰单，如果你能確保所有的同步都用同一個(gè)對(duì)象鎖，那么對(duì)象鎖也能實(shí)現(xiàn)類鎖的功能灸促。

String鎖Ｌ颉！伊者！

由于在JVM中具有String常量池緩存的功能英遭，因此相同字面量是同一個(gè)鎖。

總結(jié)

• 可重入鎖支持繼承
• 同步不具有繼承性
• 調(diào)用synchronized修飾的方法時(shí)亦渗，線程一定是排隊(duì)運(yùn)行的
• 當(dāng)線程執(zhí)行代碼時(shí)發(fā)生異常挖诸，鎖會(huì)被自動(dòng)釋放
• 線程間同時(shí)訪問同一個(gè)鎖的多個(gè)同步代碼的執(zhí)行順序不定
• 當(dāng)一個(gè)線程進(jìn)入同步方法時(shí)，其他線程可以正常訪問其他非同步方法
• 多個(gè)對(duì)象多個(gè)鎖不會(huì)存在阻塞法精，多個(gè)對(duì)象一個(gè)鎖會(huì)存在線程阻塞

最后

水平有限多律，碼字不易。如有紕漏搂蜓，望指正狼荞！