Java多線程（三）—— synchronized關鍵字詳解

時間  2019-11-10
標籤 java 多線程 synchronized 關鍵字 詳解 欄目 Java 简体版
原文   原文鏈接

1、多線程的同步多線程

一、爲何要引入同步機制併發

在多線程環境中，可能會有兩個甚至更多的線程試圖同時訪問一個有限的資源。必須對這種潛在資源衝突進行預防。dom

解決方法：在線程使用一個資源時爲其加鎖便可。ide

訪問資源的第一個線程爲其加上鎖之後，其餘線程便不能再使用那個資源，除非被解鎖。this

二、程序實例spa

用一個取錢的程序例子，來講明爲何須要引入同步。在使用同步機制前，總體程序以下：線程

package com.demo;

public class FetchMoneyTest {
    
    public static void main(String[] args){
        Bank bank = new Bank();

        Thread t1 = new MoneyThread(bank);// 從銀行取錢
        Thread t2 = new MoneyThread(bank);// 從取款機取錢

        t1.start();
        t2.start();

    }
}

class Bank{
    private int money = 1000;

    public int getMoney(int number){
        if (number < 0){
            return -1;
        }
        else if (number > money){
            return -2;
        }
        else if (money < 0) {
            return -3;
        }
        else{
            try{
                Thread.sleep(1000);
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
            money -= number;

            System.out.println("Left Money: " + money);
            return number;

        }
    }
}

class MoneyThread extends Thread{
    
    private Bank bank;

    public MoneyThread(Bank bank){
        this.bank = bank;
    }

    @Override
    public void run(){
        System.out.println(bank.getMoney(800));
    }
}

運行結果：code

Left Money: 200
800
Left Money: -600
800

     程序中定義了一個Bank類，其中包含了用戶存儲的錢（1000元），而後用兩個線程進行取錢操做，能夠看到儘管Bank類中的getMoney()方法對取錢數目與存款數據進行了判斷，可是執行後，結果輸出兩個800，代表從兩個線程中都成功地取出了800元錢。對象

　　這是爲何呢？由於getMoney()方法中有一些邏輯判斷，進入最後一個else語句塊後，有一個簡短的休眠，那麼在第一個線程休眠的過程當中，第二個線程也成功進入了這個else語句塊（由於存款的錢尚未取走），當兩個線程結束休眠後，再也不進行邏輯判斷而是直接將錢取走，因此兩個線程都取到了800元錢，此時money爲負600。blog

　　須要注意這裏並不能肯定哪個線程是第一個線程，哪個線程是第二個線程，前後順序是不定的。

　　在getMoney()方法中加入打印語句輸出剩餘的錢數，能夠看到輸出爲剩餘錢數爲200，-600，或-600，-600。這是不必定的，由於可能在第一次輸出剩餘錢數以前，另外一個線程可能尚未將錢取走，也可能已經取走。

三、解決辦法

解決辦法：在getMoney()方法上加上關鍵字synchronized。即程序改動後以下：（只是加了一個關鍵字）　

package com.demo;

public class FetchMoneyTest {
    
    public static void main(String[] args){
        Bank bank = new Bank();

        Thread t1 = new MoneyThread(bank);// 從銀行取錢
        Thread t2 = new MoneyThread(bank);// 從取款機取錢

        t1.start();
        t2.start();

    }
}

class Bank{
    private int money = 1000;

    public synchronized int getMoney(int number){
        if (number < 0){
            return -1;
        }
        else if (number > money){
            return -2;
        }
        else if (money < 0) {
            return -3;
        }
        else{
            try{
                Thread.sleep(1000);
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
            money -= number;

            System.out.println("Left Money: " + money);
            return number;

        }
    }
}

class MoneyThread extends Thread{
    
    private Bank bank;

    public MoneyThread(Bank bank){
        this.bank = bank;
    }

