欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Java多線程程序中synchronized修飾方法的使用實例

 更新時間：2016年06月15日 15:39:45   作者：fireshort  
synchronized關(guān)鍵字主要北用來進行線程同步,這里我們主要來演示Java多線程程序中synchronized修飾方法的使用實例,需要的朋友可以參考下:

在Java 5以前，是用synchronized關(guān)鍵字來實現(xiàn)鎖的功能。

synchronized關(guān)鍵字可以作為方法的修飾符（同步方法），也可作用于函數(shù)內(nèi)的語句（同步代碼塊）。

掌握synchronized，關(guān)鍵是要掌握把那個東西作為鎖。對于類的非靜態(tài)方法（成員方法）而言，意味著要取得對象實例的鎖；對于類的靜態(tài)方法（類方法）而言，要取得類的Class對象的鎖；對于同步代碼塊，要指定取得的是哪個對象的鎖。同步非靜態(tài)方法可以視為包含整個方法的synchronized(this) { … }代碼塊。   

不管是同步代碼塊還是同步方法，每次只有一個線程可以進入（在同一時刻最多只有一個線程執(zhí)行該段代碼。），如果其他線程試圖進入（不管是同一同步塊還是不同的同步塊），jvm會將它們掛起（放入到等鎖池中）。這種結(jié)構(gòu)在并發(fā)理論中稱為臨界區(qū)（critical section）。

在jvm內(nèi)部，為了提高效率，同時運行的每個線程都會有它正在處理的數(shù)據(jù)的緩存副本，當我們使用synchronzied進行同步的時候，真正被同步的是在不同線程中表示被鎖定對象的內(nèi)存塊（副本數(shù)據(jù)會保持和主內(nèi)存的同步，現(xiàn)在知道為什么要用同步這個詞匯了吧），簡單的說就是在同步塊或同步方法執(zhí)行完后，對被鎖定的對象做的任何修改要在釋放鎖之前寫回到主內(nèi)存中；在進入同步塊得到鎖之后，被鎖定對象的數(shù)據(jù)是從主內(nèi)存中讀出來的，持有鎖的線程的數(shù)據(jù)副本一定和主內(nèi)存中的數(shù)據(jù)視圖是同步的 。

下面舉具體的例子來說明synchronized的各種情況。

synchronized同步方法

首先來看同步方法的例子：

public class SynchronizedTest1 extends Thread 
{ 
  private synchronized void testSynchronizedMethod() 
  { 
    for (int i = 0; i < 10; i++) 
    { 
      System.out.println(Thread.currentThread().getName() 
          + " testSynchronizedMethod:" + i); 
 
      try 
      { 
        Thread.sleep(100); 
      } 
      catch (InterruptedException e) 
      { 
        e.printStackTrace(); 
      } 
    } 
  } 
 
  @Override 
  public void run() 
  { 
    testSynchronizedMethod(); 
  } 
 
  public static void main(String[] args) 
  { 
 
        SynchronizedTest1 t = new SynchronizedTest1(); 
    t.start(); 
    t.testSynchronizedMethod(); 
  } 
}

運行該程序輸出結(jié)果為：

main testSynchronizedMethod:0 
main testSynchronizedMethod:1 
main testSynchronizedMethod:2 
main testSynchronizedMethod:3 
main testSynchronizedMethod:4 
main testSynchronizedMethod:5 
main testSynchronizedMethod:6 
main testSynchronizedMethod:7 
main testSynchronizedMethod:8 
main testSynchronizedMethod:9 
Thread-0 testSynchronizedMethod:0 
Thread-0 testSynchronizedMethod:1 
Thread-0 testSynchronizedMethod:2 
Thread-0 testSynchronizedMethod:3 
Thread-0 testSynchronizedMethod:4 
Thread-0 testSynchronizedMethod:5 
Thread-0 testSynchronizedMethod:6 
Thread-0 testSynchronizedMethod:7 
Thread-0 testSynchronizedMethod:8 
Thread-0 testSynchronizedMethod:9

