| Issue |
Subject |
Date |
| 184
|
Deadlocks through Cyclic Dependencies
A common approach to ensuring serialization consistency in thread safe classes such as Vector, Hashtable or Throwable is to include a synchronized writeObject() method. This can result in a deadlock when the object graph contain a cyclic dependency and we serialize from two threads. Whilst unlikely, it has happened in production.
|
2010-06-04
|
| 160
|
The Law of the Uneaten Lutefisk
Imagine a very stubborn viking father insisting that his equally stubborn child eat its lutefisk before going to sleep. In real life one of the "threads" eventually will give up, but in Java, the threads become deadlocked, with neither giving an inch. In this newsletter we discover how we can sometimes escape from such deadlocked situations in Java and learn why the stop() function should never ever ever be called.
|
2008-05-12
|
| 159
|
The Law of Sudden Riches
We all expect faster hardware to make our code execute faster and better. In this newsletter we examine why this is not always true. Sometimes the code breaks on faster servers or executes slower than on worse hardware.
|
2008-05-05
|
| 156
|
The Law of Cretan Driving
The Law of Cretan Driving looks at what happens when we keep on breaking the rules. Eventually, we might experience a lot of pain when we migrate to a new architecture or Java Virtual Machine. Even if we decide not to obey them, we need to know what they are. In this newsletter, we point you to some essential reading for every Java Specialist.
|
2008-02-26
|
| 155
|
The Law of the Micromanager
In good Dilbert style, we want to avoid having Pointy-Haired-Bosses (PHBs) in our code. Commonly called micromanagers, they can make a system work extremely inefficiently. My prediction is that in the next few years, as the number of cores increases per CPU, lock contention is going to be the biggest performance problem facing companies.
|
2008-01-16
|
| 152
|
The Law of the Corrupt Politician
Corruption has a habit of creeping into system that do not have adequate controls over their threads. In this law, we look at how we can detect data races and some ideas to avoid and fix them.
|
2007-11-12
|
| 151
|
The Law of the Leaked Memo
In this fifth law of concurrency, we look at a deadly law where a field value is written early.
|
2007-10-04
|
| 150
|
The Law of the Blind Spot
In this fourth law of concurrency, we look at the problem with visibility of shared variable updates. Quite often, "clever" code that tries to avoid locking in order to remove contention, makes assumptions that may result in serious errors.
|
2007-09-05
|
| 149
|
The Law of the Overstocked Haberdashery
Learn how to write correct concurrent code by understanding the Secrets of Concurrency. This is the third part of a series of laws that help explain how we should be writing concurrent code in Java. In this section, we look at why we should avoid creating unnecessary threads, even if they are not doing anything.
|
2007-08-20
|
| 147
|
The Law of the Distracted Spearfisherman
Learn how to write correct concurrent code by understanding the Secrets of Concurrency. This is the second part of a series of laws that help explain how we should be writing concurrent code in Java. We look at how to debug a concurrent program by knowing what every thread in the system is doing.
|
2007-07-20
|
| 146
|
The Secrets of Concurrency (Part 1)
Learn how to write correct concurrent code by understanding the Secrets of Concurrency. This is the first part of a series of laws that help explain how we should be writing concurrent code in Java.
|
2007-06-26
|
| 093
|
Automatically Detecting Thread Deadlocks
|
2004-07-28
|