    @Override
    public void run(){
        System.out.println(bank.getMoney(800));
    }
}

再次運行程序，結果以下：

Left Money: 200
800
-2

代表第一次取款800元后，剩餘200元，當另外一個線程再去取的時候，已經不能再取錢了。即一個線程開始執行取錢的方法以後就阻止了其餘線程再去執行這個方法，直到本線程結束，其餘線程纔有訪問權利。

2、synchronized關鍵字詳解

     多線程的同步機制對資源進行加鎖，使得在同一個時間，只有一個線程能夠進行操做，同步用以解決多個線程同時訪問時可能出現的問題。同步機制可使用synchronized關鍵字實現。當synchronized關鍵字修飾一個方法的時候，該方法叫作同步方法。當synchronized方法執行完或發生異常時，會自動釋放鎖。下面經過一個例子來對synchronized關鍵字的用法進行解析。

一、是否使用synchronized關鍵字的不一樣

package com.demo;

public class ThreadTest {

     public static void main(String[] args){
         
        Example example = new Example();

        Thread t1 = new Thread1(example);
        Thread t2 = new Thread1(example);

        t1.start();
        t2.start();
     }
}

class Example{
    
    public synchronized void execute(){
        
        for (int i = 0; i < 10; ++i){
            try{
                Thread.sleep(500);
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("Hello: " + i);
        }
    }

}

class Thread1 extends Thread{
    
    private Example example;

    public Thread1(Example example){
        this.example = example;
    }

    @Override
    public void run(){
        example.execute();
    }

}

是否在execute()方法前加上synchronized關鍵字，這個例子程序的執行結果會有很大的不一樣。

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

Hello: 0
Hello: 1
Hello: 2
Hello: 3
Hello: 4
Hello: 5
Hello: 6
Hello: 7
Hello: 8
Hello: 9
Hello: 0
Hello: 1
Hello: 2
Hello: 3
Hello: 4
Hello: 5
Hello: 6
Hello: 7
Hello: 8
Hello: 9

不加synchronized關鍵字的運行結果：

Hello: 0
Hello: 0
Hello: 1
Hello: 1
Hello: 2
Hello: 2
Hello: 3
Hello: 3
Hello: 4
Hello: 4
Hello: 5
Hello: 5
Hello: 6
Hello: 6
Hello: 7
Hello: 7
Hello: 8
Hello: 8
Hello: 9
Hello: 9

結論：

若是不加synchronized關鍵字，則兩個線程同時執行execute()方法，輸出是兩組併發的。

若是加上synchronized關鍵字，則會先輸出一組0到9，而後再輸出下一組，說明兩個線程是順次執行的。

二、多個方法的多線程狀況

    將程序改動一下，Example類中再加入一個方法execute2()。以後再寫一個線程類Thread2，Thread2中的run()方法執行的是execute2()。Example類中的兩個方法都是被synchronized關鍵字修飾的。

package com.demo;

public class ThreadTest {

     public static void main(String[] args){
         
        Example example = new Example();

        Thread t1 = new Thread1(example);
        //Thread t2 = new Thread1(example);
        Thread t2 = new Thread2(example);

        t1.start();
        t2.start();
     }
}

class Example{
    
