2. 程式人生 > >5.並發編程-synchronized 細節說明

5.並發編程-synchronized 細節說明

阿新 • • 發佈：2018-11-20
dubbo read zed ext tro 當前 使用 current runnable

並發編程-synchronized 細節說明

1. synchronized-鎖重入 & 異常釋放鎖 說明

  • * 關鍵字synchronized 擁有鎖重入的功能，也就是在使用synchronized時，當一個線程得到一個對象的鎖後，再次請求此對象時可以再次得到該對象的鎖；

2. synchronized-代碼塊 說明

  • * 使用synchronized聲明的方法在某些情況下是比較極端的（存在弊端）：線程A調用同步的方法執行一段很長時間的任務，那麽B線程就必須等待比較長的時間才能執行；

解決方法：使用synchronized代碼塊去優化代碼執行的時間，也就是減少鎖的粒度；

  • * 特別註意一個問題：就是不要使用String的常量進行加鎖，會出現死循環的問題。
  • * 鎖對象的改變問題：當使用一個對象進行加鎖的時候，要註意對象本身發生變化的時候，那麽持有的鎖就不同。
  • 如果對象本身不發生變化，那麽依然是同步的，即使對象的屬性發生變化也是同步的。

實例：
SyncDubbo1.java 和 SyncDubbo2.java

/**
 * synchronized的重入
 * @@author Maozw
 *
 */
public class SyncDubbo1 {

  public synchronized void method1(){
    System.out.println(
 
"method1..");
    method2();
  }
  public synchronized void method2(){
    System.out.println("method2..");
    method3();
  }
  public synchronized void method3(){
    System.out.println("method3..");
  }

  public static void main(String[] args) {
    final SyncDubbo1 sd = new SyncDubbo1();
    Thread t1 
 
= new Thread(new Runnable() {
      @Override
      public void run() {
        sd.method1();
      }
    });
    t1.start();
  }
}
/**
 * synchronized的重入
 * @@author Maozw
 *
 */
public class SyncDubbo2 {