可以看到testSynchronizedMethod方法在兩個線程之間同步執(zhí)行。

如果此時將main方法修改為如下所示，則兩個線程并不能同步執(zhí)行，因為此時兩個線程的同步監(jiān)視器不是同一個對象，不能起到同步的作用。

public static void main(String[] args) 
  { 
    Thread t = new SynchronizedTest1(); 
    t.start(); 
     
    Thread t1 = new SynchronizedTest1(); 
    t1.start(); 
  }

此時輸出結(jié)果如下所示：

Thread-0 testSynchronizedMethod:0 
Thread-1 testSynchronizedMethod:0 
Thread-0 testSynchronizedMethod:1 
Thread-1 testSynchronizedMethod:1 
Thread-0 testSynchronizedMethod:2 
Thread-1 testSynchronizedMethod:2 
Thread-0 testSynchronizedMethod:3 
Thread-1 testSynchronizedMethod:3 
Thread-0 testSynchronizedMethod:4 
Thread-1 testSynchronizedMethod:4 
Thread-0 testSynchronizedMethod:5 
Thread-1 testSynchronizedMethod:5 
Thread-0 testSynchronizedMethod:6 
Thread-1 testSynchronizedMethod:6 
Thread-0 testSynchronizedMethod:7 
Thread-1 testSynchronizedMethod:7 
Thread-0 testSynchronizedMethod:8 
Thread-1 testSynchronizedMethod:8 
Thread-0 testSynchronizedMethod:9 
Thread-1 testSynchronizedMethod:9

若想修改后的main方法能夠在兩個線程之間同步運行，需要將testSynchronizedMethod方法聲明為靜態(tài)方法，這樣兩個線程的監(jiān)視器是同一個對象（類對象），能夠同步執(zhí)行。修改后的代碼如下所示：

public class SynchronizedTest1 extends Thread 
{ 
  private static synchronized void testSynchronizedMethod() 
  { 
    for (int i = 0; i < 10; i++) 
    { 
      System.out.println(Thread.currentThread().getName() 
          + " testSynchronizedMethod:" + i); 
 
      try 
      { 
        Thread.sleep(100); 
      } 
      catch (InterruptedException e) 
      { 
        e.printStackTrace(); 
      } 
    } 
  } 
 
  @Override 
  public void run() 
  { 
    testSynchronizedMethod(); 
  } 
 
  public static void main(String[] args) 
  { 
    Thread t = new SynchronizedTest1(); 
    t.start(); 
     
    Thread t1 = new SynchronizedTest1(); 
    t1.start(); 
  } 
}

輸出結(jié)果如下：

Thread-0 testSynchronizedMethod:0 
Thread-0 testSynchronizedMethod:1 
Thread-0 testSynchronizedMethod:2 
Thread-0 testSynchronizedMethod:3 
Thread-0 testSynchronizedMethod:4 
Thread-0 testSynchronizedMethod:5 
Thread-0 testSynchronizedMethod:6 
Thread-0 testSynchronizedMethod:7 
Thread-0 testSynchronizedMethod:8 
Thread-0 testSynchronizedMethod:9 
Thread-1 testSynchronizedMethod:0 
Thread-1 testSynchronizedMethod:1 
Thread-1 testSynchronizedMethod:2 
Thread-1 testSynchronizedMethod:3 
Thread-1 testSynchronizedMethod:4 
Thread-1 testSynchronizedMethod:5 
Thread-1 testSynchronizedMethod:6 
Thread-1 testSynchronizedMethod:7 
Thread-1 testSynchronizedMethod:8 
Thread-1 testSynchronizedMethod:9

同步塊的情況與同步方法類似，只是同步塊將同步控制的粒度縮小，這樣能夠更好的發(fā)揮多線程并行執(zhí)行的效率。
使用this對象控制同一對象實例之間的同步：

