Where is Java going with built-in concurrency? Java5 brought an enhanced memory model and the powerful java.util.concurrent package. And of course Java has always had the Thread class and all of its counterparts. These alone are heads above the capabilities built into C and C++. I'm not familiar with C#, but I assume it is a similar story to Java. However, all of these are building blocks that must be mastered to be put to good use. It could be easier.

Looking at combining the use of annotations and AOP techniques, some additional help can be added to Java in a standard way. For example, the JBoss AOP extensions include a @Oneway annotation. This marks a method to be wrapped at runtime by a thread. This is a very simple concurrency construct as it does not return a value and does not handle exceptions. This article shows how JBoss has used annotations to extend Java for their purposes. Interesting concepts and a good way to use standard Java extensions to add to the language.

Very intersting, but it doesn't solve all concurrency problems. OpenMP for Fortran, C and C++ allows developers to annotate for loops with pragma statements. These pragma statements are used to direct the OpenMP compiler on how to add parallelize the loop. The JOMP (Java OpenMP) effort adds the same constructs to Java. But the JOMP effort seems to have lost steam. The current implementations of annotations and AOP in Java don't seem to help here, as they cannot be applied to functional code blocks such as for loops. This leaves implementing data and nested data parallelism constructs in Java to the developer.

Languages such as Erlang have very easy to use concurrency constructs built in. For example, in Erlang, it is easy to create a "process" that accepts messages and write messages to that process from another. With a few lines of code, sans threading and locking calls, you can write a concurrent program in Erlang. When will such easy concurrency be built into Java? And should it?

I've found some movement in areas mentioned above, but most are experimental and involve either a Java pre-processor or byte code manipulation using prototypes of AOP compilers not widely available. The Java language needs to standardize on this issue or programmers that need concurrency in an easy to use manner will look for other languages to use.

ConcurrentContext.enter();
try {
   ConcurrentContext.execute(new Runnable() { 
       public void run() {... }}); // Executed concurrently. 
   ConcurrentContext.execute(new Runnable() { 
       public void run() {... }}); // Executed concurrently. 
} finally {
   ConcurrentContext.exit();
}

ConcurrentContext.enter();
try {
   ConcurrentContext.execute() { ... } // Executed concurrently
   ConcurrentContext.execute() { ... } // Executed concurrently.
} finally {
   ConcurrentContext.exit();
}

enter();
try {
   execute() { ... } // Executed concurrently
   execute() { ... } // Executed concurrently.
} finally {
   exit();
}

{
  concurrent { ... } // Executed concurrently
  concurrent { ... } // Executed concurrently
  concurrent test(); // Executed concurrently.
}

ConcurrentContext.execute() {
  {...},
  {...},
  {...}
}

ConcurrentContext.execute() {
   {...},
   {...}, 
   {...}
}

public void execute(SomeClosureType... processes)

ConcurrentContext.execute() {

  { ... },

  { ... },

  { ... }

}