/*
Java Threads, 3rd Edition
By Scott Oaks, Henry Wong
3rd Edition September 2004
ISBN: 0-596-00782-5 */
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*; //
// This is a very very slow implementation of a ReentrantLock class and is not
// for
// everyday usage. The purpose of this class is to test for deadlocks. The
// lock()
// method now throws a DeadlockDetectedException, if a deadlock occurs.
//
public class DeadlockDetectingLock extends ReentrantLock {
// List of deadlock detecting locks.
// This array is not thread safe, and must be externally synchronized
// by the class lock. Hence, it should only be called by static
// methods.
private static List deadlockLocksRegistry = new ArrayList(); private static synchronized void registerLock(DeadlockDetectingLock ddl) {
if (!deadlockLocksRegistry.contains(ddl))
deadlockLocksRegistry.add(ddl);
} private static synchronized void unregisterLock(DeadlockDetectingLock ddl) {
if (deadlockLocksRegistry.contains(ddl))
deadlockLocksRegistry.remove(ddl);
} // List of threads hard waiting for this lock.
// This array is not thread safe, and must be externally synchronized
// by the class lock. Hence, it should only be called by static
// methods.
private List hardwaitingThreads = new ArrayList(); private static synchronized void markAsHardwait(List l, Thread t) {
if (!l.contains(t))
l.add(t);
} private static synchronized void freeIfHardwait(List l, Thread t) {
if (l.contains(t))
l.remove(t);
} //
// Deadlock checking methods
//
// Given a thread, return all locks that are already owned
// Must own class lock prior to calling this method
private static Iterator getAllLocksOwned(Thread t) {
DeadlockDetectingLock current;
ArrayList results = new ArrayList(); Iterator itr = deadlockLocksRegistry.iterator();
while (itr.hasNext()) {
current = (DeadlockDetectingLock) itr.next();
if (current.getOwner() == t)
results.add(current);
}
return results.iterator();
} // Given a lock, return all threads that are hard waiting for the lock
// Must own class lock prior to calling this method
private static Iterator getAllThreadsHardwaiting(DeadlockDetectingLock l) {
return l.hardwaitingThreads.iterator();
} // Check to see if a thread can perform a hard wait on a lock
private static synchronized boolean canThreadWaitOnLock(Thread t,
DeadlockDetectingLock l) {
Iterator locksOwned = getAllLocksOwned(t);
while (locksOwned.hasNext()) {
DeadlockDetectingLock current = (DeadlockDetectingLock) locksOwned
.next(); // Thread can't wait if lock is already owned. This is the end
// condition
// for the recursive algorithm -- as the initial condition should be
// already tested for.
if (current == l)
return false; Iterator waitingThreads = getAllThreadsHardwaiting(current);
while (waitingThreads.hasNext()) {
Thread otherthread = (Thread) waitingThreads.next(); // In order for the thread to safely wait on the lock, it can't
// own any locks that have waiting threads that already owns
// lock. etc. etc. etc. recursively etc.
if (!canThreadWaitOnLock(otherthread, l)) {
return false;
}
}
}
return true;
} //
// Core Constructors
//
public DeadlockDetectingLock() {
this(false, false);
} public DeadlockDetectingLock(boolean fair) {
this(fair, false);
} private boolean debugging; public DeadlockDetectingLock(boolean fair, boolean debug) {
super(fair);
debugging = debug;
registerLock(this);
} //
// Core Methods
//
public void lock() {
// Note: Owner can't change if current thread is owner. It is
// not guaranteed otherwise. Other owners can change due to
// condition variables.
if (isHeldByCurrentThread()) {
if (debugging)
System.out.println("Already Own Lock");
super.lock();
freeIfHardwait(hardwaitingThreads, Thread.currentThread());
return;
} // Note: The wait list must be marked before it is tested because
// there is a race condition between lock() method calls.
markAsHardwait(hardwaitingThreads, Thread.currentThread());
if (canThreadWaitOnLock(Thread.currentThread(), this)) {
if (debugging)
System.out.println("Waiting For Lock");
super.lock();
freeIfHardwait(hardwaitingThreads, Thread.currentThread());
if (debugging)
System.out.println("Got New Lock");
} else {
throw new DeadlockDetectedException("DEADLOCK");
}
} //
// Note: It is debatable whether this is a hard or soft wait. Even if
// interruption is common, we don't know if the interrupting thread
// is also involved in the deadlock. As a compromise, we'll just
// not allow interrupts. This method is disabled.
public void lockInterruptibly() throws InterruptedException {
lock();
} //
// Note: It is not necessary to override the tryLock() methods. These
// methods perform a soft wait -- there is a limit to the wait. It
// not possible to deadlock when locks are not waiting indefinitely.
// // Note 1: Deadlocks are possible with any hard wait -- this includes
// the reacquitition of the lock upon return from an await() method.
// As such, condition variables will mark for the future hard
// wait, prior to releasing the lock.
// Note 2: There is no need to check for deadlock on this end because
// a deadlock can be created whether the condition variable owns the
// lock or is reacquiring it. Since we are marking *before* giving
// up ownership, the deadlock will be detected on the lock() side
// first. It is not possible to create a new deadlock just by releasing
// locks.
public class DeadlockDetectingCondition implements Condition {
Condition embedded; protected DeadlockDetectingCondition(ReentrantLock lock,
Condition embedded) {
this.embedded = embedded;
} // Note: The algorithm can detect a deadlock condition if the thead is
// either waiting for or already owns the lock, or both. This is why
// we have to mark for waiting *before* giving up the lock.
public void await() throws InterruptedException {
try {
markAsHardwait(hardwaitingThreads, Thread.currentThread());
embedded.await();
} finally {
freeIfHardwait(hardwaitingThreads, Thread.currentThread());
}
} public void awaitUninterruptibly() {
markAsHardwait(hardwaitingThreads, Thread.currentThread());
embedded.awaitUninterruptibly();
freeIfHardwait(hardwaitingThreads, Thread.currentThread());
} public long awaitNanos(long nanosTimeout) throws InterruptedException {
try {
markAsHardwait(hardwaitingThreads, Thread.currentThread());
return embedded.awaitNanos(nanosTimeout);
} finally {
freeIfHardwait(hardwaitingThreads, Thread.currentThread());
}
} public boolean await(long time, TimeUnit unit)
throws InterruptedException {
try {
markAsHardwait(hardwaitingThreads, Thread.currentThread());
return embedded.await(time, unit);
} finally {
freeIfHardwait(hardwaitingThreads, Thread.currentThread());
}
} public boolean awaitUntil(Date deadline) throws InterruptedException {
try {
markAsHardwait(hardwaitingThreads, Thread.currentThread());
return embedded.awaitUntil(deadline);
} finally {
freeIfHardwait(hardwaitingThreads, Thread.currentThread());
}
} public void signal() {
embedded.signal();
} public void signalAll() {
embedded.signalAll();
}
} // Return a condition variable that support detection of deadlocks
public Condition newCondition() {
return new DeadlockDetectingCondition(this, super.newCondition());
} //
// Testing routines here
//
// These are very simple tests -- more tests will have to be written
private static Lock a = new DeadlockDetectingLock(false, true); private static Lock b = new DeadlockDetectingLock(false, true); private static Lock c = new DeadlockDetectingLock(false, true); private static Condition wa = a.newCondition(); private static Condition wb = b.newCondition(); private static Condition wc = c.newCondition(); private static void delaySeconds(int seconds) {
try {
Thread.sleep(seconds * 1000);
} catch (InterruptedException ex) {
}
} private static void awaitSeconds(Condition c, int seconds) {
try {
c.await(seconds, TimeUnit.SECONDS);
} catch (InterruptedException ex) {
}
} private static void testOne() {
new Thread(new Runnable() {
public void run() {
System.out.println("thread one grab a");
a.lock();
delaySeconds(2);
System.out.println("thread one grab b");
b.lock();
delaySeconds(2);
a.unlock();
b.unlock();
}
}).start(); new Thread(new Runnable() {
public void run() {
System.out.println("thread two grab b");
b.lock();
delaySeconds(2);
System.out.println("thread two grab a");
a.lock();
delaySeconds(2);
a.unlock();
b.unlock();
}
}).start();
} private static void testTwo() {
new Thread(new Runnable() {
public void run() {
System.out.println("thread one grab a");
a.lock();
delaySeconds(2);
System.out.println("thread one grab b");
b.lock();
delaySeconds(10);
a.unlock();
b.unlock();
}
}).start(); new Thread(new Runnable() {
public void run() {
System.out.println("thread two grab b");
b.lock();
delaySeconds(2);
System.out.println("thread two grab c");
c.lock();
delaySeconds(10);
b.unlock();
c.unlock();
}
}).start(); new Thread(new Runnable() {
public void run() {
System.out.println("thread three grab c");
c.lock();
delaySeconds(4);
System.out.println("thread three grab a");
a.lock();
delaySeconds(10);
c.unlock();
a.unlock();
}
}).start();
} private static void testThree() {
new Thread(new Runnable() {
public void run() {
System.out.println("thread one grab b");
b.lock();
System.out.println("thread one grab a");
a.lock();
delaySeconds(2);
System.out.println("thread one waits on b");
awaitSeconds(wb, 10);
a.unlock();
b.unlock();
}
}).start(); new Thread(new Runnable() {
public void run() {
delaySeconds(1);
System.out.println("thread two grab b");
b.lock();
System.out.println("thread two grab a");
a.lock();
delaySeconds(10);
b.unlock();
c.unlock();
}
}).start(); } public static void main(String args[]) {
int test = 1;
if (args.length > 0)
test = Integer.parseInt(args[0]);
switch (test) {
case 1:
testOne(); // 2 threads deadlocking on grabbing 2 locks
break;
case 2:
testTwo(); // 3 threads deadlocking on grabbing 2 out of 3 locks
break;
case 3:
testThree(); // 2 threads deadlocking on 2 locks with CV wait
break;
default:
System.err.println("usage: java DeadlockDetectingLock [ test# ]");
}
delaySeconds(60);
System.out.println("--- End Program ---");
System.exit(0);
}
} class DeadlockDetectedException extends RuntimeException { public DeadlockDetectedException(String s) {
super(s);
}
}

