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.
Well, it depends.

You can basically solve any problem using the concurrent and collection packages.  

However, if you come to find, that you have a bottle neck just really in your synchronization, you'll probably need to do it by hand and the synchronised keyword might be just the friend you need.

I suppose, this is an unlikely problem to run into and usually, redesigning the thread responsibility will provide a cleaner solution than optimizing it by hand, while being sufficiently fast. I couldn't get my hands on the source of those packages, but I wouldn't be surprised if they actually used synchronised for implementation (but the opposite wouldn't surprise me either).