<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
    "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <title>Video of Deadlock Detection Using the NetBeans Debugger</title>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" >
        <meta name="description" content="A screencast how to detect deadlocks using the NetBeans debugger">
        <link rel="stylesheet" type="text/css" href="../../../netbeans.css">
    </head>
    <body>

<!--
Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
-->

        <h1>Video of Deadlock Detection Using the NetBeans Debugger</h1>

        <table>
            <tr>
                <td class="valign-top">

                    <p>Roman Ondruska demonstrates how to detect deadlocks using the NetBeans debugger.
                    </p>

                    <!--<p>You can get the sources for the projects used in this screencast from
                    the repository for the <a href="http://kenai.com/projects/nbdebuggerdemos/pages/Home">NetBeans Debugger Demos</a> project on Kenai.</p>
                    -->

                    <p>Author: Roman Ondruska<br>Time: 3:02</p>

                    <p><a href="http://bits.netbeans.org/media/deadlock-detection.mp4">Watch full size</a>
                        (Ctrl-Click to download, 5 MB)</p>


                    <br style="clear:both;">
                    <div class="feedback-box">
                        <a href="/about/contact_form.html?to=3&amp;subject=Feedback:%20Deadlock%20Detection%20Using%20the%20NetBeans%20Debugger">Send Feedback on This Tutorial</a>
                    </div>
                    <br style="clear:both;">
                </td>

                <td width="435" class="valign-top" class="align-center">

<object width="480" height="376" align="middle"><param name="src" value="http://bits.netbeans.org/media/deadlock-detection.mp4"/>
    <param name="autoplay" value="false"/>
    <param name="controller" value="true"/>
    <param name="scale" value="aspect"/>
    <param name="type" value="video/quicktime"/>
    <embed src="http://bits.netbeans.org/media/deadlock-detection.mp4" autoplay="false" controller="true" type="video/quicktime" scale="aspect" width="480" height="376" align="middle"></embed></object>

                </td>
            </tr>
        </table>
        <h2>Related links</h2>

        <ul>
            <li>Demo: <a href="debug-stepinto-screencast.html">Visual Step Into Action in NetBeans Debugger</a></li>
            <li>Demo: <a href="debug-multithreaded-screencast.html">Multithreaded Debugging with the NetBeans IDE</a></li>
            <li>Demo: <a href="debug-evaluator-screencast.html">Using the Code Snippet Evaluator in the NetBeans Debugger</a></li>
            <li><a href="debug-multithreaded.html">Debugging Multithreaded Applications in NetBeans IDE</a></li>
        </ul>

    </body>
</html>