Deadlock Detecting--转的更多相关文章

  1. MemcacheQ 安装与使用

    MemcacheQ 是一个基于 MemcacheDB 的消息队列服务器.官网地址:http://memcachedb.org/memcacheq/ 特点: 1.简单易用. 2.处理速度快. 3.可创建 ...

  2. MemcacheQ安装及使用

    一.MemcacheQ安装记录1.安装libevent查看是否已经安装了libeventrpm -qa|grep libevent如果没有安装使用yum安装yum install libevent l ...

  3. 持久化消息队列memcacheq的安装配置

    MemcacheQ 是一个基于 MemcacheDB 的消息队列服务器. 一.memcacheq介绍 特性: 1.简单易用 2.处理速度快 3.多条队列 4.并发性能好 5.与memcache的协议兼 ...

  4. Troubleshooting "Global Enqueue Services Deadlock detected" (Doc ID 1443482.1)

    In this Document   _afrLoop=1021148011984950&id=1443482.1&displayIndex=1&_afrWindowMode= ...

  5. 又踩.NET Core的坑:在同步方法中调用异步方法Wait时发生死锁(deadlock)

    之前在将 Memcached 客户端 EnyimMemcached 迁移 .NET Core 时被这个“坑”坑的刻骨铭心(详见以下链接),当时以为只是在构造函数中调用异步方法(注:这里的异步方法都是指 ...

  6. 【转】Deadlock的一些总结(死锁分析及处理)

    1.1.1 摘要 在系统设计过程中,系统的稳定性.响应速度和读写速度至关重要,就像12306.cn那样,当然我们可以通过提高系统并发能力来提高系统性能总体性能,但在并发作用下也会出现一些问题,例如死锁 ...

  7. 论文阅读(Xiang Bai——【CVPR2012】Detecting Texts of Arbitrary Orientations in Natural Images)

    Xiang Bai--[CVPR2012]Detecting Texts of Arbitrary Orientations in Natural Images 目录 作者和相关链接 方法概括 方法细 ...

  8. Oracle Deadlock / 死锁 处理

    Get the directory of alert log sqlplus / as sysdba show parameters udmp SQL> show parameters dump ...

  9. [No00003D]操作系统Operating Systems信号量的代码实现Coding Semaphore &死锁处理Deadlock

    操作系统Operating Systems信号量的代码实现Coding Semaphore &死锁处理Deadlock 可以操刀了—从纸上到实际 从Linux 0.11 那里学点东西… 读磁盘 ...

随机推荐

  1. spark 入门整理

    1.第一个概念:RDD RDD(Resilient DistributedDatasets) ,弹性分布式数据集,是分布式内存的一个抽象概念,RDD提供了一种高度受限的共享内存模型,即RDD是只读的记 ...

  2. 如何将本地的jar包上传到maven本地仓库中

    首先需要将本地的jar包做mvn install到本地仓库中 mvn install:install-file -Dfile=D:\skyeye-ruleInfo\lib\lucene-querypa ...

  3. Jquery学习插件之手风琴

    <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title> ...

  4. 2016huasacm暑假集训训练五 J - Max Sum

    题目链接:http://acm.hust.edu.cn/vjudge/contest/126708#problem/J 题意:求一段子的连续最大和,只要每个数都大于0 那么就会一直增加,所以只要和0 ...

  5. ios 定位

    ios 定位新功能----在程序中实现定位功能 Core Location是iOS SDK中一个提供设备位置的框架.可以使用三种技术来获取位置:GPS.蜂窝或WiFi.在这些技术中,GPS最为精准,如 ...

  6. 分布式数据库中的Paxos 算法

    分布式数据库中的Paxos 算法 http://baike.baidu.com/link?url=ChmfvtXRZQl7X1VmRU6ypsmZ4b4MbQX1pelw_VenRLnFpq7rMvY ...

  7. 使用EF取数据库返回的数据

    目录 一.取oracle自定义函数返回的自定义类型. 一.取oracle自定义函数返回的自定义类型. 1.首先创建一个函数返回自定义类型集合 --1.建立自定义类型 CREATE OR REPLACE ...

  8. Microsoft Azure Web Sites应用与实践【1】—— 打造你的第一个Microsoft Azure Website

    Microsoft Azure Web Sites应用与实践 系列: [1]—— 打造你的第一个Microsoft Azure Website [2]—— 通过本地IIS 远程管理Microsoft ...

  9. MySQL COLUMNS分区

    200 ? "200px" : this.width)!important;} --> 介绍 COLUMN分区是5.5开始引入的分区功能,只有RANGE COLUMN和LIS ...

  10. ASP.NET MVC 从零开始 - create and run

    这篇文章是从我的 github 博客 http://lxconan.github.io 导入的. 如果你想用 ASP.NET MVC 创建一个网络应用,那么你可以搜到很多的文章.但是没有多少文章告诉你 ...