{"id":7165,"date":"2018-08-20T03:11:19","date_gmt":"2018-08-20T07:11:19","guid":{"rendered":"https:\/\/www.eginnovations.com\/blog\/?p=7165"},"modified":"2022-10-31T08:44:46","modified_gmt":"2022-10-31T12:44:46","slug":"troubleshooting-java-application-deadlocks-diagnosing-application-hang-situations","status":"publish","type":"post","link":"https:\/\/www.eginnovations.com\/blog\/troubleshooting-java-application-deadlocks-diagnosing-application-hang-situations\/","title":{"rendered":"Troubleshooting Java Application Deadlocks \u2013 Diagnosing \u2018Application Hang\u2019 Situations"},"content":{"rendered":"

<\/span>A Typical Production Scenario: How Do You Handle Complaints of Slow Java Applications?<\/span><\/h2>\n

It is 2 am in the morning and you get woken up by a phone call from the helpdesk team. The helpdesk is receiving a flood of calls from application users complaining about slow Java applications<\/a> that are business impacting. Users are complaining that the browser keeps spinning and eventually all they see is a \u2018white page\u2019.<\/p>\n

Still somewhat heavy-eyed, you go through the \u2018standard operating procedure\u2019. You notice that no TCP traffic is flowing to or from the app server cluster. The application logs aren\u2019t moving either.<\/p>\n

You are wondering what could be wrong when the VP of IT Operations, pings you over Instant Messenger asking you to join a war room conference call. You will be asked to provide answers and pinpoint the root cause<\/a> of why your Java applications are slow \u2013 fast.<\/p>\n

This is a classic case of application hang due to a deadlock of threads in the Java Virtual Machine (JVM)<\/a>. This blog will explain what Java application deadlocks are, why they happen and summarize the repercussions of deadlocks and provide options to diagnose and troubleshoot them to ensure that you don’t have slow Java applications. Read on.<\/p>\n

\"\"<\/a><\/p>\n

<\/span>What are Java Application Deadlocks?<\/span><\/h2>\n

\"Slow<\/p>\n

A deadlock occurs when two or more threads in the JVM<\/a> form a cyclic dependency with each other. In this illustration \u2018thread 2\u2019 is in a wait state, waiting on Resource A owned by \u2018thread 1\u2019, while \u2018thread 1\u2019 is in a wait state, waiting on Resource B owned by \u2018thread 2\u2019. In such a condition, these two threads are \u2018hanging\u2019 indefinitely without making any further progress. This results in an \u201capplication hang\u201d where the application process is running but the system is not responding to user requests.<\/p>\n

\n

\u201cThe JVM is not nearly as helpful in resolving deadlocks as database servers are. When a set of Java threads deadlock, that\u2019s the end of the game. Depending on what those threads do, the application may stall completely.\u201d<\/p>\n

Brian G\u00f6etz, Author of Java Concurrency in Practice<\/a><\/p>\n<\/div>\n

<\/p>\n

<\/span>Main Consequences of Java Application Deadlocks<\/span><\/h2>\n

<\/span>1. Poor User Experience<\/b><\/span><\/h3>\n

When a deadlock happens, the application may stall or become very slow. Typical symptoms could be \u201cwhite pages\u201d in web applications while the browser continues to spin eventually resulting in a timeout. Often, users might attempt to retry their request by clicking refresh or resubmitting a form, which compounds the Java performance problem<\/a> further.<\/p>\n

<\/span>2. System Undergoes Exponential Degradation<\/b><\/span><\/h3>\n

When threads go into a deadlock situation, they take longer to respond. In the intervening period, a fresh set of requests may arrive into the system.<\/p>\n

\"Deadlocks<\/p>\n

When deadlocks manifest in application servers, fresh requests will get backed up in the \u2018execution queue\u2019. The application server\u2019s thread pool will hit the max utilization, thereby denying service to new requests. This causes further exponential degradation of performance.<\/p>\n

<\/span> 3. Cascading Impact on the Entire Application Server Cluster<\/b><\/span><\/h3>\n

\"Pinpointing<\/p>\n

In multi-tier applications, web servers (such as Apache or IBM HTTP Server) receive requests and forward it to application servers (such as WebLogic, WebSphere or JBoss) via a \u2018plug-in\u2019. If the plug-in detects that the application server is unhealthy, it will \u201cfail-over\u201d to another healthy application server which will accept heavier loads than usual thus resulting in further slowness. This may cause a cascading slowdown effect on the entire cluster.<\/p>\n

<\/span>Challenges with Troubleshooting Deadlocks in a Clustered, Multi-tier Environment<\/span><\/h2>\n

\"\"<\/p>\n

Application support teams are usually caught off-guard when faced with deadlocks in production environments. There are there main scenarios when it becomes difficult to detect deadlocks.<\/p>\n