< prev index next >

src/hotspot/share/services/threadService.cpp

Print this page

 413     // It isn't clear how to make deadlock detection work correctly if that
 414     // happens.
 415     waitingToLockRawMonitor = jt->current_pending_raw_monitor();
 416 
 417     if (concurrent_locks) {
 418       waitingToLockBlocker = jt->current_park_blocker();
 419     }
 420 
 421     while (waitingToLockMonitor != NULL ||
 422            waitingToLockRawMonitor != NULL ||
 423            waitingToLockBlocker != NULL) {
 424       cycle->add_thread(currentThread);
 425       // Give preference to the raw monitor
 426       if (waitingToLockRawMonitor != NULL) {
 427         Thread* owner = waitingToLockRawMonitor->owner();
 428         if (owner != NULL && // the raw monitor could be released at any time
 429             owner->is_Java_thread()) {
 430           currentThread = owner->as_Java_thread();
 431         }
 432       } else if (waitingToLockMonitor != NULL) {
 433         address currentOwner = (address)waitingToLockMonitor->owner();
 434         if (currentOwner != NULL) {
 435           currentThread = Threads::owning_thread_from_monitor_owner(t_list,
 436                                                                     currentOwner);
 437           if (currentThread == NULL) {
 438             // This function is called at a safepoint so the JavaThread
 439             // that owns waitingToLockMonitor should be findable, but
 440             // if it is not findable, then the previous currentThread is
 441             // blocked permanently. We record this as a deadlock.
 442             num_deadlocks++;
 443 
 444             cycle->set_deadlock(true);
 445 
 446             // add this cycle to the deadlocks list
 447             if (deadlocks == NULL) {
 448               deadlocks = cycle;
 449             } else {
 450               last->set_next(cycle);
 451             }
 452             last = cycle;
 453             cycle = new DeadlockCycle();
 454             break;
 455           }
 456         }

 992         if (owner->is_Java_thread()) {
 993           currentThread = owner->as_Java_thread();
 994           st->print_cr("%s \"%s\"", owner_desc, currentThread->get_thread_name());
 995         } else {
 996           st->print_cr(",\n  which has now been released");
 997         }
 998       } else {
 999         st->print_cr("%s non-Java thread=" PTR_FORMAT, owner_desc, p2i(owner));
1000       }
1001     }
1002 
1003     if (waitingToLockMonitor != NULL) {
1004       st->print("  waiting to lock monitor " INTPTR_FORMAT, p2i(waitingToLockMonitor));
1005       oop obj = waitingToLockMonitor->object();
1006       st->print(" (object " INTPTR_FORMAT ", a %s)", p2i(obj),
1007                  obj->klass()->external_name());
1008 
1009       if (!currentThread->current_pending_monitor_is_from_java()) {
1010         owner_desc = "\n  in JNI, which is held by";
1011       }
1012       currentThread = Threads::owning_thread_from_monitor_owner(t_list,
1013                                                                 (address)waitingToLockMonitor->owner());
1014       if (currentThread == NULL) {
1015         // The deadlock was detected at a safepoint so the JavaThread
1016         // that owns waitingToLockMonitor should be findable, but
1017         // if it is not findable, then the previous currentThread is
1018         // blocked permanently.
1019         st->print_cr("%s UNKNOWN_owner_addr=" PTR_FORMAT, owner_desc,
1020                   p2i(waitingToLockMonitor->owner()));
1021         continue;
1022       }
1023     } else {
1024       st->print("  waiting for ownable synchronizer " INTPTR_FORMAT ", (a %s)",
1025                 p2i(waitingToLockBlocker),
1026                 waitingToLockBlocker->klass()->external_name());
1027       assert(waitingToLockBlocker->is_a(vmClasses::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass()),
1028              "Must be an AbstractOwnableSynchronizer");
1029       oop ownerObj = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(waitingToLockBlocker);
1030       currentThread = java_lang_Thread::thread(ownerObj);
1031       assert(currentThread != NULL, "AbstractOwnableSynchronizer owning thread is unexpectedly NULL");
1032     }
1033     st->print_cr("%s \"%s\"", owner_desc, currentThread->get_thread_name());

 413     // It isn't clear how to make deadlock detection work correctly if that
 414     // happens.
 415     waitingToLockRawMonitor = jt->current_pending_raw_monitor();
 416 
 417     if (concurrent_locks) {
 418       waitingToLockBlocker = jt->current_park_blocker();
 419     }
 420 
 421     while (waitingToLockMonitor != NULL ||
 422            waitingToLockRawMonitor != NULL ||
 423            waitingToLockBlocker != NULL) {
 424       cycle->add_thread(currentThread);
 425       // Give preference to the raw monitor
 426       if (waitingToLockRawMonitor != NULL) {
 427         Thread* owner = waitingToLockRawMonitor->owner();
 428         if (owner != NULL && // the raw monitor could be released at any time
 429             owner->is_Java_thread()) {
 430           currentThread = owner->as_Java_thread();
 431         }
 432       } else if (waitingToLockMonitor != NULL) {
 433         if (waitingToLockMonitor->has_owner()) {
 434           currentThread = Threads::owning_thread_from_monitor(t_list, waitingToLockMonitor);


 435           if (currentThread == NULL) {
 436             // This function is called at a safepoint so the JavaThread
 437             // that owns waitingToLockMonitor should be findable, but
 438             // if it is not findable, then the previous currentThread is
 439             // blocked permanently. We record this as a deadlock.
 440             num_deadlocks++;
 441 
 442             cycle->set_deadlock(true);
 443 
 444             // add this cycle to the deadlocks list
 445             if (deadlocks == NULL) {
 446               deadlocks = cycle;
 447             } else {
 448               last->set_next(cycle);
 449             }
 450             last = cycle;
 451             cycle = new DeadlockCycle();
 452             break;
 453           }
 454         }

 990         if (owner->is_Java_thread()) {
 991           currentThread = owner->as_Java_thread();
 992           st->print_cr("%s \"%s\"", owner_desc, currentThread->get_thread_name());
 993         } else {
 994           st->print_cr(",\n  which has now been released");
 995         }
 996       } else {
 997         st->print_cr("%s non-Java thread=" PTR_FORMAT, owner_desc, p2i(owner));
 998       }
 999     }