    public synchronized void execute(){
        
        for (int i = 0; i < 20; ++i){
            try{
                //Thread.sleep(500);
                Thread.sleep((long) Math.random() * 1000);
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("Hello: " + i);
        }
    }
    
    public synchronized void execute2(){
        
        for (int i = 0; i < 20; ++i){
            try{
                Thread.sleep((long) Math.random() * 1000);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("World: " + i);
        }
    }

}

class Thread1 extends Thread{
    
    private Example example;

    public Thread1(Example example){
        this.example = example;
    }

    @Override
    public void run(){
        example.execute();
    }

}

class Thread2 extends Thread{
    
    private Example example;

    public Thread2(Example example){
        this.example = example;
    }

    @Override
    public void run(){
        example.execute2();
    }

}

運行結果：

Hello: 0
Hello: 1
Hello: 2
Hello: 3
Hello: 4
Hello: 5
Hello: 6
Hello: 7
Hello: 8
Hello: 9
Hello: 10
Hello: 11
Hello: 12
Hello: 13
Hello: 14
Hello: 15
Hello: 16
Hello: 17
Hello: 18
Hello: 19
World: 0
World: 1
World: 2
World: 3
World: 4
World: 5
World: 6
World: 7
World: 8
World: 9
World: 10
World: 11
World: 12
World: 13
World: 14
World: 15
World: 16
World: 17
World: 18
World: 19

若是去掉synchronized關鍵字，則兩個方法併發執行，並無相互影響。可是如例子程序中所寫，即使是兩個方法：

執行結果永遠是執行完一個線程的輸出再執行另外一個線程的。　　

說明：

　　若是一個對象有多個synchronized方法，某一時刻某個線程已經進入到了某個synchronized方法，那麼在該方法沒有執行完畢前，其餘線程是沒法訪問該對象的任何synchronized方法的。

結論：

　　當synchronized關鍵字修飾一個方法的時候，該方法叫作同步方法。

　　Java中的每一個對象都有一個鎖（lock），或者叫作監視器（monitor），當一個線程訪問某個對象的synchronized方法時，將該對象上鎖，其餘任何線程都沒法再去訪問該對象的synchronized方法了（這裏是指全部的同步方法，而不只僅是同一個方法），直到以前的那個線程執行方法完畢後（或者是拋出了異常），纔將該對象的鎖釋放掉，其餘線程纔有可能再去訪問該對象的synchronized方法。

　　注意這時候是給對象上鎖，若是是不一樣的對象，則各個對象之間沒有限制關係。

　　嘗試在代碼中構造第二個線程對象時傳入一個新的Example對象，則兩個線程的執行之間沒有什麼制約關係。

三、考慮靜態的同步方法

      當一個synchronized關鍵字修飾的方法同時又被static修飾，以前說過，非靜態的同步方法會將對象上鎖，可是靜態方法不屬於對象，而是屬於類，它會將這個方法所在的類的Class對象上鎖。一個類無論生成多少個對象，它們所對應的是同一個Class對象。

package com.demo;

public class ThreadTest {

     public static void main(String[] args){
         
        Example example = new Example();

        Thread t1 = new Thread1(example);
        
        // 此處即使傳入不一樣的對象，靜態方法同步仍然不容許多個線程同時執行
        example = new Example();
        
        Thread t2 = new Thread2(example);

        t1.start();
        t2.start();
     }
}

class Example{
    
    public synchronized static void execute(){
        
        for (int i = 0; i < 20; ++i){
            try{
                //Thread.sleep(500);
                Thread.sleep((long) Math.random() * 1000);
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("Hello: " + i);
        }
    }
    
    public synchronized static void execute2(){
        
        for (int i = 0; i < 20; ++i){
            try{
                Thread.sleep((long) Math.random() * 1000);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("World: " + i);
        }
    }

}

class Thread1 extends Thread{
    
    private Example example;

    public Thread1(Example example){
        this.example = example;
    }

    @Override
    public void run(){
        example.execute();
    }

}

class Thread2 extends Thread{
    
    private Example example;

    public Thread2(Example example){
        this.example = example;
    }

    @Override
    public void run(){
        example.execute2();
    }

}

運行結果：

Hello: 0
Hello: 1
Hello: 2
Hello: 3
Hello: 4
Hello: 5
Hello: 6
Hello: 7
Hello: 8
Hello: 9
Hello: 10
Hello: 11
Hello: 12
Hello: 13
Hello: 14
Hello: 15
Hello: 16
Hello: 17
Hello: 18
Hello: 19
World: 0
World: 1
World: 2
World: 3
World: 4
World: 5
World: 6
World: 7
World: 8
World: 9
World: 10
World: 11
World: 12
World: 13
World: 14
World: 15
World: 16
World: 17
World: 18
World: 19

     因此若是是靜態方法的狀況（execute()和execute2()都加上static關鍵字），即使是向兩個線程傳入不一樣的Example對象，這兩個線程仍然是互相制約的，必須先執行完一個，再執行下一個。

結論：

　　若是某個synchronized方法是static的，那麼當線程訪問該方法時，它鎖的並非synchronized方法所在的對象，而是synchronized方法所在的類所對應的Class對象。Java中，不管一個類有多少個對象，這些對象會對應惟一一個Class對象，所以當線程分別訪問同一個類的兩個對象的兩個static synchronized方法時，它們的執行順序也是順序的，也就是說一個線程先去執行方法，執行完畢後另外一個線程纔開始。

四、synchronized塊

synchronized塊寫法：

synchronized(object){　     

}

表示線程在執行的時候會將object對象上鎖。（注意這個對象能夠是任意類的對象，也可使用this關鍵字）。

package com.demo;

public class ThreadTest {

     public static void main(String[] args){
         
        Example example = new Example();

        Thread t1 = new Thread1(example); 
        Thread t2 = new Thread2(example);

        t1.start();
        t2.start();
     }
}

class Example{
    
    private Object object = new Object();
    
    public void execute(){
        
        synchronized(object){
            for (int i = 0; i < 20; ++i){
                try{
                    //Thread.sleep(500);
                    Thread.sleep((long) Math.random() * 1000);
                }
                catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println("Hello: " + i);
            }
        }
        
    }
    
    public void execute2(){
        
        synchronized(object){
             for (int i = 0; i < 20; ++i){
                try{
                    Thread.sleep((long) Math.random() * 1000);
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("World: " + i);
            }
        }
       
    }

}

class Thread1 extends Thread{
    
    private Example example;

    public Thread1(Example example){
        this.example = example;
    }

    @Override
    public void run(){
        example.execute();
    }

}

class Thread2 extends Thread{
    
    private Example example;

    public Thread2(Example example){
        this.example = example;
    }

    @Override
    public void run(){
        example.execute2();
    }

}

運行結果：

Hello: 0
Hello: 1
Hello: 2
Hello: 3
Hello: 4
Hello: 5
Hello: 6
Hello: 7
Hello: 8
Hello: 9
Hello: 10
Hello: 11
Hello: 12
Hello: 13
Hello: 14
Hello: 15
Hello: 16
Hello: 17
Hello: 18
Hello: 19
World: 0
World: 1
World: 2
World: 3
World: 4
World: 5
World: 6
World: 7
World: 8
World: 9
World: 10
World: 11
World: 12
World: 13
World: 14
World: 15
World: 16
World: 17
World: 18
World: 19

     例子程序4所達到的效果和例子程序2的效果同樣，都是使得兩個線程的執行順序進行，而不是併發進行，當一個線程執行時，將object對象鎖住，另外一個線程就不能執行對應的塊。

     synchronized方法實際上等同於用一個synchronized塊包住方法中的全部語句，而後在synchronized塊的括號中傳入this關鍵字。固然，若是是靜態方法，須要鎖定的則是class對象。

     可能一個方法中只有幾行代碼會涉及到線程同步問題，因此synchronized塊比synchronized方法更加細粒度地控制了多個線程的訪問，只有synchronized塊中的內容不能同時被多個線程所訪問，方法中的其餘語句仍然能夠同時被多個線程所訪問（包括synchronized塊以前的和以後的）。

　　注意：被synchronized保護的數據應該是私有的。

結論：

　　synchronized方法是一種粗粒度的併發控制，某一時刻，只能有一個線程執行該synchronized方法；

　　synchronized塊則是一種細粒度的併發控制，只會將塊中的代碼同步，位於方法內、synchronized塊以外的其餘代碼是能夠被多個線程同時訪問到的。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程