java-鎖的相關概念介紹

阿新 • • 發佈：2020-11-02

1）可重入鎖
　　如果鎖具備可重入性，則稱作為可重入鎖。像synchronized和ReentrantLock都是可重入鎖，可重入性在我看來實際上表明瞭鎖的分配機制：基於執行緒的分配，而不是基於方法呼叫的分配。

舉個簡單的例子，當一個執行緒執行到某個synchronized方法時，比如說method1，而在method1中會呼叫另外一個synchronized方法method2，此時執行緒不必重新去申請鎖，而是可以直接執行方法method2。

　　看下面這段程式碼就明白了：

class MyClass {
public synchronized void method1() {
method2();

}



public synchronized void method2() {
    

}

}

上述程式碼中的兩個方法method1和method2都用synchronized修飾了，假如某一時刻，執行緒A執行到了method1，此時執行緒A獲取了這個物件的鎖，而由於method2也是synchronized方法，

假如synchronized不具備可重入性，此時執行緒A需要重新申請鎖。但是這就會造成一個問題，因為執行緒A已經持有了該物件的鎖，而又在申請獲取該物件的鎖，這樣就會執行緒A一直等待永遠不會獲取到的鎖。

而由於synchronized和Lock都具備可重入性，所以不會發生上述現象。

2）可中斷鎖
　　可中斷鎖：顧名思義，就是可以相應中斷的鎖。

　　在Java中，synchronized就不是可中斷鎖，而Lock是可中斷鎖。

　　如果某一執行緒A正在執行鎖中的程式碼，另一執行緒B正在等待獲取該鎖，可能由於等待時間過長，執行緒B不想等待了，想先處理其他事情，

   我們可以讓它中斷自己或者在別的執行緒中中斷它，這種就是可中斷鎖。

　　lockInterruptibly()可體現了Lock的可中斷性。

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**

Created by fanqunsong on 2017/8/5.
*/
public class LockTest {

public static void main(String[] args) {

 Thread t1 = new Thread(new RunIt());
 Thread t2 = new Thread(new RunIt());
 t1.start();
 t2.start();
 t2.interrupt();

}
}
class RunIt implements Runnable{

private static Lock lock = new ReentrantLock();

@Override
public void run() {

 try {
     //----------------------a
     //lock.lock();
     lock.lockInterruptibly();
     System.out.println(Thread.currentThread().getName() + " running");
     TimeUnit.SECONDS.sleep(5);
     lock.unlock();
     System.out.println(Thread.currentThread().getName()+" finishend");
 } catch (InterruptedException e) {
     System.out.println(Thread.currentThread().getName()+ " interrupted");
 }

}
}

如果a處是lock.lock();
輸出
Thread-0 running
(這裡休眠了5s)
Thread-0 finished
Thread-1 running
Thread-1 interrupted

============================

如果a處是lock.lockInterruptibly()
Thread-0 running
Thread-1 interrupted
(這裡休眠了5s)
Thread-0 finished

3）公平鎖
　　公平鎖即儘量以請求鎖的順序來獲取鎖。比如同是有多個執行緒在等待一個鎖，當這個鎖被釋放時，等待時間最久的執行緒（最先請求的執行緒）會獲得該所，這種就是公平鎖。

　　非公平鎖即無法保證鎖的獲取是按照請求鎖的順序進行的。這樣就可能導致某個或者一些執行緒永遠獲取不到鎖。

　　在Java中，synchronized就是非公平鎖，它無法保證等待的執行緒獲取鎖的順序。

　　而對於ReentrantLock和ReentrantReadWriteLock，它預設情況下是非公平鎖，但是可以設定為公平鎖。

   在ReentrantLock中定義了2個靜態內部類，一個是NotFairSync，一個是FairSync，分別用來實現非公平鎖和公平鎖。

　　我們可以在建立ReentrantLock物件時，通過以下方式來設定鎖的公平性：

    ReentrantLock lock = new ReentrantLock(true);

