2. 程式人生 > >三、synchronized鎖機制

三、synchronized鎖機制

阿新 • • 發佈：2018-12-05

一、synchronized鎖機制

1、同步鎖

髒讀：一個常見的概念。在多執行緒中，難免會出現在多個執行緒中對同一個物件的例項變數進行併發訪問的情況，如果不做正確的同步處理，那麼產生的後果就是"髒讀"，也就是取到的資料其實是被更改過的。

示例：

public class Lock_JobRun extends Thread{
    private String str;
    private Lock_RunFuncion lockRunFuncion;
    public Lock_JobRun(String str,Lock_RunFuncion lockRunFuncion) {
        this.str=str;
        this.lockRunFuncion=lockRunFuncion;
    }
    public void run(){
        try {
            lockRunFuncion.addNumber(str);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public  class Lock_RunFuncion{
    private int num=0;
    public void addNumber(String str) throws InterruptedException {
        if(str.equals("a")){
            num=100;
            System.out.println(Thread.currentThread().getName()+"    str:   "+str+"  執行完畢睡覺去了..");
            Thread.sleep(1000);
        }else{
            num=200;
            System.out.println(Thread.currentThread().getName()+"    str:   "+str+"  執行完畢");
        }
        System.out.println(Thread.currentThread().getName()+"   執行結果:"+num);
    }
}
public class RunThread {
    public static void main(String[] args) throws InterruptedException {
     Lock_RunFuncion lockRunFuncion=new Lock_RunFuncion();
     Lock_JobRun lockJobRunA=new Lock_JobRun("a",lockRunFuncion);
     Lock_JobRun lockJobRunB=new Lock_JobRun("b",lockRunFuncion);
     lockJobRunA.start();
     lockJobRunB.start();
    }
}

結果：
Thread-0 str: a 執行完畢睡覺去了…
Thread-1 str: b 執行完畢
Thread-1 執行結果:200
Thread-0 執行結果:200

結論：一個物件分別讓兩個執行緒去執行,都是非同步的,Thread-0呼叫完後休眠1S,過程中被Thread-1給修改了,因此最後Thread-0列印到的是被Thread-1修改後的
這樣資料就不正確了啊，這時可以使用同步鎖 synchronized

加上synchronized 時呢？
程式碼示例：

public  class Lock_RunFuncion{
    private int num=0;
    public synchronized void addNumber(String str) throws InterruptedException {
        if(str.equals("a")){
            num=100;
            System.out.println(Thread.currentThread().getName()+"    str:   "+str+"  執行完畢睡覺去了..");
            Thread.sleep(1000);
        }else{
            num=200;
            System.out.println(Thread.currentThread().getName()+"    str:   "+str+"  執行完畢");
        }
        System.out.println(Thread.currentThread().getName()+"   執行結果:"+num);
    }
}

執行結果:
Thread-0 str: a 執行完畢睡覺去了…
Thread-0 執行結果:100
Thread-1 str: b 執行完畢
Thread-1 執行結果:200

總結：Thread-1 必須等Thread-0執行完後才去執行

2、多個物件多個鎖

程式碼示例：

Lock_RunFuncion lockRunFuncionA=new Lock_RunFuncion();
Lock_RunFuncion lockRunFuncionB=new Lock_RunFuncion();
Lock_JobRun lockJobRunA=new Lock_JobRun("a",lockRunFuncionA);
Lock_JobRun lockJobRunB=new Lock_JobRun("b",lockRunFuncionB);
lockJobRunA.start();
lockJobRunB.start();

結果：
Thread-1 str: b 執行完畢
Thread-0 str: a 執行完畢睡覺去了…
Thread-1 執行結果:200
Thread-0 執行結果:100

總結：看到沒有，同步鎖沒有同步執行了我。
之前例項的同步鎖,應該是物件執行完後到下一個物件。其實這只是針對同一個物件才會有等待的情況。物件都不同了都不互相干擾。

3、synchronized方法與鎖物件
(1)物件內方法鎖與非方法鎖

程式碼示例：

public  class Lock_RunFuncion_1 {
    public synchronized void synchrMethod() throws InterruptedException {
        System.out.println("synchrMethod  "+Thread.currentThread().getName()+"   start");
        Thread.sleep(3000);
        System.out.println("synchrMethod  "+Thread.currentThread().getName()+"   end");
    }
    public  void method() throws InterruptedException {
        System.out.println("method  "+Thread.currentThread().getName()+"   start");
        System.out.println("method  "+Thread.currentThread().getName()+"   end");
    }
}
public class Lock_JobRun_2 extends Thread{
    private Lock_RunFuncion_1 lockRunFuncion1;
    public Lock_JobRun_2(Lock_RunFuncion_1 lockRunFuncion1) {
        this.lockRunFuncion1 = lockRunFuncion1;
    }
    public void run(){
        try {
            lockRunFuncion1.synchrMethod();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Lock_JobRun_1 extends Thread{
    private Lock_RunFuncion_1 lockRunFuncion1;
    public Lock_JobRun_1(Lock_RunFuncion_1 lockRunFuncion1) {
        this.lockRunFuncion1 = lockRunFuncion1;
    }
    public void run(){
        try {
            lockRunFuncion1.method();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public static void main(String[] args) throws InterruptedException {
Lock_RunFuncion_1 lockRunFuncion1=new Lock_RunFuncion_1();
Lock_JobRun_1 lockJobRun1=new Lock_JobRun_1(lockRunFuncion1);
Lock_JobRun_2 lockJobRun2=new Lock_JobRun_2(lockRunFuncion1);
lockJobRun1.start();
lockJobRun2.start();
}

結果：
method Thread-0 start
synchrMethod Thread-1 start
method Thread-0 end
synchrMethod Thread-1 end

總結：一個物件中可以存在 非同步和同步方法,非同步方法當然也不需要等待同步執行完了,如果兩個方法都是同步的,會依次執行

驗證一個物件裡都加方法鎖：
程式碼示例：

public  synchronized void method() throws InterruptedException {
        System.out.println("method  "+Thread.currentThread().getName()+"   start");
        System.out.println("method  "+Thread.currentThread().getName()+"   end");
    }

結果：
method Thread-0 start
method Thread-0 end
synchrMethod Thread-1 start
synchrMethod Thread-1 end

(2)synchronized鎖重入

程式碼示例：

public  class Lock_RunFuncion_2 {
    public synchronized void method1()  {
        System.out.println("m1");
        method2();
    }
    public synchronized void method2()  {
        System.out.println("m2");
        method3();
    }
    public synchronized void method3()  {
        System.out.println("m3");
    }
}

public class Lock_JobRun_3 extends Thread{

    public void run(){
        Lock_RunFuncion_2 lock_runFuncion_2=new Lock_RunFuncion_2();
        lock_runFuncion_2.method1();
    }
}

public static void main(String[] args) {
Lock_JobRun_3 lockJobRun3=new Lock_JobRun_3();
lockJobRun3.start();
}

結果：
m1
m2
m3

總結：可以看到依次列印了。這證明了物件可以再次獲取自己的內部鎖。這種鎖重入的機制，也支援在父子類繼承的環境中。

注意： 發生異常是自動釋放鎖

(3)synchronized同步程式碼塊

有沒有想過用synchroized同對象執行的方法都要進行等待,那麼方法裡含有不需要等待的程式碼嗎？

程式碼示例：

public class sync_RunFuncion {
    int count=1000000000;
    public void  method() throws InterruptedException {
        System.out.println("not synchronized start  ---  "+Thread.currentThread().getName());
        for (int i=0;i<count;i+=2) {
            i--;
        }
        System.out.println("not synchronized find  ---  "+Thread.currentThread().getName());
        synchronized (this){
            System.out.println("synchronized start  ---  "+Thread.currentThread().getName());
            for (int i=0;i<count;i+=2) {
                i--;
            }
            System.out.println("synchronized find  ---  "+Thread.currentThread().getName());
        }
    }
}
public class Sync_JobRun extends  Thread {
    private sync_RunFuncion syncRunFuncion;
    public Sync_JobRun(sync_RunFuncion syncRunFuncion) {
        this.syncRunFuncion=syncRunFuncion;
    }
    @Override
    public void run(){
        syncRunFuncion.method();
    }
}

public static void main(String[] args) throws InterruptedException {
        sync_RunFuncion syncRunFuncion=new sync_RunFuncion();
        Sync_JobRun syncJobRun=new Sync_JobRun(syncRunFuncion);
        syncJobRun.start();
        Sync_JobRun syncJobRun2=new Sync_JobRun(syncRunFuncion);
        syncJobRun2.start();
    }

結果：
not synchronized start — Thread-1
not synchronized start — Thread-0
not synchronized find — Thread-1
synchronized start — Thread-1
not synchronized find — Thread-0
synchronized find — Thread-1
synchronized start — Thread-0
synchronized find — Thread-0

總結：可以看到執行緒1還沒呼叫完not synchronized find的方法,執行緒0就開始呼叫not synchronized start方法了。
而synchronized 方法卻老老實實地執行完start-find…。
可以得出在synchronized內當某個執行緒在訪問時,會被阻塞。而之外的卻不會。
這樣做大大地提高了效率,非同步方法也不需要等待同步方法釋放鎖了
。

（4）兩個synchronized塊之間具有互斥性

程式碼示例:

public class sync_RunFuncion {
    public void opposite_Tom(){
        synchronized (this){
            try {
                System.out.println("opposite_Tom start..  ---  "+Thread.currentThread().getName());
                Thread.sleep(1000);
                System.out.println("opposite_Tom end..  ---  "+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
    public   void  opposite_Jones(){
        synchronized (this) {
            try {
                System.out.println("opposite_Jones start..  ---  "+Thread.currentThread().getName());
                Thread.sleep(1000);
                System.out.println("opposite_Jones end..  ---  "+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


public class Sync_Op_Tom_JobRun  extends Thread{
    private sync_RunFuncion syncRunFuncion;
    public Sync_Op_Tom_JobRun(sync_RunFuncion syncRunFuncion) {
        this.syncRunFuncion=syncRunFuncion;
    }
    @Override
    public void run(){
        syncRunFuncion.opposite_Jones();
    }
}

public class Sync_Op_Jones_JobRun extends Thread{
    private sync_RunFuncion syncRunFuncion;
    public Sync_Op_Jones_JobRun(sync_RunFuncion syncRunFuncion) {
        this.syncRunFuncion=syncRunFuncion;
    }
    @Override
    public void run(){
        syncRunFuncion.opposite_Tom();
    }
}


public static void main(String[] args) {
        sync_RunFuncion syncRunFuncion=new sync_RunFuncion();
        for(int i=0;i<2;i++) {
            Sync_Op_Jones_JobRun syncOpJonesJobRun = new Sync_Op_Jones_JobRun(syncRunFuncion);
            Sync_Op_Tom_JobRun syncOpTomJobRun = new Sync_Op_Tom_JobRun(syncRunFuncion);
            syncOpJonesJobRun.start();
            syncOpTomJobRun.start();
        }
    }

結果：
opposite_Tom start… — Thread-2
opposite_Tom end… — Thread-2
opposite_Jones start… — Thread-3
opposite_Jones end… — Thread-3
opposite_Jones start… — Thread-1
opposite_Jones end… — Thread-1
opposite_Tom start… — Thread-0
opposite_Tom end… — Thread-0

總結：這裡看得不是很仔細,到sleep會暫停一會,依次執行，synchronized 塊的是獲取物件鎖,鎖的是整個物件,要麼是opposite_Tom執行要麼opposite_Jones執行,看哪個執行緒先獲取鎖,誰先執行,執行期間會將物件阻塞。

(5)synchronized塊和synchronized方法

程式碼示例：


public class sync_RunFuncion {
    public void sync_Block(){
        synchronized (this){
            try {
                System.out.println("opposite_Tom start..  ---  "+Thread.currentThread().getName());
                Thread.sleep(2000);
                System.out.println("opposite_Tom end..  ---  "+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public synchronized  void  sync_Function(){
            System.out.println("opposite_Jones start..  ---  "+Thread.currentThread().getName());
            System.out.println("opposite_Jones end..  ---  "+Thread.currentThread().getName());
    }
}
public class Sync_Op_Jones_JobRun extends Thread{
    private sync_RunFuncion syncRunFuncion;
    public Sync_Op_Jones_JobRun(sync_RunFuncion syncRunFuncion) {
        this.syncRunFuncion=syncRunFuncion;
    }
    @Override
    public void run(){
        //---呼叫sync碼塊與sync方法特性
        syncRunFuncion.sync_Block();
    }
}
public class Sync_Op_Tom_JobRun  extends Thread{
    private sync_RunFuncion syncRunFuncion;
    public Sync_Op_Tom_JobRun(sync_RunFuncion syncRunFuncion) {
        this.syncRunFuncion=syncRunFuncion;
    }
    @Override
    public void run(){
        //---呼叫sync碼塊與sync方法特性
        syncRunFuncion.sync_Function();
    }
}
 public static void main(String[] args) {
        sync_RunFuncion syncRunFuncion=new sync_RunFuncion();
        for(int i=0;i<3;i++) {
            Sync_Op_Jones_JobRun syncOpJonesJobRun = new Sync_Op_Jones_JobRun(syncRunFuncion);
            Sync_Op_Tom_JobRun syncOpTomJobRun = new Sync_Op_Tom_JobRun(syncRunFuncion);
            syncOpJonesJobRun.start();
            syncOpTomJobRun.start();
        }
    }
}

結果：
opposite_Jones start… — Thread-1
opposite_Jones end… — Thread-1
opposite_Tom start… — Thread-0
…等待2S 自己加的忽略就好
opposite_Tom end… — Thread-0
opposite_Jones start… — Thread-5
opposite_Jones end… — Thread-5
opposite_Tom start… — Thread-4
…等待2S 自己加的忽略就好
opposite_Tom end… — Thread-4
opposite_Tom start… — Thread-2
…等待2S 自己加的忽略就好
opposite_Tom end… — Thread-2
opposite_Jones start… — Thread-3
opposite_Jones end… — Thread-3

結論：synchronized方法和synchronized程式碼塊都是呼叫同一個物件鎖的。

(6)將任意物件作為物件監視器

前面都使用synchronized(this)的格式來同步程式碼塊，其實Java還支援對"任意物件"作為物件監視器來實現同步的功能。
這個"任意物件"大多數是例項變數及方法的引數，使用格式為synchronized(非this物件)。看一下將任意物件作為物件監視器的使用例子：
程式碼示例:


public class Sync_Object_JobRun extends  Thread {
    private sync_Object_RunFuncion syncRunFuncion;
    public Sync_Object_JobRun(sync_Object_RunFuncion syncRunFuncion) {
        this.syncRunFuncion=syncRunFuncion;
    }
    @Override
    public void run(){
        try {
            syncRunFuncion.method();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class RunThread {
    public static void main(String[] args) {
        sync_Object_RunFuncion syncRunFuncion=new sync_Object_RunFuncion();
        for(int i=0;i<4;i++){
            Sync_Object_JobRun syncObjectJobRun=new Sync_Object_JobRun(syncRunFuncion);
            syncObjectJobRun.start();
        }
    }
}
public class sync_Object_RunFuncion {
    private String str=new String();
    public void  method() throws InterruptedException {
        int count=1000000000;
        synchronized (str){
            System.out.println("synchronized start  ---  "+Thread.currentThread().getName());
            for (int i=0;i<count;i+=2) {
                i--;
            }
            Thread.sleep(1000);
            System.out.println("synchronized find  ---  "+ Thread.currentThread().getName());
       }
    }
}

結果：
synchronized start — Thread-1
synchronized find — Thread-1
synchronized start — Thread-2
synchronized find — Thread-2
synchronized start — Thread-3
synchronized find — Thread-3
synchronized start — Thread-0
synchronized find — Thread-0

總結：synchronized放非this的物件也實現了同步的效果,實際上在new的時候就已經例項化了物件,呼叫的都是同一個。
只要物件的引用不變，即使改變了物件的屬性，執行結果依然是同步的。

相關推薦

三、synchronized鎖機制

一、synchronized鎖機制 1、同步鎖 髒讀：一個常見的概念。在多執行緒中，難免會出現在多個執行緒中對同一個物件的例項變數進行併發訪問的情況，如果不做正確的同步處理，那麼產生的後果就是"髒讀"，也就是取到的資料其實是被更改過的。 示例： public class

三、synchronized同步鎖

一、簡介 在Java多執行緒中，我們要實現同步序列最早接觸的就是synchronized關鍵字。 基本語法如下： synchronized(鎖) { // 程式碼塊 } sychronized關鍵字的鎖主要有三種使用： 1）物件鎖 2）類鎖 3）字串鎖 二、示例 一、物

【Spark系列】三、Spark工作機制

Spark工作機制 Client Driver程式 Spark Context RDD DAG DAGSchedular TaskSchedular SparkEnv Worker Node

四、資料庫鎖機制--行級鎖（悲觀鎖與樂觀鎖）與表級鎖

上一章講到了資料庫事務的隔離級別以及併發事務在不同隔離級別下可能帶來的問題和解決思路，感興趣的朋友可以看一下！直接切入正題：      從字面上看，行級鎖的作用範圍肯定比表級鎖的作用範圍要小；行級鎖和表級鎖是根據鎖的粒度來區分的，行記錄，表都是資源，鎖是作用在這些資源上的。如

JVM（三、雙親委派機制1）

pan sent adc urn requested turn returns spa true 1.獲取ClassLoader 1 public class MyTest06 { 2 3 public static void main(Strin

Lock、Synchronized鎖解析

　　上篇博文在講解 ConcurrentHashMap 時說到 1.7 中 put 方法實現同步的方式是使用繼承了 ReentrantLock 類的 segment 內部類呼叫 lock 方法實現的，而在 1.8 中是使用 synchron

【Java線程】鎖機制：synchronized、Lock、Condition轉載

留下 初始化 char 想要 interrupt 機制 運行 -m 特性 http://www.infoq.com/cn/articles/java-memory-model-5 深入理解Java內存模型（五）——鎖 http://www.ibm.com/develope

資料庫（三） 事務、引擎與鎖機制

一、事務 事務：事務是併發控制的基本單位。即一組操作序列，這些序列要麼都執行，要麼都不執行，它是一組不可分割的工作單位；事務的提出主要是為了解決併發情況下保持資料一致性的問題，事務具有以下四個基本特徵： （1）原子性（Atomic）：事務中包含的每個操作都被看成

JAVA基礎23-多執行緒（三）【synchronized，ReentranLock，volatile、死鎖】

一、同步         大多數多執行緒應用中，兩個或兩個以上的執行緒需要共享對同一資料的存取，此時出現多個程式交替處理該資料，從而導致資料出現訛誤。 9-1.Synchronized關鍵字       &nb

【Java執行緒鎖機制】：synchronized、Lock、Condition

原文：http://blog.csdn.net/vking_wang/article/details/9952063     1、synchronized   把程式碼塊宣告為 synchronized，有兩個重要後果，通常是指該程式碼具有

【鎖機制】synchronized和ReentrantLock、鎖優化

java中的鎖的種類很多。目前對這部分知識點只是停留在瞭解的基礎上，就目前知識進行梳理，並長期補充。 java中鎖常用的為synchronized 和java.util.concurrent.Lock下的鎖。 下面對java中實現的鎖進行個人分析 Synchroni

【Java執行緒】鎖機制：synchronized、Lock、Condition

http://www.infoq.com/cn/articles/java-memory-model-5  深入理解Java記憶體模型（五）——鎖 http://www.ibm.com/developerworks/cn/java/j-jtp10264/  Java 理論與

Python 進程、線程、協程、鎖機制，你知多少？

log lex python tar apple 多少 線程 targe url 1、python的多線程到底有沒有用？ 2、 為什麽在python裏推薦使用多進程而不是多線程 3、進程、線程、協程、各種鎖 Python 進程、線程、協程、鎖機制，你知多少

JAVA synchronized關鍵字鎖機制(中)

就會 16px ride tar rac 效果 sync 靜態方法 訪問 synchronized 鎖機制簡單的用法，高效的執行效率使成為解決線程安全的首選。 下面總結其特性以及使用技巧，加深對其理解。 特性: 　　1. Java語言的關鍵字，當它用來修飾一個方法或者一個代

java並發之線程同步（synchronized和鎖機制）

blog 是否 can return nbsp jvm 環境 imp ava 使用synchronized實現同步方法 使用非依賴屬性實現同步 在同步塊中使用條件（wait(),notify(),notifyAll()） 使用鎖實現同步 使用讀寫鎖實現同步數據訪問 修改

操作系統學習（三）、分頁機制

x86 頁面 管理機 技術 由於 映射 空間 pos 邏輯地址 目錄 1.分頁機制介紹 2.頁表結構 3.頁表項格式 4.虛擬存儲 5.直達底部 分頁機制介紹 分頁機制是 80x86 內存管理機制的第二部分。它在分段機制的基礎上完成虛擬地址到物理地址的轉換過程。分段

內置鎖（三）synchronized的幾個要註意的對象監視器

sta 兩種 sys 自動裝箱 read rac nal implement ted 前言 ?? 經過前面的兩篇文章的介紹，可以清楚知道，synchronized可以用於修飾一個方法 或者 代碼塊，線程要訪問這些臨界區代碼，則要先獲取對應的 對象監視器 ，從而使多個線程互斥

java 偏向鎖、輕量級鎖及重量級鎖synchronized原理

bubuko 固定 使用情況 防止 不能 image 過程 記錄 原因 Java對象頭與Monitor java對象頭是實現synchronized的鎖對象的基礎，synchronized使用的鎖對象是存儲在Java對象頭裏的。 對象頭包含兩部分：Mark Word 和

單例模式三種模式，餓漢(饑漢)、飽漢(懶漢)、雙重鎖模式

singleton pub null 關系 設計模式的 mage 了吧 ref image 今天看某培訓機構提供面試題中設計模式部分，對飽漢和餓漢比較感興趣，就搜了一下，然後誤人子弟，然後就覺得有必要記錄一下 聲明：本人沒有看過設計模式的書籍，只是根據概念對比的看了一些博

java多執行緒物件鎖、類鎖、同步機制詳解

1.在java多執行緒程式設計中物件鎖、類鎖、同步機制synchronized詳解：     物件鎖：在java中每個物件都有一個唯一的鎖，物件鎖用於物件例項方法或者一個物件例項上面的。     類鎖：是用於一個類靜態方法或者class物件的，一個