Distributed Computing Laboratory

Emory University


Sept 3, 2007
Version 3.1 released. Now includes versions for Java 6.0
Nov 11, 2006
Version 3.0 released. Now includes versions for Java 1.2, 1.3, 1.4, and 5.0 (sic!)
Jun 4, 2006
Version 2.2 released.


This package is the backport of java.util.concurrent API, introduced in Java 5.0 and further refined in Java 6.0, to older Java platforms. The backport is based on public-domain sources from the JSR 166 CVS repository, the dl.util.concurrent package, and the Doug Lea's collections package.

The ambition of this project is to provide a concurrency library that works with uncompromised performance on all Java platforms currently in use, allowing development of fully portable concurrent applications. More precisely, the traget scope is Java 1.3 and above, and some limited support if offered for Java 1.2.

The backport is close to complete; unsupported functionality is limited to: 1) classes that rely on explicit JVM support and cannot be emulated at a satisfactory performance level on platforms before 5.0, 2) some of the functions described in the original javadoc as "designed primarily for use in monitoring in system state, not for synchronization control".

The ultimate purpose of the backport is to enable gradual migration to java.util.concurrent. In a perfect world, everybody would instantly and simultaneously upgrade to Java 6.0 once it comes out. In reality, many people are, for various reasons, still stuck to older platforms. The backport allows them to use the JSR 166 goodies without upgrading just yet. And once they are ready to switch, their concurrency code will require only very minor modifications, such as changing the import statements.

Note: Retrotranslator in an interesting alternative to using the backport directly.

Latest release

The current release is 3.1. This release features several alternative versions, all with the same API, but optimized for different Java platforms.

for the latest release

The "standard" 1.4 backport

This was the only option available in releases prior to 3.0.

The Java 1.3 backport

Compiled on 1.3.1. It runs also on Java 1.2, but it is not thoroughly tested with it.

The Java 5.0 backport

What's the point of backporting java.util.concurrent to Java 5.0? Well, there are two, actually. First, the backport is based on more recent sources of JSR 166, as they will appear in Java 6.0, and thus it has some extra functionality, bug fixes, and optimizations. (At the same time though, some stuff from j.u.c. is missing). Second, people apparently sometimes decide to stick to the backport even on 5.0, to keep their code portable. The standard 1.4 backport works on 5.0, but not as fast as JVM-supported java.util.concurrent. This new, dedicated version of the backport utilizes the native concurrency support of new JVMs, and thus achieves the same performance as java.util.concurrent.

NOTE: unfortunately, this version doesn't work on JVMs newer than 5.0. Hence, the dedicated version below.

The Java 6.0 backport

See above for the motivation. This version requires a JVM 6.0+. It will match the performance of native java.util.concurrent, and it should be forward-compatible with upcoming Java releases. (No backport version 7.0 is anticipated).


The following functionality of java.util.concurrent is supported in the backport:


This software is released to the public domain, in the spirit of the original code written by Doug Lea. The code can be used for any purpose, modified, and redistributed without acknowledgment. No warranty is provided, either express or implied.