Question: Is the synchronised keyword still required (ignore backwards compatibility, I'm thinking in terms of writing new code, today) or should we all be using the features available in the Concurrent and Collection packages?

Answer: 
The one place that `synchronized` is still used (at least in my code) is looping over Synchronized lists. The Javadocs for [`Collections.synchronizedCollection`](http://download.oracle.com/javase/6/docs/api/java/util/Collections.html#synchronizedCollection%28java.util.Collection%29) say that any time an iterator is used the entire block of code using the iterator needs to be synchronized. This is because you are not doing a single operation like `add()` or `remove()`, you are doing multiple operations.

Example code from Javadocs

```
Collection c = Collections.synchronizedCollection(myCollection);
...
synchronized(c) {
  Iterator i = c.iterator(); // Must be in the synchronized block
  while (i.hasNext())
     foo(i.next());
}

```

The only way I know to get around this limitation is to queue all operations in a SingleThreadExecutor, but that's a very expensive and archaic solution.
Yes, the synchronized modifier is very much alive and required. Sure, you can use Locks and other stuff from the `java.util.concurrent` package but in many cases this is simply quite a big overhead. If you want to ensure that a certain piece of code gets executed exclusively the synchronized keyword is the quickest and safest solutation. There are a lot of situations, where obtaining a lock, getting it and releasing it simply isn't necessary.

So yes, for a good multithreaded program the use of the synchronized keyword is indeed required.