2. 程式人生 > >程式碼淺析 Android Lock 、ReentrantLock執行緒鎖及其作用

程式碼淺析 Android Lock 、ReentrantLock執行緒鎖及其作用

阿新 • • 發佈：2019-02-01

先來了解什麼是“互斥鎖”？

百度一下，解釋如下：在程式設計中，引入了物件互斥鎖的概念，來保證共享資料操作的完整性。每個物件都對應於一個可稱為" 互斥鎖" 的標記，這個標記用來保證在任一時刻，只能有一個執行緒訪問該物件。

是的，面對高併發的讀、寫訪問，可能會出現資料丟失的問題，而Andriod系統基於Linux核心，使得併發讀、寫資料可以沒有限制的進行。因此，出於對資料，尤其是共享資料的完整性和一致性，我們需要用到鎖機制來確保資料的可靠性。

在Android中，有三類鎖可以解決上述問題：

1：synchronized

這是java中比較常見的一種同步鎖關鍵字，由於常見，這裡就不一一介紹了，詳見：http://blog.csdn.net/luoweifu/article/details/46613015

2：Lock
先看看繼承關係：


使用之前我們先看看，模擬併發的情況：

package SychronizedTest;

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

public class SychronizedTest {

	/**
	 * @author zy_style
	 * @param args
	 */
	public static void main(String[] args) {
		final Outputter outputter = new Outputter();
		// 開啟一條執行緒輸出名字的每個字元
		new Thread() {
			@Override
			public void run() {
				try {
					outputter.output("abcde");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}.start();
		// 開啟另一條執行緒
		new Thread() {
			@Override
			public void run() {
				try {
					outputter.output("fghij");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}.start();
	}
}

class Outputter {
	public void output(String name) throws InterruptedException {
		for (int i = 0; i < name.length(); i++) {
			System.out.println(name.charAt(i));
			Thread.sleep(1000);
		}
	}
}

得到的輸出結果：

a
f
g
b
h
c
d
i
j
e
可以看到，確實如我們想象的那樣，輸出的內容混在了一起，如果是對檔案進行讀寫的話，就不能保證檔案的完整性了。

現在我們加上Lock:

package SychronizedTest;

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

public class SychronizedTest {

	/**
	 * @author zy_style
	 * @param args
	 */
	public static void main(String[] args) {
		final Outputter outputter = new Outputter();
		// 開啟一條執行緒輸出名字的每個字元
		new Thread() {
			@Override
			public void run() {
				try {
					outputter.output("abcde");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}.start();
		// 開啟另一條執行緒
		new Thread() {
			@Override
			public void run() {
				try {
					outputter.output("fghij");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}.start();
	}
}

class Outputter {
	private Lock lock = new ReentrantLock(); // 定義鎖物件

	public void output(String text) throws InterruptedException {
		lock.lock(); // 得到鎖
		try {
			for (int i = 0; i < text.length(); i++) {
				System.out.println(text.charAt(i));
				Thread.sleep(1000);
			}
		} finally {
			lock.unlock(); // 釋放鎖
		}
	}
}

現在，輸出結果如下： 
a
b
c
d
e
f
g
h
i
j
可以發現，輸出的結果變得有序多了，一個執行緒獲得鎖執行完操作後，釋放鎖，下一個執行緒才能進行操作，這樣才能保證併發操作有序的進行，而不是一盤散撒。

3：ReadWriteLock
可以發現，上面的情況並不能解決併發讀寫的同步問題，比如說讀與寫互斥、寫與寫互斥的問題。先看看不考慮互斥問題的程式碼： 
package SychronizedTest;


/**
 * 讀寫鎖測試
 * 
 * @author zy_style
 */
public class ReadWriteLockTest {

	/**
	 * @author zhouyang 2016-12-1
	 * @time 下午3:01:27
	 * @param args
	 */
	public static void main(String[] args) {
		final Data data = new Data();
		// 開啟3個子執行緒,分別寫入資料
		for (int i = 0; i < 3; i++) {
			new Thread() {
				public void run() {
					for (int j = 0; j < 5; j++) {
						try {
							data.set(j); // 寫入資料
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				};
			}.start();
		}

		// 分別讀取資料
		for (int i = 0; i < 3; i++) {
			new Thread() {
				public void run() {
					for (int j = 0; j < 5; j++) {
						try {
							data.get(); // 讀取資料
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				};
			}.start();
		}
	}

}

/**
 * 需要操作的資料
 * 
 * @author zy_style
 */
class Data {
	private int data;

	public void set(int data) throws Exception {
		System.out.println(Thread.currentThread().getName() + "準備寫入資料...");
		Thread.sleep(50); // 模擬耗時操作
		this.data = data;
		System.out.println(Thread.currentThread().getName() + "寫入資料成功!");
	}

	public void get() throws Exception {
		System.out.println(Thread.currentThread().getName() + "準備讀取資料...");
		Thread.sleep(50); // 模擬耗時操作
		System.out.println(Thread.currentThread().getName() + "讀取資料:"
					+ this.data);
	}
}
部分執行結果如下： 
Thread-1寫入資料成功!
Thread-1準備寫入資料...
Thread-2寫入資料成功!
Thread-2準備寫入資料...
Thread-0準備寫入資料...
Thread-4讀取資料:0
Thread-4準備讀取資料...
Thread-3讀取資料:0
Thread-5讀取資料:0
Thread-3準備讀取資料...
Thread-5準備讀取資料...
Thread-1寫入資料成功!
沒有任何規律可言，而且容易造成資料混亂和丟失。

如果現在有這麼一個需求：讀與寫互斥、寫與寫互斥、讀與讀互斥，說白了就是讓所有的讀寫操作都互斥，互不干擾。其實很簡單，在set()和get()方法前加上sychronized修飾符即可：

public synchronized void set(int data) throws Exception {
		System.out.println(Thread.currentThread().getName() + "準備寫入資料...");
		Thread.sleep(50); // 模擬耗時操作
		this.data = data;
		System.out.println(Thread.currentThread().getName() + "寫入資料成功!");
	}

public synchronized void get() throws Exception {
		System.out.println(Thread.currentThread().getName() + "準備讀取資料...");
		Thread.sleep(50); // 模擬耗時操作
		System.out.println(Thread.currentThread().getName() + "讀取資料:"
					+ this.data);
	}

部分執行結果如下： 
Thread-0準備寫入資料...
Thread-0寫入資料成功!
Thread-0準備寫入資料...
Thread-0寫入資料成功!
Thread-5準備讀取資料...
Thread-5讀取資料:4
Thread-4準備讀取資料...
Thread-4讀取資料:4
Thread-4準備讀取資料...
Thread-4讀取資料:4
Thread-3準備讀取資料...
Thread-3讀取資料:4

既然結果確實是讀、寫互斥了，但是考慮到實際情況，我們為了提高併發的效率，其實讀與讀可以不互斥，只用保證讀與寫、讀與讀之間互斥，這樣才能最高效的執行併發操作並保證資料的完整性。這裡就用到ReadWriteLock了：

package SychronizedTest;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 讀寫鎖測試
 * 
 * @author zy_style
 */
public class ReadWriteLockTest {

	/**
	 * @author zhouyang 2016-12-1
	 * @time 下午3:01:27
	 * @param args
	 */
	public static void main(String[] args) {
		final Data data = new Data();
		// 開啟3個子執行緒,分別寫入資料
		for (int i = 0; i < 3; i++) {
			new Thread() {
				public void run() {
					for (int j = 0; j < 5; j++) {
						try {
							data.set(j); // 寫入資料
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				};
			}.start();
		}

		// 分別讀取資料
		for (int i = 0; i < 3; i++) {
			new Thread() {
				public void run() {
					for (int j = 0; j < 5; j++) {
						try {
							data.get(); // 讀取資料
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				};
			}.start();
		}
	}

}

/**
 * 需要操作的資料
 * 
 * @author zy_style
 */
class Data {
	private int data;
	private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

	public void set(int data) throws Exception {
		readWriteLock.writeLock().lock(); // 獲取寫鎖
		try {
			System.out.println(Thread.currentThread().getName() + "準備寫入資料...");
			Thread.sleep(50); // 模擬耗時操作
			this.data = data;
			System.out.println(Thread.currentThread().getName() + "寫入資料成功!");
		} finally {
			readWriteLock.writeLock().unlock(); // 釋放寫鎖
		}

	}

	public void get() throws Exception {
		readWriteLock.readLock().lock(); // 獲取讀鎖
		try {
			System.out.println(Thread.currentThread().getName() + "準備讀取資料...");
			Thread.sleep(50); // 模擬耗時操作
			System.out.println(Thread.currentThread().getName() + "讀取資料:"
					+ this.data);
		} finally {
			readWriteLock.readLock().unlock(); // 釋放讀鎖
		}

	}
}

部分執行結果如下： 
Thread-1準備寫入資料...
Thread-1寫入資料成功!
Thread-2準備寫入資料...
Thread-2寫入資料成功!
Thread-5準備讀取資料...
Thread-3準備讀取資料...
Thread-4準備讀取資料...
Thread-5讀取資料:0
Thread-3讀取資料:0
Thread-4讀取資料:0

可以看到，讀與寫、寫與寫確實互斥了，但是讀與讀沒有互斥，這就是ReadWriteLock帶來的好處，它在保證共享資料併發操作的完整性和一致性，最重要的是提高了讀寫的效率~！

相關推薦

程式碼淺析 Android Lock 、ReentrantLock執行緒鎖及其作用

先來了解什麼是“互斥鎖”？ 百度一下，解釋如下：在程式設計中，引入了物件互斥鎖的概念，來保證共享資料操作的完整性。每個物件都對應於一個可稱為" 互斥鎖" 的標記，這個標記用來保證在任一時刻，只能有一個執行緒訪問該物件。 是的，面對高併發的讀、寫訪問，可能會出現資料丟失的問題

Android進階——多執行緒系列之wait、notify、sleep、join、yield、synchronized關鍵字、ReentrantLock鎖

前言 多執行緒一直是初學者最困惑的地方，每次看到一篇文章，覺得很有難度，就馬上叉掉，不看了，我以前也是這樣過來的。後來，我發現這樣的態度不行，知難而退，永遠進步不了。於是，我狠下心來看完別人的部落格，儘管很難但還是咬著牙，不懂去查閱資料，到最後弄懂整個過程。雖

Java第十三天學習筆記~多執行緒（執行緒的狀態、建立執行緒的第二種方式、同步程式碼塊、同步函式）

                                 多執行緒 執行緒的狀態 CPU的執行資格：可以被C

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

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

執行緒間通訊、等待喚醒機制、生產者消費者問題(Lock,Condition)、停止執行緒和守護執行緒、執行緒優先順序

1  執行緒間通訊 1.1  執行緒間通訊 其實就是多個執行緒在操作同一個資源，但是操作的動作不同。 比如一個執行緒給一個變數賦值，而另一個執行緒列印這個變數。 1.2  等待喚醒機制 wait()：將執行緒等待，釋放了CPU執行權，同時將執行緒物件儲存到執行緒池中。 n

Android使用Handler實現子執行緒與子執行緒、主執行緒之間通訊

今天這篇文章只講一下怎麼使用Handler實現子執行緒與子執行緒之間、子執行緒與主執行緒之間如何進行通訊，關於具體的內部實現因為我也沒研究過，所以這篇文章講不了。 一、子執行緒向主執行緒傳值： 這個實現比較簡單，因為主執行緒自帶Looper機制，所有我們不用

Android多執行緒研究（9）——執行緒鎖Lock

在前面我們在解決執行緒同步問題的時候使用了synchronized關鍵字，今天我們來看看Java 5.0以後提供的執行緒鎖Lock.Lock介面的實現類提供了比使用synchronized關鍵字更加靈活和廣泛的鎖定物件操作，而且是以面向物件的方式進行物件加鎖。 @Overr

Android中的多程序、多執行緒

前面幾篇總結了程序、執行緒相關的知識。這裡總結下關於Android中的多程序、多執行緒及其使用。 這裡總結的Android中的多程序、多執行緒也是一個基礎，可擴充套件的很多。   Android中多程序 常見的幾種使用 Runtime.getRuntime().exec("xxx") 這個方法，呼叫

synchronized、Lock、ReentrantLock、ReadWriteLock

正在 spa 一個 div 沒有 發生 分組 讀寫 else synchronized:同步鎖，是java內置的關鍵字。當一個線程A執行到被synchronized修飾的方法時，其他線程B如果也要執行這個方法，那麽B只能等A執行完方法釋放鎖後才能獲取資源鎖執行synchro

android的四種執行緒池

四種執行緒池內部構造都是來自同一個方法：  public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,

併發伺服器的實現（多程序、多執行緒...）

一、多程序實現併發伺服器 程式碼如下：multiprocess_server.c /* ============================================================================ Name : TCPServ

主執行緒、守護執行緒、非守護執行緒

主執行緒 main，但不是守護執行緒。 守護執行緒 是指在程式執行的時候在後臺提供一種通用服務的執行緒。如gc。 非守護執行緒 也叫使用者執行緒，由使用者建立。 關係： 主執行緒和守護執行緒一起銷燬； 主執行緒和非守護執行緒互不影響。 例如： package

Java 知識 - 集合、多執行緒、IO、JVM

GitHub 專案地址 Collection Java Collection 新增、刪除等操作時可選操作，如 Arrays.asList，會產生固定大小的集合,會丟擲 UnsupportedOperationException Set HashSet、TreeSet、LinkedH

設計模式之單例模式【內附物件例項化幾種方式、實現執行緒安全幾種方式】

繼續來複習常用的設計模式-單例模式，順便回憶一下執行緒安全的幾種實現方式。 一、什麼是單例模式 單例模式，簡單常用的一種設計模式，也很好的體現了程式碼控制物件在記憶體數量的一種方式，主要分2種實現方式： ①餓漢式，執行緒安全 ②懶漢式，執行緒不安全（新增鎖機制，可以實現執行緒安全）

Android面試：主執行緒中的Looper.loop()一直無限迴圈為什麼不會造成ANR？(轉)

  引子： 正如我們所知，在android中如果主執行緒中進行耗時操作會引發ANR（Application Not Responding）異常。 造成ANR的原因一般有兩種： 只有當應用程式的UI執行緒響應超時才會引起ANR，超時產生原因一般有兩種 1. 當前的事件沒有機會

SimpleDateFormat時間格式化高併發、多執行緒時出現問題

SimpleDateFormat是是 Java 中一個非常常用的類，該類用來對日期字串進行解析和格式化輸出，但是DateFormat 和 SimpleDateFormat 類不都是執行緒安全的，在生產環境的多執行緒或高併發情況使用 format() 和 parse() 方法，會出現很多問題：

Java併發程式設計之執行緒生命週期、守護執行緒、優先順序和join、sleep、yield

Java併發程式設計中，其中一個難點是對執行緒生命週期的理解，和多種執行緒控制方法、執行緒溝通方法的靈活運用。這些方法和概念之間彼此聯絡緊密，共同構成了Java併發程式設計基石之一。 Java執行緒的生命週期 Java執行緒類定義了New、Runnable、Running Man、Blocked和Dead

二、多執行緒實現簡單的socket通訊例項（TCP）

1.伺服器端 import java.io.*; import java.net.ServerSocket; import java.net.Socket; /** * 類功能描述：先啟動伺服器端，再啟動客戶端 * * @author：*** * @createTime：2018/

DEVOPS-01多程序、多執行緒程式設計

一、多執行緒程式設計 1.1 forking工作原理 1.1.1 什麼是forking 1. fork(分岔)在Linux系統中使用非常廣泛 2.  當某一命令執行時,父程序(當前程序)fork出一個子程序 3.  父程序將自身資源拷貝一份,命令在子程序中執行時,就具

銀行業務系統（c/s架構、socket網路程式設計、多執行緒）

1、功能要求 包括兩類使用者：管理人員和普通使用者（本文只寫了普通使用者程式） 普通使用者功能：登入登出、存取款、轉賬、查詢餘額 2、技術要求 要求用到多程序多執行緒 要求同時允許多個使用者操作（因為沒有註冊賬號功能，且只初始化了兩個賬號資訊，所以同時只能允許兩個賬號線上）