多執行緒學習筆記（二）之執行緒安全問題

阿新 • • 發佈：2019-02-06

執行緒安全問題的現象

首先讓我們考慮一個問題：

class Demo implements Runnable{
    private int num = 100;
    //實現Runnable介面，覆蓋run方法
    public void run(){
        show();
    }
    public void show(){
        while (true){
            if (num>0){
                System.out.println(Thread.currentThread().getName()+"...sale..." 
+num--);
            }
        }
    }
}
public class ThreadDemo {

    public static void main(String[] args) {
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        Thread t3 = new Thread(d);
        Thread t4 = new Thread(d);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

這裡寫圖片描述

我們假設這樣一種情況，當num=1時，執行Thread-0的時候，恰巧執行完if（num>0）的判斷語句後切換到了1並且執行完System語句又回到Thread-0，那麼將會出現問題，Thread-0執行緒將會輸出-1.（由於執行緒切換是隨機的而導致的錯誤），注意由於類是覆蓋Runnable介面的run方法，介面沒有宣告過異常，因此不能在run方法後通過throws丟擲異常，而只能使用try{}catch{}塊。

執行緒安全問題的原因

原因：
1、多個執行緒在操作共享的資料。
2、操作共享資料的執行緒程式碼有多條，一個執行緒正在進行，還沒有結束的時候其他執行緒進行了一些操作。

同步程式碼塊synchronized

解決思路：就是將多條操作共享資料的執行緒程式碼封裝起來，當有執行緒在執行這些程式碼的時候，其他執行緒不可以參與運算，必須要把當前執行緒都執行完畢後，其他執行緒才可以參與運算。

class Demo implements Runnable{
    private int num = 100;
    private Object lock = new Object();
    //實現Runnable介面，覆蓋run方法
    public void run(){
        while (true){
            synchronized (lock){
                if (num>0){
                    try{
                        Thread.sleep(10);
                    }catch (InterruptedException e){

                    }
                    System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
                }
            }

        }
    }
}

在Java中使用同步程式碼塊就可以解決這個問題，同步程式碼塊的格式：

synchronize（物件）{
    需要被同步的程式碼塊；
}

其中的“物件”相當於一個鎖，只有執行完該程式碼塊才能釋放該物件鎖，下一個執行緒才能執行並鎖定該物件。

給指定物件加鎖

/**
 * 銀行賬戶類
 */
class Account {
   String name;
   float amount;

   public Account(String name, float amount) {
      this.name = name;
      this.amount = amount;
   }
   //存錢
   public  void deposit(float amt) {
      amount += amt;
      try {
         Thread.sleep(100);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }
   //取錢
   public  void withdraw(float amt) {
      amount -= amt;
      try {
         Thread.sleep(100);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }

   public float getBalance() {
      return amount;
   }
}

/**
 * 賬戶操作類
 */
class AccountOperator implements Runnable{
   private Account account;
   public AccountOperator(Account account) {
      this.account = account;
   }

   public void run() {
      synchronized (account) {
         account.deposit(500);
         account.withdraw(500);
         System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
      }
   }
}

呼叫程式碼：

Account account = new Account("zhang san", 10000.0f);
AccountOperator accountOperator = new AccountOperator(account);

final int THREAD_NUM = 5;
Thread threads[] = new Thread[THREAD_NUM];
for (int i = 0; i < THREAD_NUM; i ++) {
   threads[i] = new Thread(accountOperator, "Thread" + i);
   threads[i].start();
}

結果：

Thread3:10000.0 
Thread2:10000.0 
Thread1:10000.0 
Thread4:10000.0 
Thread0:10000.0

在AccountOperator 類中的run方法裡，我們用synchronized 給account物件加了鎖。這時，當一個執行緒訪問account物件時，其他試圖訪問account物件的執行緒將會阻塞，直到該執行緒訪問account物件結束。也就是說誰拿到那個鎖誰就可以執行它所控制的那段程式碼。

當有一個明確的物件作為鎖時，就可以用類似下面這樣的方式寫程式。

public void method3(SomeObject obj)
{
   //obj 鎖定的物件
   synchronized(obj)
   {
      // todo
   }
}

當沒有明確的物件作為鎖，只是想讓一段程式碼同步時，可以建立一個特殊的物件來充當鎖：

class Test implements Runnable
{   
    private byte[] lock = new byte[0];  
   //private Object lock = new Object();  // 特殊的instance變數
   public void method()
   {
      synchronized(lock) {
         // todo 同步程式碼塊
      }
   }

   public void run() {
        method();
   }
}

說明：零長度的byte陣列物件建立起來將比任何物件都經濟――檢視編譯後的位元組碼：生成零長度的byte[]物件只需3條操作碼，而Object lock = new Object()則需要7行操作碼。

synchronized總結
A. 無論synchronized關鍵字加在方法上還是物件上，如果它作用的物件是非靜態的，則它取得的鎖是物件；如果synchronized作用的物件是一個靜態方法或一個類，則它取得的鎖是對類，該類所有的物件同一把鎖。
B. 每個物件只有一個鎖（lock）與之相關聯，誰拿到這個鎖誰就可以執行它所控制的那段程式碼。
C. 實現同步是要很大的系統開銷作為代價的,因為同步外的執行緒都會判斷同步鎖，甚至可能造成死鎖，所以儘量避免無謂的同步控制。

同步的好處：解決了執行緒的安全問題
同步的弊端：相對降低了效率，因為同步外的執行緒都會判斷同步鎖

同步的前提：同步中必須有多個執行緒，並使用同一個鎖

class Test implements Runnable
{   
   public void method()
   {
      synchronized(lock) {
         // todo 同步程式碼塊
      }
   }

   public void run() {
        private byte[] lock = new byte[0];  
       //private Object lock = new Object();  // 特殊的instance變數
        method();
   }
}

如上所示的修改導致每個執行緒開啟執行自己的run方法時，每個run方法都有自己的區域性變數lock，因此不是同一個鎖。而像正確的方式時，棧中儲存的多個引用都指向同一個鎖（原理類似於深複製，淺複製），因此可以保證安全。

同步函式

先來看一個例子：

class Bank{
    private int sum;
    public void add(int num){
        sum+=num;
        System.out.println("sum="+sum);
    }
}

class Cus implements Runnable{
    Bank b = new Bank();//物件b是多個執行緒的共享資料
    public void run(){
        for (int x=0;x<3;x++){
            b.add(100);
        }
    }
}
public class ThreadDemo {

    public static void main(String[] args) {
        Cus c = new Cus();
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();
    }
}

這裡寫圖片描述

當一個執行緒執行sum+=num;之後，還沒有執行System語句cpu變切換到其他執行緒就造成如上現象。

修改（加上同步塊）：

class Bank{
    private int sum;
    private Object lock = new Object();
    public void add(int num){
        synchronized (lock){
            sum+=num;
            System.out.println("name="+Thread.currentThread().getName()+"sum="+sum);
        }
    }
}

仔細觀察上述程式碼，同步程式碼塊synchronized是一個封裝體（帶有同步特性），而函式add本身也是種封裝，因此讓函式具有“同步性”即可：

class Bank{
    private int sum;
    public synchronized void add(int num){
        sum+=num;
        System.out.println("name="+Thread.currentThread().getName()+"sum="+sum);
    }
}

我們回過來看上面出現過的一個問題的程式碼（進行了一些修改）：

class Demo implements Runnable{
    private int num = 100;
    //實現Runnable介面，覆蓋run方法
    public synchronized void run(){
        while (true){
                if (num>0){
                    try{
                        Thread.sleep(10);
                    }catch (InterruptedException e){

                    }
                    System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
                }           
        }
    }
}

會出現一個問題，同步的範圍加大了，因為只有if語句之後的部分是需要同步的，而範圍擴大到了run方法，導致一個執行緒進行run方法，其他執行緒無法進行，因此num–的操作完全由一個執行緒完成了。

正確的範圍加同步：

class Demo implements Runnable{
    private int num = 100;
    //實現Runnable介面，覆蓋run方法
    public void run(){
        while (true){
            synchronized (this){
                if (num>0){
                    try{
                        Thread.sleep(10);
                    }catch (InterruptedException e){

                    }
                    System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
                }
            }

        }
    }
}

或將同步部分提出來單獨封裝到一個方法中：

class Demo implements Runnable{
    private int num = 100;
    //實現Runnable介面，覆蓋run方法
    public void run(){
        while (true){            
           show();
        }
    }
    public synchorized show(){
         if (num>0){
             try{
                 Thread.sleep(10);
              }catch (InterruptedException e){

                    }
                                System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
                }
    }
}

因此可以總結出同步函式的格式：

寫法一：

public synchronized void method()
{
   // todo
}

寫法二：

public void method()
{
   synchronized(this) {
      // todo
   }
}

寫法一修飾的是一個方法，寫法二修飾的是一個程式碼塊，但寫法一與寫法二是等價的，都是鎖定了整個方法時的內容。

同步函式所用的鎖是this：同步函式僅僅是函式帶有了同步性，同步synchronized本身是不帶有鎖的，因此函式是帶有鎖的，函式使用的時候是被物件呼叫的，函式都有自己所屬的this，例如上述例項：

class Bank{
    private int sum;
    public void add(int num){
        sum+=num;
        System.out.println("sum="+sum);
    }
}

class Cus implements Runnable{
    Bank b = new Bank();//物件b是多個執行緒的共享資料
    public synchronized void run(){
        System.out.println("this:"+this);
        for (int x=0;x<3;x++){
            b.add(100);
        }
    }
}
public class ThreadDemo {

    public static void main(String[] args) {
        Cus c = new Cus();
        System.out.println("this:"+c);
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();
    }
}

這裡寫圖片描述

對比hash值即可發現，同步函式使用的鎖是this，因此保證各個執行緒使用的是相同的鎖。

同步函式與同步程式碼塊的區別：

同步函式的鎖是固定的this，同步程式碼塊的鎖可以是任意的物件
同步程式碼塊中使用的鎖是this時可以簡化為同步函式

靜態同步函式

首先，靜態函式本身不具有this，靜態的同步函式使用的鎖是該函式所屬的位元組碼檔案物件，可以用getClass方法獲取，也可以使用“類名.class”表示（類的位元組碼檔案是唯一的，只不過可以建立多個物件而已，如果是靜態方法中，使用“類名.class”，因為getClass方法不是靜態方法）

class SyncThread implements Runnable {
   private static int count;

   public SyncThread() {
      count = 0;
   }

   public synchronized static void method() {
      for (int i = 0; i < 5; i ++) {
         try {
            System.out.println(Thread.currentThread().getName() + ":" + (count++));
            Thread.sleep(100);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }

   public synchronized void run() {
      method();
   }
}

呼叫程式碼：

SyncThread syncThread1 = new SyncThread();
SyncThread syncThread2 = new SyncThread();
Thread thread1 = new Thread(syncThread1, "SyncThread1");
Thread thread2 = new Thread(syncThread2, "SyncThread2");
thread1.start();
thread2.start();

結果：

SyncThread1:0 
SyncThread1:1 
SyncThread1:2 
SyncThread1:3 
SyncThread1:4 
SyncThread2:5 
SyncThread2:6 
SyncThread2:7 
SyncThread2:8 
SyncThread2:9

syncThread1和syncThread2是SyncThread的兩個物件，但在thread1和thread2併發執行時卻保持了執行緒同步。這是因為run中呼叫了靜態方法method，而靜態方法是屬於類的，所以syncThread1和syncThread2相當於用了同一把鎖。這與Demo1是不同的。synchronized作用於一個類T時，是給這個類T加鎖，T的所有物件用的是同一把鎖。

synchorized注意事項

（1） synchronized關鍵字不能繼承。

雖然可以使用synchronized來定義方法，但synchronized並不屬於方法定義的一部分，因此，synchronized關鍵字不能被繼承。如果在父類中的某個方法使用了synchronized關鍵字，而在子類中覆蓋了這個方法，在子類中的這個方法預設情況下並不是同步的，而必須顯式地在子類的這個方法中加上synchronized關鍵字才可以。當然，還可以在子類方法中呼叫父類中相應的方法，這樣雖然子類中的方法不是同步的，但子類呼叫了父類的同步方法，因此，子類的方法也就相當於同步了。這兩種方式的例子程式碼如下：
在子類方法中加上synchronized關鍵字：

class Parent {
   public synchronized void method() { }
}
class Child extends Parent {
   public synchronized void method() { }
}

在子類方法中呼叫父類的同步方法

class Parent {
   public synchronized void method() {   }
}
class Child extends Parent {
   public void method() { super.method();   }
}

（2）在定義介面方法時不能使用synchronized關鍵字。

（3）構造方法不能使用synchronized關鍵字，但可以使用synchronized程式碼塊來進行同步。

（4）一個執行緒進入一個物件的synchronized方法（非靜態）時，其他執行緒是否可以進入此物件的其他方法？
這取決於其他方法本身，可以訪問該物件的非synchronized方法或者靜態synchronized方法，因為靜態static方法用的同步鎖是當前類的位元組碼，與非靜態方法不能同步（非靜態的方法的鎖用的是this），因此兩個方法不是用的同一個鎖，因此靜態方法可以被呼叫。

死鎖

死鎖的原因：同步的巢狀

class Demo implements Runnable{
    private int num = 100;
    public boolean flag = true;
    private Object lock = new Object();
    //實現Runnable介面，覆蓋run方法
    public void run(){
        if (flag){
            while (true){
                synchronized (lock){
                    show();//持有鎖lock，想進入鎖是this的show方法
                }
            }
        }else {
            while (true){
                show();//持有鎖this，但是show方法中想要執行需要鎖lock
            }
        }
    }
    public synchronized void show(){
        synchronized (lock){
            if (num>0){
                try{
                    Thread.sleep(10);
                }catch (InterruptedException e){

                }
                System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
            }
        }
    }
}

public class SingleDemo {
    public static void main(String[] args) {
        Demo t = new Demo();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.start();
        try{
            Thread.sleep(10);
        }catch (InterruptedException e){

        }
        t.flag = false;
        t2.start();
    }
}

多執行緒學習筆記（二）之執行緒安全問題

執行緒安全問題的現象

執行緒安全問題的原因

同步程式碼塊synchronized

同步函式

靜態同步函式

synchorized注意事項

死鎖

多執行緒學習筆記（二）之執行緒安全問題

Java 多執行緒學習筆記（二）停止執行緒的幾種方法

Java多執行緒學習筆記（一）之中斷中的Interrupt，interrupted()，isInterrupted()

多執行緒學習筆記（三）之單例模式中的執行緒問題

IO流學習筆記（二）之BufferedWriter與BufferedReader及例項Demo

Servlet學習筆記（二）之Servlet路徑對映配置、Servlet介面、ServletConfig、ServletContext

mybatis學習筆記（二）之XML方式的基本用法

A-GPS學習筆記（二）之SUPL

TensorFlow學習筆記（二）之視覺化(Tensorboard）

oracle資料庫學習筆記（二）之分組統計查詢

Android百度地圖開發學習筆記（二）之定位當前位置和自定義控制元件返回

pelican學習筆記（二）之Writing content

OSG學習筆記（二）之OSG靜態庫的使用

MongoDB 學習筆記（二）之查詢

nodejs學習筆記（二）——javascript的同步非同步行為和多執行緒

java學習筆記（二）多執行緒

多執行緒學習總結（二）

Java多執行緒學習筆記（四）

多執行緒學習筆記（一）

java多執行緒學習筆記（高階）

多執行緒學習筆記（二）之執行緒安全問題

執行緒安全問題的現象

執行緒安全問題的原因

同步程式碼塊synchronized

同步函式

靜態同步函式

synchorized注意事項

死鎖

相關推薦