A recent blog post by O'Reilly columnist Nat Torkington, Threads Considered Harmful observes the intersection of two trends as they relate to concurrent programming:

The first is a [trend] towards multicore systems and the growing importance of distributed execution... if you want your program to run faster, the days of buying faster hardware are coming to an end. Instead, we're looking at a time when you must make your program run faster on more (slow) hardware. Enter parallel programming, clusters, and their hyped big brother "grid computing..."

The second is the increasing relevance of languages like Erlang, Haskell, and E.

He points out that threads have proven difficult to program on multicore CPUs due to threads' inherently non-deterministic nature. Torkington notes that developers are increasingly open to using alternate languages to solve concurrency problems:

As the need for speed forces us out of our single core procedural comfort zone, we're looking more and more at "niche" programming languages for inspiration. Haskell has quite the following among the alpha geeks we know (e.g., the Pugs project), and OCaml has a small but growing group of devotees. Then there was the huge interest in Smalltalk at Avi Bryant's OSCON talk last year.

Torkington's post also mentions concurrency techniques not based on threads, such as MapReduce, which has implementations in several major languages.

What do you think is the future of threads in the context of today's major programming languages, such as Java?

for (String s : list) {
   doSomethingExciting(s);
}

class ForEach<T>(Function<T> f)
{
    private final Function<T> f;
 
    public ForEach(Function<T> f)
    {
        this.f = f;
    }
 
    public void exec(Iterable<T> i)
    {
        for (T t : i) {
            f.exec(t);
        }
    }
}

public interface Function<T>
{
    public void exec(T t);
}

new ForEach(new Function<String>{
   pubic void exec(String s) {
       doSomethingExciting(s);
   }
}

new ForEach(new Function<String>{
   pubic void exec(String s) {
       doSomethingExciting(s);
   }
}).exec(list);