　　如果引數為true表示為公平鎖，為fasle為非公平鎖。預設情況下，如果使用無參構造器，則是非公平鎖。

4）讀寫鎖
　　讀寫鎖將對一個資源（比如檔案）的訪問分成了2個鎖，一個讀鎖和一個寫鎖。

　　正因為有了讀寫鎖，才使得多個執行緒之間的讀操作不會發生衝突。

　　ReadWriteLock就是讀寫鎖，它是一個介面，ReentrantReadWriteLock實現了這個介面。

　　可以通過readLock()獲取讀鎖，通過writeLock()獲取寫鎖。

   在多執行緒開發中，經常會出現一種情況，我們希望讀寫分離。就是對於讀取這個動作來說，可以同時有多個執行緒同

時去讀取這個資源，但是對於寫這個動作來說，只能同時有一個執行緒來操作，而且同時，當有一個寫執行緒在操作這個資

源的時候，其他的讀執行緒是不能來操作這個資源的，這樣就極大的發揮了多執行緒的特點，能很好的將多執行緒的能力發揮。

package reed.thread;
import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest {
public static void main(String[] args) {
final Data data = new Data();
for (int i = 0; i ❤️ ; i++) {
new Thread(new Runnable() {
@Override
public void run() {
for(int j = 0; j <5;j++) {
data.set(new Random().nextInt(100));
}
}
}
).start();
}
for (int i = 0; i ❤️; i++) {
new Thread(new Runnable() {
@Override
public void run() {
for(int j = 0; j <5;j++){
data.get();
}
}
}).start();
}
}
}
class Data{
private int data;//共享資料1
private ReadWriteLock rwl = new ReentrantReadWriteLock();
public void set(int data){
rwl.writeLock().lock();// 取到寫鎖
try{
System.out.println(Thread.currentThread().getName()+"準備寫入資料");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.data = data;
System.out.println(Thread.currentThread().getName() + "寫入" + this.data);
}finally {
rwl.writeLock().unlock();
}
}
public void get() {
rwl.readLock().lock();// 取到讀鎖
try {
System.out.println(Thread.currentThread().getName() + "準備讀取資料");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "讀取" + this.data);
} finally {
rwl.readLock().unlock();// 釋放讀鎖
}
}
}

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**

使用讀寫鎖，可以實現讀寫分離鎖定，讀操作併發進行，寫操作鎖定單個執行緒
如果有一個執行緒已經佔用了讀鎖，則此時其他執行緒如果要申請寫鎖，則申請寫鎖的執行緒會一直等待釋放讀鎖。
如果有一個執行緒已經佔用了寫鎖，則此時其他執行緒如果申請寫鎖或者讀鎖，則申請的執行緒會一直等待釋放寫鎖。
@author

*/
public class MyReentrantReadWriteLock {
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    public static void main(String[] args)  {
        final MyReentrantReadWriteLock test = new MyReentrantReadWriteLock();
         
        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
                test.write(Thread.currentThread());
            };
        }.start();
         
        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
                test.write(Thread.currentThread());
            };
        }.start();
         
    }  
    
    /**
     * 讀操作,用讀鎖來鎖定
     * @param thread
     */
    public void get(Thread thread) {
        rwl.readLock().lock();
        try {
            long start = System.currentTimeMillis();
             
            while(System.currentTimeMillis() - start <= 1) {
                System.out.println(thread.getName()+"正在進行讀操作");
            }
            System.out.println(thread.getName()+"讀操作完畢");
        } finally {
            rwl.readLock().unlock();
        }
    }

    /**
     * 寫操作，用寫鎖來鎖定
     * @param thread
     */
    public void write(Thread thread) {
        rwl.writeLock().lock();;
        try {
            long start = System.currentTimeMillis();
             
            while(System.currentTimeMillis() - start <= 1) {
                System.out.println(thread.getName()+"正在進行寫操作");
            }
            System.out.println(thread.getName()+"寫操作完畢");
        } finally {
            rwl.writeLock().unlock();
        }
    }

}
一個執行緒讀的時候另外一個執行緒也可以讀

