Java鎖機制瞭解一下

時間 2019-11-16

標籤 java 機制瞭解一下欄目 Java 简体版

原文原文鏈接

前言

回顧前面：html

只有光頭才能變強！java

本文章主要講的是Java多線程加鎖機制，有兩種：編程

Synchronized
顯式Lock

不得不嘮叨幾句：c#

在《Java核心技術卷一》是先講比較難的顯式Lock，而再講的是比較簡單的Synchronized
而《Java併發編程實戰》在前4章零散地講解了Synchronized，將顯式Lock放到了13章

其實都比較坑，若是能先系統講了Synchronized鎖機制，接着講顯式Lock鎖機制，那就很容易理解了。也不須要跨那麼多章節。安全

那麼接下來咱們就開始吧~微信

1、synchronized鎖

1.1synchronized鎖是什麼？

synchronized是Java的一個關鍵字，它可以將代碼塊(方法)鎖起來多線程

它使用起來是很是簡單的，只要在代碼塊(方法)添加關鍵字synchronized，便可以實現同步的功能~

public synchronized void test() {
        // 關注公衆號Java3y
        // doSomething
    }

synchronized是一種互斥鎖併發

一次只能容許一個線程進入被鎖住的代碼塊

synchronized是一種內置鎖/監視器鎖post

Java中每一個對象都有一個內置鎖(監視器,也能夠理解成鎖標記)，而synchronized就是使用對象的內置鎖(監視器)來將代碼塊(方法)鎖定的！

1.2synchronized用處是什麼？

synchronized保證了線程的原子性。(被保護的代碼塊是一次被執行的，沒有任何線程會同時訪問)
synchronized還保證了可見性。(當執行完synchronized以後，修改後的變量對其餘的線程是可見的)

Java中的synchronized，經過使用內置鎖，來實現對變量的同步操做，進而實現了對變量操做的原子性和其餘線程對變量的可見性，從而確保了併發狀況下的線程安全。性能

1.3synchronized的原理

咱們首先來看一段synchronized修飾方法和代碼塊的代碼：

public class Main {
    //修飾方法
    public synchronized void test1(){

    }

    
    public void test2(){
        // 修飾代碼塊
        synchronized (this){

        }
    }
}

來反編譯看一下：

同步代碼塊：

monitorenter和monitorexit指令實現的

同步方法（在這看不出來須要看JVM底層實現）

方法修飾符上的ACC_SYNCHRONIZED實現。

synchronized底層是是經過monitor對象，對象有本身的對象頭，存儲了不少信息，其中一個信息標示是被哪一個線程持有。

具體可參考：

1.4synchronized如何使用

synchronized通常咱們用來修飾三種東西：

修飾普通方法
修飾代碼塊
修飾靜態方法

1.4.1修飾普通方法：

用的鎖是Java3y對象(內置鎖)

public class Java3y {


    // 修飾普通方法，此時用的鎖是Java3y對象(內置鎖)
    public synchronized void test() {
        // 關注公衆號Java3y
        // doSomething
    }

}

1.4.2修飾代碼塊：

用的鎖是Java3y對象(內置鎖)--->this

public class Java3y {
    
    public  void test() {
        
        // 修飾代碼塊，此時用的鎖是Java3y對象(內置鎖)--->this
        synchronized (this){
            // 關注公衆號Java3y
            // doSomething
        }
    }
}

固然了，咱們使用synchronized修飾代碼塊時未必使用this，還能夠使用其餘的對象(隨便一個對象都有一個內置鎖)

因此，咱們能夠這樣幹：

public class Java3y {


    // 使用object做爲鎖(任何對象都有對應的鎖標記，object也不例外)
    private Object object = new Object();


    public void test() {

        // 修飾代碼塊，此時用的鎖是本身建立的鎖Object
        synchronized (object){
            // 關注公衆號Java3y
            // doSomething
        }
    }

}

上面那種方式(隨便使用一個對象做爲鎖)在書上稱之爲-->客戶端鎖，這是不建議使用的。

書上想要實現的功能是：給ArrayList添加一個putIfAbsent()，這須要是線程安全的。

假定直接添加synchronized是不可行的

使用客戶端鎖，會將當前的實現與本來的list耦合了：

書上給出的辦法是使用組合的方式(也就是裝飾器模式)

1.4.3修飾靜態方法

獲取到的是類鎖(類的字節碼文件對象)：Java3y.class

public class Java3y {

    // 修飾靜態方法代碼塊，靜態方法屬於類方法，它屬於這個類，獲取到的鎖是屬於類的鎖(類的字節碼文件對象)-->Java3y.class
    public synchronized void test() {

        // 關注公衆號Java3y
        // doSomething
    }
}

1.4.4類鎖與對象鎖

synchronized修飾靜態方法獲取的是類鎖(類的字節碼文件對象)，synchronized修飾普通方法或代碼塊獲取的是對象鎖。

它倆是不衝突的，也就是說：獲取了類鎖的線程和獲取了對象鎖的線程是不衝突的！

public class SynchoronizedDemo {

    //synchronized修飾非靜態方法
    public synchronized void function() throws InterruptedException {
        for (int i = 0; i <3; i++) {
            Thread.sleep(1000);
            System.out.println("function running...");
        }
    }
    //synchronized修飾靜態方法
    public static synchronized void staticFunction()
            throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            Thread.sleep(1000);
            System.out.println("Static function running...");
        }
    }

    public static void main(String[] args) {
        final SynchoronizedDemo demo = new SynchoronizedDemo();

        // 建立線程執行靜態方法
        Thread t1 = new Thread(() -> {
            try {
                staticFunction();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 建立線程執行實例方法
        Thread t2 = new Thread(() -> {
            try {
                demo.function();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 啓動
        t1.start();
        t2.start();
    }
}

結果證實：類鎖和對象鎖是不會衝突的！

1.5重入鎖

咱們來看下面的代碼：

public class Widget {

    // 鎖住了
    public synchronized void doSomething() {
        ...
    }
}

public class LoggingWidget extends Widget {

    // 鎖住了
    public synchronized void doSomething() {
        System.out.println(toString() + ": calling doSomething");
        super.doSomething();
    }
}