In functional languages, you can often get concurrency for free by having a clever compiler, instead of a clever human. This is good, because clever humans are expensive. Clever compilers are too, but they're easier to copy than clever humans.
Futures are an amazingly clever way to coordinate multithreaded applications. (Obviously, it doesn't make sense in all cases, though.) The basic idea is: A method call starts a thread, but directly returns a handle to the calculation result. The returned object is a so-called "future", a placeholder for the not-yet-calculated actual result. The calling thread continues execution, it is blocked only when it actually uses the future later.
Wiki also has a bit on the topic of futures. There seem to be different levels of transparency at which futures can be built into a language (and Java is obviously not too good at it). Take a look at David's article describing futures in Objective-C to gain an insight into how cool futures can be when the technology uses a sufficient amount of introspection. :-) The Smalltalk way is even more amazing (look at the very bottom of that article to see how easy it is to use). Very cool stuff! :-)