1000 
1001     if (waitingToLockMonitor != NULL) {
1002       st->print("  waiting to lock monitor " INTPTR_FORMAT, p2i(waitingToLockMonitor));
1003       oop obj = waitingToLockMonitor->object();
1004       st->print(" (object " INTPTR_FORMAT ", a %s)", p2i(obj),
1005                  obj->klass()->external_name());
1006 
1007       if (!currentThread->current_pending_monitor_is_from_java()) {
1008         owner_desc = "\n  in JNI, which is held by";
1009       }
1010       currentThread = Threads::owning_thread_from_monitor(t_list, waitingToLockMonitor);

1011       if (currentThread == NULL) {
1012         // The deadlock was detected at a safepoint so the JavaThread
1013         // that owns waitingToLockMonitor should be findable, but
1014         // if it is not findable, then the previous currentThread is
1015         // blocked permanently.
1016         st->print_cr("%s UNKNOWN_owner_addr=" PTR_FORMAT, owner_desc,
1017                   p2i(waitingToLockMonitor->owner()));
1018         continue;
1019       }
1020     } else {
1021       st->print("  waiting for ownable synchronizer " INTPTR_FORMAT ", (a %s)",
1022                 p2i(waitingToLockBlocker),
1023                 waitingToLockBlocker->klass()->external_name());
1024       assert(waitingToLockBlocker->is_a(vmClasses::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass()),
1025              "Must be an AbstractOwnableSynchronizer");
1026       oop ownerObj = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(waitingToLockBlocker);
1027       currentThread = java_lang_Thread::thread(ownerObj);
1028       assert(currentThread != NULL, "AbstractOwnableSynchronizer owning thread is unexpectedly NULL");
1029     }
1030     st->print_cr("%s \"%s\"", owner_desc, currentThread->get_thread_name());
< prev index next >