基于Java信号量解决死锁过程解析

基于java信号量解决死锁过程解析

死锁在多线程的情况下，会出现数据不同步情况， 而为了避免这种情况，之前也说了：界区实现方法有两种，一种是用synchronized，一种是用Lock显式锁实现。

而如果不恰当的使用了锁，且出现同时要锁多个对象时，会出现死锁情况，如下：

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 开始执行");

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 开始执行");

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();

}

}

}

看打印：

Mon Mar 31 10:52:38 CST 2014 LockA 开始执行

Mon Mar 31 10:52:38 CST 2014 LockA 锁住 obj1

Mon Mar 31 10:52:38 CST 2014 LockB 开始执行

Mon Mar 31 10:52:38 CST 2014 LockB 锁住 obj2

A锁住了B需要的，B锁住了A需要的，此时死锁产生。

为了解决这个问题，我们不使用显示的去锁

信号量可以控制资源能被多少线程访问，这里我们指定只能被一个线程访问，就做到了类似锁住。而信号量可以指定去获取的超时时间，我们可以根据这个超时时间，去做一个额外处理。

对于无法成功获取的情况，一般就是重复尝试，或指定尝试的次数，也可以马上退出。

来看下如下代码：

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);

ftdqzXdMfpublic 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 开始执行");

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); // 马上进行尝试，现实情况下do something是不确定的

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

class LockBb implements Runnable {

public void run() {

try {

System.out.println(new Date().toString() + " LockB 开始执行");

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让出能执行的时间，否则两个永远是死锁

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

看打印情况：

Mon Mar 31 10:57:07 CST 2014 LockA 开始执行

Mon Mar 31 10:57:07 CST 2014 LockB 开始执行

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 LoftdqzXdMfckA 锁住 obj1

Mon Mar 31 10:57:09 CST 2014 LockA 锁住 obj2

第一次两个线程获取信号量时都会失败，因为失败后B等待时间长，所以A再次尝试时会成功。

实际中，你执行任务内容不同，所需时间是不同的。另外不同的线程，对于获取信号量失败的处理也可能是不同的。所以，虽然不会产生死锁，但是你要根据实际情况，来编写获取失败后的处理机制。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。