5）條件變數condition

條件變數很大一個程度上是為了解決Object.wait/notify/notifyAll難以使用的問題。

await*對應於Object.wait，signal對應於Object.notify，signalAll對應於Object.notifyAll。特別說明的是Condition的介面改變名稱就是為了避免與

Object中的wait/notify/notifyAll的語義和使用上混淆，因為Condition同樣有wait/notify/notifyAll方法。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test{
static class NumberWrapper {
public int value = 1;
}

public static void main(String[] args) {
	//初始化可重入鎖
	final Lock lock = new ReentrantLock();
	
	//第一個條件當螢幕上輸出到3
	final Condition reachThreeCondition = lock.newCondition();
	//第二個條件當螢幕上輸出到6
	final Condition reachSixCondition = lock.newCondition();
	
	//NumberWrapper只是為了封裝一個數字，一邊可以將數字物件共享，並可以設定為final
	//注意這裡不要用Integer, Integer 是不可變物件
	final NumberWrapper num = new NumberWrapper();
	//初始化A執行緒
	Thread threadA = new Thread(new Runnable() {
		@Override
		public void run() {
			//需要先獲得鎖
			lock.lock();
			try {
				System.out.println("threadA start write");
				//A執行緒先輸出前3個數
				while (num.value <= 3) {
					System.out.println(num.value);
					num.value++;
				}
				//輸出到3時要signal，告訴B執行緒可以開始了
				reachThreeCondition.signal();
			} finally {
				lock.unlock();
			}
			lock.lock();
			try {
				//等待輸出6的條件
				reachSixCondition.await();
				System.out.println("threadA start write");
				//輸出剩餘數字
				while (num.value <= 9) {
					System.out.println(num.value);
					num.value++;
				}

			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				lock.unlock();
			}
		}

	});


	Thread threadB = new Thread(new Runnable() {
		@Override
		public void run() {
			try {
				lock.lock();
				
				while (num.value <= 3) {
					//等待3輸出完畢的訊號
					reachThreeCondition.await();
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				lock.unlock();
			}
			try {
				lock.lock();
				//已經收到訊號，開始輸出4，5，6
				System.out.println("threadB start write");
				while (num.value <= 6) {
					System.out.println(num.value);
					num.value++;
				}
				//4，5，6輸出完畢，告訴A執行緒6輸出完了
				reachSixCondition.signal();
			} finally {
				lock.unlock();
			}
		}

	});


	//啟動兩個執行緒
	threadB.start();
	threadA.start();
}

}

java-鎖的相關概念介紹

java-鎖的相關概念介紹

執行緒介紹，常用方法，生命週期，執行緒守護，執行緒同步機制，互斥鎖，執行緒死鎖相關概念

1.2.3 執行緒安全之java鎖相關

RabbitMQ知識點整理2-相關概念介紹

LTE 承載相關概念介紹

Java 鎖概念介紹

深入理解java併發程式設計基礎篇（一）-------併發程式設計相關概念

Java 可重入鎖的概念

從synchronized優化看Java鎖概念

併發程式設計執行緒安全——Java鎖概念

Java基礎相關介紹

訊息中介軟體-RabbitMq相關概念及原理介紹【圖文並茂】

CMake學習筆記（一）基本概念介紹、入門教程及CLion安裝配置

GKE 相關概念

分散式系統、微服務架構的一致性和冪等性問題相關概念解析

ZooKeeper 相關概念以及使用小結

【Kubernetes系列】第2篇基礎概念介紹

java封裝的概念和實現方法示例

java繼承的概念及案例解析

MySQL對於各種鎖的概念理解

java-鎖的相關概念介紹

相關推薦