public class SynchronizedTest2 extends Thread 
{ 
  private void testSynchronizedBlock() 
  { 
    synchronized (this) 
    { 
      for (int i = 0; i < 10; i++) 
      { 
        System.out.println(Thread.currentThread().getName() 
            + " testSynchronizedBlock:" + i); 
 
        try 
        { 
          Thread.sleep(100); 
        } 
        catch (InterruptedException e) 
        { 
          e.printStackTrace(); 
        } 
      } 
    } 
  } 
 
  @Override 
  public void run() 
  { 
    testSynchronizedBlock(); 
  } 
 
  public static void main(String[] args) 
  { 
    SynchronizedTest2 t = new SynchronizedTest2(); 
    t.start(); 
 
    t.testSynchronizedBlock(); 
  } 
}

輸出結(jié)果：

main testSynchronizedBlock:0 
main testSynchronizedBlock:1 
main testSynchronizedBlock:2 
main testSynchronizedBlock:3 
main testSynchronizedBlock:4 
main testSynchronizedBlock:5 
main testSynchronizedBlock:6 
main testSynchronizedBlock:7 
main testSynchronizedBlock:8 
main testSynchronizedBlock:9 
Thread-0 testSynchronizedBlock:0 
Thread-0 testSynchronizedBlock:1 
Thread-0 testSynchronizedBlock:2 
Thread-0 testSynchronizedBlock:3 
Thread-0 testSynchronizedBlock:4 
Thread-0 testSynchronizedBlock:5 
Thread-0 testSynchronizedBlock:6 
Thread-0 testSynchronizedBlock:7 
Thread-0 testSynchronizedBlock:8 
Thread-0 testSynchronizedBlock:9

使用class對象控制不同實例之間的同步：

public class SynchronizedTest2 extends Thread 
{ 
  private void testSynchronizedBlock() 
  { 
    synchronized (SynchronizedTest2.class) 
    { 
      for (int i = 0; i < 10; i++) 
      { 
        System.out.println(Thread.currentThread().getName() 
            + " testSynchronizedBlock:" + i); 
 
        try 
        { 
          Thread.sleep(100); 
        } 
        catch (InterruptedException e) 
        { 
          e.printStackTrace(); 
        } 
      } 
    } 
  } 
 
  @Override 
  public void run() 
  { 
    testSynchronizedBlock(); 
  } 
 
  public static void main(String[] args) 
  { 
    Thread t = new SynchronizedTest2(); 
    t.start(); 
 
    Thread t2 = new SynchronizedTest2(); 
    t2.start(); 
  } 
}

輸出結(jié)果：

Thread-0 testSynchronizedBlock:0 
Thread-0 testSynchronizedBlock:1 
Thread-0 testSynchronizedBlock:2 
Thread-0 testSynchronizedBlock:3 
Thread-0 testSynchronizedBlock:4 
Thread-0 testSynchronizedBlock:5 
Thread-0 testSynchronizedBlock:6 
Thread-0 testSynchronizedBlock:7 
Thread-0 testSynchronizedBlock:8 
Thread-0 testSynchronizedBlock:9 
Thread-1 testSynchronizedBlock:0 
Thread-1 testSynchronizedBlock:1 
Thread-1 testSynchronizedBlock:2 
Thread-1 testSynchronizedBlock:3 
Thread-1 testSynchronizedBlock:4 
Thread-1 testSynchronizedBlock:5 
Thread-1 testSynchronizedBlock:6 
Thread-1 testSynchronizedBlock:7 
Thread-1 testSynchronizedBlock:8 
Thread-1 testSynchronizedBlock:9

 
使用synchronized關(guān)鍵字進行同步控制時，一定要把握好對象監(jiān)視器，只有獲得監(jiān)視器的進程可以運行，其它都需要等待獲取監(jiān)視器。任何一個非null的對象都可以作為對象監(jiān)視器，當synchronized作用在方法上時，鎖住的便是對象實例（this）；當作用在靜態(tài)方法時鎖住的便是對象對應的Class實例

