快捷導(dǎo)航

基于Java信號量解決死鎖過程解析

更新時間：2020年10月17日 15:24:39 作者：cuisuqiang

這篇文章主要介紹了基于Java信號量解決死鎖過程解析,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下

死鎖在多線程的情況下，會出現(xiàn)數(shù)據(jù)不同步情況，而為了避免這種情況，之前也說了：界區(qū)實現(xiàn)方法有兩種，一種是用synchronized，一種是用Lock顯式鎖實現(xiàn)。

而如果不恰當(dāng)?shù)氖褂昧随i，且出現(xiàn)同時要鎖多個對象時，會出現(xiàn)死鎖情況，如下：

package lockTest;
import java.util.Date;
/**
 * 崔素強
 * @author cuisuqiang@163.com
 */
public class LockTest {
	public static String obj1 = "obj1";
	public static String obj2 = "obj2";
	public static void main(String[] args) {
		LockA la = new LockA();
		new Thread(la).start();
		LockB lb = new LockB();
		new Thread(lb).start();
	}
}
class LockA implements Runnable{
	public void run() {
		try {
			System.out.println(new Date().toString() + " LockA 開始執(zhí)行");
			while(true){
				synchronized (LockTest.obj1) {
					System.out.println(new Date().toString() + " LockA 鎖住 obj1");
					Thread.sleep(3000); // 此處等待是給B能鎖住機會
					synchronized (LockTest.obj2) {
						System.out.println(new Date().toString() + " LockA 鎖住 obj2");
						Thread.sleep(60 * 1000); // 為測試，占用了就不放
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
class LockB implements Runnable{
	public void run() {
		try {
			System.out.println(new Date().toString() + " LockB 開始執(zhí)行");
			while(true){
				synchronized (LockTest.obj2) {
					System.out.println(new Date().toString() + " LockB 鎖住 obj2");
					Thread.sleep(3000); // 此處等待是給A能鎖住機會
					synchronized (LockTest.obj1) {
						System.out.println(new Date().toString() + " LockB 鎖住 obj1");
						Thread.sleep(60 * 1000); // 為測試，占用了就不放
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

看打?。?/p>

Mon Mar 31 10:52:38 CST 2014 LockA 開始執(zhí)行
Mon Mar 31 10:52:38 CST 2014 LockA 鎖住 obj1
Mon Mar 31 10:52:38 CST 2014 LockB 開始執(zhí)行
Mon Mar 31 10:52:38 CST 2014 LockB 鎖住 obj2

A鎖住了B需要的，B鎖住了A需要的，此時死鎖產(chǎn)生。

為了解決這個問題，我們不使用顯示的去鎖

信號量可以控制資源能被多少線程訪問，這里我們指定只能被一個線程訪問，就做到了類似鎖住。而信號量可以指定去獲取的超時時間，我們可以根據(jù)這個超時時間，去做一個額外處理。

對于無法成功獲取的情況，一般就是重復(fù)嘗試，或指定嘗試的次數(shù)，也可以馬上退出。

來看下如下代碼：

package lockTest;
import java.util.Date;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
 * 崔素強
 * @author cuisuqiang@163.com
 */
public class UnLockTest {
	public static String obj1 = "obj1";
	public static final Semaphore a1 = new Semaphore(1);
	public static String obj2 = "obj2";
	public static final Semaphore a2 = new Semaphore(1);

	public static void main(String[] args) {
		LockAa la = new LockAa();
		new Thread(la).start();
		LockBb lb = new LockBb();
		new Thread(lb).start();
	}
}
class LockAa implements Runnable {
	public void run() {
		try {
			System.out.println(new Date().toString() + " LockA 開始執(zhí)行");
			while (true) {
				if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
					System.out.println(new Date().toString() + " LockA 鎖住 obj1");
					if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
						System.out.println(new Date().toString() + " LockA 鎖住 obj2");
						Thread.sleep(60 * 1000); // do something
					}else{
						System.out.println(new Date().toString() + "LockA 鎖 obj2 失敗");
					}
				}else{
					System.out.println(new Date().toString() + "LockA 鎖 obj1 失敗");
				}
				UnLockTest.a1.release(); // 釋放
				UnLockTest.a2.release();
				Thread.sleep(1000); // 馬上進行嘗試，現(xiàn)實情況下do something是不確定的
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
class LockBb implements Runnable {
	public void run() {
		try {
			System.out.println(new Date().toString() + " LockB 開始執(zhí)行");
			while (true) {
				if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
					System.out.println(new Date().toString() + " LockB 鎖住 obj2");
					if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
						System.out.println(new Date().toString() + " LockB 鎖住 obj1");
						Thread.sleep(60 * 1000); // do something
					}else{
						System.out.println(new Date().toString() + "LockB 鎖 obj1 失敗");
					}
				}else{
					System.out.println(new Date().toString() + "LockB 鎖 obj2 失敗");
				}
				UnLockTest.a1.release(); // 釋放
				UnLockTest.a2.release();
				Thread.sleep(10 * 1000); // 這里只是為了演示，所以tryAcquire只用1秒，而且B要給A讓出能執(zhí)行的時間，否則兩個永遠(yuǎn)是死鎖
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

看打印情況：

Mon Mar 31 10:57:07 CST 2014 LockA 開始執(zhí)行
Mon Mar 31 10:57:07 CST 2014 LockB 開始執(zhí)行
Mon Mar 31 10:57:07 CST 2014 LockB 鎖住 obj2
Mon Mar 31 10:57:07 CST 2014 LockA 鎖住 obj1
Mon Mar 31 10:57:08 CST 2014LockB 鎖 obj1 失敗
Mon Mar 31 10:57:08 CST 2014LockA 鎖 obj2 失敗
Mon Mar 31 10:57:09 CST 2014 LockA 鎖住 obj1
Mon Mar 31 10:57:09 CST 2014 LockA 鎖住 obj2

第一次兩個線程獲取信號量時都會失敗，因為失敗后B等待時間長，所以A再次嘗試時會成功。

實際中，你執(zhí)行任務(wù)內(nèi)容不同，所需時間是不同的。另外不同的線程，對于獲取信號量失敗的處理也可能是不同的。所以，雖然不會產(chǎn)生死鎖，但是你要根據(jù)實際情況，來編寫獲取失敗后的處理機制。

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: