|
Diagnosing Java Code : The Orphaned Thread bug pattern
| Link ID |
27259 |
| Title |
Diagnosing Java Code : The Orphaned Thread bug pattern |
|
|
| Url |
Visit : Diagnosing Java Code : The Orphaned Thread bug pattern |
| Description |
In multithreaded code, it is often common to use a single, master thread that drives the actions the other threads take. This master thread may send messages, often by placing them on a queue, that are then processed by the other threads. But if the master thread throws an exception, the remaining threads may continue to run, awaiting more input to the queue, causing the program to freeze. This article discusses detecting, fixing, and avoiding this bug pattern. |
| Category |
Java > Tutorials > Development |
| Keywords |
Diagnosing Java Code : The Orphaned Thread bug pattern |
| Date |
Sep 20, 2007 |
Refer it to Friend ( Diagnosing Java Code : The Orphaned Thread bug pattern )
Write a Review ( Diagnosing Java Code : The Orphaned Thread bug pattern )
Report Broken Link ( Diagnosing Java Code : The Orphaned Thread bug pattern )
Add : Diagnosing Java Code : The Orphaned Thread bug pattern To Favorites
More links included : Diagnosing Java Code : The Orphaned Thread bug pattern
Site links : Diagnosing Java Code : The Orphaned Thread bug pattern
Traffic Details from Alexa : Diagnosing Java Code : The Orphaned Thread bug pattern
|
|
Other links at Java > Tutorials > Development |
| 1. |
Diagnosing Java Code: The Impostor Type bug pattern
|
|
|
When special tags in fields are used to distinguish between types of objects, errors are possible in which a tag mislabels the associated data -- a bug pattern known as the Impostor Type. This article examines the symptoms and causes of this bug, defines ways to prevent this error from occurring, and discusses a tempting hybrid implementation that does not use impostor types but, in the end, turns out to have many of the same weaknesses. Article includes code snipets.
|
| 2. |
Threading lightly : Reducing contention
|
|
|
While its common to hear that synchronized method calls can be 50 times as expensive as unsynchronized method calls, these numbers can actually be quite misleading. With each successive JVM version, overall performance has improved, and the cost of uncontended synchronization has been reduced, making the issue of uncontended synchronization overhead less significant. Contended synchronization, however, is quite expensive. Moreover, a high degree of contention is disastrous for scalability -- an application that had a high degree of contended synchronization will exhibit markedly worse performance as the load increases. This article explores several techniques for reducing contention, and hence improving scalability, in your programs.
|
| 3. |
Diagnosing Java Code : The Orphaned Thread bug pattern
|
|
|
In multithreaded code, it is often common to use a single, master thread that drives the actions the other threads take. This master thread may send messages, often by placing them on a queue, that are then processed by the other threads. But if the master thread throws an exception, the remaining threads may continue to run, awaiting more input to the queue, causing the program to freeze. This article discusses detecting, fixing, and avoiding this bug pattern.
|
| 4. |
Data Management in J2EE Apps
|
|
|
This article examines two data management strategies available on the Java platform: Java object serialization and Java Database Connectivity (JDBC). While neither data management strategy is inherently superior or inferior to the other, when it comes to managing enterprise information systems, JDBC wins hands down.
|
| 5. |
Threading lightly : Reducing contention
|
|
|
While its common to hear that synchronized method calls can be 50 times as expensive as unsynchronized method calls, these numbers can actually be quite misleading. With each successive JVM version, overall performance has improved, and the cost of uncontended synchronization has been reduced, making the issue of uncontended synchronization overhead less significant. Contended synchronization, however, is quite expensive. Moreover, a high degree of contention is disastrous for scalability -- an application that had a high degree of contended synchronization will exhibit markedly worse performance as the load increases. This article explores several techniques for reducing contention, and hence improving scalability, in your programs.
|
|
|