兩個線程同時訪問一個對象的同步方法
當兩個并發(fā)線程訪問同一個對象的同步方法時，只能有一個線程得到執(zhí)行。另一個線程必須等待當前線程執(zhí)行完這個以后才能執(zhí)行。

public class TwoThread {
  public static void main(String[] args) {
    final TwoThread twoThread = new TwoThread();

    Thread t1 = new Thread(new Runnable() {
      public void run() {
        twoThread.syncMethod();
      }
    }, "A");
    Thread t2 = new Thread(new Runnable() {
      public void run() {
        twoThread.syncMethod();
      }
    }, "B");

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

  public synchronized void syncMethod() {
    for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + " : " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }

}

輸出結(jié)果：

A : 0
A : 1
A : 2
A : 3
A : 4
B : 0
B : 1
B : 2
B : 3
B : 4

兩個線程訪問的是兩個對象的同步方法
這種情況下，synchronized不起作用，跟普通的方法一樣。因為對應的鎖是各自的對象。

public class TwoObject {
  public static void main(String[] args) {
    final TwoObject object1 = new TwoObject();
    Thread t1 = new Thread(new Runnable() {
      public void run() {
        object1.syncMethod();
      }
    }, "Object1");
    t1.start();

    final TwoObject object2 = new TwoObject();
    Thread t2 = new Thread(new Runnable() {
      public void run() {
        object2.syncMethod();
      }
    }, "Object2");
    t2.start();
  }

  public synchronized void syncMethod() {
    for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + " : " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }

}

其中一種可能的輸出結(jié)果：

Object2 : 0
Object1 : 0
Object1 : 1
Object2 : 1
Object2 : 2
Object1 : 2
Object2 : 3
Object1 : 3
Object1 : 4
Object2 : 4

兩個線程訪問的是synchronized的靜態(tài)方法
這種情況，由于鎖住的是Class，在任何時候，該靜態(tài)方法只有一個線程可以執(zhí)行。

同時訪問同步方法與非同步方法
當一個線程訪問對象的一個同步方法時，另一個線程仍然可以訪問該對象中的非同步方法。

public class SyncAndNoSync {
  public static void main(String[] args) {
    final SyncAndNoSync syncAndNoSync = new SyncAndNoSync();

    Thread t1 = new Thread(new Runnable() {
      public void run() {
        syncAndNoSync.syncMethod();
      }
    }, "A");
    t1.start();

    Thread t2 = new Thread(new Runnable() {
      public void run() {
        syncAndNoSync.noSyncMethod();
      }
    }, "B");
    t2.start();
  }

  public synchronized void syncMethod() {
    for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + " at syncMethod(): " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }

  public void noSyncMethod() {
    for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + " at noSyncMethod(): " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }

}

一種可能的輸出結(jié)果：

B at noSyncMethod(): 0
A at syncMethod(): 0
B at noSyncMethod(): 1
A at syncMethod(): 1
B at noSyncMethod(): 2
A at syncMethod(): 2
B at noSyncMethod(): 3
A at syncMethod(): 3
A at syncMethod(): 4
B at noSyncMethod(): 4

訪問同一個對象的不同同步方法
當一個線程訪問一個對象的同步方法A時，其他線程對該對象中所有其它同步方法的訪問將被阻塞。因為第一個線程已經(jīng)獲得了對象鎖，其他線程得不到鎖，則雖然是訪問不同的方法，但是沒有獲得鎖，也無法訪問。

public class TwoSyncMethod {
  public static void main(String[] args) {
    final TwoSyncMethod twoSyncMethod = new TwoSyncMethod();

    Thread t1 = new Thread(new Runnable() {
      public void run() {
        twoSyncMethod.syncMethod1();
      }
    }, "A");
    t1.start();

    Thread t2 = new Thread(new Runnable() {
      public void run() {
        twoSyncMethod.syncMethod2();
      }
    }, "B");
    t2.start();
  }

