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: 
Indeed it is needed (in specific situations). Just read through [*Java Concurrency in Practice*](http://www.javaconcurrencyinpractice.com/), it is used there many times over.

Of course, since Java 5 we can usually happily solve problems using (almost) exclusively the `java.util.concurrent` toolbox. And even if we need to write our own thread-safe classes, `synchronized` can often be completely replaced by nonblocking algorithms such as [CAS](http://www.ibm.com/developerworks/java/library/j-jtp04186/index.html). However, CAS has its price as well, in that it requires very precise reasoning, tuning etc. and it is not well understood by lots of developers. Often it may provide no performance benefit, but it complicates the code. So there are cases when it is simpler and cleaner to just use a `synchronized` block.

Note also that locks are cheaper than they used to be as the JVM improves with every release. Long ago, this price was what turned off many developers from using them, but it is not so strongly justified anymore (and even if it is, only a concrete measurement can prove whether the performance bottleneck really is in locking).
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.