  static class Main {
    public int i = 10;
    public synchronized void operationSup(){
      try {
        i--;
        System.out.println("Main print i = " + i);
        Thread.sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  static class Sub extends Main {
    public synchronized void operationSub(){
      try {
        while(i > 0) {
          i--;
          System.out.println("Sub print i = " + i);
          Thread.sleep(100);        
          this.operationSup();
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public static void main(String[] args) {

    Thread t1 = new Thread(new Runnable() {
      @Override
      public void run() {
        Sub sub = new Sub();
        sub.operationSub();
      }
    });

    t1.start();
  }
}

出現異常會釋放鎖

示例：SyncException.java
說明：對於web程序，異常釋放鎖的情況，如果來不及及時處理，很可能對應用程序的業務邏輯產出錯誤：如執行一個隊列任務，很多對象都去等待第一個對象執行完成並釋放鎖，但是第一個對象由於異常原因，導致業務邏輯沒有正常執行完成，就釋放了鎖，那麽後續任務就會產生一些問題；所以這個問題需要註意；

/**
 * synchronized異常
 * @@author Maozw
 *
 */
public class SyncException {

  private int i = 0;
  public synchronized void operation(){
    while(true){
      try {
        i++;
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName() + " , i = " + i);
        if(i == 20){
          //Integer.parseInt("a");
          throw new RuntimeException();
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public static void main(String[] args) {

    final SyncException se = new SyncException();
    Thread t1 = new Thread(new Runnable() {
      @Override
      public void run() {
        se.operation();
      }
    },"t1");
    t1.start();
  }
}

synchronized-代碼塊 說明

使用synchronized聲明的方法在某些情況下是比較極端的（存在弊端）：線程A調用同步的方法執行一段很長時間的任務，那麽B線程就必須等待比較長的時間才能執行；
* 解決方法：使用synchronized代碼塊去優化代碼執行的時間，也就是減少鎖的粒度；
* 示例：ObjectLock.java
* 說明：synchronized可以使用任務的Object對象進行加鎖，用法比較靈活；

技術分享圖片 
 1 /**
 2  * 使用synchronized代碼塊加鎖,比較靈活
 3  * @@author Maozw
 4  *
 5  */
 6 public class ObjectLock {
 7 
 8   public void method1(){
 9     synchronized (this) {    //對象鎖
10       try {
11         System.out.println("do method1..");
12         Thread.sleep(2000);
13       } catch (InterruptedException e) {
14         e.printStackTrace();
15       }
16     }
17   }
18 
19   public void method2(){        //類鎖
20     synchronized (ObjectLock.class) {
21       try {
22         System.out.println("do method2..");
23         Thread.sleep(2000);
24       } catch (InterruptedException e) {
25         e.printStackTrace();
26       }
27     }
28   }
29 
30   private Object lock = new Object();
31   public void method3(){        //任何對象鎖
32     synchronized (lock) {
33       try {
34         System.out.println("do method3..");
35         Thread.sleep(2000);
36       } catch (InterruptedException e) {
37         e.printStackTrace();
38       }
39     }
40   }
41 
42 
43   public static void main(String[] args) {
44 
45     final ObjectLock objLock = new ObjectLock();
46     Thread t1 = new Thread(new Runnable() {
47       @Override
48       public void run() {
49         objLock.method1();
50       }
51     });
52     Thread t2 = new Thread(new Runnable() {
53       @Override
54       public void run() {
55         objLock.method2();
56       }
57     });
58     Thread t3 = new Thread(new Runnable() {
59       @Override
60       public void run() {
61         objLock.method3();
62       }
63     });
64 
65     t1.start();
66     t2.start();
67     t3.start();
68   }
69 }
View Code

特別註意一個問題：就是不要使用String的常量進行加鎖，會出現死循環的問題。

* 示例：StringLock.java
* 說明：

/**
 * synchronized代碼塊對字符串的鎖，註意String常量池的緩存功能
 * @@author Maozw
 *
 */
public class StringLock {

  public void method() {
    //new String("字符串常量")
    synchronized ("字符串常量") {
      try {
        while(true){
          System.out.println("當前線程 : "  + Thread.currentThread().getName() + "開始");
          Thread.sleep(1000);        
          System.out.println("當前線程 : "  + Thread.currentThread().getName() + "結束");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public static void main(String[] args) {
    final StringLock stringLock = new StringLock();
    Thread t1 = new Thread(new Runnable() {
      @Override
      public void run() {
        stringLock.method();
      }
    },"t1");
    Thread t2 = new Thread(new Runnable() {
      @Override
      public void run() {
        stringLock.method();
      }
    },"t2");

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

鎖對象的改變問題：

* 說明：

  • 1. 當使用一個對象進行加鎖的時候，要註意對象本身發生變化的時候，那麽持有的鎖就不同。
  • 2. 如果對象本身不發生變化，那麽依然是同步的，即使對象的屬性發生變化也是同步的。

* 示例：ModifyLock.java

技術分享圖片 
  /**
   * 同一對象屬性的修改不會影響鎖的情況
   * @@author Maozw
   *
   */
  public class ModifyLock {

    private String name ;
    private int age ;

    public String getName() {
      return name;
    }
    public void setName(String name) {
      this.name = name;
    }
    public int getAge() {
      return age;
    }
    public void setAge(int age) {
      this.age = age;
    }

    public synchronized void changeAttributte(String name, int age) {
      try {
        System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 開始");
        this.setName(name);
        this.setAge(age);

        System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 修改對象內容為： "
            + this.getName() + ", " + this.getAge());

        Thread.sleep(2000);
        System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 結束");
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }

    public static void main(String[] args) {
      final ModifyLock modifyLock = new ModifyLock();
      Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
          modifyLock.changeAttributte("張三", 20);
        }
      },"t1");
      Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
          modifyLock.changeAttributte("李四", 21);
        }
      },"t2");

      t1.start();
      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      t2.start();
    }
  }
View Code

死鎖問題 ：

* 說明： 在設計程序時就應該避免雙方相互持有對方的鎖的情況
* 示例：

技術分享圖片 
/**
   * 死鎖問題，在設計程序時就應該避免雙方相互持有對方的鎖的情況
   * @@author Maozw
   *
   */
  public class DeadLock implements Runnable{

    private String tag;
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    public void setTag(String tag){
      this.tag = tag;
    }

    @Override
    public void run() {
      if(tag.equals("a")){
        synchronized (lock1) {
          try {
            System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 進入lock1執行");
            Thread.sleep(2000);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          synchronized (lock2) {
            System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 進入lock2執行");
          }
        }
      }
      if(tag.equals("b")){
        synchronized (lock2) {
          try {
            System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 進入lock2執行");
            Thread.sleep(2000);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          synchronized (lock1) {
            System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 進入lock1執行");
          }
        }
      }
    }

    public static void main(String[] args) {

      DeadLock d1 = new DeadLock();
      d1.setTag("a");
      DeadLock d2 = new DeadLock();
      d2.setTag("b");

      Thread t1 = new Thread(d1, "t1");
      Thread t2 = new Thread(d2, "t2");

      t1.start();
      try {
        Thread.sleep(500);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      t2.start();
    }
  }
View Code

5.並發編程-synchronized 細節說明

相關推薦

5.並發編程-synchronized 細節說明

dubbo read zed ext tro 當前 使用 current runnable 並發編程-synchronized 細節說明 1. synchronized-鎖重入 & 異常釋放鎖 說明 * 關鍵字synchronized 擁有鎖重入的功能，

Java並發編程 Synchronized及其實現原理

.html 隱式 註意 填充 end join() 另一個 ride 實現原理 Synchronized是Java中解決並發問題的一種最常用的方法，也是最簡單的一種方法。Synchronized的作用主要有三個：（1）確保線程互斥的訪問同步代碼（2）保證共享變量的修改能夠及

Java並發編程-synchronized

代碼執行 方法 存儲 範圍 對象的引用 locked AI ear 合並 　　這是Java並發編程學習的第一篇，最早在2013年時便勵誌要把JAVA的並發編程好好學習一下，那個時候才工作一年。後來由於各種各樣的原因，未能學習起來，5年時間過去，技術止步不前，學到的都是業務領

5 並發編程--隊列&生產者消費者模型

如果 消費者模式 view 解決 多進程 produce 2.4 color __name__ 1、隊列的介紹 進程彼此之間互相隔離，要實現進程間通信（IPC），multiprocessing模塊支持兩種形式：隊列和管道，這兩種方式都是使用消息傳遞的 創建隊列的類（底層

3.並發編程-ReentrantLock 細節說明

protect locked interrupt 簡介 數列 條件 printf 操作 這一 並發編程-ReentrantLock 細節說明 ---title: 並發編程-ReentrantLock 細節說明date: 2018-07-05 09:06:57categori

Java並發編程：synchronized

獲取對象 string 就會 同時 並不是 字節 輸出 pri special 　　雖然多線程編程極大地提高了效率，但是也會帶來一定的隱患。比如說兩個線程同時往一個數據庫表中插入不重復的數據，就可能會導致數據庫中插入了相同的數據。今天我們就來一起討論下線程安全問題，以及Ja

《java並發編程實戰》讀書筆記5--任務執行， Executor框架

調度 生產 頁面 acc 消費者模式 退出 融合 可能 第一篇 6.1 在線程中執行任務 第一步要找出清晰的任務邊界。大多數服務器應用程序都提供了一種自然的任務邊界選擇方式：以獨立的請求為邊界。 -6.6.1 串行地執行任務 最簡單的任務調度策略是在單個線程中串行地執行各項

轉：【Java並發編程】之七：使用synchronized獲取互斥鎖的幾點說明

相互 strong enter 方法 虛擬 get tar 指令 自己 轉載請註明出處：http://blog.csdn.net/ns_code/article/details/17199201 在並發編程中，多線程同時並發訪問的資源叫做臨界資源，當多個線程同時

Java並發編程之synchronized

異常 moni 實現 心態 cin 同步塊 enum 鎖對象 靈活 在Java編程中，為了保證線程安全，有3種不同的思路1、互斥同步：包括synchronized和lock等。 2、非阻塞同步：如AtomicInteger的increaseAndGet()方法等。 3、無同

【Java並發編程實戰】—–synchronized

tex family stat ring 抽屜 java虛擬機 其它 什麽 實際應用 在我們的實際應用其中可能常常會遇到這樣一個場景：多個線程讀或者、寫相同的數據，訪問相同的文件等等。對於這樣的情況假設我們不加以控制，是非常easy導致錯誤的。在java中，為了解決問題，

Java並發編程實踐讀書筆記（5） 線程池的使用

設計 java並發編程 指定 數據交換 什麽 讀書 body 發展 ima Executor與Task的耦合性 1，除非線程池很非常大，否則一個Task不要依賴同一個線程服務中的另外一個Task，因為這樣容易造成死鎖； 2，線程的執行是並行的，所以在設計Task的時候要考慮

【轉】Java並發編程：Synchronized及其實現原理

st2 等待 OS threads img 參考 使用 leg ble 一、Synchronized的基本使用 　　Synchronized是Java中解決並發問題的一種最常用的方法，也是最簡單的一種方法。Synchronized的作用主要有三個：（1）確保線程互斥的

並發編程 - 線程 - 1.互斥鎖/2.GIL解釋器鎖/3.死鎖與遞歸鎖/4.信號量/5.Event事件/6.定時器

級別 src 總結 alex post strip CQ bsp 回收機制 1.互斥鎖： 原理：將並行變成串行 精髓：局部串行，只針對共享數據修改 保護不同的數據就應該用不用的鎖 1 from threading import Thread

Java並發編程：synchronized和鎖優化

section ext 隨著 32bit 就是 -i 序列 UC 進行 每天學習一點點 編程PDF電子書、視頻教程免費下載：http://www.shitanlife.com/code 1. 使用方法 synchronized 是 java 中最常用的保證線程安全的方式，s

【並發編程】CAS與synchronized

ews 算法 正式 ima PE 理解 cnblogs inf sch 線程安全 眾所周知，Java是多線程的。但是，Java對多線程的支持其實是一把雙刃劍。一旦涉及到多個線程操作共享資源的情況時，處理不好就可能產生線程安全問題。線程安全性可能是非常復雜的，在沒有充足的同步

Java並發編程（5）- J.U.C之AQS及其相關組件詳解

cached 數字0 f11 一個 就會 interrupt 同步器 long 告訴 J.U.C之AQS-介紹 Java並發包（JUC）中提供了很多並發工具，這其中，很多我們耳熟能詳的並發工具，譬如ReentrangLock、Semaphore，而它們的實現都用到了一個共同

Java並發編程(5):volatile變量修飾符-意料之外的問題（含代碼）

需要 主存 names 順序 操作 用處 tails 一點 tar volatile用處說明在JDK1.2之前，Java的內存模型實現總是從主存（即共享內存）讀取變量，是不需要進行特別的註意的。而隨著JVM的成熟和優化，現在在多線程環境下volatile關鍵字的使用變得非常

Java並發編程（7）：使用synchronized獲取互斥鎖的幾點說明

防止 ron 互斥鎖 成員變量 線程 繼續 enter 交換 規範 在並發編程中，多線程同時並發訪問的資源叫做臨界資源，當多個線程同時訪問對象並要求操作相同資源時，分割了原子操作就有可能出現數據的不一致或數據不完整的情況，為避免這種情況的發生，我們會采取同步機制，以確保在某

並發編程之ThreadLocal、Volatile、synchronized、Atomic關鍵字掃盲

匯編指令 free clas 保持 break 作用 nta 總結 read 版權聲明：本文為博主原創文章，未經博主允許不得轉載。轉載註明出處：Sunzxyong https://blog.csdn.net/u010687392/article/details/50549

【Java_多線程並發編程】基礎篇——synchronized關鍵字

共享 訪問 不同 獲取 編程 das ron 等待 並發 1. synchronized同步鎖的原理 當我們調用某對象的synchronized方法或代碼塊時，就獲取了該對象的同步鎖。例如，synchronized(obj)就獲取了“obj這個對象&rdquo