  public synchronized void syncMethod1() {
    for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + " at syncMethod1(): " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }

  public synchronized void syncMethod2() {
    for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + " at syncMethod2(): " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }

}

輸出結(jié)果：

A at syncMethod1(): 0
A at syncMethod1(): 1
A at syncMethod1(): 2
A at syncMethod1(): 3
A at syncMethod1(): 4
B at syncMethod2(): 0
B at syncMethod2(): 1
B at syncMethod2(): 2
B at syncMethod2(): 3
B at syncMethod2(): 4

相關(guān)文章

  • springboot讀取resource配置文件生成容器對象的示例代碼

    springboot讀取resource配置文件生成容器對象的示例代碼

    這篇文章主要介紹了springboot讀取resource配置文件生成容器對象的示例代碼,本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下
    2023-07-07
  • java如何將int數(shù)組轉(zhuǎn)化為Integer數(shù)組

    java如何將int數(shù)組轉(zhuǎn)化為Integer數(shù)組

    這篇文章主要介紹了java如何將int數(shù)組轉(zhuǎn)化為Integer數(shù)組，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
    2022-11-11
  • 微信公眾帳號開發(fā)教程之圖文消息全攻略

    微信公眾帳號開發(fā)教程之圖文消息全攻略

    本篇主要介紹微信公眾帳號開發(fā)中圖文消息的使用，以及圖文消息的幾種表現(xiàn)形式。標題取名為"圖文消息全攻略"，這絕對不是標題黨，是想借此機會把大家對圖文消息相關(guān)的問題、疑慮、障礙全部清除掉。
    2016-12-12
  • 解決mybatis-plus使用jdk8的LocalDateTime 查詢時報錯的方法

    解決mybatis-plus使用jdk8的LocalDateTime 查詢時報錯的方法

    這篇文章主要介紹了解決mybatis-plus使用jdk8的LocalDateTime 查詢時報錯的方法，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
    2020-08-08
  • springcloud?feign服務(wù)之間調(diào)用,date類型轉(zhuǎn)換錯誤的問題

    springcloud?feign服務(wù)之間調(diào)用,date類型轉(zhuǎn)換錯誤的問題

    這篇文章主要介紹了springcloud?feign服務(wù)之間調(diào)用,date類型轉(zhuǎn)換錯誤的問題及解決，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
    2022-03-03
  • Jackson庫中objectMapper的用法

    Jackson庫中objectMapper的用法

    這篇文章主要介紹了Jackson庫中objectMapper的用法，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
    2021-06-06
  • Java之String.format()方法案例講解

    Java之String.format()方法案例講解

    這篇文章主要介紹了Java之String.format()方法案例講解,本篇文章通過簡要的案例,講解了該項技術(shù)的了解與使用,以下就是詳細內(nèi)容,需要的朋友可以參考下
    2021-08-08
  • 優(yōu)雅地在Java應用中實現(xiàn)全局枚舉處理的方法

    優(yōu)雅地在Java應用中實現(xiàn)全局枚舉處理的方法

    這篇文章主要給大家介紹了關(guān)于如何優(yōu)雅地在Java應用中實現(xiàn)全局枚舉處理的相關(guān)資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面來一起學習學習吧
    2019-02-02
  • SpringMvc后臺接收json數(shù)據(jù)中文亂碼問題詳解

    SpringMvc后臺接收json數(shù)據(jù)中文亂碼問題詳解

    這篇文章主要介紹了SpringMvc后臺接收json數(shù)據(jù)中文亂碼問題詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
    2019-09-09
  • 使用Feign調(diào)用第三方http接口

    使用Feign調(diào)用第三方http接口

    這篇文章主要介紹了使用Feign調(diào)用第三方http接口，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
    2022-03-03

最新評論