Java多線程學習（二）synchronized關鍵字（1）

public class HasSelfPrivateNum {

    private int num = 0;

    synchronized public void addI(String username) {
        try {
            if (username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                //若是去掉hread.sleep(2000)，那麼運行結果就會顯示爲同步的效果
                Thread.sleep(2000);
            } else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num=" + num);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

ThreadA.java

public class ThreadA extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadA(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }

    @Override
    public void run() {
        super.run();
        numRef.addI("a");
    }

}

ThreadB.java

public class ThreadB extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadB(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }

    @Override
    public void run() {
        super.run();
        numRef.addI("b");
    }

}

Run.java

public class Run {

    public static void main(String[] args) {

        HasSelfPrivateNum numRef1 = new HasSelfPrivateNum();
        HasSelfPrivateNum numRef2 = new HasSelfPrivateNum();

        ThreadA athread = new ThreadA(numRef1);
        athread.start();

        ThreadB bthread = new ThreadB(numRef2);
        bthread.start();

    }

}

運行結果：
a num=100停頓一會才執行

上面實例中兩個線程ThreadA和ThreadB分別訪問同一個類的不一樣實例的相同名稱的同步方法，可是效果確實異步執行。

爲何會這樣呢？

這是由於synchronized取得的鎖都是對象鎖，而不是把一段代碼或方法當作鎖。因此在上面的實例中，哪一個線程先執行帶synchronized關鍵字的方法，則哪一個線程就持有該方法所屬對象的鎖Lock，那麼其餘線程只能呈等待狀態，前提是多個線程訪問的是同一個對象。本例中很顯然是兩個對象。

在本例中建立了兩個HasSelfPrivateNum類對象，因此就產生了兩個鎖。當ThreadA的引用執行到addI方法中的runThread.sleep(2000)語句時，ThreadB就會「伺機執行」。因此纔會致使執行結果如上圖所示（備註：因爲runThread.sleep(2000)，「a num=100」停頓了兩秒才輸出）

四 synchronized方法與鎖對象

經過上面咱們知道synchronized取得的鎖都是對象鎖，而不是把一段代碼或方法當作鎖。若是多個線程訪問的是同一個對象，哪一個線程先執行帶synchronized關鍵字的方法，則哪一個線程就持有該方法，那麼其餘線程只能呈等待狀態。若是多個線程訪問的是多個對象則不必定，由於多個對象會產生多個鎖。

那麼咱們思考一下當多個線程訪問的是同一個對象中的非synchronized類型方法會是什麼效果？

答案是：會異步調用非synchronized類型方法，解決辦法也很簡單在非synchronized類型方法前加上synchronized關鍵字便可。

五髒讀

發生髒讀的狀況實在讀取實例變量時，此值已經被其餘線程更改過。

PublicVar.java

public class PublicVar {

    public String username = "A";
    public String password = "AA";

    synchronized public void setValue(String username, String password) {
        try {
            this.username = username;
            Thread.sleep(5000);
            this.password = password;

            System.out.println("setValue method thread name="
                    + Thread.currentThread().getName() + " username="
                    + username + " password=" + password);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
     //該方法前加上synchronized關鍵字就同步了
     public void getValue() {
        System.out.println("getValue method thread name="
                + Thread.currentThread().getName() + " username=" + username
                + " password=" + password);
    }
}

ThreadA.java

public class ThreadA extends Thread {

    private PublicVar publicVar;

    public ThreadA(PublicVar publicVar) {
        super();
        this.publicVar = publicVar;
    }

    @Override
    public void run() {
        super.run();
        publicVar.setValue("B", "BB");
    }
}

Test.java

public class Test {

    public static void main(String[] args) {
        try {
            PublicVar publicVarRef = new PublicVar();
            ThreadA thread = new ThreadA(publicVarRef);
            thread.start();

            Thread.sleep(200);//打印結果受此值大小影響

            publicVarRef.getValue();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

運行結果：

解決辦法：getValue()方法前加上synchronized關鍵字便可。

加上synchronized關鍵字後的運行結果：

六 synchronized鎖重入

「可重入鎖」概念是：本身能夠再次獲取本身的內部鎖。好比一個線程得到了某個對象的鎖，此時這個對象鎖尚未釋放，當其再次想要獲取這個對象的鎖的時候仍是能夠獲取的，若是不可鎖重入的話，就會形成死鎖。

Service.java

public class Service {

    synchronized public void service1() {
        System.out.println("service1");
        service2();
    }

    synchronized public void service2() {
        System.out.println("service2");
        service3();
    }

    synchronized public void service3() {
        System.out.println("service3");
    }

}

MyThread.java

public class MyThread extends Thread {
    @Override
    public void run() {
        Service service = new Service();
        service.service1();
    }

}

Run.java

public class Run {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
    }
}

運行結果：

另外可重入鎖也支持在父子類繼承的環境中

Main.java：

public class Main {

    public int i = 10;

    synchronized public void operateIMainMethod() {
        try {
            i--;
            System.out.println("main print i=" + i);
            Thread.sleep(100);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

Sub.java：

public class Sub extends Main {

    synchronized public void operateISubMethod() {
        try {
            while (i > 0) {
                i--;
                System.out.println("sub print i=" + i);
                Thread.sleep(100);
                this.operateIMainMethod();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

MyThread.java：

public class MyThread extends Thread {
    @Override
    public void run() {
        Sub sub = new Sub();
        sub.operateISubMethod();
    }
}

Run.java：

public class Run {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
    }
}

運行結果：

說明當存在父子類繼承關係時，子類是徹底能夠經過「可重入鎖」調用父類的同步方法。

另外出現異常時，其鎖持有的鎖會自動釋放。

七同步不具備繼承性

若是父類有一個帶synchronized關鍵字的方法，子類繼承並重寫了這個方法。
可是同步不能繼承，因此仍是須要在子類方法中添加synchronized關鍵字。

參考：
《Java多線程編程核心技術》

歡迎關注個人微信公衆號:"Java面試通關手冊"（分享各類Java學習資源，面試題，以及企業級Java實戰項目回覆關鍵字免費領取）：

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

Java多線程學習（二）synchronized關鍵字（1）

(1) synchronized同步方法

一 簡介

二 變量安全性

三 多個對象多個鎖

四 synchronized方法與鎖對象

五 髒讀

六 synchronized鎖重入

七 同步不具備繼承性

一簡介

二變量安全性

三多個對象多個鎖

五髒讀

七同步不具備繼承性